clang  9.0.0svn
CGObjCGNU.cpp
Go to the documentation of this file.
1 //===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This provides Objective-C code generation targeting the GNU runtime. The
10 // class in this file generates structures used by the GNU Objective-C runtime
11 // library. These structures are defined in objc/objc.h and objc/objc-api.h in
12 // the GNU runtime distribution.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "CGObjCRuntime.h"
17 #include "CGCleanup.h"
18 #include "CodeGenFunction.h"
19 #include "CodeGenModule.h"
20 #include "CGCXXABI.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/Decl.h"
24 #include "clang/AST/DeclObjC.h"
25 #include "clang/AST/RecordLayout.h"
26 #include "clang/AST/StmtObjC.h"
29 #include "llvm/ADT/SmallVector.h"
30 #include "llvm/ADT/StringMap.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/Intrinsics.h"
33 #include "llvm/IR/LLVMContext.h"
34 #include "llvm/IR/Module.h"
35 #include "llvm/Support/Compiler.h"
36 #include "llvm/Support/ConvertUTF.h"
37 #include <cctype>
38 
39 using namespace clang;
40 using namespace CodeGen;
41 
42 namespace {
43 
44 std::string SymbolNameForMethod( StringRef ClassName,
45  StringRef CategoryName, const Selector MethodName,
46  bool isClassMethod) {
47  std::string MethodNameColonStripped = MethodName.getAsString();
48  std::replace(MethodNameColonStripped.begin(), MethodNameColonStripped.end(),
49  ':', '_');
50  return (Twine(isClassMethod ? "_c_" : "_i_") + ClassName + "_" +
51  CategoryName + "_" + MethodNameColonStripped).str();
52 }
53 
54 /// Class that lazily initialises the runtime function. Avoids inserting the
55 /// types and the function declaration into a module if they're not used, and
56 /// avoids constructing the type more than once if it's used more than once.
57 class LazyRuntimeFunction {
58  CodeGenModule *CGM;
59  llvm::FunctionType *FTy;
60  const char *FunctionName;
61  llvm::FunctionCallee Function;
62 
63 public:
64  /// Constructor leaves this class uninitialized, because it is intended to
65  /// be used as a field in another class and not all of the types that are
66  /// used as arguments will necessarily be available at construction time.
67  LazyRuntimeFunction()
68  : CGM(nullptr), FunctionName(nullptr), Function(nullptr) {}
69 
70  /// Initialises the lazy function with the name, return type, and the types
71  /// of the arguments.
72  template <typename... Tys>
73  void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy,
74  Tys *... Types) {
75  CGM = Mod;
76  FunctionName = name;
77  Function = nullptr;
78  if(sizeof...(Tys)) {
79  SmallVector<llvm::Type *, 8> ArgTys({Types...});
80  FTy = llvm::FunctionType::get(RetTy, ArgTys, false);
81  }
82  else {
83  FTy = llvm::FunctionType::get(RetTy, None, false);
84  }
85  }
86 
87  llvm::FunctionType *getType() { return FTy; }
88 
89  /// Overloaded cast operator, allows the class to be implicitly cast to an
90  /// LLVM constant.
91  operator llvm::FunctionCallee() {
92  if (!Function) {
93  if (!FunctionName)
94  return nullptr;
95  Function = CGM->CreateRuntimeFunction(FTy, FunctionName);
96  }
97  return Function;
98  }
99 };
100 
101 
102 /// GNU Objective-C runtime code generation. This class implements the parts of
103 /// Objective-C support that are specific to the GNU family of runtimes (GCC,
104 /// GNUstep and ObjFW).
105 class CGObjCGNU : public CGObjCRuntime {
106 protected:
107  /// The LLVM module into which output is inserted
108  llvm::Module &TheModule;
109  /// strut objc_super. Used for sending messages to super. This structure
110  /// contains the receiver (object) and the expected class.
111  llvm::StructType *ObjCSuperTy;
112  /// struct objc_super*. The type of the argument to the superclass message
113  /// lookup functions.
114  llvm::PointerType *PtrToObjCSuperTy;
115  /// LLVM type for selectors. Opaque pointer (i8*) unless a header declaring
116  /// SEL is included in a header somewhere, in which case it will be whatever
117  /// type is declared in that header, most likely {i8*, i8*}.
118  llvm::PointerType *SelectorTy;
119  /// LLVM i8 type. Cached here to avoid repeatedly getting it in all of the
120  /// places where it's used
121  llvm::IntegerType *Int8Ty;
122  /// Pointer to i8 - LLVM type of char*, for all of the places where the
123  /// runtime needs to deal with C strings.
124  llvm::PointerType *PtrToInt8Ty;
125  /// struct objc_protocol type
126  llvm::StructType *ProtocolTy;
127  /// Protocol * type.
128  llvm::PointerType *ProtocolPtrTy;
129  /// Instance Method Pointer type. This is a pointer to a function that takes,
130  /// at a minimum, an object and a selector, and is the generic type for
131  /// Objective-C methods. Due to differences between variadic / non-variadic
132  /// calling conventions, it must always be cast to the correct type before
133  /// actually being used.
134  llvm::PointerType *IMPTy;
135  /// Type of an untyped Objective-C object. Clang treats id as a built-in type
136  /// when compiling Objective-C code, so this may be an opaque pointer (i8*),
137  /// but if the runtime header declaring it is included then it may be a
138  /// pointer to a structure.
139  llvm::PointerType *IdTy;
140  /// Pointer to a pointer to an Objective-C object. Used in the new ABI
141  /// message lookup function and some GC-related functions.
142  llvm::PointerType *PtrToIdTy;
143  /// The clang type of id. Used when using the clang CGCall infrastructure to
144  /// call Objective-C methods.
145  CanQualType ASTIdTy;
146  /// LLVM type for C int type.
147  llvm::IntegerType *IntTy;
148  /// LLVM type for an opaque pointer. This is identical to PtrToInt8Ty, but is
149  /// used in the code to document the difference between i8* meaning a pointer
150  /// to a C string and i8* meaning a pointer to some opaque type.
151  llvm::PointerType *PtrTy;
152  /// LLVM type for C long type. The runtime uses this in a lot of places where
153  /// it should be using intptr_t, but we can't fix this without breaking
154  /// compatibility with GCC...
155  llvm::IntegerType *LongTy;
156  /// LLVM type for C size_t. Used in various runtime data structures.
157  llvm::IntegerType *SizeTy;
158  /// LLVM type for C intptr_t.
159  llvm::IntegerType *IntPtrTy;
160  /// LLVM type for C ptrdiff_t. Mainly used in property accessor functions.
161  llvm::IntegerType *PtrDiffTy;
162  /// LLVM type for C int*. Used for GCC-ABI-compatible non-fragile instance
163  /// variables.
164  llvm::PointerType *PtrToIntTy;
165  /// LLVM type for Objective-C BOOL type.
166  llvm::Type *BoolTy;
167  /// 32-bit integer type, to save us needing to look it up every time it's used.
168  llvm::IntegerType *Int32Ty;
169  /// 64-bit integer type, to save us needing to look it up every time it's used.
170  llvm::IntegerType *Int64Ty;
171  /// The type of struct objc_property.
172  llvm::StructType *PropertyMetadataTy;
173  /// Metadata kind used to tie method lookups to message sends. The GNUstep
174  /// runtime provides some LLVM passes that can use this to do things like
175  /// automatic IMP caching and speculative inlining.
176  unsigned msgSendMDKind;
177  /// Does the current target use SEH-based exceptions? False implies
178  /// Itanium-style DWARF unwinding.
179  bool usesSEHExceptions;
180 
181  /// Helper to check if we are targeting a specific runtime version or later.
182  bool isRuntime(ObjCRuntime::Kind kind, unsigned major, unsigned minor=0) {
183  const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
184  return (R.getKind() == kind) &&
185  (R.getVersion() >= VersionTuple(major, minor));
186  }
187 
188  std::string SymbolForProtocol(StringRef Name) {
189  return (StringRef("._OBJC_PROTOCOL_") + Name).str();
190  }
191 
192  std::string SymbolForProtocolRef(StringRef Name) {
193  return (StringRef("._OBJC_REF_PROTOCOL_") + Name).str();
194  }
195 
196 
197  /// Helper function that generates a constant string and returns a pointer to
198  /// the start of the string. The result of this function can be used anywhere
199  /// where the C code specifies const char*.
200  llvm::Constant *MakeConstantString(StringRef Str, const char *Name = "") {
201  ConstantAddress Array = CGM.GetAddrOfConstantCString(Str, Name);
202  return llvm::ConstantExpr::getGetElementPtr(Array.getElementType(),
203  Array.getPointer(), Zeros);
204  }
205 
206  /// Emits a linkonce_odr string, whose name is the prefix followed by the
207  /// string value. This allows the linker to combine the strings between
208  /// different modules. Used for EH typeinfo names, selector strings, and a
209  /// few other things.
210  llvm::Constant *ExportUniqueString(const std::string &Str,
211  const std::string &prefix,
212  bool Private=false) {
213  std::string name = prefix + Str;
214  auto *ConstStr = TheModule.getGlobalVariable(name);
215  if (!ConstStr) {
216  llvm::Constant *value = llvm::ConstantDataArray::getString(VMContext,Str);
217  auto *GV = new llvm::GlobalVariable(TheModule, value->getType(), true,
218  llvm::GlobalValue::LinkOnceODRLinkage, value, name);
219  GV->setComdat(TheModule.getOrInsertComdat(name));
220  if (Private)
221  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
222  ConstStr = GV;
223  }
224  return llvm::ConstantExpr::getGetElementPtr(ConstStr->getValueType(),
225  ConstStr, Zeros);
226  }
227 
228  /// Returns a property name and encoding string.
229  llvm::Constant *MakePropertyEncodingString(const ObjCPropertyDecl *PD,
230  const Decl *Container) {
231  assert(!isRuntime(ObjCRuntime::GNUstep, 2));
232  if (isRuntime(ObjCRuntime::GNUstep, 1, 6)) {
233  std::string NameAndAttributes;
234  std::string TypeStr =
235  CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
236  NameAndAttributes += '\0';
237  NameAndAttributes += TypeStr.length() + 3;
238  NameAndAttributes += TypeStr;
239  NameAndAttributes += '\0';
240  NameAndAttributes += PD->getNameAsString();
241  return MakeConstantString(NameAndAttributes);
242  }
243  return MakeConstantString(PD->getNameAsString());
244  }
245 
246  /// Push the property attributes into two structure fields.
247  void PushPropertyAttributes(ConstantStructBuilder &Fields,
248  const ObjCPropertyDecl *property, bool isSynthesized=true, bool
249  isDynamic=true) {
250  int attrs = property->getPropertyAttributes();
251  // For read-only properties, clear the copy and retain flags
253  attrs &= ~ObjCPropertyDecl::OBJC_PR_copy;
254  attrs &= ~ObjCPropertyDecl::OBJC_PR_retain;
255  attrs &= ~ObjCPropertyDecl::OBJC_PR_weak;
256  attrs &= ~ObjCPropertyDecl::OBJC_PR_strong;
257  }
258  // The first flags field has the same attribute values as clang uses internally
259  Fields.addInt(Int8Ty, attrs & 0xff);
260  attrs >>= 8;
261  attrs <<= 2;
262  // For protocol properties, synthesized and dynamic have no meaning, so we
263  // reuse these flags to indicate that this is a protocol property (both set
264  // has no meaning, as a property can't be both synthesized and dynamic)
265  attrs |= isSynthesized ? (1<<0) : 0;
266  attrs |= isDynamic ? (1<<1) : 0;
267  // The second field is the next four fields left shifted by two, with the
268  // low bit set to indicate whether the field is synthesized or dynamic.
269  Fields.addInt(Int8Ty, attrs & 0xff);
270  // Two padding fields
271  Fields.addInt(Int8Ty, 0);
272  Fields.addInt(Int8Ty, 0);
273  }
274 
275  virtual llvm::Constant *GenerateCategoryProtocolList(const
276  ObjCCategoryDecl *OCD);
277  virtual ConstantArrayBuilder PushPropertyListHeader(ConstantStructBuilder &Fields,
278  int count) {
279  // int count;
280  Fields.addInt(IntTy, count);
281  // int size; (only in GNUstep v2 ABI.
282  if (isRuntime(ObjCRuntime::GNUstep, 2)) {
283  llvm::DataLayout td(&TheModule);
284  Fields.addInt(IntTy, td.getTypeSizeInBits(PropertyMetadataTy) /
285  CGM.getContext().getCharWidth());
286  }
287  // struct objc_property_list *next;
288  Fields.add(NULLPtr);
289  // struct objc_property properties[]
290  return Fields.beginArray(PropertyMetadataTy);
291  }
292  virtual void PushProperty(ConstantArrayBuilder &PropertiesArray,
293  const ObjCPropertyDecl *property,
294  const Decl *OCD,
295  bool isSynthesized=true, bool
296  isDynamic=true) {
297  auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy);
298  ASTContext &Context = CGM.getContext();
299  Fields.add(MakePropertyEncodingString(property, OCD));
300  PushPropertyAttributes(Fields, property, isSynthesized, isDynamic);
301  auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
302  if (accessor) {
303  std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor);
304  llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
305  Fields.add(MakeConstantString(accessor->getSelector().getAsString()));
306  Fields.add(TypeEncoding);
307  } else {
308  Fields.add(NULLPtr);
309  Fields.add(NULLPtr);
310  }
311  };
312  addPropertyMethod(property->getGetterMethodDecl());
313  addPropertyMethod(property->getSetterMethodDecl());
314  Fields.finishAndAddTo(PropertiesArray);
315  }
316 
317  /// Ensures that the value has the required type, by inserting a bitcast if
318  /// required. This function lets us avoid inserting bitcasts that are
319  /// redundant.
320  llvm::Value* EnforceType(CGBuilderTy &B, llvm::Value *V, llvm::Type *Ty) {
321  if (V->getType() == Ty) return V;
322  return B.CreateBitCast(V, Ty);
323  }
324  Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) {
325  if (V.getType() == Ty) return V;
326  return B.CreateBitCast(V, Ty);
327  }
328 
329  // Some zeros used for GEPs in lots of places.
330  llvm::Constant *Zeros[2];
331  /// Null pointer value. Mainly used as a terminator in various arrays.
332  llvm::Constant *NULLPtr;
333  /// LLVM context.
334  llvm::LLVMContext &VMContext;
335 
336 protected:
337 
338  /// Placeholder for the class. Lots of things refer to the class before we've
339  /// actually emitted it. We use this alias as a placeholder, and then replace
340  /// it with a pointer to the class structure before finally emitting the
341  /// module.
342  llvm::GlobalAlias *ClassPtrAlias;
343  /// Placeholder for the metaclass. Lots of things refer to the class before
344  /// we've / actually emitted it. We use this alias as a placeholder, and then
345  /// replace / it with a pointer to the metaclass structure before finally
346  /// emitting the / module.
347  llvm::GlobalAlias *MetaClassPtrAlias;
348  /// All of the classes that have been generated for this compilation units.
349  std::vector<llvm::Constant*> Classes;
350  /// All of the categories that have been generated for this compilation units.
351  std::vector<llvm::Constant*> Categories;
352  /// All of the Objective-C constant strings that have been generated for this
353  /// compilation units.
354  std::vector<llvm::Constant*> ConstantStrings;
355  /// Map from string values to Objective-C constant strings in the output.
356  /// Used to prevent emitting Objective-C strings more than once. This should
357  /// not be required at all - CodeGenModule should manage this list.
358  llvm::StringMap<llvm::Constant*> ObjCStrings;
359  /// All of the protocols that have been declared.
360  llvm::StringMap<llvm::Constant*> ExistingProtocols;
361  /// For each variant of a selector, we store the type encoding and a
362  /// placeholder value. For an untyped selector, the type will be the empty
363  /// string. Selector references are all done via the module's selector table,
364  /// so we create an alias as a placeholder and then replace it with the real
365  /// value later.
366  typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector;
367  /// Type of the selector map. This is roughly equivalent to the structure
368  /// used in the GNUstep runtime, which maintains a list of all of the valid
369  /// types for a selector in a table.
370  typedef llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> >
371  SelectorMap;
372  /// A map from selectors to selector types. This allows us to emit all
373  /// selectors of the same name and type together.
374  SelectorMap SelectorTable;
375 
376  /// Selectors related to memory management. When compiling in GC mode, we
377  /// omit these.
378  Selector RetainSel, ReleaseSel, AutoreleaseSel;
379  /// Runtime functions used for memory management in GC mode. Note that clang
380  /// supports code generation for calling these functions, but neither GNU
381  /// runtime actually supports this API properly yet.
382  LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn,
383  WeakAssignFn, GlobalAssignFn;
384 
385  typedef std::pair<std::string, std::string> ClassAliasPair;
386  /// All classes that have aliases set for them.
387  std::vector<ClassAliasPair> ClassAliases;
388 
389 protected:
390  /// Function used for throwing Objective-C exceptions.
391  LazyRuntimeFunction ExceptionThrowFn;
392  /// Function used for rethrowing exceptions, used at the end of \@finally or
393  /// \@synchronize blocks.
394  LazyRuntimeFunction ExceptionReThrowFn;
395  /// Function called when entering a catch function. This is required for
396  /// differentiating Objective-C exceptions and foreign exceptions.
397  LazyRuntimeFunction EnterCatchFn;
398  /// Function called when exiting from a catch block. Used to do exception
399  /// cleanup.
400  LazyRuntimeFunction ExitCatchFn;
401  /// Function called when entering an \@synchronize block. Acquires the lock.
402  LazyRuntimeFunction SyncEnterFn;
403  /// Function called when exiting an \@synchronize block. Releases the lock.
404  LazyRuntimeFunction SyncExitFn;
405 
406 private:
407  /// Function called if fast enumeration detects that the collection is
408  /// modified during the update.
409  LazyRuntimeFunction EnumerationMutationFn;
410  /// Function for implementing synthesized property getters that return an
411  /// object.
412  LazyRuntimeFunction GetPropertyFn;
413  /// Function for implementing synthesized property setters that return an
414  /// object.
415  LazyRuntimeFunction SetPropertyFn;
416  /// Function used for non-object declared property getters.
417  LazyRuntimeFunction GetStructPropertyFn;
418  /// Function used for non-object declared property setters.
419  LazyRuntimeFunction SetStructPropertyFn;
420 
421 protected:
422  /// The version of the runtime that this class targets. Must match the
423  /// version in the runtime.
424  int RuntimeVersion;
425  /// The version of the protocol class. Used to differentiate between ObjC1
426  /// and ObjC2 protocols. Objective-C 1 protocols can not contain optional
427  /// components and can not contain declared properties. We always emit
428  /// Objective-C 2 property structures, but we have to pretend that they're
429  /// Objective-C 1 property structures when targeting the GCC runtime or it
430  /// will abort.
431  const int ProtocolVersion;
432  /// The version of the class ABI. This value is used in the class structure
433  /// and indicates how various fields should be interpreted.
434  const int ClassABIVersion;
435  /// Generates an instance variable list structure. This is a structure
436  /// containing a size and an array of structures containing instance variable
437  /// metadata. This is used purely for introspection in the fragile ABI. In
438  /// the non-fragile ABI, it's used for instance variable fixup.
439  virtual llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
440  ArrayRef<llvm::Constant *> IvarTypes,
441  ArrayRef<llvm::Constant *> IvarOffsets,
442  ArrayRef<llvm::Constant *> IvarAlign,
443  ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership);
444 
445  /// Generates a method list structure. This is a structure containing a size
446  /// and an array of structures containing method metadata.
447  ///
448  /// This structure is used by both classes and categories, and contains a next
449  /// pointer allowing them to be chained together in a linked list.
450  llvm::Constant *GenerateMethodList(StringRef ClassName,
451  StringRef CategoryName,
453  bool isClassMethodList);
454 
455  /// Emits an empty protocol. This is used for \@protocol() where no protocol
456  /// is found. The runtime will (hopefully) fix up the pointer to refer to the
457  /// real protocol.
458  virtual llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName);
459 
460  /// Generates a list of property metadata structures. This follows the same
461  /// pattern as method and instance variable metadata lists.
462  llvm::Constant *GeneratePropertyList(const Decl *Container,
463  const ObjCContainerDecl *OCD,
464  bool isClassProperty=false,
465  bool protocolOptionalProperties=false);
466 
467  /// Generates a list of referenced protocols. Classes, categories, and
468  /// protocols all use this structure.
469  llvm::Constant *GenerateProtocolList(ArrayRef<std::string> Protocols);
470 
471  /// To ensure that all protocols are seen by the runtime, we add a category on
472  /// a class defined in the runtime, declaring no methods, but adopting the
473  /// protocols. This is a horribly ugly hack, but it allows us to collect all
474  /// of the protocols without changing the ABI.
475  void GenerateProtocolHolderCategory();
476 
477  /// Generates a class structure.
478  llvm::Constant *GenerateClassStructure(
479  llvm::Constant *MetaClass,
480  llvm::Constant *SuperClass,
481  unsigned info,
482  const char *Name,
483  llvm::Constant *Version,
484  llvm::Constant *InstanceSize,
485  llvm::Constant *IVars,
486  llvm::Constant *Methods,
487  llvm::Constant *Protocols,
488  llvm::Constant *IvarOffsets,
489  llvm::Constant *Properties,
490  llvm::Constant *StrongIvarBitmap,
491  llvm::Constant *WeakIvarBitmap,
492  bool isMeta=false);
493 
494  /// Generates a method list. This is used by protocols to define the required
495  /// and optional methods.
496  virtual llvm::Constant *GenerateProtocolMethodList(
498  /// Emits optional and required method lists.
499  template<class T>
500  void EmitProtocolMethodList(T &&Methods, llvm::Constant *&Required,
501  llvm::Constant *&Optional) {
504  for (const auto *I : Methods)
505  if (I->isOptional())
506  OptionalMethods.push_back(I);
507  else
508  RequiredMethods.push_back(I);
509  Required = GenerateProtocolMethodList(RequiredMethods);
510  Optional = GenerateProtocolMethodList(OptionalMethods);
511  }
512 
513  /// Returns a selector with the specified type encoding. An empty string is
514  /// used to return an untyped selector (with the types field set to NULL).
515  virtual llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
516  const std::string &TypeEncoding);
517 
518  /// Returns the name of ivar offset variables. In the GNUstep v1 ABI, this
519  /// contains the class and ivar names, in the v2 ABI this contains the type
520  /// encoding as well.
521  virtual std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
522  const ObjCIvarDecl *Ivar) {
523  const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
524  + '.' + Ivar->getNameAsString();
525  return Name;
526  }
527  /// Returns the variable used to store the offset of an instance variable.
528  llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
529  const ObjCIvarDecl *Ivar);
530  /// Emits a reference to a class. This allows the linker to object if there
531  /// is no class of the matching name.
532  void EmitClassRef(const std::string &className);
533 
534  /// Emits a pointer to the named class
535  virtual llvm::Value *GetClassNamed(CodeGenFunction &CGF,
536  const std::string &Name, bool isWeak);
537 
538  /// Looks up the method for sending a message to the specified object. This
539  /// mechanism differs between the GCC and GNU runtimes, so this method must be
540  /// overridden in subclasses.
541  virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
542  llvm::Value *&Receiver,
543  llvm::Value *cmd,
544  llvm::MDNode *node,
545  MessageSendInfo &MSI) = 0;
546 
547  /// Looks up the method for sending a message to a superclass. This
548  /// mechanism differs between the GCC and GNU runtimes, so this method must
549  /// be overridden in subclasses.
550  virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
551  Address ObjCSuper,
552  llvm::Value *cmd,
553  MessageSendInfo &MSI) = 0;
554 
555  /// Libobjc2 uses a bitfield representation where small(ish) bitfields are
556  /// stored in a 64-bit value with the low bit set to 1 and the remaining 63
557  /// bits set to their values, LSB first, while larger ones are stored in a
558  /// structure of this / form:
559  ///
560  /// struct { int32_t length; int32_t values[length]; };
561  ///
562  /// The values in the array are stored in host-endian format, with the least
563  /// significant bit being assumed to come first in the bitfield. Therefore,
564  /// a bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] },
565  /// while a bitfield / with the 63rd bit set will be 1<<64.
566  llvm::Constant *MakeBitField(ArrayRef<bool> bits);
567 
568 public:
569  CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
570  unsigned protocolClassVersion, unsigned classABI=1);
571 
572  ConstantAddress GenerateConstantString(const StringLiteral *) override;
573 
574  RValue
575  GenerateMessageSend(CodeGenFunction &CGF, ReturnValueSlot Return,
576  QualType ResultType, Selector Sel,
577  llvm::Value *Receiver, const CallArgList &CallArgs,
578  const ObjCInterfaceDecl *Class,
579  const ObjCMethodDecl *Method) override;
580  RValue
581  GenerateMessageSendSuper(CodeGenFunction &CGF, ReturnValueSlot Return,
582  QualType ResultType, Selector Sel,
583  const ObjCInterfaceDecl *Class,
584  bool isCategoryImpl, llvm::Value *Receiver,
585  bool IsClassMessage, const CallArgList &CallArgs,
586  const ObjCMethodDecl *Method) override;
587  llvm::Value *GetClass(CodeGenFunction &CGF,
588  const ObjCInterfaceDecl *OID) override;
589  llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
590  Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
591  llvm::Value *GetSelector(CodeGenFunction &CGF,
592  const ObjCMethodDecl *Method) override;
593  virtual llvm::Constant *GetConstantSelector(Selector Sel,
594  const std::string &TypeEncoding) {
595  llvm_unreachable("Runtime unable to generate constant selector");
596  }
597  llvm::Constant *GetConstantSelector(const ObjCMethodDecl *M) {
598  return GetConstantSelector(M->getSelector(),
600  }
601  llvm::Constant *GetEHType(QualType T) override;
602 
603  llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
604  const ObjCContainerDecl *CD) override;
605  void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
606  void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
607  void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override;
608  llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
609  const ObjCProtocolDecl *PD) override;
610  void GenerateProtocol(const ObjCProtocolDecl *PD) override;
611  llvm::Function *ModuleInitFunction() override;
612  llvm::FunctionCallee GetPropertyGetFunction() override;
613  llvm::FunctionCallee GetPropertySetFunction() override;
614  llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
615  bool copy) override;
616  llvm::FunctionCallee GetSetStructFunction() override;
617  llvm::FunctionCallee GetGetStructFunction() override;
618  llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
619  llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
620  llvm::FunctionCallee EnumerationMutationFunction() override;
621 
622  void EmitTryStmt(CodeGenFunction &CGF,
623  const ObjCAtTryStmt &S) override;
624  void EmitSynchronizedStmt(CodeGenFunction &CGF,
625  const ObjCAtSynchronizedStmt &S) override;
626  void EmitThrowStmt(CodeGenFunction &CGF,
627  const ObjCAtThrowStmt &S,
628  bool ClearInsertionPoint=true) override;
629  llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF,
630  Address AddrWeakObj) override;
631  void EmitObjCWeakAssign(CodeGenFunction &CGF,
632  llvm::Value *src, Address dst) override;
633  void EmitObjCGlobalAssign(CodeGenFunction &CGF,
634  llvm::Value *src, Address dest,
635  bool threadlocal=false) override;
636  void EmitObjCIvarAssign(CodeGenFunction &CGF, llvm::Value *src,
637  Address dest, llvm::Value *ivarOffset) override;
638  void EmitObjCStrongCastAssign(CodeGenFunction &CGF,
639  llvm::Value *src, Address dest) override;
640  void EmitGCMemmoveCollectable(CodeGenFunction &CGF, Address DestPtr,
641  Address SrcPtr,
642  llvm::Value *Size) override;
643  LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy,
644  llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
645  unsigned CVRQualifiers) override;
646  llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
647  const ObjCInterfaceDecl *Interface,
648  const ObjCIvarDecl *Ivar) override;
649  llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
650  llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM,
651  const CGBlockInfo &blockInfo) override {
652  return NULLPtr;
653  }
654  llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM,
655  const CGBlockInfo &blockInfo) override {
656  return NULLPtr;
657  }
658 
659  llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override {
660  return NULLPtr;
661  }
662 };
663 
664 /// Class representing the legacy GCC Objective-C ABI. This is the default when
665 /// -fobjc-nonfragile-abi is not specified.
666 ///
667 /// The GCC ABI target actually generates code that is approximately compatible
668 /// with the new GNUstep runtime ABI, but refrains from using any features that
669 /// would not work with the GCC runtime. For example, clang always generates
670 /// the extended form of the class structure, and the extra fields are simply
671 /// ignored by GCC libobjc.
672 class CGObjCGCC : public CGObjCGNU {
673  /// The GCC ABI message lookup function. Returns an IMP pointing to the
674  /// method implementation for this message.
675  LazyRuntimeFunction MsgLookupFn;
676  /// The GCC ABI superclass message lookup function. Takes a pointer to a
677  /// structure describing the receiver and the class, and a selector as
678  /// arguments. Returns the IMP for the corresponding method.
679  LazyRuntimeFunction MsgLookupSuperFn;
680 
681 protected:
682  llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
683  llvm::Value *cmd, llvm::MDNode *node,
684  MessageSendInfo &MSI) override {
685  CGBuilderTy &Builder = CGF.Builder;
686  llvm::Value *args[] = {
687  EnforceType(Builder, Receiver, IdTy),
688  EnforceType(Builder, cmd, SelectorTy) };
689  llvm::CallBase *imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
690  imp->setMetadata(msgSendMDKind, node);
691  return imp;
692  }
693 
694  llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
695  llvm::Value *cmd, MessageSendInfo &MSI) override {
696  CGBuilderTy &Builder = CGF.Builder;
697  llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper,
698  PtrToObjCSuperTy).getPointer(), cmd};
699  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
700  }
701 
702 public:
703  CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) {
704  // IMP objc_msg_lookup(id, SEL);
705  MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy);
706  // IMP objc_msg_lookup_super(struct objc_super*, SEL);
707  MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
708  PtrToObjCSuperTy, SelectorTy);
709  }
710 };
711 
712 /// Class used when targeting the new GNUstep runtime ABI.
713 class CGObjCGNUstep : public CGObjCGNU {
714  /// The slot lookup function. Returns a pointer to a cacheable structure
715  /// that contains (among other things) the IMP.
716  LazyRuntimeFunction SlotLookupFn;
717  /// The GNUstep ABI superclass message lookup function. Takes a pointer to
718  /// a structure describing the receiver and the class, and a selector as
719  /// arguments. Returns the slot for the corresponding method. Superclass
720  /// message lookup rarely changes, so this is a good caching opportunity.
721  LazyRuntimeFunction SlotLookupSuperFn;
722  /// Specialised function for setting atomic retain properties
723  LazyRuntimeFunction SetPropertyAtomic;
724  /// Specialised function for setting atomic copy properties
725  LazyRuntimeFunction SetPropertyAtomicCopy;
726  /// Specialised function for setting nonatomic retain properties
727  LazyRuntimeFunction SetPropertyNonAtomic;
728  /// Specialised function for setting nonatomic copy properties
729  LazyRuntimeFunction SetPropertyNonAtomicCopy;
730  /// Function to perform atomic copies of C++ objects with nontrivial copy
731  /// constructors from Objective-C ivars.
732  LazyRuntimeFunction CxxAtomicObjectGetFn;
733  /// Function to perform atomic copies of C++ objects with nontrivial copy
734  /// constructors to Objective-C ivars.
735  LazyRuntimeFunction CxxAtomicObjectSetFn;
736  /// Type of an slot structure pointer. This is returned by the various
737  /// lookup functions.
738  llvm::Type *SlotTy;
739 
740  public:
741  llvm::Constant *GetEHType(QualType T) override;
742 
743  protected:
744  llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
745  llvm::Value *cmd, llvm::MDNode *node,
746  MessageSendInfo &MSI) override {
747  CGBuilderTy &Builder = CGF.Builder;
748  llvm::FunctionCallee LookupFn = SlotLookupFn;
749 
750  // Store the receiver on the stack so that we can reload it later
751  Address ReceiverPtr =
752  CGF.CreateTempAlloca(Receiver->getType(), CGF.getPointerAlign());
753  Builder.CreateStore(Receiver, ReceiverPtr);
754 
755  llvm::Value *self;
756 
757  if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) {
758  self = CGF.LoadObjCSelf();
759  } else {
760  self = llvm::ConstantPointerNull::get(IdTy);
761  }
762 
763  // The lookup function is guaranteed not to capture the receiver pointer.
764  if (auto *LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee()))
765  LookupFn2->addParamAttr(0, llvm::Attribute::NoCapture);
766 
767  llvm::Value *args[] = {
768  EnforceType(Builder, ReceiverPtr.getPointer(), PtrToIdTy),
769  EnforceType(Builder, cmd, SelectorTy),
770  EnforceType(Builder, self, IdTy) };
771  llvm::CallBase *slot = CGF.EmitRuntimeCallOrInvoke(LookupFn, args);
772  slot->setOnlyReadsMemory();
773  slot->setMetadata(msgSendMDKind, node);
774 
775  // Load the imp from the slot
776  llvm::Value *imp = Builder.CreateAlignedLoad(
777  Builder.CreateStructGEP(nullptr, slot, 4), CGF.getPointerAlign());
778 
779  // The lookup function may have changed the receiver, so make sure we use
780  // the new one.
781  Receiver = Builder.CreateLoad(ReceiverPtr, true);
782  return imp;
783  }
784 
785  llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
786  llvm::Value *cmd,
787  MessageSendInfo &MSI) override {
788  CGBuilderTy &Builder = CGF.Builder;
789  llvm::Value *lookupArgs[] = {ObjCSuper.getPointer(), cmd};
790 
791  llvm::CallInst *slot =
792  CGF.EmitNounwindRuntimeCall(SlotLookupSuperFn, lookupArgs);
793  slot->setOnlyReadsMemory();
794 
795  return Builder.CreateAlignedLoad(Builder.CreateStructGEP(nullptr, slot, 4),
796  CGF.getPointerAlign());
797  }
798 
799  public:
800  CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 9, 3, 1) {}
801  CGObjCGNUstep(CodeGenModule &Mod, unsigned ABI, unsigned ProtocolABI,
802  unsigned ClassABI) :
803  CGObjCGNU(Mod, ABI, ProtocolABI, ClassABI) {
804  const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
805 
806  llvm::StructType *SlotStructTy =
807  llvm::StructType::get(PtrTy, PtrTy, PtrTy, IntTy, IMPTy);
808  SlotTy = llvm::PointerType::getUnqual(SlotStructTy);
809  // Slot_t objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
810  SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy,
811  SelectorTy, IdTy);
812  // Slot_t objc_slot_lookup_super(struct objc_super*, SEL);
813  SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy,
814  PtrToObjCSuperTy, SelectorTy);
815  // If we're in ObjC++ mode, then we want to make
816  if (usesSEHExceptions) {
817  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
818  // void objc_exception_rethrow(void)
819  ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy);
820  } else if (CGM.getLangOpts().CPlusPlus) {
821  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
822  // void *__cxa_begin_catch(void *e)
823  EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy);
824  // void __cxa_end_catch(void)
825  ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy);
826  // void _Unwind_Resume_or_Rethrow(void*)
827  ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy,
828  PtrTy);
829  } else if (R.getVersion() >= VersionTuple(1, 7)) {
830  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
831  // id objc_begin_catch(void *e)
832  EnterCatchFn.init(&CGM, "objc_begin_catch", IdTy, PtrTy);
833  // void objc_end_catch(void)
834  ExitCatchFn.init(&CGM, "objc_end_catch", VoidTy);
835  // void _Unwind_Resume_or_Rethrow(void*)
836  ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy, PtrTy);
837  }
838  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
839  SetPropertyAtomic.init(&CGM, "objc_setProperty_atomic", VoidTy, IdTy,
840  SelectorTy, IdTy, PtrDiffTy);
841  SetPropertyAtomicCopy.init(&CGM, "objc_setProperty_atomic_copy", VoidTy,
842  IdTy, SelectorTy, IdTy, PtrDiffTy);
843  SetPropertyNonAtomic.init(&CGM, "objc_setProperty_nonatomic", VoidTy,
844  IdTy, SelectorTy, IdTy, PtrDiffTy);
845  SetPropertyNonAtomicCopy.init(&CGM, "objc_setProperty_nonatomic_copy",
846  VoidTy, IdTy, SelectorTy, IdTy, PtrDiffTy);
847  // void objc_setCppObjectAtomic(void *dest, const void *src, void
848  // *helper);
849  CxxAtomicObjectSetFn.init(&CGM, "objc_setCppObjectAtomic", VoidTy, PtrTy,
850  PtrTy, PtrTy);
851  // void objc_getCppObjectAtomic(void *dest, const void *src, void
852  // *helper);
853  CxxAtomicObjectGetFn.init(&CGM, "objc_getCppObjectAtomic", VoidTy, PtrTy,
854  PtrTy, PtrTy);
855  }
856 
857  llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
858  // The optimised functions were added in version 1.7 of the GNUstep
859  // runtime.
860  assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
861  VersionTuple(1, 7));
862  return CxxAtomicObjectGetFn;
863  }
864 
865  llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
866  // The optimised functions were added in version 1.7 of the GNUstep
867  // runtime.
868  assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
869  VersionTuple(1, 7));
870  return CxxAtomicObjectSetFn;
871  }
872 
873  llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
874  bool copy) override {
875  // The optimised property functions omit the GC check, and so are not
876  // safe to use in GC mode. The standard functions are fast in GC mode,
877  // so there is less advantage in using them.
878  assert ((CGM.getLangOpts().getGC() == LangOptions::NonGC));
879  // The optimised functions were added in version 1.7 of the GNUstep
880  // runtime.
881  assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
882  VersionTuple(1, 7));
883 
884  if (atomic) {
885  if (copy) return SetPropertyAtomicCopy;
886  return SetPropertyAtomic;
887  }
888 
889  return copy ? SetPropertyNonAtomicCopy : SetPropertyNonAtomic;
890  }
891 };
892 
893 /// GNUstep Objective-C ABI version 2 implementation.
894 /// This is the ABI that provides a clean break with the legacy GCC ABI and
895 /// cleans up a number of things that were added to work around 1980s linkers.
896 class CGObjCGNUstep2 : public CGObjCGNUstep {
897  enum SectionKind
898  {
899  SelectorSection = 0,
900  ClassSection,
901  ClassReferenceSection,
902  CategorySection,
903  ProtocolSection,
904  ProtocolReferenceSection,
905  ClassAliasSection,
906  ConstantStringSection
907  };
908  static const char *const SectionsBaseNames[8];
909  template<SectionKind K>
910  std::string sectionName() {
911  std::string name(SectionsBaseNames[K]);
912  if (CGM.getTriple().isOSBinFormatCOFF())
913  name += "$m";
914  return name;
915  }
916  /// The GCC ABI superclass message lookup function. Takes a pointer to a
917  /// structure describing the receiver and the class, and a selector as
918  /// arguments. Returns the IMP for the corresponding method.
919  LazyRuntimeFunction MsgLookupSuperFn;
920  /// A flag indicating if we've emitted at least one protocol.
921  /// If we haven't, then we need to emit an empty protocol, to ensure that the
922  /// __start__objc_protocols and __stop__objc_protocols sections exist.
923  bool EmittedProtocol = false;
924  /// A flag indicating if we've emitted at least one protocol reference.
925  /// If we haven't, then we need to emit an empty protocol, to ensure that the
926  /// __start__objc_protocol_refs and __stop__objc_protocol_refs sections
927  /// exist.
928  bool EmittedProtocolRef = false;
929  /// A flag indicating if we've emitted at least one class.
930  /// If we haven't, then we need to emit an empty protocol, to ensure that the
931  /// __start__objc_classes and __stop__objc_classes sections / exist.
932  bool EmittedClass = false;
933  /// Generate the name of a symbol for a reference to a class. Accesses to
934  /// classes should be indirected via this.
935  std::string SymbolForClassRef(StringRef Name, bool isWeak) {
936  if (isWeak)
937  return (StringRef("._OBJC_WEAK_REF_CLASS_") + Name).str();
938  else
939  return (StringRef("._OBJC_REF_CLASS_") + Name).str();
940  }
941  /// Generate the name of a class symbol.
942  std::string SymbolForClass(StringRef Name) {
943  return (StringRef("._OBJC_CLASS_") + Name).str();
944  }
945  void CallRuntimeFunction(CGBuilderTy &B, StringRef FunctionName,
946  ArrayRef<llvm::Value*> Args) {
948  for (auto *Arg : Args)
949  Types.push_back(Arg->getType());
950  llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types,
951  false);
952  llvm::FunctionCallee Fn = CGM.CreateRuntimeFunction(FT, FunctionName);
953  B.CreateCall(Fn, Args);
954  }
955 
956  ConstantAddress GenerateConstantString(const StringLiteral *SL) override {
957 
958  auto Str = SL->getString();
959  CharUnits Align = CGM.getPointerAlign();
960 
961  // Look for an existing one
962  llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
963  if (old != ObjCStrings.end())
964  return ConstantAddress(old->getValue(), Align);
965 
966  bool isNonASCII = SL->containsNonAscii();
967 
968  auto LiteralLength = SL->getLength();
969 
970  if ((CGM.getTarget().getPointerWidth(0) == 64) &&
971  (LiteralLength < 9) && !isNonASCII) {
972  // Tiny strings are only used on 64-bit platforms. They store 8 7-bit
973  // ASCII characters in the high 56 bits, followed by a 4-bit length and a
974  // 3-bit tag (which is always 4).
975  uint64_t str = 0;
976  // Fill in the characters
977  for (unsigned i=0 ; i<LiteralLength ; i++)
978  str |= ((uint64_t)SL->getCodeUnit(i)) << ((64 - 4 - 3) - (i*7));
979  // Fill in the length
980  str |= LiteralLength << 3;
981  // Set the tag
982  str |= 4;
983  auto *ObjCStr = llvm::ConstantExpr::getIntToPtr(
984  llvm::ConstantInt::get(Int64Ty, str), IdTy);
985  ObjCStrings[Str] = ObjCStr;
986  return ConstantAddress(ObjCStr, Align);
987  }
988 
989  StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
990 
991  if (StringClass.empty()) StringClass = "NSConstantString";
992 
993  std::string Sym = SymbolForClass(StringClass);
994 
995  llvm::Constant *isa = TheModule.getNamedGlobal(Sym);
996 
997  if (!isa)
998  isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
999  llvm::GlobalValue::ExternalLinkage, nullptr, Sym);
1000  else if (isa->getType() != PtrToIdTy)
1001  isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy);
1002 
1003  // struct
1004  // {
1005  // Class isa;
1006  // uint32_t flags;
1007  // uint32_t length; // Number of codepoints
1008  // uint32_t size; // Number of bytes
1009  // uint32_t hash;
1010  // const char *data;
1011  // };
1012 
1013  ConstantInitBuilder Builder(CGM);
1014  auto Fields = Builder.beginStruct();
1015  Fields.add(isa);
1016  // For now, all non-ASCII strings are represented as UTF-16. As such, the
1017  // number of bytes is simply double the number of UTF-16 codepoints. In
1018  // ASCII strings, the number of bytes is equal to the number of non-ASCII
1019  // codepoints.
1020  if (isNonASCII) {
1021  unsigned NumU8CodeUnits = Str.size();
1022  // A UTF-16 representation of a unicode string contains at most the same
1023  // number of code units as a UTF-8 representation. Allocate that much
1024  // space, plus one for the final null character.
1025  SmallVector<llvm::UTF16, 128> ToBuf(NumU8CodeUnits + 1);
1026  const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)Str.data();
1027  llvm::UTF16 *ToPtr = &ToBuf[0];
1028  (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumU8CodeUnits,
1029  &ToPtr, ToPtr + NumU8CodeUnits, llvm::strictConversion);
1030  uint32_t StringLength = ToPtr - &ToBuf[0];
1031  // Add null terminator
1032  *ToPtr = 0;
1033  // Flags: 2 indicates UTF-16 encoding
1034  Fields.addInt(Int32Ty, 2);
1035  // Number of UTF-16 codepoints
1036  Fields.addInt(Int32Ty, StringLength);
1037  // Number of bytes
1038  Fields.addInt(Int32Ty, StringLength * 2);
1039  // Hash. Not currently initialised by the compiler.
1040  Fields.addInt(Int32Ty, 0);
1041  // pointer to the data string.
1042  auto Arr = llvm::makeArrayRef(&ToBuf[0], ToPtr+1);
1043  auto *C = llvm::ConstantDataArray::get(VMContext, Arr);
1044  auto *Buffer = new llvm::GlobalVariable(TheModule, C->getType(),
1045  /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, C, ".str");
1046  Buffer->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1047  Fields.add(Buffer);
1048  } else {
1049  // Flags: 0 indicates ASCII encoding
1050  Fields.addInt(Int32Ty, 0);
1051  // Number of UTF-16 codepoints, each ASCII byte is a UTF-16 codepoint
1052  Fields.addInt(Int32Ty, Str.size());
1053  // Number of bytes
1054  Fields.addInt(Int32Ty, Str.size());
1055  // Hash. Not currently initialised by the compiler.
1056  Fields.addInt(Int32Ty, 0);
1057  // Data pointer
1058  Fields.add(MakeConstantString(Str));
1059  }
1060  std::string StringName;
1061  bool isNamed = !isNonASCII;
1062  if (isNamed) {
1063  StringName = ".objc_str_";
1064  for (int i=0,e=Str.size() ; i<e ; ++i) {
1065  unsigned char c = Str[i];
1066  if (isalnum(c))
1067  StringName += c;
1068  else if (c == ' ')
1069  StringName += '_';
1070  else {
1071  isNamed = false;
1072  break;
1073  }
1074  }
1075  }
1076  auto *ObjCStrGV =
1077  Fields.finishAndCreateGlobal(
1078  isNamed ? StringRef(StringName) : ".objc_string",
1079  Align, false, isNamed ? llvm::GlobalValue::LinkOnceODRLinkage
1080  : llvm::GlobalValue::PrivateLinkage);
1081  ObjCStrGV->setSection(sectionName<ConstantStringSection>());
1082  if (isNamed) {
1083  ObjCStrGV->setComdat(TheModule.getOrInsertComdat(StringName));
1084  ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1085  }
1086  llvm::Constant *ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStrGV, IdTy);
1087  ObjCStrings[Str] = ObjCStr;
1088  ConstantStrings.push_back(ObjCStr);
1089  return ConstantAddress(ObjCStr, Align);
1090  }
1091 
1092  void PushProperty(ConstantArrayBuilder &PropertiesArray,
1093  const ObjCPropertyDecl *property,
1094  const Decl *OCD,
1095  bool isSynthesized=true, bool
1096  isDynamic=true) override {
1097  // struct objc_property
1098  // {
1099  // const char *name;
1100  // const char *attributes;
1101  // const char *type;
1102  // SEL getter;
1103  // SEL setter;
1104  // };
1105  auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy);
1106  ASTContext &Context = CGM.getContext();
1107  Fields.add(MakeConstantString(property->getNameAsString()));
1108  std::string TypeStr =
1109  CGM.getContext().getObjCEncodingForPropertyDecl(property, OCD);
1110  Fields.add(MakeConstantString(TypeStr));
1111  std::string typeStr;
1112  Context.getObjCEncodingForType(property->getType(), typeStr);
1113  Fields.add(MakeConstantString(typeStr));
1114  auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
1115  if (accessor) {
1116  std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor);
1117  Fields.add(GetConstantSelector(accessor->getSelector(), TypeStr));
1118  } else {
1119  Fields.add(NULLPtr);
1120  }
1121  };
1122  addPropertyMethod(property->getGetterMethodDecl());
1123  addPropertyMethod(property->getSetterMethodDecl());
1124  Fields.finishAndAddTo(PropertiesArray);
1125  }
1126 
1127  llvm::Constant *
1128  GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) override {
1129  // struct objc_protocol_method_description
1130  // {
1131  // SEL selector;
1132  // const char *types;
1133  // };
1134  llvm::StructType *ObjCMethodDescTy =
1135  llvm::StructType::get(CGM.getLLVMContext(),
1136  { PtrToInt8Ty, PtrToInt8Ty });
1137  ASTContext &Context = CGM.getContext();
1138  ConstantInitBuilder Builder(CGM);
1139  // struct objc_protocol_method_description_list
1140  // {
1141  // int count;
1142  // int size;
1143  // struct objc_protocol_method_description methods[];
1144  // };
1145  auto MethodList = Builder.beginStruct();
1146  // int count;
1147  MethodList.addInt(IntTy, Methods.size());
1148  // int size; // sizeof(struct objc_method_description)
1149  llvm::DataLayout td(&TheModule);
1150  MethodList.addInt(IntTy, td.getTypeSizeInBits(ObjCMethodDescTy) /
1151  CGM.getContext().getCharWidth());
1152  // struct objc_method_description[]
1153  auto MethodArray = MethodList.beginArray(ObjCMethodDescTy);
1154  for (auto *M : Methods) {
1155  auto Method = MethodArray.beginStruct(ObjCMethodDescTy);
1156  Method.add(CGObjCGNU::GetConstantSelector(M));
1157  Method.add(GetTypeString(Context.getObjCEncodingForMethodDecl(M, true)));
1158  Method.finishAndAddTo(MethodArray);
1159  }
1160  MethodArray.finishAndAddTo(MethodList);
1161  return MethodList.finishAndCreateGlobal(".objc_protocol_method_list",
1162  CGM.getPointerAlign());
1163  }
1164  llvm::Constant *GenerateCategoryProtocolList(const ObjCCategoryDecl *OCD)
1165  override {
1167  for (const auto *PI : OCD->getReferencedProtocols())
1168  Protocols.push_back(
1169  llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI),
1170  ProtocolPtrTy));
1171  return GenerateProtocolList(Protocols);
1172  }
1173 
1174  llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
1175  llvm::Value *cmd, MessageSendInfo &MSI) override {
1176  // Don't access the slot unless we're trying to cache the result.
1177  CGBuilderTy &Builder = CGF.Builder;
1178  llvm::Value *lookupArgs[] = {CGObjCGNU::EnforceType(Builder, ObjCSuper,
1179  PtrToObjCSuperTy).getPointer(), cmd};
1180  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
1181  }
1182 
1183  llvm::GlobalVariable *GetClassVar(StringRef Name, bool isWeak=false) {
1184  std::string SymbolName = SymbolForClassRef(Name, isWeak);
1185  auto *ClassSymbol = TheModule.getNamedGlobal(SymbolName);
1186  if (ClassSymbol)
1187  return ClassSymbol;
1188  ClassSymbol = new llvm::GlobalVariable(TheModule,
1190  nullptr, SymbolName);
1191  // If this is a weak symbol, then we are creating a valid definition for
1192  // the symbol, pointing to a weak definition of the real class pointer. If
1193  // this is not a weak reference, then we are expecting another compilation
1194  // unit to provide the real indirection symbol.
1195  if (isWeak)
1196  ClassSymbol->setInitializer(new llvm::GlobalVariable(TheModule,
1197  Int8Ty, false, llvm::GlobalValue::ExternalWeakLinkage,
1198  nullptr, SymbolForClass(Name)));
1199  assert(ClassSymbol->getName() == SymbolName);
1200  return ClassSymbol;
1201  }
1202  llvm::Value *GetClassNamed(CodeGenFunction &CGF,
1203  const std::string &Name,
1204  bool isWeak) override {
1205  return CGF.Builder.CreateLoad(Address(GetClassVar(Name, isWeak),
1206  CGM.getPointerAlign()));
1207  }
1208  int32_t FlagsForOwnership(Qualifiers::ObjCLifetime Ownership) {
1209  // typedef enum {
1210  // ownership_invalid = 0,
1211  // ownership_strong = 1,
1212  // ownership_weak = 2,
1213  // ownership_unsafe = 3
1214  // } ivar_ownership;
1215  int Flag;
1216  switch (Ownership) {
1218  Flag = 1;
1219  break;
1220  case Qualifiers::OCL_Weak:
1221  Flag = 2;
1222  break;
1224  Flag = 3;
1225  break;
1226  case Qualifiers::OCL_None:
1228  assert(Ownership != Qualifiers::OCL_Autoreleasing);
1229  Flag = 0;
1230  }
1231  return Flag;
1232  }
1233  llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
1234  ArrayRef<llvm::Constant *> IvarTypes,
1235  ArrayRef<llvm::Constant *> IvarOffsets,
1236  ArrayRef<llvm::Constant *> IvarAlign,
1237  ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) override {
1238  llvm_unreachable("Method should not be called!");
1239  }
1240 
1241  llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName) override {
1242  std::string Name = SymbolForProtocol(ProtocolName);
1243  auto *GV = TheModule.getGlobalVariable(Name);
1244  if (!GV) {
1245  // Emit a placeholder symbol.
1246  GV = new llvm::GlobalVariable(TheModule, ProtocolTy, false,
1247  llvm::GlobalValue::ExternalLinkage, nullptr, Name);
1248  GV->setAlignment(CGM.getPointerAlign().getQuantity());
1249  }
1250  return llvm::ConstantExpr::getBitCast(GV, ProtocolPtrTy);
1251  }
1252 
1253  /// Existing protocol references.
1254  llvm::StringMap<llvm::Constant*> ExistingProtocolRefs;
1255 
1256  llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1257  const ObjCProtocolDecl *PD) override {
1258  auto Name = PD->getNameAsString();
1259  auto *&Ref = ExistingProtocolRefs[Name];
1260  if (!Ref) {
1261  auto *&Protocol = ExistingProtocols[Name];
1262  if (!Protocol)
1263  Protocol = GenerateProtocolRef(PD);
1264  std::string RefName = SymbolForProtocolRef(Name);
1265  assert(!TheModule.getGlobalVariable(RefName));
1266  // Emit a reference symbol.
1267  auto GV = new llvm::GlobalVariable(TheModule, ProtocolPtrTy,
1268  false, llvm::GlobalValue::LinkOnceODRLinkage,
1269  llvm::ConstantExpr::getBitCast(Protocol, ProtocolPtrTy), RefName);
1270  GV->setComdat(TheModule.getOrInsertComdat(RefName));
1271  GV->setSection(sectionName<ProtocolReferenceSection>());
1272  GV->setAlignment(CGM.getPointerAlign().getQuantity());
1273  Ref = GV;
1274  }
1275  EmittedProtocolRef = true;
1276  return CGF.Builder.CreateAlignedLoad(Ref, CGM.getPointerAlign());
1277  }
1278 
1279  llvm::Constant *GenerateProtocolList(ArrayRef<llvm::Constant*> Protocols) {
1280  llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(ProtocolPtrTy,
1281  Protocols.size());
1282  llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1283  Protocols);
1284  ConstantInitBuilder builder(CGM);
1285  auto ProtocolBuilder = builder.beginStruct();
1286  ProtocolBuilder.addNullPointer(PtrTy);
1287  ProtocolBuilder.addInt(SizeTy, Protocols.size());
1288  ProtocolBuilder.add(ProtocolArray);
1289  return ProtocolBuilder.finishAndCreateGlobal(".objc_protocol_list",
1291  }
1292 
1293  void GenerateProtocol(const ObjCProtocolDecl *PD) override {
1294  // Do nothing - we only emit referenced protocols.
1295  }
1296  llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD) {
1297  std::string ProtocolName = PD->getNameAsString();
1298  auto *&Protocol = ExistingProtocols[ProtocolName];
1299  if (Protocol)
1300  return Protocol;
1301 
1302  EmittedProtocol = true;
1303 
1304  auto SymName = SymbolForProtocol(ProtocolName);
1305  auto *OldGV = TheModule.getGlobalVariable(SymName);
1306 
1307  // Use the protocol definition, if there is one.
1308  if (const ObjCProtocolDecl *Def = PD->getDefinition())
1309  PD = Def;
1310  else {
1311  // If there is no definition, then create an external linkage symbol and
1312  // hope that someone else fills it in for us (and fail to link if they
1313  // don't).
1314  assert(!OldGV);
1315  Protocol = new llvm::GlobalVariable(TheModule, ProtocolTy,
1316  /*isConstant*/false,
1317  llvm::GlobalValue::ExternalLinkage, nullptr, SymName);
1318  return Protocol;
1319  }
1320 
1322  for (const auto *PI : PD->protocols())
1323  Protocols.push_back(
1324  llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI),
1325  ProtocolPtrTy));
1326  llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
1327 
1328  // Collect information about methods
1329  llvm::Constant *InstanceMethodList, *OptionalInstanceMethodList;
1330  llvm::Constant *ClassMethodList, *OptionalClassMethodList;
1331  EmitProtocolMethodList(PD->instance_methods(), InstanceMethodList,
1332  OptionalInstanceMethodList);
1333  EmitProtocolMethodList(PD->class_methods(), ClassMethodList,
1334  OptionalClassMethodList);
1335 
1336  // The isa pointer must be set to a magic number so the runtime knows it's
1337  // the correct layout.
1338  ConstantInitBuilder builder(CGM);
1339  auto ProtocolBuilder = builder.beginStruct();
1340  ProtocolBuilder.add(llvm::ConstantExpr::getIntToPtr(
1341  llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
1342  ProtocolBuilder.add(MakeConstantString(ProtocolName));
1343  ProtocolBuilder.add(ProtocolList);
1344  ProtocolBuilder.add(InstanceMethodList);
1345  ProtocolBuilder.add(ClassMethodList);
1346  ProtocolBuilder.add(OptionalInstanceMethodList);
1347  ProtocolBuilder.add(OptionalClassMethodList);
1348  // Required instance properties
1349  ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, false));
1350  // Optional instance properties
1351  ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, true));
1352  // Required class properties
1353  ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, false));
1354  // Optional class properties
1355  ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, true));
1356 
1357  auto *GV = ProtocolBuilder.finishAndCreateGlobal(SymName,
1359  GV->setSection(sectionName<ProtocolSection>());
1360  GV->setComdat(TheModule.getOrInsertComdat(SymName));
1361  if (OldGV) {
1362  OldGV->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GV,
1363  OldGV->getType()));
1364  OldGV->removeFromParent();
1365  GV->setName(SymName);
1366  }
1367  Protocol = GV;
1368  return GV;
1369  }
1370  llvm::Constant *EnforceType(llvm::Constant *Val, llvm::Type *Ty) {
1371  if (Val->getType() == Ty)
1372  return Val;
1373  return llvm::ConstantExpr::getBitCast(Val, Ty);
1374  }
1375  llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
1376  const std::string &TypeEncoding) override {
1377  return GetConstantSelector(Sel, TypeEncoding);
1378  }
1379  llvm::Constant *GetTypeString(llvm::StringRef TypeEncoding) {
1380  if (TypeEncoding.empty())
1381  return NULLPtr;
1382  std::string MangledTypes = TypeEncoding;
1383  std::replace(MangledTypes.begin(), MangledTypes.end(),
1384  '@', '\1');
1385  std::string TypesVarName = ".objc_sel_types_" + MangledTypes;
1386  auto *TypesGlobal = TheModule.getGlobalVariable(TypesVarName);
1387  if (!TypesGlobal) {
1388  llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
1389  TypeEncoding);
1390  auto *GV = new llvm::GlobalVariable(TheModule, Init->getType(),
1391  true, llvm::GlobalValue::LinkOnceODRLinkage, Init, TypesVarName);
1392  GV->setComdat(TheModule.getOrInsertComdat(TypesVarName));
1393  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1394  TypesGlobal = GV;
1395  }
1396  return llvm::ConstantExpr::getGetElementPtr(TypesGlobal->getValueType(),
1397  TypesGlobal, Zeros);
1398  }
1399  llvm::Constant *GetConstantSelector(Selector Sel,
1400  const std::string &TypeEncoding) override {
1401  // @ is used as a special character in symbol names (used for symbol
1402  // versioning), so mangle the name to not include it. Replace it with a
1403  // character that is not a valid type encoding character (and, being
1404  // non-printable, never will be!)
1405  std::string MangledTypes = TypeEncoding;
1406  std::replace(MangledTypes.begin(), MangledTypes.end(),
1407  '@', '\1');
1408  auto SelVarName = (StringRef(".objc_selector_") + Sel.getAsString() + "_" +
1409  MangledTypes).str();
1410  if (auto *GV = TheModule.getNamedGlobal(SelVarName))
1411  return EnforceType(GV, SelectorTy);
1412  ConstantInitBuilder builder(CGM);
1413  auto SelBuilder = builder.beginStruct();
1414  SelBuilder.add(ExportUniqueString(Sel.getAsString(), ".objc_sel_name_",
1415  true));
1416  SelBuilder.add(GetTypeString(TypeEncoding));
1417  auto *GV = SelBuilder.finishAndCreateGlobal(SelVarName,
1418  CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
1419  GV->setComdat(TheModule.getOrInsertComdat(SelVarName));
1420  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1421  GV->setSection(sectionName<SelectorSection>());
1422  auto *SelVal = EnforceType(GV, SelectorTy);
1423  return SelVal;
1424  }
1425  llvm::StructType *emptyStruct = nullptr;
1426 
1427  /// Return pointers to the start and end of a section. On ELF platforms, we
1428  /// use the __start_ and __stop_ symbols that GNU-compatible linkers will set
1429  /// to the start and end of section names, as long as those section names are
1430  /// valid identifiers and the symbols are referenced but not defined. On
1431  /// Windows, we use the fact that MSVC-compatible linkers will lexically sort
1432  /// by subsections and place everything that we want to reference in a middle
1433  /// subsection and then insert zero-sized symbols in subsections a and z.
1434  std::pair<llvm::Constant*,llvm::Constant*>
1435  GetSectionBounds(StringRef Section) {
1436  if (CGM.getTriple().isOSBinFormatCOFF()) {
1437  if (emptyStruct == nullptr) {
1438  emptyStruct = llvm::StructType::create(VMContext, ".objc_section_sentinel");
1439  emptyStruct->setBody({}, /*isPacked*/true);
1440  }
1441  auto ZeroInit = llvm::Constant::getNullValue(emptyStruct);
1442  auto Sym = [&](StringRef Prefix, StringRef SecSuffix) {
1443  auto *Sym = new llvm::GlobalVariable(TheModule, emptyStruct,
1444  /*isConstant*/false,
1445  llvm::GlobalValue::LinkOnceODRLinkage, ZeroInit, Prefix +
1446  Section);
1447  Sym->setVisibility(llvm::GlobalValue::HiddenVisibility);
1448  Sym->setSection((Section + SecSuffix).str());
1449  Sym->setComdat(TheModule.getOrInsertComdat((Prefix +
1450  Section).str()));
1451  Sym->setAlignment(1);
1452  return Sym;
1453  };
1454  return { Sym("__start_", "$a"), Sym("__stop", "$z") };
1455  }
1456  auto *Start = new llvm::GlobalVariable(TheModule, PtrTy,
1457  /*isConstant*/false,
1458  llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__start_") +
1459  Section);
1460  Start->setVisibility(llvm::GlobalValue::HiddenVisibility);
1461  auto *Stop = new llvm::GlobalVariable(TheModule, PtrTy,
1462  /*isConstant*/false,
1463  llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__stop_") +
1464  Section);
1465  Stop->setVisibility(llvm::GlobalValue::HiddenVisibility);
1466  return { Start, Stop };
1467  }
1468  CatchTypeInfo getCatchAllTypeInfo() override {
1469  return CGM.getCXXABI().getCatchAllTypeInfo();
1470  }
1471  llvm::Function *ModuleInitFunction() override {
1472  llvm::Function *LoadFunction = llvm::Function::Create(
1473  llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
1474  llvm::GlobalValue::LinkOnceODRLinkage, ".objcv2_load_function",
1475  &TheModule);
1476  LoadFunction->setVisibility(llvm::GlobalValue::HiddenVisibility);
1477  LoadFunction->setComdat(TheModule.getOrInsertComdat(".objcv2_load_function"));
1478 
1479  llvm::BasicBlock *EntryBB =
1480  llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
1481  CGBuilderTy B(CGM, VMContext);
1482  B.SetInsertPoint(EntryBB);
1483  ConstantInitBuilder builder(CGM);
1484  auto InitStructBuilder = builder.beginStruct();
1485  InitStructBuilder.addInt(Int64Ty, 0);
1486  for (auto *s : SectionsBaseNames) {
1487  auto bounds = GetSectionBounds(s);
1488  InitStructBuilder.add(bounds.first);
1489  InitStructBuilder.add(bounds.second);
1490  };
1491  auto *InitStruct = InitStructBuilder.finishAndCreateGlobal(".objc_init",
1492  CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
1493  InitStruct->setVisibility(llvm::GlobalValue::HiddenVisibility);
1494  InitStruct->setComdat(TheModule.getOrInsertComdat(".objc_init"));
1495 
1496  CallRuntimeFunction(B, "__objc_load", {InitStruct});;
1497  B.CreateRetVoid();
1498  // Make sure that the optimisers don't delete this function.
1499  CGM.addCompilerUsedGlobal(LoadFunction);
1500  // FIXME: Currently ELF only!
1501  // We have to do this by hand, rather than with @llvm.ctors, so that the
1502  // linker can remove the duplicate invocations.
1503  auto *InitVar = new llvm::GlobalVariable(TheModule, LoadFunction->getType(),
1504  /*isConstant*/true, llvm::GlobalValue::LinkOnceAnyLinkage,
1505  LoadFunction, ".objc_ctor");
1506  // Check that this hasn't been renamed. This shouldn't happen, because
1507  // this function should be called precisely once.
1508  assert(InitVar->getName() == ".objc_ctor");
1509  // In Windows, initialisers are sorted by the suffix. XCL is for library
1510  // initialisers, which run before user initialisers. We are running
1511  // Objective-C loads at the end of library load. This means +load methods
1512  // will run before any other static constructors, but that static
1513  // constructors can see a fully initialised Objective-C state.
1514  if (CGM.getTriple().isOSBinFormatCOFF())
1515  InitVar->setSection(".CRT$XCLz");
1516  else
1517  InitVar->setSection(".ctors");
1518  InitVar->setVisibility(llvm::GlobalValue::HiddenVisibility);
1519  InitVar->setComdat(TheModule.getOrInsertComdat(".objc_ctor"));
1520  CGM.addUsedGlobal(InitVar);
1521  for (auto *C : Categories) {
1522  auto *Cat = cast<llvm::GlobalVariable>(C->stripPointerCasts());
1523  Cat->setSection(sectionName<CategorySection>());
1524  CGM.addUsedGlobal(Cat);
1525  }
1526  auto createNullGlobal = [&](StringRef Name, ArrayRef<llvm::Constant*> Init,
1527  StringRef Section) {
1528  auto nullBuilder = builder.beginStruct();
1529  for (auto *F : Init)
1530  nullBuilder.add(F);
1531  auto GV = nullBuilder.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
1532  false, llvm::GlobalValue::LinkOnceODRLinkage);
1533  GV->setSection(Section);
1534  GV->setComdat(TheModule.getOrInsertComdat(Name));
1535  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1536  CGM.addUsedGlobal(GV);
1537  return GV;
1538  };
1539  for (auto clsAlias : ClassAliases)
1540  createNullGlobal(std::string(".objc_class_alias") +
1541  clsAlias.second, { MakeConstantString(clsAlias.second),
1542  GetClassVar(clsAlias.first) }, sectionName<ClassAliasSection>());
1543  // On ELF platforms, add a null value for each special section so that we
1544  // can always guarantee that the _start and _stop symbols will exist and be
1545  // meaningful. This is not required on COFF platforms, where our start and
1546  // stop symbols will create the section.
1547  if (!CGM.getTriple().isOSBinFormatCOFF()) {
1548  createNullGlobal(".objc_null_selector", {NULLPtr, NULLPtr},
1549  sectionName<SelectorSection>());
1550  if (Categories.empty())
1551  createNullGlobal(".objc_null_category", {NULLPtr, NULLPtr,
1552  NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr},
1553  sectionName<CategorySection>());
1554  if (!EmittedClass) {
1555  createNullGlobal(".objc_null_cls_init_ref", NULLPtr,
1556  sectionName<ClassSection>());
1557  createNullGlobal(".objc_null_class_ref", { NULLPtr, NULLPtr },
1558  sectionName<ClassReferenceSection>());
1559  }
1560  if (!EmittedProtocol)
1561  createNullGlobal(".objc_null_protocol", {NULLPtr, NULLPtr, NULLPtr,
1562  NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr,
1563  NULLPtr}, sectionName<ProtocolSection>());
1564  if (!EmittedProtocolRef)
1565  createNullGlobal(".objc_null_protocol_ref", {NULLPtr},
1566  sectionName<ProtocolReferenceSection>());
1567  if (ClassAliases.empty())
1568  createNullGlobal(".objc_null_class_alias", { NULLPtr, NULLPtr },
1569  sectionName<ClassAliasSection>());
1570  if (ConstantStrings.empty()) {
1571  auto i32Zero = llvm::ConstantInt::get(Int32Ty, 0);
1572  createNullGlobal(".objc_null_constant_string", { NULLPtr, i32Zero,
1573  i32Zero, i32Zero, i32Zero, NULLPtr },
1574  sectionName<ConstantStringSection>());
1575  }
1576  }
1577  ConstantStrings.clear();
1578  Categories.clear();
1579  Classes.clear();
1580  return nullptr;
1581  }
1582  /// In the v2 ABI, ivar offset variables use the type encoding in their name
1583  /// to trigger linker failures if the types don't match.
1584  std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
1585  const ObjCIvarDecl *Ivar) override {
1586  std::string TypeEncoding;
1587  CGM.getContext().getObjCEncodingForType(Ivar->getType(), TypeEncoding);
1588  // Prevent the @ from being interpreted as a symbol version.
1589  std::replace(TypeEncoding.begin(), TypeEncoding.end(),
1590  '@', '\1');
1591  const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
1592  + '.' + Ivar->getNameAsString() + '.' + TypeEncoding;
1593  return Name;
1594  }
1595  llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
1596  const ObjCInterfaceDecl *Interface,
1597  const ObjCIvarDecl *Ivar) override {
1598  const std::string Name = GetIVarOffsetVariableName(Ivar->getContainingInterface(), Ivar);
1599  llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
1600  if (!IvarOffsetPointer)
1601  IvarOffsetPointer = new llvm::GlobalVariable(TheModule, IntTy, false,
1602  llvm::GlobalValue::ExternalLinkage, nullptr, Name);
1603  CharUnits Align = CGM.getIntAlign();
1604  llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(IvarOffsetPointer, Align);
1605  if (Offset->getType() != PtrDiffTy)
1606  Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
1607  return Offset;
1608  }
1609  void GenerateClass(const ObjCImplementationDecl *OID) override {
1610  ASTContext &Context = CGM.getContext();
1611 
1612  // Get the class name
1613  ObjCInterfaceDecl *classDecl =
1614  const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
1615  std::string className = classDecl->getNameAsString();
1616  auto *classNameConstant = MakeConstantString(className);
1617 
1618  ConstantInitBuilder builder(CGM);
1619  auto metaclassFields = builder.beginStruct();
1620  // struct objc_class *isa;
1621  metaclassFields.addNullPointer(PtrTy);
1622  // struct objc_class *super_class;
1623  metaclassFields.addNullPointer(PtrTy);
1624  // const char *name;
1625  metaclassFields.add(classNameConstant);
1626  // long version;
1627  metaclassFields.addInt(LongTy, 0);
1628  // unsigned long info;
1629  // objc_class_flag_meta
1630  metaclassFields.addInt(LongTy, 1);
1631  // long instance_size;
1632  // Setting this to zero is consistent with the older ABI, but it might be
1633  // more sensible to set this to sizeof(struct objc_class)
1634  metaclassFields.addInt(LongTy, 0);
1635  // struct objc_ivar_list *ivars;
1636  metaclassFields.addNullPointer(PtrTy);
1637  // struct objc_method_list *methods
1638  // FIXME: Almost identical code is copied and pasted below for the
1639  // class, but refactoring it cleanly requires C++14 generic lambdas.
1640  if (OID->classmeth_begin() == OID->classmeth_end())
1641  metaclassFields.addNullPointer(PtrTy);
1642  else {
1643  SmallVector<ObjCMethodDecl*, 16> ClassMethods;
1644  ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(),
1645  OID->classmeth_end());
1646  metaclassFields.addBitCast(
1647  GenerateMethodList(className, "", ClassMethods, true),
1648  PtrTy);
1649  }
1650  // void *dtable;
1651  metaclassFields.addNullPointer(PtrTy);
1652  // IMP cxx_construct;
1653  metaclassFields.addNullPointer(PtrTy);
1654  // IMP cxx_destruct;
1655  metaclassFields.addNullPointer(PtrTy);
1656  // struct objc_class *subclass_list
1657  metaclassFields.addNullPointer(PtrTy);
1658  // struct objc_class *sibling_class
1659  metaclassFields.addNullPointer(PtrTy);
1660  // struct objc_protocol_list *protocols;
1661  metaclassFields.addNullPointer(PtrTy);
1662  // struct reference_list *extra_data;
1663  metaclassFields.addNullPointer(PtrTy);
1664  // long abi_version;
1665  metaclassFields.addInt(LongTy, 0);
1666  // struct objc_property_list *properties
1667  metaclassFields.add(GeneratePropertyList(OID, classDecl, /*isClassProperty*/true));
1668 
1669  auto *metaclass = metaclassFields.finishAndCreateGlobal("._OBJC_METACLASS_"
1670  + className, CGM.getPointerAlign());
1671 
1672  auto classFields = builder.beginStruct();
1673  // struct objc_class *isa;
1674  classFields.add(metaclass);
1675  // struct objc_class *super_class;
1676  // Get the superclass name.
1677  const ObjCInterfaceDecl * SuperClassDecl =
1678  OID->getClassInterface()->getSuperClass();
1679  if (SuperClassDecl) {
1680  auto SuperClassName = SymbolForClass(SuperClassDecl->getNameAsString());
1681  llvm::Constant *SuperClass = TheModule.getNamedGlobal(SuperClassName);
1682  if (!SuperClass)
1683  {
1684  SuperClass = new llvm::GlobalVariable(TheModule, PtrTy, false,
1685  llvm::GlobalValue::ExternalLinkage, nullptr, SuperClassName);
1686  }
1687  classFields.add(llvm::ConstantExpr::getBitCast(SuperClass, PtrTy));
1688  } else
1689  classFields.addNullPointer(PtrTy);
1690  // const char *name;
1691  classFields.add(classNameConstant);
1692  // long version;
1693  classFields.addInt(LongTy, 0);
1694  // unsigned long info;
1695  // !objc_class_flag_meta
1696  classFields.addInt(LongTy, 0);
1697  // long instance_size;
1698  int superInstanceSize = !SuperClassDecl ? 0 :
1699  Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
1700  // Instance size is negative for classes that have not yet had their ivar
1701  // layout calculated.
1702  classFields.addInt(LongTy,
1703  0 - (Context.getASTObjCImplementationLayout(OID).getSize().getQuantity() -
1704  superInstanceSize));
1705 
1706  if (classDecl->all_declared_ivar_begin() == nullptr)
1707  classFields.addNullPointer(PtrTy);
1708  else {
1709  int ivar_count = 0;
1710  for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD;
1711  IVD = IVD->getNextIvar()) ivar_count++;
1712  llvm::DataLayout td(&TheModule);
1713  // struct objc_ivar_list *ivars;
1714  ConstantInitBuilder b(CGM);
1715  auto ivarListBuilder = b.beginStruct();
1716  // int count;
1717  ivarListBuilder.addInt(IntTy, ivar_count);
1718  // size_t size;
1719  llvm::StructType *ObjCIvarTy = llvm::StructType::get(
1720  PtrToInt8Ty,
1721  PtrToInt8Ty,
1722  PtrToInt8Ty,
1723  Int32Ty,
1724  Int32Ty);
1725  ivarListBuilder.addInt(SizeTy, td.getTypeSizeInBits(ObjCIvarTy) /
1726  CGM.getContext().getCharWidth());
1727  // struct objc_ivar ivars[]
1728  auto ivarArrayBuilder = ivarListBuilder.beginArray();
1729  for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD;
1730  IVD = IVD->getNextIvar()) {
1731  auto ivarTy = IVD->getType();
1732  auto ivarBuilder = ivarArrayBuilder.beginStruct();
1733  // const char *name;
1734  ivarBuilder.add(MakeConstantString(IVD->getNameAsString()));
1735  // const char *type;
1736  std::string TypeStr;
1737  //Context.getObjCEncodingForType(ivarTy, TypeStr, IVD, true);
1738  Context.getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, ivarTy, TypeStr, true);
1739  ivarBuilder.add(MakeConstantString(TypeStr));
1740  // int *offset;
1741  uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
1742  uint64_t Offset = BaseOffset - superInstanceSize;
1743  llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
1744  std::string OffsetName = GetIVarOffsetVariableName(classDecl, IVD);
1745  llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
1746  if (OffsetVar)
1747  OffsetVar->setInitializer(OffsetValue);
1748  else
1749  OffsetVar = new llvm::GlobalVariable(TheModule, IntTy,
1751  OffsetValue, OffsetName);
1752  auto ivarVisibility =
1753  (IVD->getAccessControl() == ObjCIvarDecl::Private ||
1754  IVD->getAccessControl() == ObjCIvarDecl::Package ||
1755  classDecl->getVisibility() == HiddenVisibility) ?
1758  OffsetVar->setVisibility(ivarVisibility);
1759  ivarBuilder.add(OffsetVar);
1760  // Ivar size
1761  ivarBuilder.addInt(Int32Ty,
1762  CGM.getContext().getTypeSizeInChars(ivarTy).getQuantity());
1763  // Alignment will be stored as a base-2 log of the alignment.
1764  int align = llvm::Log2_32(Context.getTypeAlignInChars(ivarTy).getQuantity());
1765  // Objects that require more than 2^64-byte alignment should be impossible!
1766  assert(align < 64);
1767  // uint32_t flags;
1768  // Bits 0-1 are ownership.
1769  // Bit 2 indicates an extended type encoding
1770  // Bits 3-8 contain log2(aligment)
1771  ivarBuilder.addInt(Int32Ty,
1772  (align << 3) | (1<<2) |
1773  FlagsForOwnership(ivarTy.getQualifiers().getObjCLifetime()));
1774  ivarBuilder.finishAndAddTo(ivarArrayBuilder);
1775  }
1776  ivarArrayBuilder.finishAndAddTo(ivarListBuilder);
1777  auto ivarList = ivarListBuilder.finishAndCreateGlobal(".objc_ivar_list",
1778  CGM.getPointerAlign(), /*constant*/ false,
1779  llvm::GlobalValue::PrivateLinkage);
1780  classFields.add(ivarList);
1781  }
1782  // struct objc_method_list *methods
1784  InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(),
1785  OID->instmeth_end());
1786  for (auto *propImpl : OID->property_impls())
1787  if (propImpl->getPropertyImplementation() ==
1789  ObjCPropertyDecl *prop = propImpl->getPropertyDecl();
1790  auto addIfExists = [&](const ObjCMethodDecl* OMD) {
1791  if (OMD)
1792  InstanceMethods.push_back(OMD);
1793  };
1794  addIfExists(prop->getGetterMethodDecl());
1795  addIfExists(prop->getSetterMethodDecl());
1796  }
1797 
1798  if (InstanceMethods.size() == 0)
1799  classFields.addNullPointer(PtrTy);
1800  else
1801  classFields.addBitCast(
1802  GenerateMethodList(className, "", InstanceMethods, false),
1803  PtrTy);
1804  // void *dtable;
1805  classFields.addNullPointer(PtrTy);
1806  // IMP cxx_construct;
1807  classFields.addNullPointer(PtrTy);
1808  // IMP cxx_destruct;
1809  classFields.addNullPointer(PtrTy);
1810  // struct objc_class *subclass_list
1811  classFields.addNullPointer(PtrTy);
1812  // struct objc_class *sibling_class
1813  classFields.addNullPointer(PtrTy);
1814  // struct objc_protocol_list *protocols;
1816  for (const auto *I : classDecl->protocols())
1817  Protocols.push_back(
1818  llvm::ConstantExpr::getBitCast(GenerateProtocolRef(I),
1819  ProtocolPtrTy));
1820  if (Protocols.empty())
1821  classFields.addNullPointer(PtrTy);
1822  else
1823  classFields.add(GenerateProtocolList(Protocols));
1824  // struct reference_list *extra_data;
1825  classFields.addNullPointer(PtrTy);
1826  // long abi_version;
1827  classFields.addInt(LongTy, 0);
1828  // struct objc_property_list *properties
1829  classFields.add(GeneratePropertyList(OID, classDecl));
1830 
1831  auto *classStruct =
1832  classFields.finishAndCreateGlobal(SymbolForClass(className),
1834 
1835  if (CGM.getTriple().isOSBinFormatCOFF()) {
1836  auto Storage = llvm::GlobalValue::DefaultStorageClass;
1837  if (OID->getClassInterface()->hasAttr<DLLImportAttr>())
1838  Storage = llvm::GlobalValue::DLLImportStorageClass;
1839  else if (OID->getClassInterface()->hasAttr<DLLExportAttr>())
1840  Storage = llvm::GlobalValue::DLLExportStorageClass;
1841  cast<llvm::GlobalValue>(classStruct)->setDLLStorageClass(Storage);
1842  }
1843 
1844  auto *classRefSymbol = GetClassVar(className);
1845  classRefSymbol->setSection(sectionName<ClassReferenceSection>());
1846  classRefSymbol->setInitializer(llvm::ConstantExpr::getBitCast(classStruct, IdTy));
1847 
1848 
1849  // Resolve the class aliases, if they exist.
1850  // FIXME: Class pointer aliases shouldn't exist!
1851  if (ClassPtrAlias) {
1852  ClassPtrAlias->replaceAllUsesWith(
1853  llvm::ConstantExpr::getBitCast(classStruct, IdTy));
1854  ClassPtrAlias->eraseFromParent();
1855  ClassPtrAlias = nullptr;
1856  }
1857  if (auto Placeholder =
1858  TheModule.getNamedGlobal(SymbolForClass(className)))
1859  if (Placeholder != classStruct) {
1860  Placeholder->replaceAllUsesWith(
1861  llvm::ConstantExpr::getBitCast(classStruct, Placeholder->getType()));
1862  Placeholder->eraseFromParent();
1863  classStruct->setName(SymbolForClass(className));
1864  }
1865  if (MetaClassPtrAlias) {
1866  MetaClassPtrAlias->replaceAllUsesWith(
1867  llvm::ConstantExpr::getBitCast(metaclass, IdTy));
1868  MetaClassPtrAlias->eraseFromParent();
1869  MetaClassPtrAlias = nullptr;
1870  }
1871  assert(classStruct->getName() == SymbolForClass(className));
1872 
1873  auto classInitRef = new llvm::GlobalVariable(TheModule,
1874  classStruct->getType(), false, llvm::GlobalValue::ExternalLinkage,
1875  classStruct, "._OBJC_INIT_CLASS_" + className);
1876  classInitRef->setSection(sectionName<ClassSection>());
1877  CGM.addUsedGlobal(classInitRef);
1878 
1879  EmittedClass = true;
1880  }
1881  public:
1882  CGObjCGNUstep2(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 10, 4, 2) {
1883  MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
1884  PtrToObjCSuperTy, SelectorTy);
1885  // struct objc_property
1886  // {
1887  // const char *name;
1888  // const char *attributes;
1889  // const char *type;
1890  // SEL getter;
1891  // SEL setter;
1892  // }
1893  PropertyMetadataTy =
1894  llvm::StructType::get(CGM.getLLVMContext(),
1895  { PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty });
1896  }
1897 
1898 };
1899 
1900 const char *const CGObjCGNUstep2::SectionsBaseNames[8] =
1901 {
1902 "__objc_selectors",
1903 "__objc_classes",
1904 "__objc_class_refs",
1905 "__objc_cats",
1906 "__objc_protocols",
1907 "__objc_protocol_refs",
1908 "__objc_class_aliases",
1909 "__objc_constant_string"
1910 };
1911 
1912 /// Support for the ObjFW runtime.
1913 class CGObjCObjFW: public CGObjCGNU {
1914 protected:
1915  /// The GCC ABI message lookup function. Returns an IMP pointing to the
1916  /// method implementation for this message.
1917  LazyRuntimeFunction MsgLookupFn;
1918  /// stret lookup function. While this does not seem to make sense at the
1919  /// first look, this is required to call the correct forwarding function.
1920  LazyRuntimeFunction MsgLookupFnSRet;
1921  /// The GCC ABI superclass message lookup function. Takes a pointer to a
1922  /// structure describing the receiver and the class, and a selector as
1923  /// arguments. Returns the IMP for the corresponding method.
1924  LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet;
1925 
1926  llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
1927  llvm::Value *cmd, llvm::MDNode *node,
1928  MessageSendInfo &MSI) override {
1929  CGBuilderTy &Builder = CGF.Builder;
1930  llvm::Value *args[] = {
1931  EnforceType(Builder, Receiver, IdTy),
1932  EnforceType(Builder, cmd, SelectorTy) };
1933 
1934  llvm::CallBase *imp;
1935  if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
1936  imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFnSRet, args);
1937  else
1938  imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
1939 
1940  imp->setMetadata(msgSendMDKind, node);
1941  return imp;
1942  }
1943 
1944  llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
1945  llvm::Value *cmd, MessageSendInfo &MSI) override {
1946  CGBuilderTy &Builder = CGF.Builder;
1947  llvm::Value *lookupArgs[] = {
1948  EnforceType(Builder, ObjCSuper.getPointer(), PtrToObjCSuperTy), cmd,
1949  };
1950 
1951  if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
1952  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFnSRet, lookupArgs);
1953  else
1954  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
1955  }
1956 
1957  llvm::Value *GetClassNamed(CodeGenFunction &CGF, const std::string &Name,
1958  bool isWeak) override {
1959  if (isWeak)
1960  return CGObjCGNU::GetClassNamed(CGF, Name, isWeak);
1961 
1962  EmitClassRef(Name);
1963  std::string SymbolName = "_OBJC_CLASS_" + Name;
1964  llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(SymbolName);
1965  if (!ClassSymbol)
1966  ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
1968  nullptr, SymbolName);
1969  return ClassSymbol;
1970  }
1971 
1972 public:
1973  CGObjCObjFW(CodeGenModule &Mod): CGObjCGNU(Mod, 9, 3) {
1974  // IMP objc_msg_lookup(id, SEL);
1975  MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy);
1976  MsgLookupFnSRet.init(&CGM, "objc_msg_lookup_stret", IMPTy, IdTy,
1977  SelectorTy);
1978  // IMP objc_msg_lookup_super(struct objc_super*, SEL);
1979  MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
1980  PtrToObjCSuperTy, SelectorTy);
1981  MsgLookupSuperFnSRet.init(&CGM, "objc_msg_lookup_super_stret", IMPTy,
1982  PtrToObjCSuperTy, SelectorTy);
1983  }
1984 };
1985 } // end anonymous namespace
1986 
1987 /// Emits a reference to a dummy variable which is emitted with each class.
1988 /// This ensures that a linker error will be generated when trying to link
1989 /// together modules where a referenced class is not defined.
1990 void CGObjCGNU::EmitClassRef(const std::string &className) {
1991  std::string symbolRef = "__objc_class_ref_" + className;
1992  // Don't emit two copies of the same symbol
1993  if (TheModule.getGlobalVariable(symbolRef))
1994  return;
1995  std::string symbolName = "__objc_class_name_" + className;
1996  llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);
1997  if (!ClassSymbol) {
1998  ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
2000  nullptr, symbolName);
2001  }
2002  new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true,
2003  llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);
2004 }
2005 
2006 CGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
2007  unsigned protocolClassVersion, unsigned classABI)
2008  : CGObjCRuntime(cgm), TheModule(CGM.getModule()),
2009  VMContext(cgm.getLLVMContext()), ClassPtrAlias(nullptr),
2010  MetaClassPtrAlias(nullptr), RuntimeVersion(runtimeABIVersion),
2011  ProtocolVersion(protocolClassVersion), ClassABIVersion(classABI) {
2012 
2013  msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend");
2014  usesSEHExceptions =
2015  cgm.getContext().getTargetInfo().getTriple().isWindowsMSVCEnvironment();
2016 
2017  CodeGenTypes &Types = CGM.getTypes();
2018  IntTy = cast<llvm::IntegerType>(
2019  Types.ConvertType(CGM.getContext().IntTy));
2020  LongTy = cast<llvm::IntegerType>(
2021  Types.ConvertType(CGM.getContext().LongTy));
2022  SizeTy = cast<llvm::IntegerType>(
2023  Types.ConvertType(CGM.getContext().getSizeType()));
2024  PtrDiffTy = cast<llvm::IntegerType>(
2025  Types.ConvertType(CGM.getContext().getPointerDiffType()));
2026  BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
2027 
2028  Int8Ty = llvm::Type::getInt8Ty(VMContext);
2029  // C string type. Used in lots of places.
2030  PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
2031  ProtocolPtrTy = llvm::PointerType::getUnqual(
2032  Types.ConvertType(CGM.getContext().getObjCProtoType()));
2033 
2034  Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
2035  Zeros[1] = Zeros[0];
2036  NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);
2037  // Get the selector Type.
2038  QualType selTy = CGM.getContext().getObjCSelType();
2039  if (QualType() == selTy) {
2040  SelectorTy = PtrToInt8Ty;
2041  } else {
2042  SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
2043  }
2044 
2045  PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
2046  PtrTy = PtrToInt8Ty;
2047 
2048  Int32Ty = llvm::Type::getInt32Ty(VMContext);
2049  Int64Ty = llvm::Type::getInt64Ty(VMContext);
2050 
2051  IntPtrTy =
2052  CGM.getDataLayout().getPointerSizeInBits() == 32 ? Int32Ty : Int64Ty;
2053 
2054  // Object type
2055  QualType UnqualIdTy = CGM.getContext().getObjCIdType();
2056  ASTIdTy = CanQualType();
2057  if (UnqualIdTy != QualType()) {
2058  ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy);
2059  IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
2060  } else {
2061  IdTy = PtrToInt8Ty;
2062  }
2063  PtrToIdTy = llvm::PointerType::getUnqual(IdTy);
2064  ProtocolTy = llvm::StructType::get(IdTy,
2065  PtrToInt8Ty, // name
2066  PtrToInt8Ty, // protocols
2067  PtrToInt8Ty, // instance methods
2068  PtrToInt8Ty, // class methods
2069  PtrToInt8Ty, // optional instance methods
2070  PtrToInt8Ty, // optional class methods
2071  PtrToInt8Ty, // properties
2072  PtrToInt8Ty);// optional properties
2073 
2074  // struct objc_property_gsv1
2075  // {
2076  // const char *name;
2077  // char attributes;
2078  // char attributes2;
2079  // char unused1;
2080  // char unused2;
2081  // const char *getter_name;
2082  // const char *getter_types;
2083  // const char *setter_name;
2084  // const char *setter_types;
2085  // }
2086  PropertyMetadataTy = llvm::StructType::get(CGM.getLLVMContext(), {
2087  PtrToInt8Ty, Int8Ty, Int8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty,
2088  PtrToInt8Ty, PtrToInt8Ty });
2089 
2090  ObjCSuperTy = llvm::StructType::get(IdTy, IdTy);
2091  PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy);
2092 
2093  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
2094 
2095  // void objc_exception_throw(id);
2096  ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy);
2097  ExceptionReThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy);
2098  // int objc_sync_enter(id);
2099  SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy);
2100  // int objc_sync_exit(id);
2101  SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy);
2102 
2103  // void objc_enumerationMutation (id)
2104  EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy, IdTy);
2105 
2106  // id objc_getProperty(id, SEL, ptrdiff_t, BOOL)
2107  GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy,
2108  PtrDiffTy, BoolTy);
2109  // void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, BOOL)
2110  SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy,
2111  PtrDiffTy, IdTy, BoolTy, BoolTy);
2112  // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
2113  GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy,
2114  PtrDiffTy, BoolTy, BoolTy);
2115  // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
2116  SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy,
2117  PtrDiffTy, BoolTy, BoolTy);
2118 
2119  // IMP type
2120  llvm::Type *IMPArgs[] = { IdTy, SelectorTy };
2121  IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,
2122  true));
2123 
2124  const LangOptions &Opts = CGM.getLangOpts();
2125  if ((Opts.getGC() != LangOptions::NonGC) || Opts.ObjCAutoRefCount)
2126  RuntimeVersion = 10;
2127 
2128  // Don't bother initialising the GC stuff unless we're compiling in GC mode
2129  if (Opts.getGC() != LangOptions::NonGC) {
2130  // This is a bit of an hack. We should sort this out by having a proper
2131  // CGObjCGNUstep subclass for GC, but we may want to really support the old
2132  // ABI and GC added in ObjectiveC2.framework, so we fudge it a bit for now
2133  // Get selectors needed in GC mode
2134  RetainSel = GetNullarySelector("retain", CGM.getContext());
2135  ReleaseSel = GetNullarySelector("release", CGM.getContext());
2136  AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext());
2137 
2138  // Get functions needed in GC mode
2139 
2140  // id objc_assign_ivar(id, id, ptrdiff_t);
2141  IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy);
2142  // id objc_assign_strongCast (id, id*)
2143  StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy,
2144  PtrToIdTy);
2145  // id objc_assign_global(id, id*);
2146  GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy);
2147  // id objc_assign_weak(id, id*);
2148  WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy);
2149  // id objc_read_weak(id*);
2150  WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy);
2151  // void *objc_memmove_collectable(void*, void *, size_t);
2152  MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy,
2153  SizeTy);
2154  }
2155 }
2156 
2157 llvm::Value *CGObjCGNU::GetClassNamed(CodeGenFunction &CGF,
2158  const std::string &Name, bool isWeak) {
2159  llvm::Constant *ClassName = MakeConstantString(Name);
2160  // With the incompatible ABI, this will need to be replaced with a direct
2161  // reference to the class symbol. For the compatible nonfragile ABI we are
2162  // still performing this lookup at run time but emitting the symbol for the
2163  // class externally so that we can make the switch later.
2164  //
2165  // Libobjc2 contains an LLVM pass that replaces calls to objc_lookup_class
2166  // with memoized versions or with static references if it's safe to do so.
2167  if (!isWeak)
2168  EmitClassRef(Name);
2169 
2170  llvm::FunctionCallee ClassLookupFn = CGM.CreateRuntimeFunction(
2171  llvm::FunctionType::get(IdTy, PtrToInt8Ty, true), "objc_lookup_class");
2172  return CGF.EmitNounwindRuntimeCall(ClassLookupFn, ClassName);
2173 }
2174 
2175 // This has to perform the lookup every time, since posing and related
2176 // techniques can modify the name -> class mapping.
2177 llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF,
2178  const ObjCInterfaceDecl *OID) {
2179  auto *Value =
2180  GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported());
2181  if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value))
2182  CGM.setGVProperties(ClassSymbol, OID);
2183  return Value;
2184 }
2185 
2186 llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
2187  auto *Value = GetClassNamed(CGF, "NSAutoreleasePool", false);
2188  if (CGM.getTriple().isOSBinFormatCOFF()) {
2189  if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) {
2190  IdentifierInfo &II = CGF.CGM.getContext().Idents.get("NSAutoreleasePool");
2193 
2194  const VarDecl *VD = nullptr;
2195  for (const auto &Result : DC->lookup(&II))
2196  if ((VD = dyn_cast<VarDecl>(Result)))
2197  break;
2198 
2199  CGM.setGVProperties(ClassSymbol, VD);
2200  }
2201  }
2202  return Value;
2203 }
2204 
2205 llvm::Value *CGObjCGNU::GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
2206  const std::string &TypeEncoding) {
2207  SmallVectorImpl<TypedSelector> &Types = SelectorTable[Sel];
2208  llvm::GlobalAlias *SelValue = nullptr;
2209 
2210  for (SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
2211  e = Types.end() ; i!=e ; i++) {
2212  if (i->first == TypeEncoding) {
2213  SelValue = i->second;
2214  break;
2215  }
2216  }
2217  if (!SelValue) {
2218  SelValue = llvm::GlobalAlias::create(
2219  SelectorTy->getElementType(), 0, llvm::GlobalValue::PrivateLinkage,
2220  ".objc_selector_" + Sel.getAsString(), &TheModule);
2221  Types.emplace_back(TypeEncoding, SelValue);
2222  }
2223 
2224  return SelValue;
2225 }
2226 
2227 Address CGObjCGNU::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
2228  llvm::Value *SelValue = GetSelector(CGF, Sel);
2229 
2230  // Store it to a temporary. Does this satisfy the semantics of
2231  // GetAddrOfSelector? Hopefully.
2232  Address tmp = CGF.CreateTempAlloca(SelValue->getType(),
2233  CGF.getPointerAlign());
2234  CGF.Builder.CreateStore(SelValue, tmp);
2235  return tmp;
2236 }
2237 
2238 llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel) {
2239  return GetTypedSelector(CGF, Sel, std::string());
2240 }
2241 
2242 llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF,
2243  const ObjCMethodDecl *Method) {
2244  std::string SelTypes = CGM.getContext().getObjCEncodingForMethodDecl(Method);
2245  return GetTypedSelector(CGF, Method->getSelector(), SelTypes);
2246 }
2247 
2248 llvm::Constant *CGObjCGNU::GetEHType(QualType T) {
2249  if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
2250  // With the old ABI, there was only one kind of catchall, which broke
2251  // foreign exceptions. With the new ABI, we use __objc_id_typeinfo as
2252  // a pointer indicating object catchalls, and NULL to indicate real
2253  // catchalls
2254  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2255  return MakeConstantString("@id");
2256  } else {
2257  return nullptr;
2258  }
2259  }
2260 
2261  // All other types should be Objective-C interface pointer types.
2263  assert(OPT && "Invalid @catch type.");
2264  const ObjCInterfaceDecl *IDecl = OPT->getObjectType()->getInterface();
2265  assert(IDecl && "Invalid @catch type.");
2266  return MakeConstantString(IDecl->getIdentifier()->getName());
2267 }
2268 
2269 llvm::Constant *CGObjCGNUstep::GetEHType(QualType T) {
2270  if (usesSEHExceptions)
2271  return CGM.getCXXABI().getAddrOfRTTIDescriptor(T);
2272 
2273  if (!CGM.getLangOpts().CPlusPlus)
2274  return CGObjCGNU::GetEHType(T);
2275 
2276  // For Objective-C++, we want to provide the ability to catch both C++ and
2277  // Objective-C objects in the same function.
2278 
2279  // There's a particular fixed type info for 'id'.
2280  if (T->isObjCIdType() ||
2281  T->isObjCQualifiedIdType()) {
2282  llvm::Constant *IDEHType =
2283  CGM.getModule().getGlobalVariable("__objc_id_type_info");
2284  if (!IDEHType)
2285  IDEHType =
2286  new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty,
2287  false,
2289  nullptr, "__objc_id_type_info");
2290  return llvm::ConstantExpr::getBitCast(IDEHType, PtrToInt8Ty);
2291  }
2292 
2293  const ObjCObjectPointerType *PT =
2295  assert(PT && "Invalid @catch type.");
2296  const ObjCInterfaceType *IT = PT->getInterfaceType();
2297  assert(IT && "Invalid @catch type.");
2298  std::string className = IT->getDecl()->getIdentifier()->getName();
2299 
2300  std::string typeinfoName = "__objc_eh_typeinfo_" + className;
2301 
2302  // Return the existing typeinfo if it exists
2303  llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName);
2304  if (typeinfo)
2305  return llvm::ConstantExpr::getBitCast(typeinfo, PtrToInt8Ty);
2306 
2307  // Otherwise create it.
2308 
2309  // vtable for gnustep::libobjc::__objc_class_type_info
2310  // It's quite ugly hard-coding this. Ideally we'd generate it using the host
2311  // platform's name mangling.
2312  const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE";
2313  auto *Vtable = TheModule.getGlobalVariable(vtableName);
2314  if (!Vtable) {
2315  Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true,
2317  nullptr, vtableName);
2318  }
2319  llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);
2320  auto *BVtable = llvm::ConstantExpr::getBitCast(
2321  llvm::ConstantExpr::getGetElementPtr(Vtable->getValueType(), Vtable, Two),
2322  PtrToInt8Ty);
2323 
2324  llvm::Constant *typeName =
2325  ExportUniqueString(className, "__objc_eh_typename_");
2326 
2327  ConstantInitBuilder builder(CGM);
2328  auto fields = builder.beginStruct();
2329  fields.add(BVtable);
2330  fields.add(typeName);
2331  llvm::Constant *TI =
2332  fields.finishAndCreateGlobal("__objc_eh_typeinfo_" + className,
2333  CGM.getPointerAlign(),
2334  /*constant*/ false,
2335  llvm::GlobalValue::LinkOnceODRLinkage);
2336  return llvm::ConstantExpr::getBitCast(TI, PtrToInt8Ty);
2337 }
2338 
2339 /// Generate an NSConstantString object.
2340 ConstantAddress CGObjCGNU::GenerateConstantString(const StringLiteral *SL) {
2341 
2342  std::string Str = SL->getString().str();
2343  CharUnits Align = CGM.getPointerAlign();
2344 
2345  // Look for an existing one
2346  llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
2347  if (old != ObjCStrings.end())
2348  return ConstantAddress(old->getValue(), Align);
2349 
2350  StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
2351 
2352  if (StringClass.empty()) StringClass = "NSConstantString";
2353 
2354  std::string Sym = "_OBJC_CLASS_";
2355  Sym += StringClass;
2356 
2357  llvm::Constant *isa = TheModule.getNamedGlobal(Sym);
2358 
2359  if (!isa)
2360  isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
2361  llvm::GlobalValue::ExternalWeakLinkage, nullptr, Sym);
2362  else if (isa->getType() != PtrToIdTy)
2363  isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy);
2364 
2365  ConstantInitBuilder Builder(CGM);
2366  auto Fields = Builder.beginStruct();
2367  Fields.add(isa);
2368  Fields.add(MakeConstantString(Str));
2369  Fields.addInt(IntTy, Str.size());
2370  llvm::Constant *ObjCStr =
2371  Fields.finishAndCreateGlobal(".objc_str", Align);
2372  ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty);
2373  ObjCStrings[Str] = ObjCStr;
2374  ConstantStrings.push_back(ObjCStr);
2375  return ConstantAddress(ObjCStr, Align);
2376 }
2377 
2378 ///Generates a message send where the super is the receiver. This is a message
2379 ///send to self with special delivery semantics indicating which class's method
2380 ///should be called.
2381 RValue
2382 CGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF,
2383  ReturnValueSlot Return,
2384  QualType ResultType,
2385  Selector Sel,
2386  const ObjCInterfaceDecl *Class,
2387  bool isCategoryImpl,
2388  llvm::Value *Receiver,
2389  bool IsClassMessage,
2390  const CallArgList &CallArgs,
2391  const ObjCMethodDecl *Method) {
2392  CGBuilderTy &Builder = CGF.Builder;
2393  if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
2394  if (Sel == RetainSel || Sel == AutoreleaseSel) {
2395  return RValue::get(EnforceType(Builder, Receiver,
2396  CGM.getTypes().ConvertType(ResultType)));
2397  }
2398  if (Sel == ReleaseSel) {
2399  return RValue::get(nullptr);
2400  }
2401  }
2402 
2403  llvm::Value *cmd = GetSelector(CGF, Sel);
2404  CallArgList ActualArgs;
2405 
2406  ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);
2407  ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
2408  ActualArgs.addFrom(CallArgs);
2409 
2410  MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2411 
2412  llvm::Value *ReceiverClass = nullptr;
2413  bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2);
2414  if (isV2ABI) {
2415  ReceiverClass = GetClassNamed(CGF,
2416  Class->getSuperClass()->getNameAsString(), /*isWeak*/false);
2417  if (IsClassMessage) {
2418  // Load the isa pointer of the superclass is this is a class method.
2419  ReceiverClass = Builder.CreateBitCast(ReceiverClass,
2420  llvm::PointerType::getUnqual(IdTy));
2421  ReceiverClass =
2422  Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign());
2423  }
2424  ReceiverClass = EnforceType(Builder, ReceiverClass, IdTy);
2425  } else {
2426  if (isCategoryImpl) {
2427  llvm::FunctionCallee classLookupFunction = nullptr;
2428  if (IsClassMessage) {
2429  classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
2430  IdTy, PtrTy, true), "objc_get_meta_class");
2431  } else {
2432  classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
2433  IdTy, PtrTy, true), "objc_get_class");
2434  }
2435  ReceiverClass = Builder.CreateCall(classLookupFunction,
2436  MakeConstantString(Class->getNameAsString()));
2437  } else {
2438  // Set up global aliases for the metaclass or class pointer if they do not
2439  // already exist. These will are forward-references which will be set to
2440  // pointers to the class and metaclass structure created for the runtime
2441  // load function. To send a message to super, we look up the value of the
2442  // super_class pointer from either the class or metaclass structure.
2443  if (IsClassMessage) {
2444  if (!MetaClassPtrAlias) {
2445  MetaClassPtrAlias = llvm::GlobalAlias::create(
2446  IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage,
2447  ".objc_metaclass_ref" + Class->getNameAsString(), &TheModule);
2448  }
2449  ReceiverClass = MetaClassPtrAlias;
2450  } else {
2451  if (!ClassPtrAlias) {
2452  ClassPtrAlias = llvm::GlobalAlias::create(
2453  IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage,
2454  ".objc_class_ref" + Class->getNameAsString(), &TheModule);
2455  }
2456  ReceiverClass = ClassPtrAlias;
2457  }
2458  }
2459  // Cast the pointer to a simplified version of the class structure
2460  llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy);
2461  ReceiverClass = Builder.CreateBitCast(ReceiverClass,
2462  llvm::PointerType::getUnqual(CastTy));
2463  // Get the superclass pointer
2464  ReceiverClass = Builder.CreateStructGEP(CastTy, ReceiverClass, 1);
2465  // Load the superclass pointer
2466  ReceiverClass =
2467  Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign());
2468  }
2469  // Construct the structure used to look up the IMP
2470  llvm::StructType *ObjCSuperTy =
2471  llvm::StructType::get(Receiver->getType(), IdTy);
2472 
2473  Address ObjCSuper = CGF.CreateTempAlloca(ObjCSuperTy,
2474  CGF.getPointerAlign());
2475 
2476  Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
2477  Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
2478 
2479  ObjCSuper = EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy);
2480 
2481  // Get the IMP
2482  llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd, MSI);
2483  imp = EnforceType(Builder, imp, MSI.MessengerType);
2484 
2485  llvm::Metadata *impMD[] = {
2486  llvm::MDString::get(VMContext, Sel.getAsString()),
2487  llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()),
2488  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
2489  llvm::Type::getInt1Ty(VMContext), IsClassMessage))};
2490  llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
2491 
2492  CGCallee callee(CGCalleeInfo(), imp);
2493 
2494  llvm::CallBase *call;
2495  RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
2496  call->setMetadata(msgSendMDKind, node);
2497  return msgRet;
2498 }
2499 
2500 /// Generate code for a message send expression.
2501 RValue
2502 CGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF,
2503  ReturnValueSlot Return,
2504  QualType ResultType,
2505  Selector Sel,
2506  llvm::Value *Receiver,
2507  const CallArgList &CallArgs,
2508  const ObjCInterfaceDecl *Class,
2509  const ObjCMethodDecl *Method) {
2510  CGBuilderTy &Builder = CGF.Builder;
2511 
2512  // Strip out message sends to retain / release in GC mode
2513  if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
2514  if (Sel == RetainSel || Sel == AutoreleaseSel) {
2515  return RValue::get(EnforceType(Builder, Receiver,
2516  CGM.getTypes().ConvertType(ResultType)));
2517  }
2518  if (Sel == ReleaseSel) {
2519  return RValue::get(nullptr);
2520  }
2521  }
2522 
2523  // If the return type is something that goes in an integer register, the
2524  // runtime will handle 0 returns. For other cases, we fill in the 0 value
2525  // ourselves.
2526  //
2527  // The language spec says the result of this kind of message send is
2528  // undefined, but lots of people seem to have forgotten to read that
2529  // paragraph and insist on sending messages to nil that have structure
2530  // returns. With GCC, this generates a random return value (whatever happens
2531  // to be on the stack / in those registers at the time) on most platforms,
2532  // and generates an illegal instruction trap on SPARC. With LLVM it corrupts
2533  // the stack.
2534  bool isPointerSizedReturn = (ResultType->isAnyPointerType() ||
2535  ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType());
2536 
2537  llvm::BasicBlock *startBB = nullptr;
2538  llvm::BasicBlock *messageBB = nullptr;
2539  llvm::BasicBlock *continueBB = nullptr;
2540 
2541  if (!isPointerSizedReturn) {
2542  startBB = Builder.GetInsertBlock();
2543  messageBB = CGF.createBasicBlock("msgSend");
2544  continueBB = CGF.createBasicBlock("continue");
2545 
2546  llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,
2547  llvm::Constant::getNullValue(Receiver->getType()));
2548  Builder.CreateCondBr(isNil, continueBB, messageBB);
2549  CGF.EmitBlock(messageBB);
2550  }
2551 
2552  IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
2553  llvm::Value *cmd;
2554  if (Method)
2555  cmd = GetSelector(CGF, Method);
2556  else
2557  cmd = GetSelector(CGF, Sel);
2558  cmd = EnforceType(Builder, cmd, SelectorTy);
2559  Receiver = EnforceType(Builder, Receiver, IdTy);
2560 
2561  llvm::Metadata *impMD[] = {
2562  llvm::MDString::get(VMContext, Sel.getAsString()),
2563  llvm::MDString::get(VMContext, Class ? Class->getNameAsString() : ""),
2564  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
2565  llvm::Type::getInt1Ty(VMContext), Class != nullptr))};
2566  llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
2567 
2568  CallArgList ActualArgs;
2569  ActualArgs.add(RValue::get(Receiver), ASTIdTy);
2570  ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
2571  ActualArgs.addFrom(CallArgs);
2572 
2573  MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2574 
2575  // Get the IMP to call
2576  llvm::Value *imp;
2577 
2578  // If we have non-legacy dispatch specified, we try using the objc_msgSend()
2579  // functions. These are not supported on all platforms (or all runtimes on a
2580  // given platform), so we
2581  switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
2583  imp = LookupIMP(CGF, Receiver, cmd, node, MSI);
2584  break;
2585  case CodeGenOptions::Mixed:
2587  if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2588  imp =
2589  CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
2590  "objc_msgSend_fpret")
2591  .getCallee();
2592  } else if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) {
2593  // The actual types here don't matter - we're going to bitcast the
2594  // function anyway
2595  imp =
2596  CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
2597  "objc_msgSend_stret")
2598  .getCallee();
2599  } else {
2600  imp = CGM.CreateRuntimeFunction(
2601  llvm::FunctionType::get(IdTy, IdTy, true), "objc_msgSend")
2602  .getCallee();
2603  }
2604  }
2605 
2606  // Reset the receiver in case the lookup modified it
2607  ActualArgs[0] = CallArg(RValue::get(Receiver), ASTIdTy);
2608 
2609  imp = EnforceType(Builder, imp, MSI.MessengerType);
2610 
2611  llvm::CallBase *call;
2612  CGCallee callee(CGCalleeInfo(), imp);
2613  RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
2614  call->setMetadata(msgSendMDKind, node);
2615 
2616 
2617  if (!isPointerSizedReturn) {
2618  messageBB = CGF.Builder.GetInsertBlock();
2619  CGF.Builder.CreateBr(continueBB);
2620  CGF.EmitBlock(continueBB);
2621  if (msgRet.isScalar()) {
2622  llvm::Value *v = msgRet.getScalarVal();
2623  llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
2624  phi->addIncoming(v, messageBB);
2625  phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB);
2626  msgRet = RValue::get(phi);
2627  } else if (msgRet.isAggregate()) {
2628  Address v = msgRet.getAggregateAddress();
2629  llvm::PHINode *phi = Builder.CreatePHI(v.getType(), 2);
2630  llvm::Type *RetTy = v.getElementType();
2631  Address NullVal = CGF.CreateTempAlloca(RetTy, v.getAlignment(), "null");
2632  CGF.InitTempAlloca(NullVal, llvm::Constant::getNullValue(RetTy));
2633  phi->addIncoming(v.getPointer(), messageBB);
2634  phi->addIncoming(NullVal.getPointer(), startBB);
2635  msgRet = RValue::getAggregate(Address(phi, v.getAlignment()));
2636  } else /* isComplex() */ {
2637  std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal();
2638  llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2);
2639  phi->addIncoming(v.first, messageBB);
2640  phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
2641  startBB);
2642  llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2);
2643  phi2->addIncoming(v.second, messageBB);
2644  phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
2645  startBB);
2646  msgRet = RValue::getComplex(phi, phi2);
2647  }
2648  }
2649  return msgRet;
2650 }
2651 
2652 /// Generates a MethodList. Used in construction of a objc_class and
2653 /// objc_category structures.
2654 llvm::Constant *CGObjCGNU::
2655 GenerateMethodList(StringRef ClassName,
2656  StringRef CategoryName,
2658  bool isClassMethodList) {
2659  if (Methods.empty())
2660  return NULLPtr;
2661 
2662  ConstantInitBuilder Builder(CGM);
2663 
2664  auto MethodList = Builder.beginStruct();
2665  MethodList.addNullPointer(CGM.Int8PtrTy);
2666  MethodList.addInt(Int32Ty, Methods.size());
2667 
2668  // Get the method structure type.
2669  llvm::StructType *ObjCMethodTy =
2670  llvm::StructType::get(CGM.getLLVMContext(), {
2671  PtrToInt8Ty, // Really a selector, but the runtime creates it us.
2672  PtrToInt8Ty, // Method types
2673  IMPTy // Method pointer
2674  });
2675  bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2);
2676  if (isV2ABI) {
2677  // size_t size;
2678  llvm::DataLayout td(&TheModule);
2679  MethodList.addInt(SizeTy, td.getTypeSizeInBits(ObjCMethodTy) /
2680  CGM.getContext().getCharWidth());
2681  ObjCMethodTy =
2682  llvm::StructType::get(CGM.getLLVMContext(), {
2683  IMPTy, // Method pointer
2684  PtrToInt8Ty, // Selector
2685  PtrToInt8Ty // Extended type encoding
2686  });
2687  } else {
2688  ObjCMethodTy =
2689  llvm::StructType::get(CGM.getLLVMContext(), {
2690  PtrToInt8Ty, // Really a selector, but the runtime creates it us.
2691  PtrToInt8Ty, // Method types
2692  IMPTy // Method pointer
2693  });
2694  }
2695  auto MethodArray = MethodList.beginArray();
2696  ASTContext &Context = CGM.getContext();
2697  for (const auto *OMD : Methods) {
2698  llvm::Constant *FnPtr =
2699  TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
2700  OMD->getSelector(),
2701  isClassMethodList));
2702  assert(FnPtr && "Can't generate metadata for method that doesn't exist");
2703  auto Method = MethodArray.beginStruct(ObjCMethodTy);
2704  if (isV2ABI) {
2705  Method.addBitCast(FnPtr, IMPTy);
2706  Method.add(GetConstantSelector(OMD->getSelector(),
2707  Context.getObjCEncodingForMethodDecl(OMD)));
2708  Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD, true)));
2709  } else {
2710  Method.add(MakeConstantString(OMD->getSelector().getAsString()));
2711  Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD)));
2712  Method.addBitCast(FnPtr, IMPTy);
2713  }
2714  Method.finishAndAddTo(MethodArray);
2715  }
2716  MethodArray.finishAndAddTo(MethodList);
2717 
2718  // Create an instance of the structure
2719  return MethodList.finishAndCreateGlobal(".objc_method_list",
2720  CGM.getPointerAlign());
2721 }
2722 
2723 /// Generates an IvarList. Used in construction of a objc_class.
2724 llvm::Constant *CGObjCGNU::
2725 GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
2726  ArrayRef<llvm::Constant *> IvarTypes,
2727  ArrayRef<llvm::Constant *> IvarOffsets,
2728  ArrayRef<llvm::Constant *> IvarAlign,
2729  ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) {
2730  if (IvarNames.empty())
2731  return NULLPtr;
2732 
2733  ConstantInitBuilder Builder(CGM);
2734 
2735  // Structure containing array count followed by array.
2736  auto IvarList = Builder.beginStruct();
2737  IvarList.addInt(IntTy, (int)IvarNames.size());
2738 
2739  // Get the ivar structure type.
2740  llvm::StructType *ObjCIvarTy =
2741  llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy);
2742 
2743  // Array of ivar structures.
2744  auto Ivars = IvarList.beginArray(ObjCIvarTy);
2745  for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
2746  auto Ivar = Ivars.beginStruct(ObjCIvarTy);
2747  Ivar.add(IvarNames[i]);
2748  Ivar.add(IvarTypes[i]);
2749  Ivar.add(IvarOffsets[i]);
2750  Ivar.finishAndAddTo(Ivars);
2751  }
2752  Ivars.finishAndAddTo(IvarList);
2753 
2754  // Create an instance of the structure
2755  return IvarList.finishAndCreateGlobal(".objc_ivar_list",
2756  CGM.getPointerAlign());
2757 }
2758 
2759 /// Generate a class structure
2760 llvm::Constant *CGObjCGNU::GenerateClassStructure(
2761  llvm::Constant *MetaClass,
2762  llvm::Constant *SuperClass,
2763  unsigned info,
2764  const char *Name,
2765  llvm::Constant *Version,
2766  llvm::Constant *InstanceSize,
2767  llvm::Constant *IVars,
2768  llvm::Constant *Methods,
2769  llvm::Constant *Protocols,
2770  llvm::Constant *IvarOffsets,
2771  llvm::Constant *Properties,
2772  llvm::Constant *StrongIvarBitmap,
2773  llvm::Constant *WeakIvarBitmap,
2774  bool isMeta) {
2775  // Set up the class structure
2776  // Note: Several of these are char*s when they should be ids. This is
2777  // because the runtime performs this translation on load.
2778  //
2779  // Fields marked New ABI are part of the GNUstep runtime. We emit them
2780  // anyway; the classes will still work with the GNU runtime, they will just
2781  // be ignored.
2782  llvm::StructType *ClassTy = llvm::StructType::get(
2783  PtrToInt8Ty, // isa
2784  PtrToInt8Ty, // super_class
2785  PtrToInt8Ty, // name
2786  LongTy, // version
2787  LongTy, // info
2788  LongTy, // instance_size
2789  IVars->getType(), // ivars
2790  Methods->getType(), // methods
2791  // These are all filled in by the runtime, so we pretend
2792  PtrTy, // dtable
2793  PtrTy, // subclass_list
2794  PtrTy, // sibling_class
2795  PtrTy, // protocols
2796  PtrTy, // gc_object_type
2797  // New ABI:
2798  LongTy, // abi_version
2799  IvarOffsets->getType(), // ivar_offsets
2800  Properties->getType(), // properties
2801  IntPtrTy, // strong_pointers
2802  IntPtrTy // weak_pointers
2803  );
2804 
2805  ConstantInitBuilder Builder(CGM);
2806  auto Elements = Builder.beginStruct(ClassTy);
2807 
2808  // Fill in the structure
2809 
2810  // isa
2811  Elements.addBitCast(MetaClass, PtrToInt8Ty);
2812  // super_class
2813  Elements.add(SuperClass);
2814  // name
2815  Elements.add(MakeConstantString(Name, ".class_name"));
2816  // version
2817  Elements.addInt(LongTy, 0);
2818  // info
2819  Elements.addInt(LongTy, info);
2820  // instance_size
2821  if (isMeta) {
2822  llvm::DataLayout td(&TheModule);
2823  Elements.addInt(LongTy,
2824  td.getTypeSizeInBits(ClassTy) /
2825  CGM.getContext().getCharWidth());
2826  } else
2827  Elements.add(InstanceSize);
2828  // ivars
2829  Elements.add(IVars);
2830  // methods
2831  Elements.add(Methods);
2832  // These are all filled in by the runtime, so we pretend
2833  // dtable
2834  Elements.add(NULLPtr);
2835  // subclass_list
2836  Elements.add(NULLPtr);
2837  // sibling_class
2838  Elements.add(NULLPtr);
2839  // protocols
2840  Elements.addBitCast(Protocols, PtrTy);
2841  // gc_object_type
2842  Elements.add(NULLPtr);
2843  // abi_version
2844  Elements.addInt(LongTy, ClassABIVersion);
2845  // ivar_offsets
2846  Elements.add(IvarOffsets);
2847  // properties
2848  Elements.add(Properties);
2849  // strong_pointers
2850  Elements.add(StrongIvarBitmap);
2851  // weak_pointers
2852  Elements.add(WeakIvarBitmap);
2853  // Create an instance of the structure
2854  // This is now an externally visible symbol, so that we can speed up class
2855  // messages in the next ABI. We may already have some weak references to
2856  // this, so check and fix them properly.
2857  std::string ClassSym((isMeta ? "_OBJC_METACLASS_": "_OBJC_CLASS_") +
2858  std::string(Name));
2859  llvm::GlobalVariable *ClassRef = TheModule.getNamedGlobal(ClassSym);
2860  llvm::Constant *Class =
2861  Elements.finishAndCreateGlobal(ClassSym, CGM.getPointerAlign(), false,
2863  if (ClassRef) {
2864  ClassRef->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(Class,
2865  ClassRef->getType()));
2866  ClassRef->removeFromParent();
2867  Class->setName(ClassSym);
2868  }
2869  return Class;
2870 }
2871 
2872 llvm::Constant *CGObjCGNU::
2873 GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) {
2874  // Get the method structure type.
2875  llvm::StructType *ObjCMethodDescTy =
2876  llvm::StructType::get(CGM.getLLVMContext(), { PtrToInt8Ty, PtrToInt8Ty });
2877  ASTContext &Context = CGM.getContext();
2878  ConstantInitBuilder Builder(CGM);
2879  auto MethodList = Builder.beginStruct();
2880  MethodList.addInt(IntTy, Methods.size());
2881  auto MethodArray = MethodList.beginArray(ObjCMethodDescTy);
2882  for (auto *M : Methods) {
2883  auto Method = MethodArray.beginStruct(ObjCMethodDescTy);
2884  Method.add(MakeConstantString(M->getSelector().getAsString()));
2885  Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(M)));
2886  Method.finishAndAddTo(MethodArray);
2887  }
2888  MethodArray.finishAndAddTo(MethodList);
2889  return MethodList.finishAndCreateGlobal(".objc_method_list",
2890  CGM.getPointerAlign());
2891 }
2892 
2893 // Create the protocol list structure used in classes, categories and so on
2894 llvm::Constant *
2895 CGObjCGNU::GenerateProtocolList(ArrayRef<std::string> Protocols) {
2896 
2897  ConstantInitBuilder Builder(CGM);
2898  auto ProtocolList = Builder.beginStruct();
2899  ProtocolList.add(NULLPtr);
2900  ProtocolList.addInt(LongTy, Protocols.size());
2901 
2902  auto Elements = ProtocolList.beginArray(PtrToInt8Ty);
2903  for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
2904  iter != endIter ; iter++) {
2905  llvm::Constant *protocol = nullptr;
2906  llvm::StringMap<llvm::Constant*>::iterator value =
2907  ExistingProtocols.find(*iter);
2908  if (value == ExistingProtocols.end()) {
2909  protocol = GenerateEmptyProtocol(*iter);
2910  } else {
2911  protocol = value->getValue();
2912  }
2913  Elements.addBitCast(protocol, PtrToInt8Ty);
2914  }
2915  Elements.finishAndAddTo(ProtocolList);
2916  return ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
2917  CGM.getPointerAlign());
2918 }
2919 
2920 llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF,
2921  const ObjCProtocolDecl *PD) {
2922  llvm::Constant *&protocol = ExistingProtocols[PD->getNameAsString()];
2923  if (!protocol)
2924  GenerateProtocol(PD);
2925  llvm::Type *T =
2927  return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
2928 }
2929 
2930 llvm::Constant *
2931 CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) {
2932  llvm::Constant *ProtocolList = GenerateProtocolList({});
2933  llvm::Constant *MethodList = GenerateProtocolMethodList({});
2934  MethodList = llvm::ConstantExpr::getBitCast(MethodList, PtrToInt8Ty);
2935  // Protocols are objects containing lists of the methods implemented and
2936  // protocols adopted.
2937  ConstantInitBuilder Builder(CGM);
2938  auto Elements = Builder.beginStruct();
2939 
2940  // The isa pointer must be set to a magic number so the runtime knows it's
2941  // the correct layout.
2942  Elements.add(llvm::ConstantExpr::getIntToPtr(
2943  llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
2944 
2945  Elements.add(MakeConstantString(ProtocolName, ".objc_protocol_name"));
2946  Elements.add(ProtocolList); /* .protocol_list */
2947  Elements.add(MethodList); /* .instance_methods */
2948  Elements.add(MethodList); /* .class_methods */
2949  Elements.add(MethodList); /* .optional_instance_methods */
2950  Elements.add(MethodList); /* .optional_class_methods */
2951  Elements.add(NULLPtr); /* .properties */
2952  Elements.add(NULLPtr); /* .optional_properties */
2953  return Elements.finishAndCreateGlobal(SymbolForProtocol(ProtocolName),
2954  CGM.getPointerAlign());
2955 }
2956 
2957 void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
2958  std::string ProtocolName = PD->getNameAsString();
2959 
2960  // Use the protocol definition, if there is one.
2961  if (const ObjCProtocolDecl *Def = PD->getDefinition())
2962  PD = Def;
2963 
2964  SmallVector<std::string, 16> Protocols;
2965  for (const auto *PI : PD->protocols())
2966  Protocols.push_back(PI->getNameAsString());
2968  SmallVector<const ObjCMethodDecl*, 16> OptionalInstanceMethods;
2969  for (const auto *I : PD->instance_methods())
2970  if (I->isOptional())
2971  OptionalInstanceMethods.push_back(I);
2972  else
2973  InstanceMethods.push_back(I);
2974  // Collect information about class methods:
2976  SmallVector<const ObjCMethodDecl*, 16> OptionalClassMethods;
2977  for (const auto *I : PD->class_methods())
2978  if (I->isOptional())
2979  OptionalClassMethods.push_back(I);
2980  else
2981  ClassMethods.push_back(I);
2982 
2983  llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
2984  llvm::Constant *InstanceMethodList =
2985  GenerateProtocolMethodList(InstanceMethods);
2986  llvm::Constant *ClassMethodList =
2987  GenerateProtocolMethodList(ClassMethods);
2988  llvm::Constant *OptionalInstanceMethodList =
2989  GenerateProtocolMethodList(OptionalInstanceMethods);
2990  llvm::Constant *OptionalClassMethodList =
2991  GenerateProtocolMethodList(OptionalClassMethods);
2992 
2993  // Property metadata: name, attributes, isSynthesized, setter name, setter
2994  // types, getter name, getter types.
2995  // The isSynthesized value is always set to 0 in a protocol. It exists to
2996  // simplify the runtime library by allowing it to use the same data
2997  // structures for protocol metadata everywhere.
2998 
2999  llvm::Constant *PropertyList =
3000  GeneratePropertyList(nullptr, PD, false, false);
3001  llvm::Constant *OptionalPropertyList =
3002  GeneratePropertyList(nullptr, PD, false, true);
3003 
3004  // Protocols are objects containing lists of the methods implemented and
3005  // protocols adopted.
3006  // The isa pointer must be set to a magic number so the runtime knows it's
3007  // the correct layout.
3008  ConstantInitBuilder Builder(CGM);
3009  auto Elements = Builder.beginStruct();
3010  Elements.add(
3011  llvm::ConstantExpr::getIntToPtr(
3012  llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
3013  Elements.add(MakeConstantString(ProtocolName));
3014  Elements.add(ProtocolList);
3015  Elements.add(InstanceMethodList);
3016  Elements.add(ClassMethodList);
3017  Elements.add(OptionalInstanceMethodList);
3018  Elements.add(OptionalClassMethodList);
3019  Elements.add(PropertyList);
3020  Elements.add(OptionalPropertyList);
3021  ExistingProtocols[ProtocolName] =
3022  llvm::ConstantExpr::getBitCast(
3023  Elements.finishAndCreateGlobal(".objc_protocol", CGM.getPointerAlign()),
3024  IdTy);
3025 }
3026 void CGObjCGNU::GenerateProtocolHolderCategory() {
3027  // Collect information about instance methods
3028 
3029  ConstantInitBuilder Builder(CGM);
3030  auto Elements = Builder.beginStruct();
3031 
3032  const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack";
3033  const std::string CategoryName = "AnotherHack";
3034  Elements.add(MakeConstantString(CategoryName));
3035  Elements.add(MakeConstantString(ClassName));
3036  // Instance method list
3037  Elements.addBitCast(GenerateMethodList(
3038  ClassName, CategoryName, {}, false), PtrTy);
3039  // Class method list
3040  Elements.addBitCast(GenerateMethodList(
3041  ClassName, CategoryName, {}, true), PtrTy);
3042 
3043  // Protocol list
3044  ConstantInitBuilder ProtocolListBuilder(CGM);
3045  auto ProtocolList = ProtocolListBuilder.beginStruct();
3046  ProtocolList.add(NULLPtr);
3047  ProtocolList.addInt(LongTy, ExistingProtocols.size());
3048  auto ProtocolElements = ProtocolList.beginArray(PtrTy);
3049  for (auto iter = ExistingProtocols.begin(), endIter = ExistingProtocols.end();
3050  iter != endIter ; iter++) {
3051  ProtocolElements.addBitCast(iter->getValue(), PtrTy);
3052  }
3053  ProtocolElements.finishAndAddTo(ProtocolList);
3054  Elements.addBitCast(
3055  ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
3056  CGM.getPointerAlign()),
3057  PtrTy);
3058  Categories.push_back(llvm::ConstantExpr::getBitCast(
3059  Elements.finishAndCreateGlobal("", CGM.getPointerAlign()),
3060  PtrTy));
3061 }
3062 
3063 /// Libobjc2 uses a bitfield representation where small(ish) bitfields are
3064 /// stored in a 64-bit value with the low bit set to 1 and the remaining 63
3065 /// bits set to their values, LSB first, while larger ones are stored in a
3066 /// structure of this / form:
3067 ///
3068 /// struct { int32_t length; int32_t values[length]; };
3069 ///
3070 /// The values in the array are stored in host-endian format, with the least
3071 /// significant bit being assumed to come first in the bitfield. Therefore, a
3072 /// bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] }, while a
3073 /// bitfield / with the 63rd bit set will be 1<<64.
3074 llvm::Constant *CGObjCGNU::MakeBitField(ArrayRef<bool> bits) {
3075  int bitCount = bits.size();
3076  int ptrBits = CGM.getDataLayout().getPointerSizeInBits();
3077  if (bitCount < ptrBits) {
3078  uint64_t val = 1;
3079  for (int i=0 ; i<bitCount ; ++i) {
3080  if (bits[i]) val |= 1ULL<<(i+1);
3081  }
3082  return llvm::ConstantInt::get(IntPtrTy, val);
3083  }
3085  int v=0;
3086  while (v < bitCount) {
3087  int32_t word = 0;
3088  for (int i=0 ; (i<32) && (v<bitCount) ; ++i) {
3089  if (bits[v]) word |= 1<<i;
3090  v++;
3091  }
3092  values.push_back(llvm::ConstantInt::get(Int32Ty, word));
3093  }
3094 
3095  ConstantInitBuilder builder(CGM);
3096  auto fields = builder.beginStruct();
3097  fields.addInt(Int32Ty, values.size());
3098  auto array = fields.beginArray();
3099  for (auto v : values) array.add(v);
3100  array.finishAndAddTo(fields);
3101 
3102  llvm::Constant *GS =
3103  fields.finishAndCreateGlobal("", CharUnits::fromQuantity(4));
3104  llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy);
3105  return ptr;
3106 }
3107 
3108 llvm::Constant *CGObjCGNU::GenerateCategoryProtocolList(const
3109  ObjCCategoryDecl *OCD) {
3110  SmallVector<std::string, 16> Protocols;
3111  for (const auto *PD : OCD->getReferencedProtocols())
3112  Protocols.push_back(PD->getNameAsString());
3113  return GenerateProtocolList(Protocols);
3114 }
3115 
3116 void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3117  const ObjCInterfaceDecl *Class = OCD->getClassInterface();
3118  std::string ClassName = Class->getNameAsString();
3119  std::string CategoryName = OCD->getNameAsString();
3120 
3121  // Collect the names of referenced protocols
3122  const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl();
3123 
3124  ConstantInitBuilder Builder(CGM);
3125  auto Elements = Builder.beginStruct();
3126  Elements.add(MakeConstantString(CategoryName));
3127  Elements.add(MakeConstantString(ClassName));
3128  // Instance method list
3129  SmallVector<ObjCMethodDecl*, 16> InstanceMethods;
3130  InstanceMethods.insert(InstanceMethods.begin(), OCD->instmeth_begin(),
3131  OCD->instmeth_end());
3132  Elements.addBitCast(
3133  GenerateMethodList(ClassName, CategoryName, InstanceMethods, false),
3134  PtrTy);
3135  // Class method list
3136 
3137  SmallVector<ObjCMethodDecl*, 16> ClassMethods;
3138  ClassMethods.insert(ClassMethods.begin(), OCD->classmeth_begin(),
3139  OCD->classmeth_end());
3140  Elements.addBitCast(
3141  GenerateMethodList(ClassName, CategoryName, ClassMethods, true),
3142  PtrTy);
3143  // Protocol list
3144  Elements.addBitCast(GenerateCategoryProtocolList(CatDecl), PtrTy);
3145  if (isRuntime(ObjCRuntime::GNUstep, 2)) {
3146  const ObjCCategoryDecl *Category =
3147  Class->FindCategoryDeclaration(OCD->getIdentifier());
3148  if (Category) {
3149  // Instance properties
3150  Elements.addBitCast(GeneratePropertyList(OCD, Category, false), PtrTy);
3151  // Class properties
3152  Elements.addBitCast(GeneratePropertyList(OCD, Category, true), PtrTy);
3153  } else {
3154  Elements.addNullPointer(PtrTy);
3155  Elements.addNullPointer(PtrTy);
3156  }
3157  }
3158 
3159  Categories.push_back(llvm::ConstantExpr::getBitCast(
3160  Elements.finishAndCreateGlobal(
3161  std::string(".objc_category_")+ClassName+CategoryName,
3162  CGM.getPointerAlign()),
3163  PtrTy));
3164 }
3165 
3166 llvm::Constant *CGObjCGNU::GeneratePropertyList(const Decl *Container,
3167  const ObjCContainerDecl *OCD,
3168  bool isClassProperty,
3169  bool protocolOptionalProperties) {
3170 
3172  llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3173  bool isProtocol = isa<ObjCProtocolDecl>(OCD);
3174  ASTContext &Context = CGM.getContext();
3175 
3176  std::function<void(const ObjCProtocolDecl *Proto)> collectProtocolProperties
3177  = [&](const ObjCProtocolDecl *Proto) {
3178  for (const auto *P : Proto->protocols())
3179  collectProtocolProperties(P);
3180  for (const auto *PD : Proto->properties()) {
3181  if (isClassProperty != PD->isClassProperty())
3182  continue;
3183  // Skip any properties that are declared in protocols that this class
3184  // conforms to but are not actually implemented by this class.
3185  if (!isProtocol && !Context.getObjCPropertyImplDeclForPropertyDecl(PD, Container))
3186  continue;
3187  if (!PropertySet.insert(PD->getIdentifier()).second)
3188  continue;
3189  Properties.push_back(PD);
3190  }
3191  };
3192 
3193  if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3194  for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3195  for (auto *PD : ClassExt->properties()) {
3196  if (isClassProperty != PD->isClassProperty())
3197  continue;
3198  PropertySet.insert(PD->getIdentifier());
3199  Properties.push_back(PD);
3200  }
3201 
3202  for (const auto *PD : OCD->properties()) {
3203  if (isClassProperty != PD->isClassProperty())
3204  continue;
3205  // If we're generating a list for a protocol, skip optional / required ones
3206  // when generating the other list.
3207  if (isProtocol && (protocolOptionalProperties != PD->isOptional()))
3208  continue;
3209  // Don't emit duplicate metadata for properties that were already in a
3210  // class extension.
3211  if (!PropertySet.insert(PD->getIdentifier()).second)
3212  continue;
3213 
3214  Properties.push_back(PD);
3215  }
3216 
3217  if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3218  for (const auto *P : OID->all_referenced_protocols())
3219  collectProtocolProperties(P);
3220  else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD))
3221  for (const auto *P : CD->protocols())
3222  collectProtocolProperties(P);
3223 
3224  auto numProperties = Properties.size();
3225 
3226  if (numProperties == 0)
3227  return NULLPtr;
3228 
3229  ConstantInitBuilder builder(CGM);
3230  auto propertyList = builder.beginStruct();
3231  auto properties = PushPropertyListHeader(propertyList, numProperties);
3232 
3233  // Add all of the property methods need adding to the method list and to the
3234  // property metadata list.
3235  for (auto *property : Properties) {
3236  bool isSynthesized = false;
3237  bool isDynamic = false;
3238  if (!isProtocol) {
3239  auto *propertyImpl = Context.getObjCPropertyImplDeclForPropertyDecl(property, Container);
3240  if (propertyImpl) {
3241  isSynthesized = (propertyImpl->getPropertyImplementation() ==
3243  isDynamic = (propertyImpl->getPropertyImplementation() ==
3245  }
3246  }
3247  PushProperty(properties, property, Container, isSynthesized, isDynamic);
3248  }
3249  properties.finishAndAddTo(propertyList);
3250 
3251  return propertyList.finishAndCreateGlobal(".objc_property_list",
3252  CGM.getPointerAlign());
3253 }
3254 
3255 void CGObjCGNU::RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {
3256  // Get the class declaration for which the alias is specified.
3257  ObjCInterfaceDecl *ClassDecl =
3258  const_cast<ObjCInterfaceDecl *>(OAD->getClassInterface());
3259  ClassAliases.emplace_back(ClassDecl->getNameAsString(),
3260  OAD->getNameAsString());
3261 }
3262 
3263 void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
3264  ASTContext &Context = CGM.getContext();
3265 
3266  // Get the superclass name.
3267  const ObjCInterfaceDecl * SuperClassDecl =
3268  OID->getClassInterface()->getSuperClass();
3269  std::string SuperClassName;
3270  if (SuperClassDecl) {
3271  SuperClassName = SuperClassDecl->getNameAsString();
3272  EmitClassRef(SuperClassName);
3273  }
3274 
3275  // Get the class name
3276  ObjCInterfaceDecl *ClassDecl =
3277  const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
3278  std::string ClassName = ClassDecl->getNameAsString();
3279 
3280  // Emit the symbol that is used to generate linker errors if this class is
3281  // referenced in other modules but not declared.
3282  std::string classSymbolName = "__objc_class_name_" + ClassName;
3283  if (auto *symbol = TheModule.getGlobalVariable(classSymbolName)) {
3284  symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
3285  } else {
3286  new llvm::GlobalVariable(TheModule, LongTy, false,
3288  llvm::ConstantInt::get(LongTy, 0),
3289  classSymbolName);
3290  }
3291 
3292  // Get the size of instances.
3293  int instanceSize =
3295 
3296  // Collect information about instance variables.
3302 
3303  ConstantInitBuilder IvarOffsetBuilder(CGM);
3304  auto IvarOffsetValues = IvarOffsetBuilder.beginArray(PtrToIntTy);
3305  SmallVector<bool, 16> WeakIvars;
3306  SmallVector<bool, 16> StrongIvars;
3307 
3308  int superInstanceSize = !SuperClassDecl ? 0 :
3309  Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
3310  // For non-fragile ivars, set the instance size to 0 - {the size of just this
3311  // class}. The runtime will then set this to the correct value on load.
3312  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
3313  instanceSize = 0 - (instanceSize - superInstanceSize);
3314  }
3315 
3316  for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
3317  IVD = IVD->getNextIvar()) {
3318  // Store the name
3319  IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));
3320  // Get the type encoding for this ivar
3321  std::string TypeStr;
3322  Context.getObjCEncodingForType(IVD->getType(), TypeStr, IVD);
3323  IvarTypes.push_back(MakeConstantString(TypeStr));
3324  IvarAligns.push_back(llvm::ConstantInt::get(IntTy,
3325  Context.getTypeSize(IVD->getType())));
3326  // Get the offset
3327  uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
3328  uint64_t Offset = BaseOffset;
3329  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
3330  Offset = BaseOffset - superInstanceSize;
3331  }
3332  llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
3333  // Create the direct offset value
3334  std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." +
3335  IVD->getNameAsString();
3336 
3337  llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
3338  if (OffsetVar) {
3339  OffsetVar->setInitializer(OffsetValue);
3340  // If this is the real definition, change its linkage type so that
3341  // different modules will use this one, rather than their private
3342  // copy.
3343  OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage);
3344  } else
3345  OffsetVar = new llvm::GlobalVariable(TheModule, Int32Ty,
3347  OffsetValue, OffsetName);
3348  IvarOffsets.push_back(OffsetValue);
3349  IvarOffsetValues.add(OffsetVar);
3350  Qualifiers::ObjCLifetime lt = IVD->getType().getQualifiers().getObjCLifetime();
3351  IvarOwnership.push_back(lt);
3352  switch (lt) {
3354  StrongIvars.push_back(true);
3355  WeakIvars.push_back(false);
3356  break;
3357  case Qualifiers::OCL_Weak:
3358  StrongIvars.push_back(false);
3359  WeakIvars.push_back(true);
3360  break;
3361  default:
3362  StrongIvars.push_back(false);
3363  WeakIvars.push_back(false);
3364  }
3365  }
3366  llvm::Constant *StrongIvarBitmap = MakeBitField(StrongIvars);
3367  llvm::Constant *WeakIvarBitmap = MakeBitField(WeakIvars);
3368  llvm::GlobalVariable *IvarOffsetArray =
3369  IvarOffsetValues.finishAndCreateGlobal(".ivar.offsets",
3370  CGM.getPointerAlign());
3371 
3372  // Collect information about instance methods
3374  InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(),
3375  OID->instmeth_end());
3376 
3378  ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(),
3379  OID->classmeth_end());
3380 
3381  // Collect the same information about synthesized properties, which don't
3382  // show up in the instance method lists.
3383  for (auto *propertyImpl : OID->property_impls())
3384  if (propertyImpl->getPropertyImplementation() ==
3386  ObjCPropertyDecl *property = propertyImpl->getPropertyDecl();
3387  auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
3388  if (accessor)
3389  InstanceMethods.push_back(accessor);
3390  };
3391  addPropertyMethod(property->getGetterMethodDecl());
3392  addPropertyMethod(property->getSetterMethodDecl());
3393  }
3394 
3395  llvm::Constant *Properties = GeneratePropertyList(OID, ClassDecl);
3396 
3397  // Collect the names of referenced protocols
3398  SmallVector<std::string, 16> Protocols;
3399  for (const auto *I : ClassDecl->protocols())
3400  Protocols.push_back(I->getNameAsString());
3401 
3402  // Get the superclass pointer.
3403  llvm::Constant *SuperClass;
3404  if (!SuperClassName.empty()) {
3405  SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
3406  } else {
3407  SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);
3408  }
3409  // Empty vector used to construct empty method lists
3411  // Generate the method and instance variable lists
3412  llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
3413  InstanceMethods, false);
3414  llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
3415  ClassMethods, true);
3416  llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
3417  IvarOffsets, IvarAligns, IvarOwnership);
3418  // Irrespective of whether we are compiling for a fragile or non-fragile ABI,
3419  // we emit a symbol containing the offset for each ivar in the class. This
3420  // allows code compiled for the non-Fragile ABI to inherit from code compiled
3421  // for the legacy ABI, without causing problems. The converse is also
3422  // possible, but causes all ivar accesses to be fragile.
3423 
3424  // Offset pointer for getting at the correct field in the ivar list when
3425  // setting up the alias. These are: The base address for the global, the
3426  // ivar array (second field), the ivar in this list (set for each ivar), and
3427  // the offset (third field in ivar structure)
3428  llvm::Type *IndexTy = Int32Ty;
3429  llvm::Constant *offsetPointerIndexes[] = {Zeros[0],
3430  llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 2 : 1), nullptr,
3431  llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 3 : 2) };
3432 
3433  unsigned ivarIndex = 0;
3434  for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
3435  IVD = IVD->getNextIvar()) {
3436  const std::string Name = GetIVarOffsetVariableName(ClassDecl, IVD);
3437  offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex);
3438  // Get the correct ivar field
3439  llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(
3440  cast<llvm::GlobalVariable>(IvarList)->getValueType(), IvarList,
3441  offsetPointerIndexes);
3442  // Get the existing variable, if one exists.
3443  llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);
3444  if (offset) {
3445  offset->setInitializer(offsetValue);
3446  // If this is the real definition, change its linkage type so that
3447  // different modules will use this one, rather than their private
3448  // copy.
3449  offset->setLinkage(llvm::GlobalValue::ExternalLinkage);
3450  } else
3451  // Add a new alias if there isn't one already.
3452  new llvm::GlobalVariable(TheModule, offsetValue->getType(),
3453  false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);
3454  ++ivarIndex;
3455  }
3456  llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0);
3457 
3458  //Generate metaclass for class methods
3459  llvm::Constant *MetaClassStruct = GenerateClassStructure(
3460  NULLPtr, NULLPtr, 0x12L, ClassName.c_str(), nullptr, Zeros[0],
3461  NULLPtr, ClassMethodList, NULLPtr, NULLPtr,
3462  GeneratePropertyList(OID, ClassDecl, true), ZeroPtr, ZeroPtr, true);
3463  CGM.setGVProperties(cast<llvm::GlobalValue>(MetaClassStruct),
3464  OID->getClassInterface());
3465 
3466  // Generate the class structure
3467  llvm::Constant *ClassStruct = GenerateClassStructure(
3468  MetaClassStruct, SuperClass, 0x11L, ClassName.c_str(), nullptr,
3469  llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList,
3470  GenerateProtocolList(Protocols), IvarOffsetArray, Properties,
3471  StrongIvarBitmap, WeakIvarBitmap);
3472  CGM.setGVProperties(cast<llvm::GlobalValue>(ClassStruct),
3473  OID->getClassInterface());
3474 
3475  // Resolve the class aliases, if they exist.
3476  if (ClassPtrAlias) {
3477  ClassPtrAlias->replaceAllUsesWith(
3478  llvm::ConstantExpr::getBitCast(ClassStruct, IdTy));
3479  ClassPtrAlias->eraseFromParent();
3480  ClassPtrAlias = nullptr;
3481  }
3482  if (MetaClassPtrAlias) {
3483  MetaClassPtrAlias->replaceAllUsesWith(
3484  llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy));
3485  MetaClassPtrAlias->eraseFromParent();
3486  MetaClassPtrAlias = nullptr;
3487  }
3488 
3489  // Add class structure to list to be added to the symtab later
3490  ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
3491  Classes.push_back(ClassStruct);
3492 }
3493 
3494 llvm::Function *CGObjCGNU::ModuleInitFunction() {
3495  // Only emit an ObjC load function if no Objective-C stuff has been called
3496  if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
3497  ExistingProtocols.empty() && SelectorTable.empty())
3498  return nullptr;
3499 
3500  // Add all referenced protocols to a category.
3501  GenerateProtocolHolderCategory();
3502 
3503  llvm::StructType *selStructTy =
3504  dyn_cast<llvm::StructType>(SelectorTy->getElementType());
3505  llvm::Type *selStructPtrTy = SelectorTy;
3506  if (!selStructTy) {
3507  selStructTy = llvm::StructType::get(CGM.getLLVMContext(),
3508  { PtrToInt8Ty, PtrToInt8Ty });
3509  selStructPtrTy = llvm::PointerType::getUnqual(selStructTy);
3510  }
3511 
3512  // Generate statics list:
3513  llvm::Constant *statics = NULLPtr;
3514  if (!ConstantStrings.empty()) {
3515  llvm::GlobalVariable *fileStatics = [&] {
3516  ConstantInitBuilder builder(CGM);
3517  auto staticsStruct = builder.beginStruct();
3518 
3519  StringRef stringClass = CGM.getLangOpts().ObjCConstantStringClass;
3520  if (stringClass.empty()) stringClass = "NXConstantString";
3521  staticsStruct.add(MakeConstantString(stringClass,
3522  ".objc_static_class_name"));
3523 
3524  auto array = staticsStruct.beginArray();
3525  array.addAll(ConstantStrings);
3526  array.add(NULLPtr);
3527  array.finishAndAddTo(staticsStruct);
3528 
3529  return staticsStruct.finishAndCreateGlobal(".objc_statics",
3530  CGM.getPointerAlign());
3531  }();
3532 
3533  ConstantInitBuilder builder(CGM);
3534  auto allStaticsArray = builder.beginArray(fileStatics->getType());
3535  allStaticsArray.add(fileStatics);
3536  allStaticsArray.addNullPointer(fileStatics->getType());
3537 
3538  statics = allStaticsArray.finishAndCreateGlobal(".objc_statics_ptr",
3539  CGM.getPointerAlign());
3540  statics = llvm::ConstantExpr::getBitCast(statics, PtrTy);
3541  }
3542 
3543  // Array of classes, categories, and constant objects.
3544 
3545  SmallVector<llvm::GlobalAlias*, 16> selectorAliases;
3546  unsigned selectorCount;
3547 
3548  // Pointer to an array of selectors used in this module.
3549  llvm::GlobalVariable *selectorList = [&] {
3550  ConstantInitBuilder builder(CGM);
3551  auto selectors = builder.beginArray(selStructTy);
3552  auto &table = SelectorTable; // MSVC workaround
3553  std::vector<Selector> allSelectors;
3554  for (auto &entry : table)
3555  allSelectors.push_back(entry.first);
3556  llvm::sort(allSelectors);
3557 
3558  for (auto &untypedSel : allSelectors) {
3559  std::string selNameStr = untypedSel.getAsString();
3560  llvm::Constant *selName = ExportUniqueString(selNameStr, ".objc_sel_name");
3561 
3562  for (TypedSelector &sel : table[untypedSel]) {
3563  llvm::Constant *selectorTypeEncoding = NULLPtr;
3564  if (!sel.first.empty())
3565  selectorTypeEncoding =
3566  MakeConstantString(sel.first, ".objc_sel_types");
3567 
3568  auto selStruct = selectors.beginStruct(selStructTy);
3569  selStruct.add(selName);
3570  selStruct.add(selectorTypeEncoding);
3571  selStruct.finishAndAddTo(selectors);
3572 
3573  // Store the selector alias for later replacement
3574  selectorAliases.push_back(sel.second);
3575  }
3576  }
3577 
3578  // Remember the number of entries in the selector table.
3579  selectorCount = selectors.size();
3580 
3581  // NULL-terminate the selector list. This should not actually be required,
3582  // because the selector list has a length field. Unfortunately, the GCC
3583  // runtime decides to ignore the length field and expects a NULL terminator,
3584  // and GCC cooperates with this by always setting the length to 0.
3585  auto selStruct = selectors.beginStruct(selStructTy);
3586  selStruct.add(NULLPtr);
3587  selStruct.add(NULLPtr);
3588  selStruct.finishAndAddTo(selectors);
3589 
3590  return selectors.finishAndCreateGlobal(".objc_selector_list",
3591  CGM.getPointerAlign());
3592  }();
3593 
3594  // Now that all of the static selectors exist, create pointers to them.
3595  for (unsigned i = 0; i < selectorCount; ++i) {
3596  llvm::Constant *idxs[] = {
3597  Zeros[0],
3598  llvm::ConstantInt::get(Int32Ty, i)
3599  };
3600  // FIXME: We're generating redundant loads and stores here!
3601  llvm::Constant *selPtr = llvm::ConstantExpr::getGetElementPtr(
3602  selectorList->getValueType(), selectorList, idxs);
3603  // If selectors are defined as an opaque type, cast the pointer to this
3604  // type.
3605  selPtr = llvm::ConstantExpr::getBitCast(selPtr, SelectorTy);
3606  selectorAliases[i]->replaceAllUsesWith(selPtr);
3607  selectorAliases[i]->eraseFromParent();
3608  }
3609 
3610  llvm::GlobalVariable *symtab = [&] {
3611  ConstantInitBuilder builder(CGM);
3612  auto symtab = builder.beginStruct();
3613 
3614  // Number of static selectors
3615  symtab.addInt(LongTy, selectorCount);
3616 
3617  symtab.addBitCast(selectorList, selStructPtrTy);
3618 
3619  // Number of classes defined.
3620  symtab.addInt(CGM.Int16Ty, Classes.size());
3621  // Number of categories defined
3622  symtab.addInt(CGM.Int16Ty, Categories.size());
3623 
3624  // Create an array of classes, then categories, then static object instances
3625  auto classList = symtab.beginArray(PtrToInt8Ty);
3626  classList.addAll(Classes);
3627  classList.addAll(Categories);
3628  // NULL-terminated list of static object instances (mainly constant strings)
3629  classList.add(statics);
3630  classList.add(NULLPtr);
3631  classList.finishAndAddTo(symtab);
3632 
3633  // Construct the symbol table.
3634  return symtab.finishAndCreateGlobal("", CGM.getPointerAlign());
3635  }();
3636 
3637  // The symbol table is contained in a module which has some version-checking
3638  // constants
3639  llvm::Constant *module = [&] {
3640  llvm::Type *moduleEltTys[] = {
3641  LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy
3642  };
3643  llvm::StructType *moduleTy =
3644  llvm::StructType::get(CGM.getLLVMContext(),
3645  makeArrayRef(moduleEltTys).drop_back(unsigned(RuntimeVersion < 10)));
3646 
3647  ConstantInitBuilder builder(CGM);
3648  auto module = builder.beginStruct(moduleTy);
3649  // Runtime version, used for ABI compatibility checking.
3650  module.addInt(LongTy, RuntimeVersion);
3651  // sizeof(ModuleTy)
3652  module.addInt(LongTy, CGM.getDataLayout().getTypeStoreSize(moduleTy));
3653 
3654  // The path to the source file where this module was declared
3656  const FileEntry *mainFile = SM.getFileEntryForID(SM.getMainFileID());
3657  std::string path =
3658  (Twine(mainFile->getDir()->getName()) + "/" + mainFile->getName()).str();
3659  module.add(MakeConstantString(path, ".objc_source_file_name"));
3660  module.add(symtab);
3661 
3662  if (RuntimeVersion >= 10) {
3663  switch (CGM.getLangOpts().getGC()) {
3664  case LangOptions::GCOnly:
3665  module.addInt(IntTy, 2);
3666  break;
3667  case LangOptions::NonGC:
3668  if (CGM.getLangOpts().ObjCAutoRefCount)
3669  module.addInt(IntTy, 1);
3670  else
3671  module.addInt(IntTy, 0);
3672  break;
3673  case LangOptions::HybridGC:
3674  module.addInt(IntTy, 1);
3675  break;
3676  }
3677  }
3678 
3679  return module.finishAndCreateGlobal("", CGM.getPointerAlign());
3680  }();
3681 
3682  // Create the load function calling the runtime entry point with the module
3683  // structure
3684  llvm::Function * LoadFunction = llvm::Function::Create(
3685  llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
3686  llvm::GlobalValue::InternalLinkage, ".objc_load_function",
3687  &TheModule);
3688  llvm::BasicBlock *EntryBB =
3689  llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
3690  CGBuilderTy Builder(CGM, VMContext);
3691  Builder.SetInsertPoint(EntryBB);
3692 
3693  llvm::FunctionType *FT =
3694  llvm::FunctionType::get(Builder.getVoidTy(), module->getType(), true);
3695  llvm::FunctionCallee Register =
3696  CGM.CreateRuntimeFunction(FT, "__objc_exec_class");
3697  Builder.CreateCall(Register, module);
3698 
3699  if (!ClassAliases.empty()) {
3700  llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty};
3701  llvm::FunctionType *RegisterAliasTy =
3702  llvm::FunctionType::get(Builder.getVoidTy(),
3703  ArgTypes, false);
3704  llvm::Function *RegisterAlias = llvm::Function::Create(
3705  RegisterAliasTy,
3706  llvm::GlobalValue::ExternalWeakLinkage, "class_registerAlias_np",
3707  &TheModule);
3708  llvm::BasicBlock *AliasBB =
3709  llvm::BasicBlock::Create(VMContext, "alias", LoadFunction);
3710  llvm::BasicBlock *NoAliasBB =
3711  llvm::BasicBlock::Create(VMContext, "no_alias", LoadFunction);
3712 
3713  // Branch based on whether the runtime provided class_registerAlias_np()
3714  llvm::Value *HasRegisterAlias = Builder.CreateICmpNE(RegisterAlias,
3715  llvm::Constant::getNullValue(RegisterAlias->getType()));
3716  Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB);
3717 
3718  // The true branch (has alias registration function):
3719  Builder.SetInsertPoint(AliasBB);
3720  // Emit alias registration calls:
3721  for (std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin();
3722  iter != ClassAliases.end(); ++iter) {
3723  llvm::Constant *TheClass =
3724  TheModule.getGlobalVariable("_OBJC_CLASS_" + iter->first, true);
3725  if (TheClass) {
3726  TheClass = llvm::ConstantExpr::getBitCast(TheClass, PtrTy);
3727  Builder.CreateCall(RegisterAlias,
3728  {TheClass, MakeConstantString(iter->second)});
3729  }
3730  }
3731  // Jump to end:
3732  Builder.CreateBr(NoAliasBB);
3733 
3734  // Missing alias registration function, just return from the function:
3735  Builder.SetInsertPoint(NoAliasBB);
3736  }
3737  Builder.CreateRetVoid();
3738 
3739  return LoadFunction;
3740 }
3741 
3742 llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
3743  const ObjCContainerDecl *CD) {
3744  const ObjCCategoryImplDecl *OCD =
3745  dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext());
3746  StringRef CategoryName = OCD ? OCD->getName() : "";
3747  StringRef ClassName = CD->getName();
3748  Selector MethodName = OMD->getSelector();
3749  bool isClassMethod = !OMD->isInstanceMethod();
3750 
3751  CodeGenTypes &Types = CGM.getTypes();
3752  llvm::FunctionType *MethodTy =
3754  std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
3755  MethodName, isClassMethod);
3756 
3757  llvm::Function *Method
3758  = llvm::Function::Create(MethodTy,
3760  FunctionName,
3761  &TheModule);
3762  return Method;
3763 }
3764 
3765 llvm::FunctionCallee CGObjCGNU::GetPropertyGetFunction() {
3766  return GetPropertyFn;
3767 }
3768 
3769 llvm::FunctionCallee CGObjCGNU::GetPropertySetFunction() {
3770  return SetPropertyFn;
3771 }
3772 
3773 llvm::FunctionCallee CGObjCGNU::GetOptimizedPropertySetFunction(bool atomic,
3774  bool copy) {
3775  return nullptr;
3776 }
3777 
3778 llvm::FunctionCallee CGObjCGNU::GetGetStructFunction() {
3779  return GetStructPropertyFn;
3780 }
3781 
3782 llvm::FunctionCallee CGObjCGNU::GetSetStructFunction() {
3783  return SetStructPropertyFn;
3784 }
3785 
3786 llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectGetFunction() {
3787  return nullptr;
3788 }
3789 
3790 llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectSetFunction() {
3791  return nullptr;
3792 }
3793 
3794 llvm::FunctionCallee CGObjCGNU::EnumerationMutationFunction() {
3795  return EnumerationMutationFn;
3796 }
3797 
3798 void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF,
3799  const ObjCAtSynchronizedStmt &S) {
3800  EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn);
3801 }
3802 
3803 
3804 void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF,
3805  const ObjCAtTryStmt &S) {
3806  // Unlike the Apple non-fragile runtimes, which also uses
3807  // unwind-based zero cost exceptions, the GNU Objective C runtime's
3808  // EH support isn't a veneer over C++ EH. Instead, exception
3809  // objects are created by objc_exception_throw and destroyed by
3810  // the personality function; this avoids the need for bracketing
3811  // catch handlers with calls to __blah_begin_catch/__blah_end_catch
3812  // (or even _Unwind_DeleteException), but probably doesn't
3813  // interoperate very well with foreign exceptions.
3814  //
3815  // In Objective-C++ mode, we actually emit something equivalent to the C++
3816  // exception handler.
3817  EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn);
3818 }
3819 
3820 void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF,
3821  const ObjCAtThrowStmt &S,
3822  bool ClearInsertionPoint) {
3823  llvm::Value *ExceptionAsObject;
3824  bool isRethrow = false;
3825 
3826  if (const Expr *ThrowExpr = S.getThrowExpr()) {
3827  llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
3828  ExceptionAsObject = Exception;
3829  } else {
3830  assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
3831  "Unexpected rethrow outside @catch block.");
3832  ExceptionAsObject = CGF.ObjCEHValueStack.back();
3833  isRethrow = true;
3834  }
3835  if (isRethrow && usesSEHExceptions) {
3836  // For SEH, ExceptionAsObject may be undef, because the catch handler is
3837  // not passed it for catchalls and so it is not visible to the catch
3838  // funclet. The real thrown object will still be live on the stack at this
3839  // point and will be rethrown. If we are explicitly rethrowing the object
3840  // that was passed into the `@catch` block, then this code path is not
3841  // reached and we will instead call `objc_exception_throw` with an explicit
3842  // argument.
3843  llvm::CallBase *Throw = CGF.EmitRuntimeCallOrInvoke(ExceptionReThrowFn);
3844  Throw->setDoesNotReturn();
3845  }
3846  else {
3847  ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy);
3848  llvm::CallBase *Throw =
3849  CGF.EmitRuntimeCallOrInvoke(ExceptionThrowFn, ExceptionAsObject);
3850  Throw->setDoesNotReturn();
3851  }
3852  CGF.Builder.CreateUnreachable();
3853  if (ClearInsertionPoint)
3854  CGF.Builder.ClearInsertionPoint();
3855 }
3856 
3857 llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF,
3858  Address AddrWeakObj) {
3859  CGBuilderTy &B = CGF.Builder;
3860  AddrWeakObj = EnforceType(B, AddrWeakObj, PtrToIdTy);
3861  return B.CreateCall(WeakReadFn, AddrWeakObj.getPointer());
3862 }
3863 
3864 void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF,
3865  llvm::Value *src, Address dst) {
3866  CGBuilderTy &B = CGF.Builder;
3867  src = EnforceType(B, src, IdTy);
3868  dst = EnforceType(B, dst, PtrToIdTy);
3869  B.CreateCall(WeakAssignFn, {src, dst.getPointer()});
3870 }
3871 
3872 void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF,
3873  llvm::Value *src, Address dst,
3874  bool threadlocal) {
3875  CGBuilderTy &B = CGF.Builder;
3876  src = EnforceType(B, src, IdTy);
3877  dst = EnforceType(B, dst, PtrToIdTy);
3878  // FIXME. Add threadloca assign API
3879  assert(!threadlocal && "EmitObjCGlobalAssign - Threal Local API NYI");
3880  B.CreateCall(GlobalAssignFn, {src, dst.getPointer()});
3881 }
3882 
3883 void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF,
3884  llvm::Value *src, Address dst,
3885  llvm::Value *ivarOffset) {
3886  CGBuilderTy &B = CGF.Builder;
3887  src = EnforceType(B, src, IdTy);
3888  dst = EnforceType(B, dst, IdTy);
3889  B.CreateCall(IvarAssignFn, {src, dst.getPointer(), ivarOffset});
3890 }
3891 
3892 void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF,
3893  llvm::Value *src, Address dst) {
3894  CGBuilderTy &B = CGF.Builder;
3895  src = EnforceType(B, src, IdTy);
3896  dst = EnforceType(B, dst, PtrToIdTy);
3897  B.CreateCall(StrongCastAssignFn, {src, dst.getPointer()});
3898 }
3899 
3900 void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF,
3901  Address DestPtr,
3902  Address SrcPtr,
3903  llvm::Value *Size) {
3904  CGBuilderTy &B = CGF.Builder;
3905  DestPtr = EnforceType(B, DestPtr, PtrTy);
3906  SrcPtr = EnforceType(B, SrcPtr, PtrTy);
3907 
3908  B.CreateCall(MemMoveFn, {DestPtr.getPointer(), SrcPtr.getPointer(), Size});
3909 }
3910 
3911 llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(
3912  const ObjCInterfaceDecl *ID,
3913  const ObjCIvarDecl *Ivar) {
3914  const std::string Name = GetIVarOffsetVariableName(ID, Ivar);
3915  // Emit the variable and initialize it with what we think the correct value
3916  // is. This allows code compiled with non-fragile ivars to work correctly
3917  // when linked against code which isn't (most of the time).
3918  llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
3919  if (!IvarOffsetPointer)
3920  IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
3921  llvm::Type::getInt32PtrTy(VMContext), false,
3922  llvm::GlobalValue::ExternalLinkage, nullptr, Name);
3923  return IvarOffsetPointer;
3924 }
3925 
3926 LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF,
3927  QualType ObjectTy,
3928  llvm::Value *BaseValue,
3929  const ObjCIvarDecl *Ivar,
3930  unsigned CVRQualifiers) {
3931  const ObjCInterfaceDecl *ID =
3932  ObjectTy->getAs<ObjCObjectType>()->getInterface();
3933  return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
3934  EmitIvarOffset(CGF, ID, Ivar));
3935 }
3936 
3938  const ObjCInterfaceDecl *OID,
3939  const ObjCIvarDecl *OIVD) {
3940  for (const ObjCIvarDecl *next = OID->all_declared_ivar_begin(); next;
3941  next = next->getNextIvar()) {
3942  if (OIVD == next)
3943  return OID;
3944  }
3945 
3946  // Otherwise check in the super class.
3947  if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
3948  return FindIvarInterface(Context, Super, OIVD);
3949 
3950  return nullptr;
3951 }
3952 
3953 llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF,
3954  const ObjCInterfaceDecl *Interface,
3955  const ObjCIvarDecl *Ivar) {
3956  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
3957  Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar);
3958 
3959  // The MSVC linker cannot have a single global defined as LinkOnceAnyLinkage
3960  // and ExternalLinkage, so create a reference to the ivar global and rely on
3961  // the definition being created as part of GenerateClass.
3962  if (RuntimeVersion < 10 ||
3963  CGF.CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment())
3964  return CGF.Builder.CreateZExtOrBitCast(
3966  Int32Ty, CGF.Builder.CreateAlignedLoad(
3967  ObjCIvarOffsetVariable(Interface, Ivar),
3968  CGF.getPointerAlign(), "ivar"),
3970  PtrDiffTy);
3971  std::string name = "__objc_ivar_offset_value_" +
3972  Interface->getNameAsString() +"." + Ivar->getNameAsString();
3973  CharUnits Align = CGM.getIntAlign();
3974  llvm::Value *Offset = TheModule.getGlobalVariable(name);
3975  if (!Offset) {
3976  auto GV = new llvm::GlobalVariable(TheModule, IntTy,
3977  false, llvm::GlobalValue::LinkOnceAnyLinkage,
3978  llvm::Constant::getNullValue(IntTy), name);
3979  GV->setAlignment(Align.getQuantity());
3980  Offset = GV;
3981  }
3982  Offset = CGF.Builder.CreateAlignedLoad(Offset, Align);
3983  if (Offset->getType() != PtrDiffTy)
3984  Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
3985  return Offset;
3986  }
3987  uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar);
3988  return llvm::ConstantInt::get(PtrDiffTy, Offset, /*isSigned*/true);
3989 }
3990 
3991 CGObjCRuntime *
3993  auto Runtime = CGM.getLangOpts().ObjCRuntime;
3994  switch (Runtime.getKind()) {
3995  case ObjCRuntime::GNUstep:
3996  if (Runtime.getVersion() >= VersionTuple(2, 0))
3997  return new CGObjCGNUstep2(CGM);
3998  return new CGObjCGNUstep(CGM);
3999 
4000  case ObjCRuntime::GCC:
4001  return new CGObjCGCC(CGM);
4002 
4003  case ObjCRuntime::ObjFW:
4004  return new CGObjCObjFW(CGM);
4005 
4007  case ObjCRuntime::MacOSX:
4008  case ObjCRuntime::iOS:
4009  case ObjCRuntime::WatchOS:
4010  llvm_unreachable("these runtimes are not GNU runtimes");
4011  }
4012  llvm_unreachable("bad runtime");
4013 }
bool isAggregate() const
Definition: CGValue.h:53
const llvm::DataLayout & getDataLayout() const
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:363
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1552
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
Definition: CGBuilder.h:178
Defines the clang::ASTContext interface.
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:59
protocol_range protocols() const
Definition: DeclObjC.h:1365
Smart pointer class that efficiently represents Objective-C method names.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1848
A (possibly-)qualified type.
Definition: Type.h:634
bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)
Return true iff the given type uses &#39;sret&#39; when used as a return type.
Definition: CGCall.cpp:1505
const CodeGenOptions & getCodeGenOpts() const
all_protocol_range all_referenced_protocols() const
Definition: DeclObjC.h:1423
Defines the clang::FileManager interface and associated types.
llvm::LLVMContext & getLLVMContext()
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
The standard implementation of ConstantInitBuilder used in Clang.
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:2348
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:962
Implements runtime-specific code generation functions.
Definition: CGObjCRuntime.h:63
Defines the SourceManager interface.
const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const
Get or compute information about the layout of the specified Objective-C implementation.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
static void add(Kind k)
Definition: DeclBase.cpp:192
StringRef P
Represents Objective-C&#39;s @throw statement.
Definition: StmtObjC.h:312
CanQualType LongTy
Definition: ASTContext.h:1024
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:689
instmeth_iterator instmeth_end() const
Definition: DeclObjC.h:1061
constexpr XRayInstrMask Function
Definition: XRayInstr.h:38
&#39;gcc&#39; is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
Definition: ObjCRuntime.h:52
Represents a variable declaration or definition.
Definition: Decl.h:812
uint64_t ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM, const ObjCInterfaceDecl *OID, const ObjCIvarDecl *Ivar)
Compute an offset to the given ivar, suitable for passing to EmitValueForIvarAtOffset.
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition: Visibility.h:36
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6761
llvm::GlobalVariable * finishAndCreateGlobal(As &&...args)
Given that this builder was created by beginning an array or struct directly on a ConstantInitBuilder...
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
llvm::Value * getPointer() const
Definition: Address.h:37
Defines the Objective-C statement AST node classes.
classmeth_range class_methods() const
Definition: DeclObjC.h:1070
protocol_range protocols() const
Definition: DeclObjC.h:2128
void add(RValue rvalue, QualType type)
Definition: CGCall.h:287
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
Definition: CGObjC.cpp:3249
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:358
One of these records is kept for each identifier that is lexed.
&#39;macosx-fragile&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition: ObjCRuntime.h:39
void EmitAtSynchronizedStmt(CodeGenFunction &CGF, const ObjCAtSynchronizedStmt &S, llvm::FunctionCallee syncEnterFn, llvm::FunctionCallee syncExitFn)
Emits an @synchronize() statement, using the syncEnterFn and syncExitFn arguments as the functions ca...
This table allows us to fully hide how we implement multi-keyword caching.
Represents a class type in Objective C.
Definition: Type.h:5543
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
bool isObjCIdType() const
Definition: Type.h:6427
static const ObjCInterfaceDecl * FindIvarInterface(ASTContext &Context, const ObjCInterfaceDecl *OID, const ObjCIvarDecl *OIVD)
Definition: CGObjCGNU.cpp:3937
instmeth_range instance_methods() const
Definition: DeclObjC.h:1053
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:924
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
prop_range properties() const
Definition: DeclObjC.h:987
int Category
Definition: Format.cpp:1631
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const
Get or compute information about the layout of the specified Objective-C interface.
void InitTempAlloca(Address Alloca, llvm::Value *Value)
InitTempAlloca - Provide an initial value for the given alloca which will be observable at all locati...
Definition: CGExpr.cpp:125
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6657
IdentifierTable & Idents
Definition: ASTContext.h:565
Objects with "default" visibility are seen by the dynamic linker and act like normal objects...
Definition: Visibility.h:45
virtual llvm::Value * EmitIvarOffset(CodeGen::CodeGenFunction &CGF, const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)=0
MessageSendInfo getMessageSendInfo(const ObjCMethodDecl *method, QualType resultType, CallArgList &callArgs)
Compute the pointer-to-function type to which a message send should be casted in order to correctly c...
unsigned getLength() const
Definition: Expr.h:1711
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:81
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:968
const Expr * getThrowExpr() const
Definition: StmtObjC.h:324
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:37
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:66
Selector GetNullarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing a nullary selector.
Definition: ASTContext.h:2977
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
Definition: DeclObjC.h:2209
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void addCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2063
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:105
Represents an ObjC class declaration.
Definition: DeclObjC.h:1171
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5778
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:70
QualType getObjCProtoType() const
Retrieve the type of the Objective-C Protocol class.
Definition: ASTContext.h:1894
std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, bool Extended=false) const
Emit the encoded type for the method declaration Decl into S.
This object can be modified without requiring retains or releases.
Definition: Type.h:158
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1598
&#39;watchos&#39; is a variant of iOS for Apple&#39;s watchOS.
Definition: ObjCRuntime.h:48
bool hasAttr() const
Definition: DeclBase.h:533
return Out str()
StringRef getString() const
Definition: Expr.h:1682
void addFrom(const CallArgList &other)
Add all the arguments from another CallArgList to this one.
Definition: CGCall.h:296
ArrayBuilder beginArray(llvm::Type *eltTy=nullptr)
CGBlockInfo - Information to generate a block literal.
Definition: CGBlocks.h:152
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:38
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:178
unsigned Offset
Definition: Format.cpp:1630
This represents one expression.
Definition: Expr.h:108
known_extensions_range known_extensions() const
Definition: DeclObjC.h:1760
&#39;macosx&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition: ObjCRuntime.h:34
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
Definition: CGValue.h:65
std::string getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const
getObjCEncodingForPropertyDecl - Return the encoded type for this method declaration.
virtual void RegisterAlias(const ObjCCompatibleAliasDecl *OAD)=0
Register an class alias.
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:43
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
DeclContext * getDeclContext()
Definition: DeclBase.h:429
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1697
Represents Objective-C&#39;s @synchronized statement.
Definition: StmtObjC.h:261
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:337
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:62
virtual llvm::Value * GetSelector(CodeGenFunction &CGF, Selector Sel)=0
Get a selector for the specified name and type values.
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:206
propimpl_range property_impls() const
Definition: DeclObjC.h:2466
bool isa(CodeGen::Address addr)
Definition: Address.h:111
bool isInstanceMethod() const
Definition: DeclObjC.h:421
const TargetInfo & getTarget() const
Selector getSelector() const
Definition: DeclObjC.h:320
&#39;gnustep&#39; is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:55
const LangOptions & getLangOpts() const
ASTContext & getContext() const
QualType getType() const
Definition: DeclObjC.h:828
do v
Definition: arm_acle.h:78
const SourceManager & SM
Definition: Format.cpp:1489
static bool isNamed(const NamedDecl *ND, const char(&Str)[Len])
Definition: Decl.cpp:2754
void finishAndAddTo(AggregateBuilderBase &parent)
Given that this builder was created by beginning an array or struct component on the given parent bui...
The l-value was considered opaque, so the alignment was determined from a type.
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:94
There is no lifetime qualification on this type.
Definition: Type.h:154
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:141
std::string getAsString() const
Derive the full selector name (e.g.
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:165
bool ReturnTypeUsesFPRet(QualType ResultType)
Return true iff the given type uses &#39;fpret&#39; when used as a return type.
Definition: CGCall.cpp:1515
classmeth_iterator classmeth_end() const
Definition: DeclObjC.h:1078
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5756
static DeclContext * castToDeclContext(const TranslationUnitDecl *D)
Definition: Decl.h:129
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
virtual void GenerateProtocol(const ObjCProtocolDecl *OPD)=0
Generate the named protocol.
StringRef getName() const
Definition: FileManager.h:84
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5743
&#39;objfw&#39; is the Objective-C runtime included in ObjFW
Definition: ObjCRuntime.h:58
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
Definition: CGCall.cpp:3801
SmallVector< llvm::Value *, 8 > ObjCEHValueStack
ObjCEHValueStack - Stack of Objective-C exception values, used for rethrows.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Definition: Decl.h:291
void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const
Set visibility, dllimport/dllexport and dso_local.
Kind getKind() const
Definition: ObjCRuntime.h:76
ObjCCategoryDecl * getCategoryDecl() const
Definition: DeclObjC.cpp:2063
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C &#39;SEL&#39; type.
Definition: ASTContext.h:1858
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Objective-C methods are C functions with some implicit parameters.
Definition: CGCall.cpp:463
virtual CatchTypeInfo getCatchAllTypeInfo()
Definition: CGCXXABI.cpp:314
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2279
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
bool isAnyPointerType() const
Definition: Type.h:6305
An aligned address.
Definition: Address.h:24
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:728
All available information about a concrete callee.
Definition: CGCall.h:66
Assigning into this object requires a lifetime extension.
Definition: Type.h:171
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:77
classmeth_iterator classmeth_begin() const
Definition: DeclObjC.h:1074
The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler...
Definition: CGCleanup.h:37
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition: DeclBase.cpp:684
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating &#39;\0&#39; character...
StringRef getName() const
Return the actual identifier string.
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1977
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:58
This class organizes the cross-function state that is used while generating LLVM code.
StructBuilder beginStruct(llvm::StructType *ty=nullptr)
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2439
Dataflow Directional Tag Classes.
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:183
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1265
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
Definition: CGValue.h:92
void EmitTryCatchStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S, llvm::FunctionCallee beginCatchFn, llvm::FunctionCallee endCatchFn, llvm::FunctionCallee exceptionRethrowFn)
Emits a try / catch statement.
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:27
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:90
FileID getMainFileID() const
Returns the FileID of the main source file.
llvm::Constant * getPointer() const
Definition: Address.h:83
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:69
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5840
const ObjCInterfaceDecl * getContainingInterface() const
Return the class interface that this ivar is logically contained in; this is either the interface whe...
Definition: DeclObjC.cpp:1789
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:107
llvm::Module & getModule() const
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2746
&#39;ios&#39; is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
Definition: ObjCRuntime.h:44
Represents a pointer to an Objective C object.
Definition: Type.h:5799
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2551
virtual llvm::Constant * getAddrOfRTTIDescriptor(QualType Ty)=0
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:51
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2076
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:118
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
bool isObjCQualifiedIdType() const
Definition: Type.h:6415
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false)
Create or return a runtime function declaration with the specified type and name. ...
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:450
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2072
SourceManager & getSourceManager()
Definition: ASTContext.h:661
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2266
Reading or writing from this object requires a barrier call.
Definition: Type.h:168
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1008
bool isVoidType() const
Definition: Type.h:6553
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:74
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1944
A helper class of ConstantInitBuilder, used for building constant struct initializers.
bool containsNonAscii() const
Definition: Expr.h:1725
void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, QualType T, std::string &S, bool Extended) const
getObjCEncodingForMethodParameter - Return the encoded type for a single method parameter or return t...
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:60
Represents Objective-C&#39;s @try ... @catch ... @finally statement.
Definition: StmtObjC.h:153
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1599
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
CGCXXABI & getCXXABI() const
CanQualType IntTy
Definition: ASTContext.h:1024
The top declaration context.
Definition: Decl.h:107
static RValue get(llvm::Value *V)
Definition: CGValue.h:85
Visibility getVisibility() const
Determines the visibility of this entity.
Definition: Decl.h:390
LValue EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF, const ObjCInterfaceDecl *OID, llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers, llvm::Value *Offset)
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
llvm::Value * LoadObjCSelf()
LoadObjCSelf - Load the value of self.
Definition: CGObjC.cpp:1577
QualType getType() const
Definition: Decl.h:647
std::string ObjCConstantStringClass
Definition: LangOptions.h:210
static RValue getAggregate(Address addr, bool isVolatile=false)
Definition: CGValue.h:106
instmeth_iterator instmeth_begin() const
Definition: DeclObjC.h:1057
LValue - This represents an lvalue references.
Definition: CGValue.h:166
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:921
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1591
CanQualType BoolTy
Definition: ASTContext.h:1016
Kind
The basic Objective-C runtimes that we know about.
Definition: ObjCRuntime.h:30
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value *> args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition: CGCall.cpp:3761
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:262
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2498
This class handles loading and caching of source files into memory.
A helper class of ConstantInitBuilder, used for building constant array initializers.
Abstract information about a function or function prototype.
Definition: CGCall.h:44
bool isScalar() const
Definition: CGValue.h:51
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2728
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
StringRef getName() const
Definition: FileManager.h:51
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CGObjCRuntime * CreateGNUObjCRuntime(CodeGenModule &CGM)
Creates an instance of an Objective-C runtime class.
Definition: CGObjCGNU.cpp:3992
ObjCCategoryDecl * FindCategoryDeclaration(IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
Definition: DeclObjC.cpp:1663
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1549
const llvm::Triple & getTriple() const