clang  3.8.0
CGObjCGNU.cpp
Go to the documentation of this file.
1 //===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides Objective-C code generation targeting the GNU runtime. The
11 // class in this file generates structures used by the GNU Objective-C runtime
12 // library. These structures are defined in objc/objc.h and objc/objc-api.h in
13 // the GNU runtime distribution.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "CGObjCRuntime.h"
18 #include "CGCleanup.h"
19 #include "CodeGenFunction.h"
20 #include "CodeGenModule.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/Decl.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/StmtObjC.h"
28 #include "llvm/ADT/SmallVector.h"
29 #include "llvm/ADT/StringMap.h"
30 #include "llvm/IR/CallSite.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 <cstdarg>
37 
38 
39 using namespace clang;
40 using namespace CodeGen;
41 
42 
43 namespace {
44 /// Class that lazily initialises the runtime function. Avoids inserting the
45 /// types and the function declaration into a module if they're not used, and
46 /// avoids constructing the type more than once if it's used more than once.
47 class LazyRuntimeFunction {
48  CodeGenModule *CGM;
49  llvm::FunctionType *FTy;
50  const char *FunctionName;
51  llvm::Constant *Function;
52 
53 public:
54  /// Constructor leaves this class uninitialized, because it is intended to
55  /// be used as a field in another class and not all of the types that are
56  /// used as arguments will necessarily be available at construction time.
57  LazyRuntimeFunction()
58  : CGM(nullptr), FunctionName(nullptr), Function(nullptr) {}
59 
60  /// Initialises the lazy function with the name, return type, and the types
61  /// of the arguments.
62  LLVM_END_WITH_NULL
63  void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy, ...) {
64  CGM = Mod;
65  FunctionName = name;
66  Function = nullptr;
67  std::vector<llvm::Type *> ArgTys;
68  va_list Args;
69  va_start(Args, RetTy);
70  while (llvm::Type *ArgTy = va_arg(Args, llvm::Type *))
71  ArgTys.push_back(ArgTy);
72  va_end(Args);
73  FTy = llvm::FunctionType::get(RetTy, ArgTys, false);
74  }
75 
76  llvm::FunctionType *getType() { return FTy; }
77 
78  /// Overloaded cast operator, allows the class to be implicitly cast to an
79  /// LLVM constant.
80  operator llvm::Constant *() {
81  if (!Function) {
82  if (!FunctionName)
83  return nullptr;
84  Function =
85  cast<llvm::Constant>(CGM->CreateRuntimeFunction(FTy, FunctionName));
86  }
87  return Function;
88  }
89  operator llvm::Function *() {
90  return cast<llvm::Function>((llvm::Constant *)*this);
91  }
92 };
93 
94 
95 /// GNU Objective-C runtime code generation. This class implements the parts of
96 /// Objective-C support that are specific to the GNU family of runtimes (GCC,
97 /// GNUstep and ObjFW).
98 class CGObjCGNU : public CGObjCRuntime {
99 protected:
100  /// The LLVM module into which output is inserted
101  llvm::Module &TheModule;
102  /// strut objc_super. Used for sending messages to super. This structure
103  /// contains the receiver (object) and the expected class.
104  llvm::StructType *ObjCSuperTy;
105  /// struct objc_super*. The type of the argument to the superclass message
106  /// lookup functions.
107  llvm::PointerType *PtrToObjCSuperTy;
108  /// LLVM type for selectors. Opaque pointer (i8*) unless a header declaring
109  /// SEL is included in a header somewhere, in which case it will be whatever
110  /// type is declared in that header, most likely {i8*, i8*}.
111  llvm::PointerType *SelectorTy;
112  /// LLVM i8 type. Cached here to avoid repeatedly getting it in all of the
113  /// places where it's used
114  llvm::IntegerType *Int8Ty;
115  /// Pointer to i8 - LLVM type of char*, for all of the places where the
116  /// runtime needs to deal with C strings.
117  llvm::PointerType *PtrToInt8Ty;
118  /// Instance Method Pointer type. This is a pointer to a function that takes,
119  /// at a minimum, an object and a selector, and is the generic type for
120  /// Objective-C methods. Due to differences between variadic / non-variadic
121  /// calling conventions, it must always be cast to the correct type before
122  /// actually being used.
123  llvm::PointerType *IMPTy;
124  /// Type of an untyped Objective-C object. Clang treats id as a built-in type
125  /// when compiling Objective-C code, so this may be an opaque pointer (i8*),
126  /// but if the runtime header declaring it is included then it may be a
127  /// pointer to a structure.
128  llvm::PointerType *IdTy;
129  /// Pointer to a pointer to an Objective-C object. Used in the new ABI
130  /// message lookup function and some GC-related functions.
131  llvm::PointerType *PtrToIdTy;
132  /// The clang type of id. Used when using the clang CGCall infrastructure to
133  /// call Objective-C methods.
134  CanQualType ASTIdTy;
135  /// LLVM type for C int type.
136  llvm::IntegerType *IntTy;
137  /// LLVM type for an opaque pointer. This is identical to PtrToInt8Ty, but is
138  /// used in the code to document the difference between i8* meaning a pointer
139  /// to a C string and i8* meaning a pointer to some opaque type.
140  llvm::PointerType *PtrTy;
141  /// LLVM type for C long type. The runtime uses this in a lot of places where
142  /// it should be using intptr_t, but we can't fix this without breaking
143  /// compatibility with GCC...
144  llvm::IntegerType *LongTy;
145  /// LLVM type for C size_t. Used in various runtime data structures.
146  llvm::IntegerType *SizeTy;
147  /// LLVM type for C intptr_t.
148  llvm::IntegerType *IntPtrTy;
149  /// LLVM type for C ptrdiff_t. Mainly used in property accessor functions.
150  llvm::IntegerType *PtrDiffTy;
151  /// LLVM type for C int*. Used for GCC-ABI-compatible non-fragile instance
152  /// variables.
153  llvm::PointerType *PtrToIntTy;
154  /// LLVM type for Objective-C BOOL type.
155  llvm::Type *BoolTy;
156  /// 32-bit integer type, to save us needing to look it up every time it's used.
157  llvm::IntegerType *Int32Ty;
158  /// 64-bit integer type, to save us needing to look it up every time it's used.
159  llvm::IntegerType *Int64Ty;
160  /// Metadata kind used to tie method lookups to message sends. The GNUstep
161  /// runtime provides some LLVM passes that can use this to do things like
162  /// automatic IMP caching and speculative inlining.
163  unsigned msgSendMDKind;
164  /// Helper function that generates a constant string and returns a pointer to
165  /// the start of the string. The result of this function can be used anywhere
166  /// where the C code specifies const char*.
167  llvm::Constant *MakeConstantString(const std::string &Str,
168  const std::string &Name="") {
169  ConstantAddress Array = CGM.GetAddrOfConstantCString(Str, Name.c_str());
170  return llvm::ConstantExpr::getGetElementPtr(Array.getElementType(),
171  Array.getPointer(), Zeros);
172  }
173  /// Emits a linkonce_odr string, whose name is the prefix followed by the
174  /// string value. This allows the linker to combine the strings between
175  /// different modules. Used for EH typeinfo names, selector strings, and a
176  /// few other things.
177  llvm::Constant *ExportUniqueString(const std::string &Str,
178  const std::string prefix) {
179  std::string name = prefix + Str;
180  auto *ConstStr = TheModule.getGlobalVariable(name);
181  if (!ConstStr) {
182  llvm::Constant *value = llvm::ConstantDataArray::getString(VMContext,Str);
183  ConstStr = new llvm::GlobalVariable(TheModule, value->getType(), true,
184  llvm::GlobalValue::LinkOnceODRLinkage, value, prefix + Str);
185  }
186  return llvm::ConstantExpr::getGetElementPtr(ConstStr->getValueType(),
187  ConstStr, Zeros);
188  }
189  /// Generates a global structure, initialized by the elements in the vector.
190  /// The element types must match the types of the structure elements in the
191  /// first argument.
192  llvm::GlobalVariable *MakeGlobal(llvm::StructType *Ty,
194  CharUnits Align,
195  StringRef Name="",
196  llvm::GlobalValue::LinkageTypes linkage
198  llvm::Constant *C = llvm::ConstantStruct::get(Ty, V);
199  auto GV = new llvm::GlobalVariable(TheModule, Ty, false,
200  linkage, C, Name);
201  GV->setAlignment(Align.getQuantity());
202  return GV;
203  }
204  /// Generates a global array. The vector must contain the same number of
205  /// elements that the array type declares, of the type specified as the array
206  /// element type.
207  llvm::GlobalVariable *MakeGlobal(llvm::ArrayType *Ty,
209  CharUnits Align,
210  StringRef Name="",
211  llvm::GlobalValue::LinkageTypes linkage
213  llvm::Constant *C = llvm::ConstantArray::get(Ty, V);
214  auto GV = new llvm::GlobalVariable(TheModule, Ty, false,
215  linkage, C, Name);
216  GV->setAlignment(Align.getQuantity());
217  return GV;
218  }
219  /// Generates a global array, inferring the array type from the specified
220  /// element type and the size of the initialiser.
221  llvm::GlobalVariable *MakeGlobalArray(llvm::Type *Ty,
223  CharUnits Align,
224  StringRef Name="",
225  llvm::GlobalValue::LinkageTypes linkage
227  llvm::ArrayType *ArrayTy = llvm::ArrayType::get(Ty, V.size());
228  return MakeGlobal(ArrayTy, V, Align, Name, linkage);
229  }
230  /// Returns a property name and encoding string.
231  llvm::Constant *MakePropertyEncodingString(const ObjCPropertyDecl *PD,
232  const Decl *Container) {
233  const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
234  if ((R.getKind() == ObjCRuntime::GNUstep) &&
235  (R.getVersion() >= VersionTuple(1, 6))) {
236  std::string NameAndAttributes;
237  std::string TypeStr;
238  CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
239  NameAndAttributes += '\0';
240  NameAndAttributes += TypeStr.length() + 3;
241  NameAndAttributes += TypeStr;
242  NameAndAttributes += '\0';
243  NameAndAttributes += PD->getNameAsString();
244  return MakeConstantString(NameAndAttributes);
245  }
246  return MakeConstantString(PD->getNameAsString());
247  }
248  /// Push the property attributes into two structure fields.
249  void PushPropertyAttributes(std::vector<llvm::Constant*> &Fields,
250  ObjCPropertyDecl *property, bool isSynthesized=true, bool
251  isDynamic=true) {
252  int attrs = property->getPropertyAttributes();
253  // For read-only properties, clear the copy and retain flags
255  attrs &= ~ObjCPropertyDecl::OBJC_PR_copy;
256  attrs &= ~ObjCPropertyDecl::OBJC_PR_retain;
257  attrs &= ~ObjCPropertyDecl::OBJC_PR_weak;
258  attrs &= ~ObjCPropertyDecl::OBJC_PR_strong;
259  }
260  // The first flags field has the same attribute values as clang uses internally
261  Fields.push_back(llvm::ConstantInt::get(Int8Ty, attrs & 0xff));
262  attrs >>= 8;
263  attrs <<= 2;
264  // For protocol properties, synthesized and dynamic have no meaning, so we
265  // reuse these flags to indicate that this is a protocol property (both set
266  // has no meaning, as a property can't be both synthesized and dynamic)
267  attrs |= isSynthesized ? (1<<0) : 0;
268  attrs |= isDynamic ? (1<<1) : 0;
269  // The second field is the next four fields left shifted by two, with the
270  // low bit set to indicate whether the field is synthesized or dynamic.
271  Fields.push_back(llvm::ConstantInt::get(Int8Ty, attrs & 0xff));
272  // Two padding fields
273  Fields.push_back(llvm::ConstantInt::get(Int8Ty, 0));
274  Fields.push_back(llvm::ConstantInt::get(Int8Ty, 0));
275  }
276  /// Ensures that the value has the required type, by inserting a bitcast if
277  /// required. This function lets us avoid inserting bitcasts that are
278  /// redundant.
279  llvm::Value* EnforceType(CGBuilderTy &B, llvm::Value *V, llvm::Type *Ty) {
280  if (V->getType() == Ty) return V;
281  return B.CreateBitCast(V, Ty);
282  }
283  Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) {
284  if (V.getType() == Ty) return V;
285  return B.CreateBitCast(V, Ty);
286  }
287  // Some zeros used for GEPs in lots of places.
288  llvm::Constant *Zeros[2];
289  /// Null pointer value. Mainly used as a terminator in various arrays.
290  llvm::Constant *NULLPtr;
291  /// LLVM context.
292  llvm::LLVMContext &VMContext;
293 private:
294  /// Placeholder for the class. Lots of things refer to the class before we've
295  /// actually emitted it. We use this alias as a placeholder, and then replace
296  /// it with a pointer to the class structure before finally emitting the
297  /// module.
298  llvm::GlobalAlias *ClassPtrAlias;
299  /// Placeholder for the metaclass. Lots of things refer to the class before
300  /// we've / actually emitted it. We use this alias as a placeholder, and then
301  /// replace / it with a pointer to the metaclass structure before finally
302  /// emitting the / module.
303  llvm::GlobalAlias *MetaClassPtrAlias;
304  /// All of the classes that have been generated for this compilation units.
305  std::vector<llvm::Constant*> Classes;
306  /// All of the categories that have been generated for this compilation units.
307  std::vector<llvm::Constant*> Categories;
308  /// All of the Objective-C constant strings that have been generated for this
309  /// compilation units.
310  std::vector<llvm::Constant*> ConstantStrings;
311  /// Map from string values to Objective-C constant strings in the output.
312  /// Used to prevent emitting Objective-C strings more than once. This should
313  /// not be required at all - CodeGenModule should manage this list.
314  llvm::StringMap<llvm::Constant*> ObjCStrings;
315  /// All of the protocols that have been declared.
316  llvm::StringMap<llvm::Constant*> ExistingProtocols;
317  /// For each variant of a selector, we store the type encoding and a
318  /// placeholder value. For an untyped selector, the type will be the empty
319  /// string. Selector references are all done via the module's selector table,
320  /// so we create an alias as a placeholder and then replace it with the real
321  /// value later.
322  typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector;
323  /// Type of the selector map. This is roughly equivalent to the structure
324  /// used in the GNUstep runtime, which maintains a list of all of the valid
325  /// types for a selector in a table.
326  typedef llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> >
327  SelectorMap;
328  /// A map from selectors to selector types. This allows us to emit all
329  /// selectors of the same name and type together.
330  SelectorMap SelectorTable;
331 
332  /// Selectors related to memory management. When compiling in GC mode, we
333  /// omit these.
334  Selector RetainSel, ReleaseSel, AutoreleaseSel;
335  /// Runtime functions used for memory management in GC mode. Note that clang
336  /// supports code generation for calling these functions, but neither GNU
337  /// runtime actually supports this API properly yet.
338  LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn,
339  WeakAssignFn, GlobalAssignFn;
340 
341  typedef std::pair<std::string, std::string> ClassAliasPair;
342  /// All classes that have aliases set for them.
343  std::vector<ClassAliasPair> ClassAliases;
344 
345 protected:
346  /// Function used for throwing Objective-C exceptions.
347  LazyRuntimeFunction ExceptionThrowFn;
348  /// Function used for rethrowing exceptions, used at the end of \@finally or
349  /// \@synchronize blocks.
350  LazyRuntimeFunction ExceptionReThrowFn;
351  /// Function called when entering a catch function. This is required for
352  /// differentiating Objective-C exceptions and foreign exceptions.
353  LazyRuntimeFunction EnterCatchFn;
354  /// Function called when exiting from a catch block. Used to do exception
355  /// cleanup.
356  LazyRuntimeFunction ExitCatchFn;
357  /// Function called when entering an \@synchronize block. Acquires the lock.
358  LazyRuntimeFunction SyncEnterFn;
359  /// Function called when exiting an \@synchronize block. Releases the lock.
360  LazyRuntimeFunction SyncExitFn;
361 
362 private:
363 
364  /// Function called if fast enumeration detects that the collection is
365  /// modified during the update.
366  LazyRuntimeFunction EnumerationMutationFn;
367  /// Function for implementing synthesized property getters that return an
368  /// object.
369  LazyRuntimeFunction GetPropertyFn;
370  /// Function for implementing synthesized property setters that return an
371  /// object.
372  LazyRuntimeFunction SetPropertyFn;
373  /// Function used for non-object declared property getters.
374  LazyRuntimeFunction GetStructPropertyFn;
375  /// Function used for non-object declared property setters.
376  LazyRuntimeFunction SetStructPropertyFn;
377 
378  /// The version of the runtime that this class targets. Must match the
379  /// version in the runtime.
380  int RuntimeVersion;
381  /// The version of the protocol class. Used to differentiate between ObjC1
382  /// and ObjC2 protocols. Objective-C 1 protocols can not contain optional
383  /// components and can not contain declared properties. We always emit
384  /// Objective-C 2 property structures, but we have to pretend that they're
385  /// Objective-C 1 property structures when targeting the GCC runtime or it
386  /// will abort.
387  const int ProtocolVersion;
388 private:
389  /// Generates an instance variable list structure. This is a structure
390  /// containing a size and an array of structures containing instance variable
391  /// metadata. This is used purely for introspection in the fragile ABI. In
392  /// the non-fragile ABI, it's used for instance variable fixup.
393  llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
394  ArrayRef<llvm::Constant *> IvarTypes,
395  ArrayRef<llvm::Constant *> IvarOffsets);
396  /// Generates a method list structure. This is a structure containing a size
397  /// and an array of structures containing method metadata.
398  ///
399  /// This structure is used by both classes and categories, and contains a next
400  /// pointer allowing them to be chained together in a linked list.
401  llvm::Constant *GenerateMethodList(StringRef ClassName,
402  StringRef CategoryName,
403  ArrayRef<Selector> MethodSels,
404  ArrayRef<llvm::Constant *> MethodTypes,
405  bool isClassMethodList);
406  /// Emits an empty protocol. This is used for \@protocol() where no protocol
407  /// is found. The runtime will (hopefully) fix up the pointer to refer to the
408  /// real protocol.
409  llvm::Constant *GenerateEmptyProtocol(const std::string &ProtocolName);
410  /// Generates a list of property metadata structures. This follows the same
411  /// pattern as method and instance variable metadata lists.
412  llvm::Constant *GeneratePropertyList(const ObjCImplementationDecl *OID,
413  SmallVectorImpl<Selector> &InstanceMethodSels,
414  SmallVectorImpl<llvm::Constant*> &InstanceMethodTypes);
415  /// Generates a list of referenced protocols. Classes, categories, and
416  /// protocols all use this structure.
417  llvm::Constant *GenerateProtocolList(ArrayRef<std::string> Protocols);
418  /// To ensure that all protocols are seen by the runtime, we add a category on
419  /// a class defined in the runtime, declaring no methods, but adopting the
420  /// protocols. This is a horribly ugly hack, but it allows us to collect all
421  /// of the protocols without changing the ABI.
422  void GenerateProtocolHolderCategory();
423  /// Generates a class structure.
424  llvm::Constant *GenerateClassStructure(
425  llvm::Constant *MetaClass,
426  llvm::Constant *SuperClass,
427  unsigned info,
428  const char *Name,
429  llvm::Constant *Version,
430  llvm::Constant *InstanceSize,
431  llvm::Constant *IVars,
432  llvm::Constant *Methods,
433  llvm::Constant *Protocols,
434  llvm::Constant *IvarOffsets,
435  llvm::Constant *Properties,
436  llvm::Constant *StrongIvarBitmap,
437  llvm::Constant *WeakIvarBitmap,
438  bool isMeta=false);
439  /// Generates a method list. This is used by protocols to define the required
440  /// and optional methods.
441  llvm::Constant *GenerateProtocolMethodList(
442  ArrayRef<llvm::Constant *> MethodNames,
443  ArrayRef<llvm::Constant *> MethodTypes);
444  /// Returns a selector with the specified type encoding. An empty string is
445  /// used to return an untyped selector (with the types field set to NULL).
446  llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel,
447  const std::string &TypeEncoding);
448  /// Returns the variable used to store the offset of an instance variable.
449  llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
450  const ObjCIvarDecl *Ivar);
451  /// Emits a reference to a class. This allows the linker to object if there
452  /// is no class of the matching name.
453 protected:
454  void EmitClassRef(const std::string &className);
455  /// Emits a pointer to the named class
456  virtual llvm::Value *GetClassNamed(CodeGenFunction &CGF,
457  const std::string &Name, bool isWeak);
458  /// Looks up the method for sending a message to the specified object. This
459  /// mechanism differs between the GCC and GNU runtimes, so this method must be
460  /// overridden in subclasses.
461  virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
462  llvm::Value *&Receiver,
463  llvm::Value *cmd,
464  llvm::MDNode *node,
465  MessageSendInfo &MSI) = 0;
466  /// Looks up the method for sending a message to a superclass. This
467  /// mechanism differs between the GCC and GNU runtimes, so this method must
468  /// be overridden in subclasses.
469  virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
470  Address ObjCSuper,
471  llvm::Value *cmd,
472  MessageSendInfo &MSI) = 0;
473  /// Libobjc2 uses a bitfield representation where small(ish) bitfields are
474  /// stored in a 64-bit value with the low bit set to 1 and the remaining 63
475  /// bits set to their values, LSB first, while larger ones are stored in a
476  /// structure of this / form:
477  ///
478  /// struct { int32_t length; int32_t values[length]; };
479  ///
480  /// The values in the array are stored in host-endian format, with the least
481  /// significant bit being assumed to come first in the bitfield. Therefore,
482  /// a bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] },
483  /// while a bitfield / with the 63rd bit set will be 1<<64.
484  llvm::Constant *MakeBitField(ArrayRef<bool> bits);
485 public:
486  CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
487  unsigned protocolClassVersion);
488 
489  ConstantAddress GenerateConstantString(const StringLiteral *) override;
490 
491  RValue
492  GenerateMessageSend(CodeGenFunction &CGF, ReturnValueSlot Return,
493  QualType ResultType, Selector Sel,
494  llvm::Value *Receiver, const CallArgList &CallArgs,
495  const ObjCInterfaceDecl *Class,
496  const ObjCMethodDecl *Method) override;
497  RValue
498  GenerateMessageSendSuper(CodeGenFunction &CGF, ReturnValueSlot Return,
499  QualType ResultType, Selector Sel,
500  const ObjCInterfaceDecl *Class,
501  bool isCategoryImpl, llvm::Value *Receiver,
502  bool IsClassMessage, const CallArgList &CallArgs,
503  const ObjCMethodDecl *Method) override;
504  llvm::Value *GetClass(CodeGenFunction &CGF,
505  const ObjCInterfaceDecl *OID) override;
506  llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
507  Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
508  llvm::Value *GetSelector(CodeGenFunction &CGF,
509  const ObjCMethodDecl *Method) override;
510  llvm::Constant *GetEHType(QualType T) override;
511 
512  llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
513  const ObjCContainerDecl *CD) override;
514  void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
515  void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
516  void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override;
517  llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
518  const ObjCProtocolDecl *PD) override;
519  void GenerateProtocol(const ObjCProtocolDecl *PD) override;
520  llvm::Function *ModuleInitFunction() override;
521  llvm::Constant *GetPropertyGetFunction() override;
522  llvm::Constant *GetPropertySetFunction() override;
523  llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
524  bool copy) override;
525  llvm::Constant *GetSetStructFunction() override;
526  llvm::Constant *GetGetStructFunction() override;
527  llvm::Constant *GetCppAtomicObjectGetFunction() override;
528  llvm::Constant *GetCppAtomicObjectSetFunction() override;
529  llvm::Constant *EnumerationMutationFunction() override;
530 
531  void EmitTryStmt(CodeGenFunction &CGF,
532  const ObjCAtTryStmt &S) override;
533  void EmitSynchronizedStmt(CodeGenFunction &CGF,
534  const ObjCAtSynchronizedStmt &S) override;
535  void EmitThrowStmt(CodeGenFunction &CGF,
536  const ObjCAtThrowStmt &S,
537  bool ClearInsertionPoint=true) override;
538  llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF,
539  Address AddrWeakObj) override;
540  void EmitObjCWeakAssign(CodeGenFunction &CGF,
541  llvm::Value *src, Address dst) override;
542  void EmitObjCGlobalAssign(CodeGenFunction &CGF,
543  llvm::Value *src, Address dest,
544  bool threadlocal=false) override;
545  void EmitObjCIvarAssign(CodeGenFunction &CGF, llvm::Value *src,
546  Address dest, llvm::Value *ivarOffset) override;
547  void EmitObjCStrongCastAssign(CodeGenFunction &CGF,
548  llvm::Value *src, Address dest) override;
549  void EmitGCMemmoveCollectable(CodeGenFunction &CGF, Address DestPtr,
550  Address SrcPtr,
551  llvm::Value *Size) override;
552  LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy,
553  llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
554  unsigned CVRQualifiers) override;
555  llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
556  const ObjCInterfaceDecl *Interface,
557  const ObjCIvarDecl *Ivar) override;
558  llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
559  llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM,
560  const CGBlockInfo &blockInfo) override {
561  return NULLPtr;
562  }
563  llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM,
564  const CGBlockInfo &blockInfo) override {
565  return NULLPtr;
566  }
567 
568  llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override {
569  return NULLPtr;
570  }
571 
572  llvm::GlobalVariable *GetClassGlobal(const std::string &Name,
573  bool Weak = false) override {
574  return nullptr;
575  }
576 };
577 /// Class representing the legacy GCC Objective-C ABI. This is the default when
578 /// -fobjc-nonfragile-abi is not specified.
579 ///
580 /// The GCC ABI target actually generates code that is approximately compatible
581 /// with the new GNUstep runtime ABI, but refrains from using any features that
582 /// would not work with the GCC runtime. For example, clang always generates
583 /// the extended form of the class structure, and the extra fields are simply
584 /// ignored by GCC libobjc.
585 class CGObjCGCC : public CGObjCGNU {
586  /// The GCC ABI message lookup function. Returns an IMP pointing to the
587  /// method implementation for this message.
588  LazyRuntimeFunction MsgLookupFn;
589  /// The GCC ABI superclass message lookup function. Takes a pointer to a
590  /// structure describing the receiver and the class, and a selector as
591  /// arguments. Returns the IMP for the corresponding method.
592  LazyRuntimeFunction MsgLookupSuperFn;
593 protected:
594  llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
595  llvm::Value *cmd, llvm::MDNode *node,
596  MessageSendInfo &MSI) override {
597  CGBuilderTy &Builder = CGF.Builder;
598  llvm::Value *args[] = {
599  EnforceType(Builder, Receiver, IdTy),
600  EnforceType(Builder, cmd, SelectorTy) };
601  llvm::CallSite imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
602  imp->setMetadata(msgSendMDKind, node);
603  return imp.getInstruction();
604  }
605  llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
606  llvm::Value *cmd, MessageSendInfo &MSI) override {
607  CGBuilderTy &Builder = CGF.Builder;
608  llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper,
609  PtrToObjCSuperTy).getPointer(), cmd};
610  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
611  }
612  public:
613  CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) {
614  // IMP objc_msg_lookup(id, SEL);
615  MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy,
616  nullptr);
617  // IMP objc_msg_lookup_super(struct objc_super*, SEL);
618  MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
619  PtrToObjCSuperTy, SelectorTy, nullptr);
620  }
621 };
622 /// Class used when targeting the new GNUstep runtime ABI.
623 class CGObjCGNUstep : public CGObjCGNU {
624  /// The slot lookup function. Returns a pointer to a cacheable structure
625  /// that contains (among other things) the IMP.
626  LazyRuntimeFunction SlotLookupFn;
627  /// The GNUstep ABI superclass message lookup function. Takes a pointer to
628  /// a structure describing the receiver and the class, and a selector as
629  /// arguments. Returns the slot for the corresponding method. Superclass
630  /// message lookup rarely changes, so this is a good caching opportunity.
631  LazyRuntimeFunction SlotLookupSuperFn;
632  /// Specialised function for setting atomic retain properties
633  LazyRuntimeFunction SetPropertyAtomic;
634  /// Specialised function for setting atomic copy properties
635  LazyRuntimeFunction SetPropertyAtomicCopy;
636  /// Specialised function for setting nonatomic retain properties
637  LazyRuntimeFunction SetPropertyNonAtomic;
638  /// Specialised function for setting nonatomic copy properties
639  LazyRuntimeFunction SetPropertyNonAtomicCopy;
640  /// Function to perform atomic copies of C++ objects with nontrivial copy
641  /// constructors from Objective-C ivars.
642  LazyRuntimeFunction CxxAtomicObjectGetFn;
643  /// Function to perform atomic copies of C++ objects with nontrivial copy
644  /// constructors to Objective-C ivars.
645  LazyRuntimeFunction CxxAtomicObjectSetFn;
646  /// Type of an slot structure pointer. This is returned by the various
647  /// lookup functions.
648  llvm::Type *SlotTy;
649  public:
650  llvm::Constant *GetEHType(QualType T) override;
651  protected:
652  llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
653  llvm::Value *cmd, llvm::MDNode *node,
654  MessageSendInfo &MSI) override {
655  CGBuilderTy &Builder = CGF.Builder;
656  llvm::Function *LookupFn = SlotLookupFn;
657 
658  // Store the receiver on the stack so that we can reload it later
659  Address ReceiverPtr =
660  CGF.CreateTempAlloca(Receiver->getType(), CGF.getPointerAlign());
661  Builder.CreateStore(Receiver, ReceiverPtr);
662 
663  llvm::Value *self;
664 
665  if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) {
666  self = CGF.LoadObjCSelf();
667  } else {
668  self = llvm::ConstantPointerNull::get(IdTy);
669  }
670 
671  // The lookup function is guaranteed not to capture the receiver pointer.
672  LookupFn->setDoesNotCapture(1);
673 
674  llvm::Value *args[] = {
675  EnforceType(Builder, ReceiverPtr.getPointer(), PtrToIdTy),
676  EnforceType(Builder, cmd, SelectorTy),
677  EnforceType(Builder, self, IdTy) };
678  llvm::CallSite slot = CGF.EmitRuntimeCallOrInvoke(LookupFn, args);
679  slot.setOnlyReadsMemory();
680  slot->setMetadata(msgSendMDKind, node);
681 
682  // Load the imp from the slot
683  llvm::Value *imp = Builder.CreateAlignedLoad(
684  Builder.CreateStructGEP(nullptr, slot.getInstruction(), 4),
685  CGF.getPointerAlign());
686 
687  // The lookup function may have changed the receiver, so make sure we use
688  // the new one.
689  Receiver = Builder.CreateLoad(ReceiverPtr, true);
690  return imp;
691  }
692  llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
693  llvm::Value *cmd,
694  MessageSendInfo &MSI) override {
695  CGBuilderTy &Builder = CGF.Builder;
696  llvm::Value *lookupArgs[] = {ObjCSuper.getPointer(), cmd};
697 
698  llvm::CallInst *slot =
699  CGF.EmitNounwindRuntimeCall(SlotLookupSuperFn, lookupArgs);
700  slot->setOnlyReadsMemory();
701 
702  return Builder.CreateAlignedLoad(Builder.CreateStructGEP(nullptr, slot, 4),
703  CGF.getPointerAlign());
704  }
705  public:
706  CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNU(Mod, 9, 3) {
707  const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
708 
709  llvm::StructType *SlotStructTy = llvm::StructType::get(PtrTy,
710  PtrTy, PtrTy, IntTy, IMPTy, nullptr);
711  SlotTy = llvm::PointerType::getUnqual(SlotStructTy);
712  // Slot_t objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
713  SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy,
714  SelectorTy, IdTy, nullptr);
715  // Slot_t objc_msg_lookup_super(struct objc_super*, SEL);
716  SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy,
717  PtrToObjCSuperTy, SelectorTy, nullptr);
718  // If we're in ObjC++ mode, then we want to make
719  if (CGM.getLangOpts().CPlusPlus) {
720  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
721  // void *__cxa_begin_catch(void *e)
722  EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy, nullptr);
723  // void __cxa_end_catch(void)
724  ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy, nullptr);
725  // void _Unwind_Resume_or_Rethrow(void*)
726  ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy,
727  PtrTy, nullptr);
728  } else if (R.getVersion() >= VersionTuple(1, 7)) {
729  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
730  // id objc_begin_catch(void *e)
731  EnterCatchFn.init(&CGM, "objc_begin_catch", IdTy, PtrTy, nullptr);
732  // void objc_end_catch(void)
733  ExitCatchFn.init(&CGM, "objc_end_catch", VoidTy, nullptr);
734  // void _Unwind_Resume_or_Rethrow(void*)
735  ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy,
736  PtrTy, nullptr);
737  }
738  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
739  SetPropertyAtomic.init(&CGM, "objc_setProperty_atomic", VoidTy, IdTy,
740  SelectorTy, IdTy, PtrDiffTy, nullptr);
741  SetPropertyAtomicCopy.init(&CGM, "objc_setProperty_atomic_copy", VoidTy,
742  IdTy, SelectorTy, IdTy, PtrDiffTy, nullptr);
743  SetPropertyNonAtomic.init(&CGM, "objc_setProperty_nonatomic", VoidTy,
744  IdTy, SelectorTy, IdTy, PtrDiffTy, nullptr);
745  SetPropertyNonAtomicCopy.init(&CGM, "objc_setProperty_nonatomic_copy",
746  VoidTy, IdTy, SelectorTy, IdTy, PtrDiffTy, nullptr);
747  // void objc_setCppObjectAtomic(void *dest, const void *src, void
748  // *helper);
749  CxxAtomicObjectSetFn.init(&CGM, "objc_setCppObjectAtomic", VoidTy, PtrTy,
750  PtrTy, PtrTy, nullptr);
751  // void objc_getCppObjectAtomic(void *dest, const void *src, void
752  // *helper);
753  CxxAtomicObjectGetFn.init(&CGM, "objc_getCppObjectAtomic", VoidTy, PtrTy,
754  PtrTy, PtrTy, nullptr);
755  }
756  llvm::Constant *GetCppAtomicObjectGetFunction() override {
757  // The optimised functions were added in version 1.7 of the GNUstep
758  // runtime.
759  assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
760  VersionTuple(1, 7));
761  return CxxAtomicObjectGetFn;
762  }
763  llvm::Constant *GetCppAtomicObjectSetFunction() override {
764  // The optimised functions were added in version 1.7 of the GNUstep
765  // runtime.
766  assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
767  VersionTuple(1, 7));
768  return CxxAtomicObjectSetFn;
769  }
770  llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
771  bool copy) override {
772  // The optimised property functions omit the GC check, and so are not
773  // safe to use in GC mode. The standard functions are fast in GC mode,
774  // so there is less advantage in using them.
775  assert ((CGM.getLangOpts().getGC() == LangOptions::NonGC));
776  // The optimised functions were added in version 1.7 of the GNUstep
777  // runtime.
778  assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
779  VersionTuple(1, 7));
780 
781  if (atomic) {
782  if (copy) return SetPropertyAtomicCopy;
783  return SetPropertyAtomic;
784  }
785 
786  return copy ? SetPropertyNonAtomicCopy : SetPropertyNonAtomic;
787  }
788 };
789 
790 /// Support for the ObjFW runtime.
791 class CGObjCObjFW: public CGObjCGNU {
792 protected:
793  /// The GCC ABI message lookup function. Returns an IMP pointing to the
794  /// method implementation for this message.
795  LazyRuntimeFunction MsgLookupFn;
796  /// stret lookup function. While this does not seem to make sense at the
797  /// first look, this is required to call the correct forwarding function.
798  LazyRuntimeFunction MsgLookupFnSRet;
799  /// The GCC ABI superclass message lookup function. Takes a pointer to a
800  /// structure describing the receiver and the class, and a selector as
801  /// arguments. Returns the IMP for the corresponding method.
802  LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet;
803 
804  llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
805  llvm::Value *cmd, llvm::MDNode *node,
806  MessageSendInfo &MSI) override {
807  CGBuilderTy &Builder = CGF.Builder;
808  llvm::Value *args[] = {
809  EnforceType(Builder, Receiver, IdTy),
810  EnforceType(Builder, cmd, SelectorTy) };
811 
812  llvm::CallSite imp;
813  if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
814  imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFnSRet, args);
815  else
816  imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
817 
818  imp->setMetadata(msgSendMDKind, node);
819  return imp.getInstruction();
820  }
821 
822  llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
823  llvm::Value *cmd, MessageSendInfo &MSI) override {
824  CGBuilderTy &Builder = CGF.Builder;
825  llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper.getPointer(),
826  PtrToObjCSuperTy), cmd};
827 
828  if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
829  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFnSRet, lookupArgs);
830  else
831  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
832  }
833 
834  llvm::Value *GetClassNamed(CodeGenFunction &CGF,
835  const std::string &Name, bool isWeak) override {
836  if (isWeak)
837  return CGObjCGNU::GetClassNamed(CGF, Name, isWeak);
838 
839  EmitClassRef(Name);
840 
841  std::string SymbolName = "_OBJC_CLASS_" + Name;
842 
843  llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(SymbolName);
844 
845  if (!ClassSymbol)
846  ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
848  nullptr, SymbolName);
849 
850  return ClassSymbol;
851  }
852 
853 public:
854  CGObjCObjFW(CodeGenModule &Mod): CGObjCGNU(Mod, 9, 3) {
855  // IMP objc_msg_lookup(id, SEL);
856  MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy, nullptr);
857  MsgLookupFnSRet.init(&CGM, "objc_msg_lookup_stret", IMPTy, IdTy,
858  SelectorTy, nullptr);
859  // IMP objc_msg_lookup_super(struct objc_super*, SEL);
860  MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
861  PtrToObjCSuperTy, SelectorTy, nullptr);
862  MsgLookupSuperFnSRet.init(&CGM, "objc_msg_lookup_super_stret", IMPTy,
863  PtrToObjCSuperTy, SelectorTy, nullptr);
864  }
865 };
866 } // end anonymous namespace
867 
868 
869 /// Emits a reference to a dummy variable which is emitted with each class.
870 /// This ensures that a linker error will be generated when trying to link
871 /// together modules where a referenced class is not defined.
872 void CGObjCGNU::EmitClassRef(const std::string &className) {
873  std::string symbolRef = "__objc_class_ref_" + className;
874  // Don't emit two copies of the same symbol
875  if (TheModule.getGlobalVariable(symbolRef))
876  return;
877  std::string symbolName = "__objc_class_name_" + className;
878  llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);
879  if (!ClassSymbol) {
880  ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
882  nullptr, symbolName);
883  }
884  new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true,
885  llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);
886 }
887 
888 static std::string SymbolNameForMethod( StringRef ClassName,
889  StringRef CategoryName, const Selector MethodName,
890  bool isClassMethod) {
891  std::string MethodNameColonStripped = MethodName.getAsString();
892  std::replace(MethodNameColonStripped.begin(), MethodNameColonStripped.end(),
893  ':', '_');
894  return (Twine(isClassMethod ? "_c_" : "_i_") + ClassName + "_" +
895  CategoryName + "_" + MethodNameColonStripped).str();
896 }
897 
898 CGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
899  unsigned protocolClassVersion)
900  : CGObjCRuntime(cgm), TheModule(CGM.getModule()),
901  VMContext(cgm.getLLVMContext()), ClassPtrAlias(nullptr),
902  MetaClassPtrAlias(nullptr), RuntimeVersion(runtimeABIVersion),
903  ProtocolVersion(protocolClassVersion) {
904 
905  msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend");
906 
907  CodeGenTypes &Types = CGM.getTypes();
908  IntTy = cast<llvm::IntegerType>(
909  Types.ConvertType(CGM.getContext().IntTy));
910  LongTy = cast<llvm::IntegerType>(
911  Types.ConvertType(CGM.getContext().LongTy));
912  SizeTy = cast<llvm::IntegerType>(
913  Types.ConvertType(CGM.getContext().getSizeType()));
914  PtrDiffTy = cast<llvm::IntegerType>(
915  Types.ConvertType(CGM.getContext().getPointerDiffType()));
916  BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
917 
918  Int8Ty = llvm::Type::getInt8Ty(VMContext);
919  // C string type. Used in lots of places.
920  PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
921 
922  Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
923  Zeros[1] = Zeros[0];
924  NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);
925  // Get the selector Type.
926  QualType selTy = CGM.getContext().getObjCSelType();
927  if (QualType() == selTy) {
928  SelectorTy = PtrToInt8Ty;
929  } else {
930  SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
931  }
932 
933  PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
934  PtrTy = PtrToInt8Ty;
935 
936  Int32Ty = llvm::Type::getInt32Ty(VMContext);
937  Int64Ty = llvm::Type::getInt64Ty(VMContext);
938 
939  IntPtrTy =
940  CGM.getDataLayout().getPointerSizeInBits() == 32 ? Int32Ty : Int64Ty;
941 
942  // Object type
943  QualType UnqualIdTy = CGM.getContext().getObjCIdType();
944  ASTIdTy = CanQualType();
945  if (UnqualIdTy != QualType()) {
946  ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy);
947  IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
948  } else {
949  IdTy = PtrToInt8Ty;
950  }
951  PtrToIdTy = llvm::PointerType::getUnqual(IdTy);
952 
953  ObjCSuperTy = llvm::StructType::get(IdTy, IdTy, nullptr);
954  PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy);
955 
956  llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
957 
958  // void objc_exception_throw(id);
959  ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy, nullptr);
960  ExceptionReThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy, nullptr);
961  // int objc_sync_enter(id);
962  SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy, nullptr);
963  // int objc_sync_exit(id);
964  SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy, nullptr);
965 
966  // void objc_enumerationMutation (id)
967  EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy,
968  IdTy, nullptr);
969 
970  // id objc_getProperty(id, SEL, ptrdiff_t, BOOL)
971  GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy,
972  PtrDiffTy, BoolTy, nullptr);
973  // void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, BOOL)
974  SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy,
975  PtrDiffTy, IdTy, BoolTy, BoolTy, nullptr);
976  // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
977  GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy,
978  PtrDiffTy, BoolTy, BoolTy, nullptr);
979  // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
980  SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy,
981  PtrDiffTy, BoolTy, BoolTy, nullptr);
982 
983  // IMP type
984  llvm::Type *IMPArgs[] = { IdTy, SelectorTy };
985  IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,
986  true));
987 
988  const LangOptions &Opts = CGM.getLangOpts();
989  if ((Opts.getGC() != LangOptions::NonGC) || Opts.ObjCAutoRefCount)
990  RuntimeVersion = 10;
991 
992  // Don't bother initialising the GC stuff unless we're compiling in GC mode
993  if (Opts.getGC() != LangOptions::NonGC) {
994  // This is a bit of an hack. We should sort this out by having a proper
995  // CGObjCGNUstep subclass for GC, but we may want to really support the old
996  // ABI and GC added in ObjectiveC2.framework, so we fudge it a bit for now
997  // Get selectors needed in GC mode
998  RetainSel = GetNullarySelector("retain", CGM.getContext());
999  ReleaseSel = GetNullarySelector("release", CGM.getContext());
1000  AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext());
1001 
1002  // Get functions needed in GC mode
1003 
1004  // id objc_assign_ivar(id, id, ptrdiff_t);
1005  IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy,
1006  nullptr);
1007  // id objc_assign_strongCast (id, id*)
1008  StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy,
1009  PtrToIdTy, nullptr);
1010  // id objc_assign_global(id, id*);
1011  GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy,
1012  nullptr);
1013  // id objc_assign_weak(id, id*);
1014  WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy, nullptr);
1015  // id objc_read_weak(id*);
1016  WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy, nullptr);
1017  // void *objc_memmove_collectable(void*, void *, size_t);
1018  MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy,
1019  SizeTy, nullptr);
1020  }
1021 }
1022 
1023 llvm::Value *CGObjCGNU::GetClassNamed(CodeGenFunction &CGF,
1024  const std::string &Name,
1025  bool isWeak) {
1026  llvm::Constant *ClassName = MakeConstantString(Name);
1027  // With the incompatible ABI, this will need to be replaced with a direct
1028  // reference to the class symbol. For the compatible nonfragile ABI we are
1029  // still performing this lookup at run time but emitting the symbol for the
1030  // class externally so that we can make the switch later.
1031  //
1032  // Libobjc2 contains an LLVM pass that replaces calls to objc_lookup_class
1033  // with memoized versions or with static references if it's safe to do so.
1034  if (!isWeak)
1035  EmitClassRef(Name);
1036 
1037  llvm::Constant *ClassLookupFn =
1038  CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, PtrToInt8Ty, true),
1039  "objc_lookup_class");
1040  return CGF.EmitNounwindRuntimeCall(ClassLookupFn, ClassName);
1041 }
1042 
1043 // This has to perform the lookup every time, since posing and related
1044 // techniques can modify the name -> class mapping.
1045 llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF,
1046  const ObjCInterfaceDecl *OID) {
1047  return GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported());
1048 }
1049 llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
1050  return GetClassNamed(CGF, "NSAutoreleasePool", false);
1051 }
1052 
1053 llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel,
1054  const std::string &TypeEncoding) {
1055 
1057  llvm::GlobalAlias *SelValue = nullptr;
1058 
1059  for (SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
1060  e = Types.end() ; i!=e ; i++) {
1061  if (i->first == TypeEncoding) {
1062  SelValue = i->second;
1063  break;
1064  }
1065  }
1066  if (!SelValue) {
1067  SelValue = llvm::GlobalAlias::create(
1068  SelectorTy->getElementType(), 0, llvm::GlobalValue::PrivateLinkage,
1069  ".objc_selector_" + Sel.getAsString(), &TheModule);
1070  Types.emplace_back(TypeEncoding, SelValue);
1071  }
1072 
1073  return SelValue;
1074 }
1075 
1076 Address CGObjCGNU::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1077  llvm::Value *SelValue = GetSelector(CGF, Sel);
1078 
1079  // Store it to a temporary. Does this satisfy the semantics of
1080  // GetAddrOfSelector? Hopefully.
1081  Address tmp = CGF.CreateTempAlloca(SelValue->getType(),
1082  CGF.getPointerAlign());
1083  CGF.Builder.CreateStore(SelValue, tmp);
1084  return tmp;
1085 }
1086 
1087 llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1088  return GetSelector(CGF, Sel, std::string());
1089 }
1090 
1091 llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF,
1092  const ObjCMethodDecl *Method) {
1093  std::string SelTypes;
1094  CGM.getContext().getObjCEncodingForMethodDecl(Method, SelTypes);
1095  return GetSelector(CGF, Method->getSelector(), SelTypes);
1096 }
1097 
1098 llvm::Constant *CGObjCGNU::GetEHType(QualType T) {
1099  if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
1100  // With the old ABI, there was only one kind of catchall, which broke
1101  // foreign exceptions. With the new ABI, we use __objc_id_typeinfo as
1102  // a pointer indicating object catchalls, and NULL to indicate real
1103  // catchalls
1104  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
1105  return MakeConstantString("@id");
1106  } else {
1107  return nullptr;
1108  }
1109  }
1110 
1111  // All other types should be Objective-C interface pointer types.
1113  assert(OPT && "Invalid @catch type.");
1114  const ObjCInterfaceDecl *IDecl = OPT->getObjectType()->getInterface();
1115  assert(IDecl && "Invalid @catch type.");
1116  return MakeConstantString(IDecl->getIdentifier()->getName());
1117 }
1118 
1119 llvm::Constant *CGObjCGNUstep::GetEHType(QualType T) {
1120  if (!CGM.getLangOpts().CPlusPlus)
1121  return CGObjCGNU::GetEHType(T);
1122 
1123  // For Objective-C++, we want to provide the ability to catch both C++ and
1124  // Objective-C objects in the same function.
1125 
1126  // There's a particular fixed type info for 'id'.
1127  if (T->isObjCIdType() ||
1128  T->isObjCQualifiedIdType()) {
1129  llvm::Constant *IDEHType =
1130  CGM.getModule().getGlobalVariable("__objc_id_type_info");
1131  if (!IDEHType)
1132  IDEHType =
1133  new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty,
1134  false,
1136  nullptr, "__objc_id_type_info");
1137  return llvm::ConstantExpr::getBitCast(IDEHType, PtrToInt8Ty);
1138  }
1139 
1140  const ObjCObjectPointerType *PT =
1142  assert(PT && "Invalid @catch type.");
1143  const ObjCInterfaceType *IT = PT->getInterfaceType();
1144  assert(IT && "Invalid @catch type.");
1145  std::string className = IT->getDecl()->getIdentifier()->getName();
1146 
1147  std::string typeinfoName = "__objc_eh_typeinfo_" + className;
1148 
1149  // Return the existing typeinfo if it exists
1150  llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName);
1151  if (typeinfo)
1152  return llvm::ConstantExpr::getBitCast(typeinfo, PtrToInt8Ty);
1153 
1154  // Otherwise create it.
1155 
1156  // vtable for gnustep::libobjc::__objc_class_type_info
1157  // It's quite ugly hard-coding this. Ideally we'd generate it using the host
1158  // platform's name mangling.
1159  const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE";
1160  auto *Vtable = TheModule.getGlobalVariable(vtableName);
1161  if (!Vtable) {
1162  Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true,
1164  nullptr, vtableName);
1165  }
1166  llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);
1167  auto *BVtable = llvm::ConstantExpr::getBitCast(
1168  llvm::ConstantExpr::getGetElementPtr(Vtable->getValueType(), Vtable, Two),
1169  PtrToInt8Ty);
1170 
1171  llvm::Constant *typeName =
1172  ExportUniqueString(className, "__objc_eh_typename_");
1173 
1174  std::vector<llvm::Constant*> fields;
1175  fields.push_back(BVtable);
1176  fields.push_back(typeName);
1177  llvm::Constant *TI =
1178  MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, nullptr),
1179  fields, CGM.getPointerAlign(),
1180  "__objc_eh_typeinfo_" + className,
1181  llvm::GlobalValue::LinkOnceODRLinkage);
1182  return llvm::ConstantExpr::getBitCast(TI, PtrToInt8Ty);
1183 }
1184 
1185 /// Generate an NSConstantString object.
1186 ConstantAddress CGObjCGNU::GenerateConstantString(const StringLiteral *SL) {
1187 
1188  std::string Str = SL->getString().str();
1189  CharUnits Align = CGM.getPointerAlign();
1190 
1191  // Look for an existing one
1192  llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
1193  if (old != ObjCStrings.end())
1194  return ConstantAddress(old->getValue(), Align);
1195 
1196  StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1197 
1198  if (StringClass.empty()) StringClass = "NXConstantString";
1199 
1200  std::string Sym = "_OBJC_CLASS_";
1201  Sym += StringClass;
1202 
1203  llvm::Constant *isa = TheModule.getNamedGlobal(Sym);
1204 
1205  if (!isa)
1206  isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
1207  llvm::GlobalValue::ExternalWeakLinkage, nullptr, Sym);
1208  else if (isa->getType() != PtrToIdTy)
1209  isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy);
1210 
1211  std::vector<llvm::Constant*> Ivars;
1212  Ivars.push_back(isa);
1213  Ivars.push_back(MakeConstantString(Str));
1214  Ivars.push_back(llvm::ConstantInt::get(IntTy, Str.size()));
1215  llvm::Constant *ObjCStr = MakeGlobal(
1216  llvm::StructType::get(PtrToIdTy, PtrToInt8Ty, IntTy, nullptr),
1217  Ivars, Align, ".objc_str");
1218  ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty);
1219  ObjCStrings[Str] = ObjCStr;
1220  ConstantStrings.push_back(ObjCStr);
1221  return ConstantAddress(ObjCStr, Align);
1222 }
1223 
1224 ///Generates a message send where the super is the receiver. This is a message
1225 ///send to self with special delivery semantics indicating which class's method
1226 ///should be called.
1227 RValue
1228 CGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF,
1229  ReturnValueSlot Return,
1230  QualType ResultType,
1231  Selector Sel,
1232  const ObjCInterfaceDecl *Class,
1233  bool isCategoryImpl,
1234  llvm::Value *Receiver,
1235  bool IsClassMessage,
1236  const CallArgList &CallArgs,
1237  const ObjCMethodDecl *Method) {
1238  CGBuilderTy &Builder = CGF.Builder;
1239  if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
1240  if (Sel == RetainSel || Sel == AutoreleaseSel) {
1241  return RValue::get(EnforceType(Builder, Receiver,
1242  CGM.getTypes().ConvertType(ResultType)));
1243  }
1244  if (Sel == ReleaseSel) {
1245  return RValue::get(nullptr);
1246  }
1247  }
1248 
1249  llvm::Value *cmd = GetSelector(CGF, Sel);
1250 
1251 
1252  CallArgList ActualArgs;
1253 
1254  ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);
1255  ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
1256  ActualArgs.addFrom(CallArgs);
1257 
1258  MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
1259 
1260  llvm::Value *ReceiverClass = nullptr;
1261  if (isCategoryImpl) {
1262  llvm::Constant *classLookupFunction = nullptr;
1263  if (IsClassMessage) {
1264  classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
1265  IdTy, PtrTy, true), "objc_get_meta_class");
1266  } else {
1267  classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
1268  IdTy, PtrTy, true), "objc_get_class");
1269  }
1270  ReceiverClass = Builder.CreateCall(classLookupFunction,
1271  MakeConstantString(Class->getNameAsString()));
1272  } else {
1273  // Set up global aliases for the metaclass or class pointer if they do not
1274  // already exist. These will are forward-references which will be set to
1275  // pointers to the class and metaclass structure created for the runtime
1276  // load function. To send a message to super, we look up the value of the
1277  // super_class pointer from either the class or metaclass structure.
1278  if (IsClassMessage) {
1279  if (!MetaClassPtrAlias) {
1280  MetaClassPtrAlias = llvm::GlobalAlias::create(
1281  IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage,
1282  ".objc_metaclass_ref" + Class->getNameAsString(), &TheModule);
1283  }
1284  ReceiverClass = MetaClassPtrAlias;
1285  } else {
1286  if (!ClassPtrAlias) {
1287  ClassPtrAlias = llvm::GlobalAlias::create(
1288  IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage,
1289  ".objc_class_ref" + Class->getNameAsString(), &TheModule);
1290  }
1291  ReceiverClass = ClassPtrAlias;
1292  }
1293  }
1294  // Cast the pointer to a simplified version of the class structure
1295  llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy, nullptr);
1296  ReceiverClass = Builder.CreateBitCast(ReceiverClass,
1297  llvm::PointerType::getUnqual(CastTy));
1298  // Get the superclass pointer
1299  ReceiverClass = Builder.CreateStructGEP(CastTy, ReceiverClass, 1);
1300  // Load the superclass pointer
1301  ReceiverClass =
1302  Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign());
1303  // Construct the structure used to look up the IMP
1304  llvm::StructType *ObjCSuperTy = llvm::StructType::get(
1305  Receiver->getType(), IdTy, nullptr);
1306 
1307  // FIXME: Is this really supposed to be a dynamic alloca?
1308  Address ObjCSuper = Address(Builder.CreateAlloca(ObjCSuperTy),
1309  CGF.getPointerAlign());
1310 
1311  Builder.CreateStore(Receiver,
1312  Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
1313  Builder.CreateStore(ReceiverClass,
1314  Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
1315 
1316  ObjCSuper = EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy);
1317 
1318  // Get the IMP
1319  llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd, MSI);
1320  imp = EnforceType(Builder, imp, MSI.MessengerType);
1321 
1322  llvm::Metadata *impMD[] = {
1323  llvm::MDString::get(VMContext, Sel.getAsString()),
1324  llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()),
1325  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1326  llvm::Type::getInt1Ty(VMContext), IsClassMessage))};
1327  llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
1328 
1329  llvm::Instruction *call;
1330  RValue msgRet = CGF.EmitCall(MSI.CallInfo, imp, Return, ActualArgs,
1331  CGCalleeInfo(), &call);
1332  call->setMetadata(msgSendMDKind, node);
1333  return msgRet;
1334 }
1335 
1336 /// Generate code for a message send expression.
1337 RValue
1338 CGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF,
1339  ReturnValueSlot Return,
1340  QualType ResultType,
1341  Selector Sel,
1342  llvm::Value *Receiver,
1343  const CallArgList &CallArgs,
1344  const ObjCInterfaceDecl *Class,
1345  const ObjCMethodDecl *Method) {
1346  CGBuilderTy &Builder = CGF.Builder;
1347 
1348  // Strip out message sends to retain / release in GC mode
1349  if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
1350  if (Sel == RetainSel || Sel == AutoreleaseSel) {
1351  return RValue::get(EnforceType(Builder, Receiver,
1352  CGM.getTypes().ConvertType(ResultType)));
1353  }
1354  if (Sel == ReleaseSel) {
1355  return RValue::get(nullptr);
1356  }
1357  }
1358 
1359  // If the return type is something that goes in an integer register, the
1360  // runtime will handle 0 returns. For other cases, we fill in the 0 value
1361  // ourselves.
1362  //
1363  // The language spec says the result of this kind of message send is
1364  // undefined, but lots of people seem to have forgotten to read that
1365  // paragraph and insist on sending messages to nil that have structure
1366  // returns. With GCC, this generates a random return value (whatever happens
1367  // to be on the stack / in those registers at the time) on most platforms,
1368  // and generates an illegal instruction trap on SPARC. With LLVM it corrupts
1369  // the stack.
1370  bool isPointerSizedReturn = (ResultType->isAnyPointerType() ||
1371  ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType());
1372 
1373  llvm::BasicBlock *startBB = nullptr;
1374  llvm::BasicBlock *messageBB = nullptr;
1375  llvm::BasicBlock *continueBB = nullptr;
1376 
1377  if (!isPointerSizedReturn) {
1378  startBB = Builder.GetInsertBlock();
1379  messageBB = CGF.createBasicBlock("msgSend");
1380  continueBB = CGF.createBasicBlock("continue");
1381 
1382  llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,
1383  llvm::Constant::getNullValue(Receiver->getType()));
1384  Builder.CreateCondBr(isNil, continueBB, messageBB);
1385  CGF.EmitBlock(messageBB);
1386  }
1387 
1388  IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
1389  llvm::Value *cmd;
1390  if (Method)
1391  cmd = GetSelector(CGF, Method);
1392  else
1393  cmd = GetSelector(CGF, Sel);
1394  cmd = EnforceType(Builder, cmd, SelectorTy);
1395  Receiver = EnforceType(Builder, Receiver, IdTy);
1396 
1397  llvm::Metadata *impMD[] = {
1398  llvm::MDString::get(VMContext, Sel.getAsString()),
1399  llvm::MDString::get(VMContext, Class ? Class->getNameAsString() : ""),
1400  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1401  llvm::Type::getInt1Ty(VMContext), Class != nullptr))};
1402  llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
1403 
1404  CallArgList ActualArgs;
1405  ActualArgs.add(RValue::get(Receiver), ASTIdTy);
1406  ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
1407  ActualArgs.addFrom(CallArgs);
1408 
1409  MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
1410 
1411  // Get the IMP to call
1412  llvm::Value *imp;
1413 
1414  // If we have non-legacy dispatch specified, we try using the objc_msgSend()
1415  // functions. These are not supported on all platforms (or all runtimes on a
1416  // given platform), so we
1417  switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
1418  case CodeGenOptions::Legacy:
1419  imp = LookupIMP(CGF, Receiver, cmd, node, MSI);
1420  break;
1421  case CodeGenOptions::Mixed:
1422  case CodeGenOptions::NonLegacy:
1423  if (CGM.ReturnTypeUsesFPRet(ResultType)) {
1424  imp = CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
1425  "objc_msgSend_fpret");
1426  } else if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) {
1427  // The actual types here don't matter - we're going to bitcast the
1428  // function anyway
1429  imp = CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
1430  "objc_msgSend_stret");
1431  } else {
1432  imp = CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
1433  "objc_msgSend");
1434  }
1435  }
1436 
1437  // Reset the receiver in case the lookup modified it
1438  ActualArgs[0] = CallArg(RValue::get(Receiver), ASTIdTy, false);
1439 
1440  imp = EnforceType(Builder, imp, MSI.MessengerType);
1441 
1442  llvm::Instruction *call;
1443  RValue msgRet = CGF.EmitCall(MSI.CallInfo, imp, Return, ActualArgs,
1444  CGCalleeInfo(), &call);
1445  call->setMetadata(msgSendMDKind, node);
1446 
1447 
1448  if (!isPointerSizedReturn) {
1449  messageBB = CGF.Builder.GetInsertBlock();
1450  CGF.Builder.CreateBr(continueBB);
1451  CGF.EmitBlock(continueBB);
1452  if (msgRet.isScalar()) {
1453  llvm::Value *v = msgRet.getScalarVal();
1454  llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
1455  phi->addIncoming(v, messageBB);
1456  phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB);
1457  msgRet = RValue::get(phi);
1458  } else if (msgRet.isAggregate()) {
1459  Address v = msgRet.getAggregateAddress();
1460  llvm::PHINode *phi = Builder.CreatePHI(v.getType(), 2);
1461  llvm::Type *RetTy = v.getElementType();
1462  Address NullVal = CGF.CreateTempAlloca(RetTy, v.getAlignment(), "null");
1463  CGF.InitTempAlloca(NullVal, llvm::Constant::getNullValue(RetTy));
1464  phi->addIncoming(v.getPointer(), messageBB);
1465  phi->addIncoming(NullVal.getPointer(), startBB);
1466  msgRet = RValue::getAggregate(Address(phi, v.getAlignment()));
1467  } else /* isComplex() */ {
1468  std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal();
1469  llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2);
1470  phi->addIncoming(v.first, messageBB);
1471  phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
1472  startBB);
1473  llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2);
1474  phi2->addIncoming(v.second, messageBB);
1475  phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
1476  startBB);
1477  msgRet = RValue::getComplex(phi, phi2);
1478  }
1479  }
1480  return msgRet;
1481 }
1482 
1483 /// Generates a MethodList. Used in construction of a objc_class and
1484 /// objc_category structures.
1485 llvm::Constant *CGObjCGNU::
1486 GenerateMethodList(StringRef ClassName,
1487  StringRef CategoryName,
1488  ArrayRef<Selector> MethodSels,
1489  ArrayRef<llvm::Constant *> MethodTypes,
1490  bool isClassMethodList) {
1491  if (MethodSels.empty())
1492  return NULLPtr;
1493  // Get the method structure type.
1494  llvm::StructType *ObjCMethodTy = llvm::StructType::get(
1495  PtrToInt8Ty, // Really a selector, but the runtime creates it us.
1496  PtrToInt8Ty, // Method types
1497  IMPTy, //Method pointer
1498  nullptr);
1499  std::vector<llvm::Constant*> Methods;
1500  std::vector<llvm::Constant*> Elements;
1501  for (unsigned int i = 0, e = MethodTypes.size(); i < e; ++i) {
1502  Elements.clear();
1503  llvm::Constant *Method =
1504  TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
1505  MethodSels[i],
1506  isClassMethodList));
1507  assert(Method && "Can't generate metadata for method that doesn't exist");
1508  llvm::Constant *C = MakeConstantString(MethodSels[i].getAsString());
1509  Elements.push_back(C);
1510  Elements.push_back(MethodTypes[i]);
1511  Method = llvm::ConstantExpr::getBitCast(Method,
1512  IMPTy);
1513  Elements.push_back(Method);
1514  Methods.push_back(llvm::ConstantStruct::get(ObjCMethodTy, Elements));
1515  }
1516 
1517  // Array of method structures
1518  llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodTy,
1519  Methods.size());
1520  llvm::Constant *MethodArray = llvm::ConstantArray::get(ObjCMethodArrayTy,
1521  Methods);
1522 
1523  // Structure containing list pointer, array and array count
1524  llvm::StructType *ObjCMethodListTy = llvm::StructType::create(VMContext);
1525  llvm::Type *NextPtrTy = llvm::PointerType::getUnqual(ObjCMethodListTy);
1526  ObjCMethodListTy->setBody(
1527  NextPtrTy,
1528  IntTy,
1529  ObjCMethodArrayTy,
1530  nullptr);
1531 
1532  Methods.clear();
1533  Methods.push_back(llvm::ConstantPointerNull::get(
1534  llvm::PointerType::getUnqual(ObjCMethodListTy)));
1535  Methods.push_back(llvm::ConstantInt::get(Int32Ty, MethodTypes.size()));
1536  Methods.push_back(MethodArray);
1537 
1538  // Create an instance of the structure
1539  return MakeGlobal(ObjCMethodListTy, Methods, CGM.getPointerAlign(),
1540  ".objc_method_list");
1541 }
1542 
1543 /// Generates an IvarList. Used in construction of a objc_class.
1544 llvm::Constant *CGObjCGNU::
1545 GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
1546  ArrayRef<llvm::Constant *> IvarTypes,
1547  ArrayRef<llvm::Constant *> IvarOffsets) {
1548  if (IvarNames.size() == 0)
1549  return NULLPtr;
1550  // Get the method structure type.
1551  llvm::StructType *ObjCIvarTy = llvm::StructType::get(
1552  PtrToInt8Ty,
1553  PtrToInt8Ty,
1554  IntTy,
1555  nullptr);
1556  std::vector<llvm::Constant*> Ivars;
1557  std::vector<llvm::Constant*> Elements;
1558  for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
1559  Elements.clear();
1560  Elements.push_back(IvarNames[i]);
1561  Elements.push_back(IvarTypes[i]);
1562  Elements.push_back(IvarOffsets[i]);
1563  Ivars.push_back(llvm::ConstantStruct::get(ObjCIvarTy, Elements));
1564  }
1565 
1566  // Array of method structures
1567  llvm::ArrayType *ObjCIvarArrayTy = llvm::ArrayType::get(ObjCIvarTy,
1568  IvarNames.size());
1569 
1570 
1571  Elements.clear();
1572  Elements.push_back(llvm::ConstantInt::get(IntTy, (int)IvarNames.size()));
1573  Elements.push_back(llvm::ConstantArray::get(ObjCIvarArrayTy, Ivars));
1574  // Structure containing array and array count
1575  llvm::StructType *ObjCIvarListTy = llvm::StructType::get(IntTy,
1576  ObjCIvarArrayTy,
1577  nullptr);
1578 
1579  // Create an instance of the structure
1580  return MakeGlobal(ObjCIvarListTy, Elements, CGM.getPointerAlign(),
1581  ".objc_ivar_list");
1582 }
1583 
1584 /// Generate a class structure
1585 llvm::Constant *CGObjCGNU::GenerateClassStructure(
1586  llvm::Constant *MetaClass,
1587  llvm::Constant *SuperClass,
1588  unsigned info,
1589  const char *Name,
1590  llvm::Constant *Version,
1591  llvm::Constant *InstanceSize,
1592  llvm::Constant *IVars,
1593  llvm::Constant *Methods,
1594  llvm::Constant *Protocols,
1595  llvm::Constant *IvarOffsets,
1596  llvm::Constant *Properties,
1597  llvm::Constant *StrongIvarBitmap,
1598  llvm::Constant *WeakIvarBitmap,
1599  bool isMeta) {
1600  // Set up the class structure
1601  // Note: Several of these are char*s when they should be ids. This is
1602  // because the runtime performs this translation on load.
1603  //
1604  // Fields marked New ABI are part of the GNUstep runtime. We emit them
1605  // anyway; the classes will still work with the GNU runtime, they will just
1606  // be ignored.
1607  llvm::StructType *ClassTy = llvm::StructType::get(
1608  PtrToInt8Ty, // isa
1609  PtrToInt8Ty, // super_class
1610  PtrToInt8Ty, // name
1611  LongTy, // version
1612  LongTy, // info
1613  LongTy, // instance_size
1614  IVars->getType(), // ivars
1615  Methods->getType(), // methods
1616  // These are all filled in by the runtime, so we pretend
1617  PtrTy, // dtable
1618  PtrTy, // subclass_list
1619  PtrTy, // sibling_class
1620  PtrTy, // protocols
1621  PtrTy, // gc_object_type
1622  // New ABI:
1623  LongTy, // abi_version
1624  IvarOffsets->getType(), // ivar_offsets
1625  Properties->getType(), // properties
1626  IntPtrTy, // strong_pointers
1627  IntPtrTy, // weak_pointers
1628  nullptr);
1629  llvm::Constant *Zero = llvm::ConstantInt::get(LongTy, 0);
1630  // Fill in the structure
1631  std::vector<llvm::Constant*> Elements;
1632  Elements.push_back(llvm::ConstantExpr::getBitCast(MetaClass, PtrToInt8Ty));
1633  Elements.push_back(SuperClass);
1634  Elements.push_back(MakeConstantString(Name, ".class_name"));
1635  Elements.push_back(Zero);
1636  Elements.push_back(llvm::ConstantInt::get(LongTy, info));
1637  if (isMeta) {
1638  llvm::DataLayout td(&TheModule);
1639  Elements.push_back(
1640  llvm::ConstantInt::get(LongTy,
1641  td.getTypeSizeInBits(ClassTy) /
1642  CGM.getContext().getCharWidth()));
1643  } else
1644  Elements.push_back(InstanceSize);
1645  Elements.push_back(IVars);
1646  Elements.push_back(Methods);
1647  Elements.push_back(NULLPtr);
1648  Elements.push_back(NULLPtr);
1649  Elements.push_back(NULLPtr);
1650  Elements.push_back(llvm::ConstantExpr::getBitCast(Protocols, PtrTy));
1651  Elements.push_back(NULLPtr);
1652  Elements.push_back(llvm::ConstantInt::get(LongTy, 1));
1653  Elements.push_back(IvarOffsets);
1654  Elements.push_back(Properties);
1655  Elements.push_back(StrongIvarBitmap);
1656  Elements.push_back(WeakIvarBitmap);
1657  // Create an instance of the structure
1658  // This is now an externally visible symbol, so that we can speed up class
1659  // messages in the next ABI. We may already have some weak references to
1660  // this, so check and fix them properly.
1661  std::string ClassSym((isMeta ? "_OBJC_METACLASS_": "_OBJC_CLASS_") +
1662  std::string(Name));
1663  llvm::GlobalVariable *ClassRef = TheModule.getNamedGlobal(ClassSym);
1664  llvm::Constant *Class =
1665  MakeGlobal(ClassTy, Elements, CGM.getPointerAlign(), ClassSym,
1667  if (ClassRef) {
1668  ClassRef->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(Class,
1669  ClassRef->getType()));
1670  ClassRef->removeFromParent();
1671  Class->setName(ClassSym);
1672  }
1673  return Class;
1674 }
1675 
1676 llvm::Constant *CGObjCGNU::
1677 GenerateProtocolMethodList(ArrayRef<llvm::Constant *> MethodNames,
1678  ArrayRef<llvm::Constant *> MethodTypes) {
1679  // Get the method structure type.
1680  llvm::StructType *ObjCMethodDescTy = llvm::StructType::get(
1681  PtrToInt8Ty, // Really a selector, but the runtime does the casting for us.
1682  PtrToInt8Ty,
1683  nullptr);
1684  std::vector<llvm::Constant*> Methods;
1685  std::vector<llvm::Constant*> Elements;
1686  for (unsigned int i = 0, e = MethodTypes.size() ; i < e ; i++) {
1687  Elements.clear();
1688  Elements.push_back(MethodNames[i]);
1689  Elements.push_back(MethodTypes[i]);
1690  Methods.push_back(llvm::ConstantStruct::get(ObjCMethodDescTy, Elements));
1691  }
1692  llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodDescTy,
1693  MethodNames.size());
1694  llvm::Constant *Array = llvm::ConstantArray::get(ObjCMethodArrayTy,
1695  Methods);
1696  llvm::StructType *ObjCMethodDescListTy = llvm::StructType::get(
1697  IntTy, ObjCMethodArrayTy, nullptr);
1698  Methods.clear();
1699  Methods.push_back(llvm::ConstantInt::get(IntTy, MethodNames.size()));
1700  Methods.push_back(Array);
1701  return MakeGlobal(ObjCMethodDescListTy, Methods, CGM.getPointerAlign(),
1702  ".objc_method_list");
1703 }
1704 
1705 // Create the protocol list structure used in classes, categories and so on
1706 llvm::Constant *CGObjCGNU::GenerateProtocolList(ArrayRef<std::string>Protocols){
1707  llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
1708  Protocols.size());
1709  llvm::StructType *ProtocolListTy = llvm::StructType::get(
1710  PtrTy, //Should be a recurisve pointer, but it's always NULL here.
1711  SizeTy,
1712  ProtocolArrayTy,
1713  nullptr);
1714  std::vector<llvm::Constant*> Elements;
1715  for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
1716  iter != endIter ; iter++) {
1717  llvm::Constant *protocol = nullptr;
1719  ExistingProtocols.find(*iter);
1720  if (value == ExistingProtocols.end()) {
1721  protocol = GenerateEmptyProtocol(*iter);
1722  } else {
1723  protocol = value->getValue();
1724  }
1725  llvm::Constant *Ptr = llvm::ConstantExpr::getBitCast(protocol,
1726  PtrToInt8Ty);
1727  Elements.push_back(Ptr);
1728  }
1729  llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1730  Elements);
1731  Elements.clear();
1732  Elements.push_back(NULLPtr);
1733  Elements.push_back(llvm::ConstantInt::get(LongTy, Protocols.size()));
1734  Elements.push_back(ProtocolArray);
1735  return MakeGlobal(ProtocolListTy, Elements, CGM.getPointerAlign(),
1736  ".objc_protocol_list");
1737 }
1738 
1739 llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF,
1740  const ObjCProtocolDecl *PD) {
1741  llvm::Value *protocol = ExistingProtocols[PD->getNameAsString()];
1742  llvm::Type *T =
1743  CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType());
1744  return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
1745 }
1746 
1747 llvm::Constant *CGObjCGNU::GenerateEmptyProtocol(
1748  const std::string &ProtocolName) {
1749  SmallVector<std::string, 0> EmptyStringVector;
1750  SmallVector<llvm::Constant*, 0> EmptyConstantVector;
1751 
1752  llvm::Constant *ProtocolList = GenerateProtocolList(EmptyStringVector);
1753  llvm::Constant *MethodList =
1754  GenerateProtocolMethodList(EmptyConstantVector, EmptyConstantVector);
1755  // Protocols are objects containing lists of the methods implemented and
1756  // protocols adopted.
1757  llvm::StructType *ProtocolTy = llvm::StructType::get(IdTy,
1758  PtrToInt8Ty,
1759  ProtocolList->getType(),
1760  MethodList->getType(),
1761  MethodList->getType(),
1762  MethodList->getType(),
1763  MethodList->getType(),
1764  nullptr);
1765  std::vector<llvm::Constant*> Elements;
1766  // The isa pointer must be set to a magic number so the runtime knows it's
1767  // the correct layout.
1768  Elements.push_back(llvm::ConstantExpr::getIntToPtr(
1769  llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
1770  Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
1771  Elements.push_back(ProtocolList);
1772  Elements.push_back(MethodList);
1773  Elements.push_back(MethodList);
1774  Elements.push_back(MethodList);
1775  Elements.push_back(MethodList);
1776  return MakeGlobal(ProtocolTy, Elements, CGM.getPointerAlign(),
1777  ".objc_protocol");
1778 }
1779 
1780 void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
1781  ASTContext &Context = CGM.getContext();
1782  std::string ProtocolName = PD->getNameAsString();
1783 
1784  // Use the protocol definition, if there is one.
1785  if (const ObjCProtocolDecl *Def = PD->getDefinition())
1786  PD = Def;
1787 
1788  SmallVector<std::string, 16> Protocols;
1789  for (const auto *PI : PD->protocols())
1790  Protocols.push_back(PI->getNameAsString());
1791  SmallVector<llvm::Constant*, 16> InstanceMethodNames;
1792  SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
1793  SmallVector<llvm::Constant*, 16> OptionalInstanceMethodNames;
1794  SmallVector<llvm::Constant*, 16> OptionalInstanceMethodTypes;
1795  for (const auto *I : PD->instance_methods()) {
1796  std::string TypeStr;
1797  Context.getObjCEncodingForMethodDecl(I, TypeStr);
1798  if (I->getImplementationControl() == ObjCMethodDecl::Optional) {
1799  OptionalInstanceMethodNames.push_back(
1800  MakeConstantString(I->getSelector().getAsString()));
1801  OptionalInstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1802  } else {
1803  InstanceMethodNames.push_back(
1804  MakeConstantString(I->getSelector().getAsString()));
1805  InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1806  }
1807  }
1808  // Collect information about class methods:
1809  SmallVector<llvm::Constant*, 16> ClassMethodNames;
1810  SmallVector<llvm::Constant*, 16> ClassMethodTypes;
1811  SmallVector<llvm::Constant*, 16> OptionalClassMethodNames;
1812  SmallVector<llvm::Constant*, 16> OptionalClassMethodTypes;
1813  for (const auto *I : PD->class_methods()) {
1814  std::string TypeStr;
1815  Context.getObjCEncodingForMethodDecl(I,TypeStr);
1816  if (I->getImplementationControl() == ObjCMethodDecl::Optional) {
1817  OptionalClassMethodNames.push_back(
1818  MakeConstantString(I->getSelector().getAsString()));
1819  OptionalClassMethodTypes.push_back(MakeConstantString(TypeStr));
1820  } else {
1821  ClassMethodNames.push_back(
1822  MakeConstantString(I->getSelector().getAsString()));
1823  ClassMethodTypes.push_back(MakeConstantString(TypeStr));
1824  }
1825  }
1826 
1827  llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
1828  llvm::Constant *InstanceMethodList =
1829  GenerateProtocolMethodList(InstanceMethodNames, InstanceMethodTypes);
1830  llvm::Constant *ClassMethodList =
1831  GenerateProtocolMethodList(ClassMethodNames, ClassMethodTypes);
1832  llvm::Constant *OptionalInstanceMethodList =
1833  GenerateProtocolMethodList(OptionalInstanceMethodNames,
1834  OptionalInstanceMethodTypes);
1835  llvm::Constant *OptionalClassMethodList =
1836  GenerateProtocolMethodList(OptionalClassMethodNames,
1837  OptionalClassMethodTypes);
1838 
1839  // Property metadata: name, attributes, isSynthesized, setter name, setter
1840  // types, getter name, getter types.
1841  // The isSynthesized value is always set to 0 in a protocol. It exists to
1842  // simplify the runtime library by allowing it to use the same data
1843  // structures for protocol metadata everywhere.
1844  llvm::StructType *PropertyMetadataTy = llvm::StructType::get(
1845  PtrToInt8Ty, Int8Ty, Int8Ty, Int8Ty, Int8Ty, PtrToInt8Ty,
1846  PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, nullptr);
1847  std::vector<llvm::Constant*> Properties;
1848  std::vector<llvm::Constant*> OptionalProperties;
1849 
1850  // Add all of the property methods need adding to the method list and to the
1851  // property metadata list.
1852  for (auto *property : PD->properties()) {
1853  std::vector<llvm::Constant*> Fields;
1854 
1855  Fields.push_back(MakePropertyEncodingString(property, nullptr));
1856  PushPropertyAttributes(Fields, property);
1857 
1858  if (ObjCMethodDecl *getter = property->getGetterMethodDecl()) {
1859  std::string TypeStr;
1860  Context.getObjCEncodingForMethodDecl(getter,TypeStr);
1861  llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1862  InstanceMethodTypes.push_back(TypeEncoding);
1863  Fields.push_back(MakeConstantString(getter->getSelector().getAsString()));
1864  Fields.push_back(TypeEncoding);
1865  } else {
1866  Fields.push_back(NULLPtr);
1867  Fields.push_back(NULLPtr);
1868  }
1869  if (ObjCMethodDecl *setter = property->getSetterMethodDecl()) {
1870  std::string TypeStr;
1871  Context.getObjCEncodingForMethodDecl(setter,TypeStr);
1872  llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1873  InstanceMethodTypes.push_back(TypeEncoding);
1874  Fields.push_back(MakeConstantString(setter->getSelector().getAsString()));
1875  Fields.push_back(TypeEncoding);
1876  } else {
1877  Fields.push_back(NULLPtr);
1878  Fields.push_back(NULLPtr);
1879  }
1880  if (property->getPropertyImplementation() == ObjCPropertyDecl::Optional) {
1881  OptionalProperties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1882  } else {
1883  Properties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1884  }
1885  }
1886  llvm::Constant *PropertyArray = llvm::ConstantArray::get(
1887  llvm::ArrayType::get(PropertyMetadataTy, Properties.size()), Properties);
1888  llvm::Constant* PropertyListInitFields[] =
1889  {llvm::ConstantInt::get(IntTy, Properties.size()), NULLPtr, PropertyArray};
1890 
1891  llvm::Constant *PropertyListInit =
1892  llvm::ConstantStruct::getAnon(PropertyListInitFields);
1893  llvm::Constant *PropertyList = new llvm::GlobalVariable(TheModule,
1894  PropertyListInit->getType(), false, llvm::GlobalValue::InternalLinkage,
1895  PropertyListInit, ".objc_property_list");
1896 
1897  llvm::Constant *OptionalPropertyArray =
1898  llvm::ConstantArray::get(llvm::ArrayType::get(PropertyMetadataTy,
1899  OptionalProperties.size()) , OptionalProperties);
1900  llvm::Constant* OptionalPropertyListInitFields[] = {
1901  llvm::ConstantInt::get(IntTy, OptionalProperties.size()), NULLPtr,
1902  OptionalPropertyArray };
1903 
1904  llvm::Constant *OptionalPropertyListInit =
1905  llvm::ConstantStruct::getAnon(OptionalPropertyListInitFields);
1906  llvm::Constant *OptionalPropertyList = new llvm::GlobalVariable(TheModule,
1907  OptionalPropertyListInit->getType(), false,
1908  llvm::GlobalValue::InternalLinkage, OptionalPropertyListInit,
1909  ".objc_property_list");
1910 
1911  // Protocols are objects containing lists of the methods implemented and
1912  // protocols adopted.
1913  llvm::StructType *ProtocolTy = llvm::StructType::get(IdTy,
1914  PtrToInt8Ty,
1915  ProtocolList->getType(),
1916  InstanceMethodList->getType(),
1917  ClassMethodList->getType(),
1918  OptionalInstanceMethodList->getType(),
1919  OptionalClassMethodList->getType(),
1920  PropertyList->getType(),
1921  OptionalPropertyList->getType(),
1922  nullptr);
1923  std::vector<llvm::Constant*> Elements;
1924  // The isa pointer must be set to a magic number so the runtime knows it's
1925  // the correct layout.
1926  Elements.push_back(llvm::ConstantExpr::getIntToPtr(
1927  llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
1928  Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
1929  Elements.push_back(ProtocolList);
1930  Elements.push_back(InstanceMethodList);
1931  Elements.push_back(ClassMethodList);
1932  Elements.push_back(OptionalInstanceMethodList);
1933  Elements.push_back(OptionalClassMethodList);
1934  Elements.push_back(PropertyList);
1935  Elements.push_back(OptionalPropertyList);
1936  ExistingProtocols[ProtocolName] =
1937  llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolTy, Elements,
1938  CGM.getPointerAlign(), ".objc_protocol"), IdTy);
1939 }
1940 void CGObjCGNU::GenerateProtocolHolderCategory() {
1941  // Collect information about instance methods
1942  SmallVector<Selector, 1> MethodSels;
1943  SmallVector<llvm::Constant*, 1> MethodTypes;
1944 
1945  std::vector<llvm::Constant*> Elements;
1946  const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack";
1947  const std::string CategoryName = "AnotherHack";
1948  Elements.push_back(MakeConstantString(CategoryName));
1949  Elements.push_back(MakeConstantString(ClassName));
1950  // Instance method list
1951  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1952  ClassName, CategoryName, MethodSels, MethodTypes, false), PtrTy));
1953  // Class method list
1954  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1955  ClassName, CategoryName, MethodSels, MethodTypes, true), PtrTy));
1956  // Protocol list
1957  llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrTy,
1958  ExistingProtocols.size());
1959  llvm::StructType *ProtocolListTy = llvm::StructType::get(
1960  PtrTy, //Should be a recurisve pointer, but it's always NULL here.
1961  SizeTy,
1962  ProtocolArrayTy,
1963  nullptr);
1964  std::vector<llvm::Constant*> ProtocolElements;
1965  for (llvm::StringMapIterator<llvm::Constant*> iter =
1966  ExistingProtocols.begin(), endIter = ExistingProtocols.end();
1967  iter != endIter ; iter++) {
1968  llvm::Constant *Ptr = llvm::ConstantExpr::getBitCast(iter->getValue(),
1969  PtrTy);
1970  ProtocolElements.push_back(Ptr);
1971  }
1972  llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1973  ProtocolElements);
1974  ProtocolElements.clear();
1975  ProtocolElements.push_back(NULLPtr);
1976  ProtocolElements.push_back(llvm::ConstantInt::get(LongTy,
1977  ExistingProtocols.size()));
1978  ProtocolElements.push_back(ProtocolArray);
1979  Elements.push_back(llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolListTy,
1980  ProtocolElements, CGM.getPointerAlign(),
1981  ".objc_protocol_list"), PtrTy));
1982  Categories.push_back(llvm::ConstantExpr::getBitCast(
1983  MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty,
1984  PtrTy, PtrTy, PtrTy, nullptr), Elements, CGM.getPointerAlign()),
1985  PtrTy));
1986 }
1987 
1988 /// Libobjc2 uses a bitfield representation where small(ish) bitfields are
1989 /// stored in a 64-bit value with the low bit set to 1 and the remaining 63
1990 /// bits set to their values, LSB first, while larger ones are stored in a
1991 /// structure of this / form:
1992 ///
1993 /// struct { int32_t length; int32_t values[length]; };
1994 ///
1995 /// The values in the array are stored in host-endian format, with the least
1996 /// significant bit being assumed to come first in the bitfield. Therefore, a
1997 /// bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] }, while a
1998 /// bitfield / with the 63rd bit set will be 1<<64.
1999 llvm::Constant *CGObjCGNU::MakeBitField(ArrayRef<bool> bits) {
2000  int bitCount = bits.size();
2001  int ptrBits = CGM.getDataLayout().getPointerSizeInBits();
2002  if (bitCount < ptrBits) {
2003  uint64_t val = 1;
2004  for (int i=0 ; i<bitCount ; ++i) {
2005  if (bits[i]) val |= 1ULL<<(i+1);
2006  }
2007  return llvm::ConstantInt::get(IntPtrTy, val);
2008  }
2010  int v=0;
2011  while (v < bitCount) {
2012  int32_t word = 0;
2013  for (int i=0 ; (i<32) && (v<bitCount) ; ++i) {
2014  if (bits[v]) word |= 1<<i;
2015  v++;
2016  }
2017  values.push_back(llvm::ConstantInt::get(Int32Ty, word));
2018  }
2019  llvm::ArrayType *arrayTy = llvm::ArrayType::get(Int32Ty, values.size());
2020  llvm::Constant *array = llvm::ConstantArray::get(arrayTy, values);
2021  llvm::Constant *fields[2] = {
2022  llvm::ConstantInt::get(Int32Ty, values.size()),
2023  array };
2024  llvm::Constant *GS = MakeGlobal(llvm::StructType::get(Int32Ty, arrayTy,
2025  nullptr), fields, CharUnits::fromQuantity(4));
2026  llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy);
2027  return ptr;
2028 }
2029 
2030 void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
2031  std::string ClassName = OCD->getClassInterface()->getNameAsString();
2032  std::string CategoryName = OCD->getNameAsString();
2033  // Collect information about instance methods
2034  SmallVector<Selector, 16> InstanceMethodSels;
2035  SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
2036  for (const auto *I : OCD->instance_methods()) {
2037  InstanceMethodSels.push_back(I->getSelector());
2038  std::string TypeStr;
2039  CGM.getContext().getObjCEncodingForMethodDecl(I,TypeStr);
2040  InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
2041  }
2042 
2043  // Collect information about class methods
2044  SmallVector<Selector, 16> ClassMethodSels;
2045  SmallVector<llvm::Constant*, 16> ClassMethodTypes;
2046  for (const auto *I : OCD->class_methods()) {
2047  ClassMethodSels.push_back(I->getSelector());
2048  std::string TypeStr;
2049  CGM.getContext().getObjCEncodingForMethodDecl(I,TypeStr);
2050  ClassMethodTypes.push_back(MakeConstantString(TypeStr));
2051  }
2052 
2053  // Collect the names of referenced protocols
2054  SmallVector<std::string, 16> Protocols;
2055  const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl();
2056  const ObjCList<ObjCProtocolDecl> &Protos = CatDecl->getReferencedProtocols();
2058  E = Protos.end(); I != E; ++I)
2059  Protocols.push_back((*I)->getNameAsString());
2060 
2061  std::vector<llvm::Constant*> Elements;
2062  Elements.push_back(MakeConstantString(CategoryName));
2063  Elements.push_back(MakeConstantString(ClassName));
2064  // Instance method list
2065  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
2066  ClassName, CategoryName, InstanceMethodSels, InstanceMethodTypes,
2067  false), PtrTy));
2068  // Class method list
2069  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
2070  ClassName, CategoryName, ClassMethodSels, ClassMethodTypes, true),
2071  PtrTy));
2072  // Protocol list
2073  Elements.push_back(llvm::ConstantExpr::getBitCast(
2074  GenerateProtocolList(Protocols), PtrTy));
2075  Categories.push_back(llvm::ConstantExpr::getBitCast(
2076  MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty,
2077  PtrTy, PtrTy, PtrTy, nullptr), Elements, CGM.getPointerAlign()),
2078  PtrTy));
2079 }
2080 
2081 llvm::Constant *CGObjCGNU::GeneratePropertyList(const ObjCImplementationDecl *OID,
2082  SmallVectorImpl<Selector> &InstanceMethodSels,
2083  SmallVectorImpl<llvm::Constant*> &InstanceMethodTypes) {
2084  ASTContext &Context = CGM.getContext();
2085  // Property metadata: name, attributes, attributes2, padding1, padding2,
2086  // setter name, setter types, getter name, getter types.
2087  llvm::StructType *PropertyMetadataTy = llvm::StructType::get(
2088  PtrToInt8Ty, Int8Ty, Int8Ty, Int8Ty, Int8Ty, PtrToInt8Ty,
2089  PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, nullptr);
2090  std::vector<llvm::Constant*> Properties;
2091 
2092  // Add all of the property methods need adding to the method list and to the
2093  // property metadata list.
2094  for (auto *propertyImpl : OID->property_impls()) {
2095  std::vector<llvm::Constant*> Fields;
2096  ObjCPropertyDecl *property = propertyImpl->getPropertyDecl();
2097  bool isSynthesized = (propertyImpl->getPropertyImplementation() ==
2098  ObjCPropertyImplDecl::Synthesize);
2099  bool isDynamic = (propertyImpl->getPropertyImplementation() ==
2100  ObjCPropertyImplDecl::Dynamic);
2101 
2102  Fields.push_back(MakePropertyEncodingString(property, OID));
2103  PushPropertyAttributes(Fields, property, isSynthesized, isDynamic);
2104  if (ObjCMethodDecl *getter = property->getGetterMethodDecl()) {
2105  std::string TypeStr;
2106  Context.getObjCEncodingForMethodDecl(getter,TypeStr);
2107  llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
2108  if (isSynthesized) {
2109  InstanceMethodTypes.push_back(TypeEncoding);
2110  InstanceMethodSels.push_back(getter->getSelector());
2111  }
2112  Fields.push_back(MakeConstantString(getter->getSelector().getAsString()));
2113  Fields.push_back(TypeEncoding);
2114  } else {
2115  Fields.push_back(NULLPtr);
2116  Fields.push_back(NULLPtr);
2117  }
2118  if (ObjCMethodDecl *setter = property->getSetterMethodDecl()) {
2119  std::string TypeStr;
2120  Context.getObjCEncodingForMethodDecl(setter,TypeStr);
2121  llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
2122  if (isSynthesized) {
2123  InstanceMethodTypes.push_back(TypeEncoding);
2124  InstanceMethodSels.push_back(setter->getSelector());
2125  }
2126  Fields.push_back(MakeConstantString(setter->getSelector().getAsString()));
2127  Fields.push_back(TypeEncoding);
2128  } else {
2129  Fields.push_back(NULLPtr);
2130  Fields.push_back(NULLPtr);
2131  }
2132  Properties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
2133  }
2134  llvm::ArrayType *PropertyArrayTy =
2135  llvm::ArrayType::get(PropertyMetadataTy, Properties.size());
2136  llvm::Constant *PropertyArray = llvm::ConstantArray::get(PropertyArrayTy,
2137  Properties);
2138  llvm::Constant* PropertyListInitFields[] =
2139  {llvm::ConstantInt::get(IntTy, Properties.size()), NULLPtr, PropertyArray};
2140 
2141  llvm::Constant *PropertyListInit =
2142  llvm::ConstantStruct::getAnon(PropertyListInitFields);
2143  return new llvm::GlobalVariable(TheModule, PropertyListInit->getType(), false,
2144  llvm::GlobalValue::InternalLinkage, PropertyListInit,
2145  ".objc_property_list");
2146 }
2147 
2148 void CGObjCGNU::RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {
2149  // Get the class declaration for which the alias is specified.
2150  ObjCInterfaceDecl *ClassDecl =
2151  const_cast<ObjCInterfaceDecl *>(OAD->getClassInterface());
2152  ClassAliases.emplace_back(ClassDecl->getNameAsString(),
2153  OAD->getNameAsString());
2154 }
2155 
2156 void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
2157  ASTContext &Context = CGM.getContext();
2158 
2159  // Get the superclass name.
2160  const ObjCInterfaceDecl * SuperClassDecl =
2161  OID->getClassInterface()->getSuperClass();
2162  std::string SuperClassName;
2163  if (SuperClassDecl) {
2164  SuperClassName = SuperClassDecl->getNameAsString();
2165  EmitClassRef(SuperClassName);
2166  }
2167 
2168  // Get the class name
2169  ObjCInterfaceDecl *ClassDecl =
2170  const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
2171  std::string ClassName = ClassDecl->getNameAsString();
2172  // Emit the symbol that is used to generate linker errors if this class is
2173  // referenced in other modules but not declared.
2174  std::string classSymbolName = "__objc_class_name_" + ClassName;
2175  if (llvm::GlobalVariable *symbol =
2176  TheModule.getGlobalVariable(classSymbolName)) {
2177  symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
2178  } else {
2179  new llvm::GlobalVariable(TheModule, LongTy, false,
2180  llvm::GlobalValue::ExternalLinkage, llvm::ConstantInt::get(LongTy, 0),
2181  classSymbolName);
2182  }
2183 
2184  // Get the size of instances.
2185  int instanceSize =
2187 
2188  // Collect information about instance variables.
2192 
2193  std::vector<llvm::Constant*> IvarOffsetValues;
2194  SmallVector<bool, 16> WeakIvars;
2195  SmallVector<bool, 16> StrongIvars;
2196 
2197  int superInstanceSize = !SuperClassDecl ? 0 :
2198  Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
2199  // For non-fragile ivars, set the instance size to 0 - {the size of just this
2200  // class}. The runtime will then set this to the correct value on load.
2201  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2202  instanceSize = 0 - (instanceSize - superInstanceSize);
2203  }
2204 
2205  for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
2206  IVD = IVD->getNextIvar()) {
2207  // Store the name
2208  IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));
2209  // Get the type encoding for this ivar
2210  std::string TypeStr;
2211  Context.getObjCEncodingForType(IVD->getType(), TypeStr);
2212  IvarTypes.push_back(MakeConstantString(TypeStr));
2213  // Get the offset
2214  uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
2215  uint64_t Offset = BaseOffset;
2216  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2217  Offset = BaseOffset - superInstanceSize;
2218  }
2219  llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
2220  // Create the direct offset value
2221  std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." +
2222  IVD->getNameAsString();
2223  llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
2224  if (OffsetVar) {
2225  OffsetVar->setInitializer(OffsetValue);
2226  // If this is the real definition, change its linkage type so that
2227  // different modules will use this one, rather than their private
2228  // copy.
2229  OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage);
2230  } else
2231  OffsetVar = new llvm::GlobalVariable(TheModule, IntTy,
2233  OffsetValue,
2234  "__objc_ivar_offset_value_" + ClassName +"." +
2235  IVD->getNameAsString());
2236  IvarOffsets.push_back(OffsetValue);
2237  IvarOffsetValues.push_back(OffsetVar);
2238  Qualifiers::ObjCLifetime lt = IVD->getType().getQualifiers().getObjCLifetime();
2239  switch (lt) {
2240  case Qualifiers::OCL_Strong:
2241  StrongIvars.push_back(true);
2242  WeakIvars.push_back(false);
2243  break;
2244  case Qualifiers::OCL_Weak:
2245  StrongIvars.push_back(false);
2246  WeakIvars.push_back(true);
2247  break;
2248  default:
2249  StrongIvars.push_back(false);
2250  WeakIvars.push_back(false);
2251  }
2252  }
2253  llvm::Constant *StrongIvarBitmap = MakeBitField(StrongIvars);
2254  llvm::Constant *WeakIvarBitmap = MakeBitField(WeakIvars);
2255  llvm::GlobalVariable *IvarOffsetArray =
2256  MakeGlobalArray(PtrToIntTy, IvarOffsetValues, CGM.getPointerAlign(),
2257  ".ivar.offsets");
2258 
2259 
2260  // Collect information about instance methods
2261  SmallVector<Selector, 16> InstanceMethodSels;
2262  SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
2263  for (const auto *I : OID->instance_methods()) {
2264  InstanceMethodSels.push_back(I->getSelector());
2265  std::string TypeStr;
2266  Context.getObjCEncodingForMethodDecl(I,TypeStr);
2267  InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
2268  }
2269 
2270  llvm::Constant *Properties = GeneratePropertyList(OID, InstanceMethodSels,
2271  InstanceMethodTypes);
2272 
2273 
2274  // Collect information about class methods
2275  SmallVector<Selector, 16> ClassMethodSels;
2276  SmallVector<llvm::Constant*, 16> ClassMethodTypes;
2277  for (const auto *I : OID->class_methods()) {
2278  ClassMethodSels.push_back(I->getSelector());
2279  std::string TypeStr;
2280  Context.getObjCEncodingForMethodDecl(I,TypeStr);
2281  ClassMethodTypes.push_back(MakeConstantString(TypeStr));
2282  }
2283  // Collect the names of referenced protocols
2284  SmallVector<std::string, 16> Protocols;
2285  for (const auto *I : ClassDecl->protocols())
2286  Protocols.push_back(I->getNameAsString());
2287 
2288  // Get the superclass pointer.
2289  llvm::Constant *SuperClass;
2290  if (!SuperClassName.empty()) {
2291  SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
2292  } else {
2293  SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);
2294  }
2295  // Empty vector used to construct empty method lists
2297  // Generate the method and instance variable lists
2298  llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
2299  InstanceMethodSels, InstanceMethodTypes, false);
2300  llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
2301  ClassMethodSels, ClassMethodTypes, true);
2302  llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
2303  IvarOffsets);
2304  // Irrespective of whether we are compiling for a fragile or non-fragile ABI,
2305  // we emit a symbol containing the offset for each ivar in the class. This
2306  // allows code compiled for the non-Fragile ABI to inherit from code compiled
2307  // for the legacy ABI, without causing problems. The converse is also
2308  // possible, but causes all ivar accesses to be fragile.
2309 
2310  // Offset pointer for getting at the correct field in the ivar list when
2311  // setting up the alias. These are: The base address for the global, the
2312  // ivar array (second field), the ivar in this list (set for each ivar), and
2313  // the offset (third field in ivar structure)
2314  llvm::Type *IndexTy = Int32Ty;
2315  llvm::Constant *offsetPointerIndexes[] = {Zeros[0],
2316  llvm::ConstantInt::get(IndexTy, 1), nullptr,
2317  llvm::ConstantInt::get(IndexTy, 2) };
2318 
2319  unsigned ivarIndex = 0;
2320  for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
2321  IVD = IVD->getNextIvar()) {
2322  const std::string Name = "__objc_ivar_offset_" + ClassName + '.'
2323  + IVD->getNameAsString();
2324  offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex);
2325  // Get the correct ivar field
2326  llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(
2327  cast<llvm::GlobalVariable>(IvarList)->getValueType(), IvarList,
2328  offsetPointerIndexes);
2329  // Get the existing variable, if one exists.
2330  llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);
2331  if (offset) {
2332  offset->setInitializer(offsetValue);
2333  // If this is the real definition, change its linkage type so that
2334  // different modules will use this one, rather than their private
2335  // copy.
2336  offset->setLinkage(llvm::GlobalValue::ExternalLinkage);
2337  } else {
2338  // Add a new alias if there isn't one already.
2339  offset = new llvm::GlobalVariable(TheModule, offsetValue->getType(),
2340  false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);
2341  (void) offset; // Silence dead store warning.
2342  }
2343  ++ivarIndex;
2344  }
2345  llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0);
2346  //Generate metaclass for class methods
2347  llvm::Constant *MetaClassStruct = GenerateClassStructure(NULLPtr,
2348  NULLPtr, 0x12L, ClassName.c_str(), nullptr, Zeros[0], GenerateIvarList(
2349  empty, empty, empty), ClassMethodList, NULLPtr,
2350  NULLPtr, NULLPtr, ZeroPtr, ZeroPtr, true);
2351 
2352  // Generate the class structure
2353  llvm::Constant *ClassStruct =
2354  GenerateClassStructure(MetaClassStruct, SuperClass, 0x11L,
2355  ClassName.c_str(), nullptr,
2356  llvm::ConstantInt::get(LongTy, instanceSize), IvarList,
2357  MethodList, GenerateProtocolList(Protocols), IvarOffsetArray,
2358  Properties, StrongIvarBitmap, WeakIvarBitmap);
2359 
2360  // Resolve the class aliases, if they exist.
2361  if (ClassPtrAlias) {
2362  ClassPtrAlias->replaceAllUsesWith(
2363  llvm::ConstantExpr::getBitCast(ClassStruct, IdTy));
2364  ClassPtrAlias->eraseFromParent();
2365  ClassPtrAlias = nullptr;
2366  }
2367  if (MetaClassPtrAlias) {
2368  MetaClassPtrAlias->replaceAllUsesWith(
2369  llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy));
2370  MetaClassPtrAlias->eraseFromParent();
2371  MetaClassPtrAlias = nullptr;
2372  }
2373 
2374  // Add class structure to list to be added to the symtab later
2375  ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
2376  Classes.push_back(ClassStruct);
2377 }
2378 
2379 
2380 llvm::Function *CGObjCGNU::ModuleInitFunction() {
2381  // Only emit an ObjC load function if no Objective-C stuff has been called
2382  if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
2383  ExistingProtocols.empty() && SelectorTable.empty())
2384  return nullptr;
2385 
2386  // Add all referenced protocols to a category.
2387  GenerateProtocolHolderCategory();
2388 
2389  llvm::StructType *SelStructTy = dyn_cast<llvm::StructType>(
2390  SelectorTy->getElementType());
2391  llvm::Type *SelStructPtrTy = SelectorTy;
2392  if (!SelStructTy) {
2393  SelStructTy = llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, nullptr);
2394  SelStructPtrTy = llvm::PointerType::getUnqual(SelStructTy);
2395  }
2396 
2397  std::vector<llvm::Constant*> Elements;
2398  llvm::Constant *Statics = NULLPtr;
2399  // Generate statics list:
2400  if (!ConstantStrings.empty()) {
2401  llvm::ArrayType *StaticsArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
2402  ConstantStrings.size() + 1);
2403  ConstantStrings.push_back(NULLPtr);
2404 
2405  StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
2406 
2407  if (StringClass.empty()) StringClass = "NXConstantString";
2408 
2409  Elements.push_back(MakeConstantString(StringClass,
2410  ".objc_static_class_name"));
2411  Elements.push_back(llvm::ConstantArray::get(StaticsArrayTy,
2412  ConstantStrings));
2413  llvm::StructType *StaticsListTy =
2414  llvm::StructType::get(PtrToInt8Ty, StaticsArrayTy, nullptr);
2415  llvm::Type *StaticsListPtrTy =
2416  llvm::PointerType::getUnqual(StaticsListTy);
2417  Statics = MakeGlobal(StaticsListTy, Elements, CGM.getPointerAlign(),
2418  ".objc_statics");
2419  llvm::ArrayType *StaticsListArrayTy =
2420  llvm::ArrayType::get(StaticsListPtrTy, 2);
2421  Elements.clear();
2422  Elements.push_back(Statics);
2423  Elements.push_back(llvm::Constant::getNullValue(StaticsListPtrTy));
2424  Statics = MakeGlobal(StaticsListArrayTy, Elements,
2425  CGM.getPointerAlign(), ".objc_statics_ptr");
2426  Statics = llvm::ConstantExpr::getBitCast(Statics, PtrTy);
2427  }
2428  // Array of classes, categories, and constant objects
2429  llvm::ArrayType *ClassListTy = llvm::ArrayType::get(PtrToInt8Ty,
2430  Classes.size() + Categories.size() + 2);
2431  llvm::StructType *SymTabTy = llvm::StructType::get(LongTy, SelStructPtrTy,
2432  llvm::Type::getInt16Ty(VMContext),
2433  llvm::Type::getInt16Ty(VMContext),
2434  ClassListTy, nullptr);
2435 
2436  Elements.clear();
2437  // Pointer to an array of selectors used in this module.
2438  std::vector<llvm::Constant*> Selectors;
2439  std::vector<llvm::GlobalAlias*> SelectorAliases;
2440  for (SelectorMap::iterator iter = SelectorTable.begin(),
2441  iterEnd = SelectorTable.end(); iter != iterEnd ; ++iter) {
2442 
2443  std::string SelNameStr = iter->first.getAsString();
2444  llvm::Constant *SelName = ExportUniqueString(SelNameStr, ".objc_sel_name");
2445 
2446  SmallVectorImpl<TypedSelector> &Types = iter->second;
2447  for (SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
2448  e = Types.end() ; i!=e ; i++) {
2449 
2450  llvm::Constant *SelectorTypeEncoding = NULLPtr;
2451  if (!i->first.empty())
2452  SelectorTypeEncoding = MakeConstantString(i->first, ".objc_sel_types");
2453 
2454  Elements.push_back(SelName);
2455  Elements.push_back(SelectorTypeEncoding);
2456  Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
2457  Elements.clear();
2458 
2459  // Store the selector alias for later replacement
2460  SelectorAliases.push_back(i->second);
2461  }
2462  }
2463  unsigned SelectorCount = Selectors.size();
2464  // NULL-terminate the selector list. This should not actually be required,
2465  // because the selector list has a length field. Unfortunately, the GCC
2466  // runtime decides to ignore the length field and expects a NULL terminator,
2467  // and GCC cooperates with this by always setting the length to 0.
2468  Elements.push_back(NULLPtr);
2469  Elements.push_back(NULLPtr);
2470  Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
2471  Elements.clear();
2472 
2473  // Number of static selectors
2474  Elements.push_back(llvm::ConstantInt::get(LongTy, SelectorCount));
2475  llvm::GlobalVariable *SelectorList =
2476  MakeGlobalArray(SelStructTy, Selectors, CGM.getPointerAlign(),
2477  ".objc_selector_list");
2478  Elements.push_back(llvm::ConstantExpr::getBitCast(SelectorList,
2479  SelStructPtrTy));
2480 
2481  // Now that all of the static selectors exist, create pointers to them.
2482  for (unsigned int i=0 ; i<SelectorCount ; i++) {
2483 
2484  llvm::Constant *Idxs[] = {Zeros[0],
2485  llvm::ConstantInt::get(Int32Ty, i), Zeros[0]};
2486  // FIXME: We're generating redundant loads and stores here!
2487  llvm::Constant *SelPtr = llvm::ConstantExpr::getGetElementPtr(
2488  SelectorList->getValueType(), SelectorList, makeArrayRef(Idxs, 2));
2489  // If selectors are defined as an opaque type, cast the pointer to this
2490  // type.
2491  SelPtr = llvm::ConstantExpr::getBitCast(SelPtr, SelectorTy);
2492  SelectorAliases[i]->replaceAllUsesWith(SelPtr);
2493  SelectorAliases[i]->eraseFromParent();
2494  }
2495 
2496  // Number of classes defined.
2497  Elements.push_back(llvm::ConstantInt::get(llvm::Type::getInt16Ty(VMContext),
2498  Classes.size()));
2499  // Number of categories defined
2500  Elements.push_back(llvm::ConstantInt::get(llvm::Type::getInt16Ty(VMContext),
2501  Categories.size()));
2502  // Create an array of classes, then categories, then static object instances
2503  Classes.insert(Classes.end(), Categories.begin(), Categories.end());
2504  // NULL-terminated list of static object instances (mainly constant strings)
2505  Classes.push_back(Statics);
2506  Classes.push_back(NULLPtr);
2507  llvm::Constant *ClassList = llvm::ConstantArray::get(ClassListTy, Classes);
2508  Elements.push_back(ClassList);
2509  // Construct the symbol table
2510  llvm::Constant *SymTab =
2511  MakeGlobal(SymTabTy, Elements, CGM.getPointerAlign());
2512 
2513  // The symbol table is contained in a module which has some version-checking
2514  // constants
2515  llvm::StructType * ModuleTy = llvm::StructType::get(LongTy, LongTy,
2516  PtrToInt8Ty, llvm::PointerType::getUnqual(SymTabTy),
2517  (RuntimeVersion >= 10) ? IntTy : nullptr, nullptr);
2518  Elements.clear();
2519  // Runtime version, used for ABI compatibility checking.
2520  Elements.push_back(llvm::ConstantInt::get(LongTy, RuntimeVersion));
2521  // sizeof(ModuleTy)
2522  llvm::DataLayout td(&TheModule);
2523  Elements.push_back(
2524  llvm::ConstantInt::get(LongTy,
2525  td.getTypeSizeInBits(ModuleTy) /
2526  CGM.getContext().getCharWidth()));
2527 
2528  // The path to the source file where this module was declared
2529  SourceManager &SM = CGM.getContext().getSourceManager();
2530  const FileEntry *mainFile = SM.getFileEntryForID(SM.getMainFileID());
2531  std::string path =
2532  std::string(mainFile->getDir()->getName()) + '/' + mainFile->getName();
2533  Elements.push_back(MakeConstantString(path, ".objc_source_file_name"));
2534  Elements.push_back(SymTab);
2535 
2536  if (RuntimeVersion >= 10)
2537  switch (CGM.getLangOpts().getGC()) {
2538  case LangOptions::GCOnly:
2539  Elements.push_back(llvm::ConstantInt::get(IntTy, 2));
2540  break;
2541  case LangOptions::NonGC:
2542  if (CGM.getLangOpts().ObjCAutoRefCount)
2543  Elements.push_back(llvm::ConstantInt::get(IntTy, 1));
2544  else
2545  Elements.push_back(llvm::ConstantInt::get(IntTy, 0));
2546  break;
2547  case LangOptions::HybridGC:
2548  Elements.push_back(llvm::ConstantInt::get(IntTy, 1));
2549  break;
2550  }
2551 
2552  llvm::Value *Module = MakeGlobal(ModuleTy, Elements, CGM.getPointerAlign());
2553 
2554  // Create the load function calling the runtime entry point with the module
2555  // structure
2556  llvm::Function * LoadFunction = llvm::Function::Create(
2557  llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
2558  llvm::GlobalValue::InternalLinkage, ".objc_load_function",
2559  &TheModule);
2560  llvm::BasicBlock *EntryBB =
2561  llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
2562  CGBuilderTy Builder(CGM, VMContext);
2563  Builder.SetInsertPoint(EntryBB);
2564 
2565  llvm::FunctionType *FT =
2566  llvm::FunctionType::get(Builder.getVoidTy(),
2567  llvm::PointerType::getUnqual(ModuleTy), true);
2568  llvm::Value *Register = CGM.CreateRuntimeFunction(FT, "__objc_exec_class");
2569  Builder.CreateCall(Register, Module);
2570 
2571  if (!ClassAliases.empty()) {
2572  llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty};
2573  llvm::FunctionType *RegisterAliasTy =
2574  llvm::FunctionType::get(Builder.getVoidTy(),
2575  ArgTypes, false);
2576  llvm::Function *RegisterAlias = llvm::Function::Create(
2577  RegisterAliasTy,
2578  llvm::GlobalValue::ExternalWeakLinkage, "class_registerAlias_np",
2579  &TheModule);
2580  llvm::BasicBlock *AliasBB =
2581  llvm::BasicBlock::Create(VMContext, "alias", LoadFunction);
2582  llvm::BasicBlock *NoAliasBB =
2583  llvm::BasicBlock::Create(VMContext, "no_alias", LoadFunction);
2584 
2585  // Branch based on whether the runtime provided class_registerAlias_np()
2586  llvm::Value *HasRegisterAlias = Builder.CreateICmpNE(RegisterAlias,
2587  llvm::Constant::getNullValue(RegisterAlias->getType()));
2588  Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB);
2589 
2590  // The true branch (has alias registration function):
2591  Builder.SetInsertPoint(AliasBB);
2592  // Emit alias registration calls:
2593  for (std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin();
2594  iter != ClassAliases.end(); ++iter) {
2595  llvm::Constant *TheClass =
2596  TheModule.getGlobalVariable(("_OBJC_CLASS_" + iter->first).c_str(),
2597  true);
2598  if (TheClass) {
2599  TheClass = llvm::ConstantExpr::getBitCast(TheClass, PtrTy);
2600  Builder.CreateCall(RegisterAlias,
2601  {TheClass, MakeConstantString(iter->second)});
2602  }
2603  }
2604  // Jump to end:
2605  Builder.CreateBr(NoAliasBB);
2606 
2607  // Missing alias registration function, just return from the function:
2608  Builder.SetInsertPoint(NoAliasBB);
2609  }
2610  Builder.CreateRetVoid();
2611 
2612  return LoadFunction;
2613 }
2614 
2615 llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
2616  const ObjCContainerDecl *CD) {
2617  const ObjCCategoryImplDecl *OCD =
2618  dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext());
2619  StringRef CategoryName = OCD ? OCD->getName() : "";
2620  StringRef ClassName = CD->getName();
2621  Selector MethodName = OMD->getSelector();
2622  bool isClassMethod = !OMD->isInstanceMethod();
2623 
2624  CodeGenTypes &Types = CGM.getTypes();
2625  llvm::FunctionType *MethodTy =
2627  std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
2628  MethodName, isClassMethod);
2629 
2630  llvm::Function *Method
2631  = llvm::Function::Create(MethodTy,
2633  FunctionName,
2634  &TheModule);
2635  return Method;
2636 }
2637 
2638 llvm::Constant *CGObjCGNU::GetPropertyGetFunction() {
2639  return GetPropertyFn;
2640 }
2641 
2642 llvm::Constant *CGObjCGNU::GetPropertySetFunction() {
2643  return SetPropertyFn;
2644 }
2645 
2646 llvm::Constant *CGObjCGNU::GetOptimizedPropertySetFunction(bool atomic,
2647  bool copy) {
2648  return nullptr;
2649 }
2650 
2651 llvm::Constant *CGObjCGNU::GetGetStructFunction() {
2652  return GetStructPropertyFn;
2653 }
2654 llvm::Constant *CGObjCGNU::GetSetStructFunction() {
2655  return SetStructPropertyFn;
2656 }
2657 llvm::Constant *CGObjCGNU::GetCppAtomicObjectGetFunction() {
2658  return nullptr;
2659 }
2660 llvm::Constant *CGObjCGNU::GetCppAtomicObjectSetFunction() {
2661  return nullptr;
2662 }
2663 
2664 llvm::Constant *CGObjCGNU::EnumerationMutationFunction() {
2665  return EnumerationMutationFn;
2666 }
2667 
2668 void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF,
2669  const ObjCAtSynchronizedStmt &S) {
2670  EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn);
2671 }
2672 
2673 
2674 void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF,
2675  const ObjCAtTryStmt &S) {
2676  // Unlike the Apple non-fragile runtimes, which also uses
2677  // unwind-based zero cost exceptions, the GNU Objective C runtime's
2678  // EH support isn't a veneer over C++ EH. Instead, exception
2679  // objects are created by objc_exception_throw and destroyed by
2680  // the personality function; this avoids the need for bracketing
2681  // catch handlers with calls to __blah_begin_catch/__blah_end_catch
2682  // (or even _Unwind_DeleteException), but probably doesn't
2683  // interoperate very well with foreign exceptions.
2684  //
2685  // In Objective-C++ mode, we actually emit something equivalent to the C++
2686  // exception handler.
2687  EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn);
2688  return ;
2689 }
2690 
2691 void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF,
2692  const ObjCAtThrowStmt &S,
2693  bool ClearInsertionPoint) {
2694  llvm::Value *ExceptionAsObject;
2695 
2696  if (const Expr *ThrowExpr = S.getThrowExpr()) {
2697  llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
2698  ExceptionAsObject = Exception;
2699  } else {
2700  assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
2701  "Unexpected rethrow outside @catch block.");
2702  ExceptionAsObject = CGF.ObjCEHValueStack.back();
2703  }
2704  ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy);
2705  llvm::CallSite Throw =
2706  CGF.EmitRuntimeCallOrInvoke(ExceptionThrowFn, ExceptionAsObject);
2707  Throw.setDoesNotReturn();
2708  CGF.Builder.CreateUnreachable();
2709  if (ClearInsertionPoint)
2710  CGF.Builder.ClearInsertionPoint();
2711 }
2712 
2713 llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF,
2714  Address AddrWeakObj) {
2715  CGBuilderTy &B = CGF.Builder;
2716  AddrWeakObj = EnforceType(B, AddrWeakObj, PtrToIdTy);
2717  return B.CreateCall(WeakReadFn.getType(), WeakReadFn,
2718  AddrWeakObj.getPointer());
2719 }
2720 
2721 void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF,
2722  llvm::Value *src, Address dst) {
2723  CGBuilderTy &B = CGF.Builder;
2724  src = EnforceType(B, src, IdTy);
2725  dst = EnforceType(B, dst, PtrToIdTy);
2726  B.CreateCall(WeakAssignFn.getType(), WeakAssignFn,
2727  {src, dst.getPointer()});
2728 }
2729 
2730 void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF,
2731  llvm::Value *src, Address dst,
2732  bool threadlocal) {
2733  CGBuilderTy &B = CGF.Builder;
2734  src = EnforceType(B, src, IdTy);
2735  dst = EnforceType(B, dst, PtrToIdTy);
2736  // FIXME. Add threadloca assign API
2737  assert(!threadlocal && "EmitObjCGlobalAssign - Threal Local API NYI");
2738  B.CreateCall(GlobalAssignFn.getType(), GlobalAssignFn,
2739  {src, dst.getPointer()});
2740 }
2741 
2742 void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF,
2743  llvm::Value *src, Address dst,
2744  llvm::Value *ivarOffset) {
2745  CGBuilderTy &B = CGF.Builder;
2746  src = EnforceType(B, src, IdTy);
2747  dst = EnforceType(B, dst, IdTy);
2748  B.CreateCall(IvarAssignFn.getType(), IvarAssignFn,
2749  {src, dst.getPointer(), ivarOffset});
2750 }
2751 
2752 void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF,
2753  llvm::Value *src, Address dst) {
2754  CGBuilderTy &B = CGF.Builder;
2755  src = EnforceType(B, src, IdTy);
2756  dst = EnforceType(B, dst, PtrToIdTy);
2757  B.CreateCall(StrongCastAssignFn.getType(), StrongCastAssignFn,
2758  {src, dst.getPointer()});
2759 }
2760 
2761 void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF,
2762  Address DestPtr,
2763  Address SrcPtr,
2764  llvm::Value *Size) {
2765  CGBuilderTy &B = CGF.Builder;
2766  DestPtr = EnforceType(B, DestPtr, PtrTy);
2767  SrcPtr = EnforceType(B, SrcPtr, PtrTy);
2768 
2769  B.CreateCall(MemMoveFn.getType(), MemMoveFn,
2770  {DestPtr.getPointer(), SrcPtr.getPointer(), Size});
2771 }
2772 
2773 llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(
2774  const ObjCInterfaceDecl *ID,
2775  const ObjCIvarDecl *Ivar) {
2776  const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
2777  + '.' + Ivar->getNameAsString();
2778  // Emit the variable and initialize it with what we think the correct value
2779  // is. This allows code compiled with non-fragile ivars to work correctly
2780  // when linked against code which isn't (most of the time).
2781  llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
2782  if (!IvarOffsetPointer) {
2783  // This will cause a run-time crash if we accidentally use it. A value of
2784  // 0 would seem more sensible, but will silently overwrite the isa pointer
2785  // causing a great deal of confusion.
2786  uint64_t Offset = -1;
2787  // We can't call ComputeIvarBaseOffset() here if we have the
2788  // implementation, because it will create an invalid ASTRecordLayout object
2789  // that we are then stuck with forever, so we only initialize the ivar
2790  // offset variable with a guess if we only have the interface. The
2791  // initializer will be reset later anyway, when we are generating the class
2792  // description.
2793  if (!CGM.getContext().getObjCImplementation(
2794  const_cast<ObjCInterfaceDecl *>(ID)))
2795  Offset = ComputeIvarBaseOffset(CGM, ID, Ivar);
2796 
2797  llvm::ConstantInt *OffsetGuess = llvm::ConstantInt::get(Int32Ty, Offset,
2798  /*isSigned*/true);
2799  // Don't emit the guess in non-PIC code because the linker will not be able
2800  // to replace it with the real version for a library. In non-PIC code you
2801  // must compile with the fragile ABI if you want to use ivars from a
2802  // GCC-compiled class.
2803  if (CGM.getLangOpts().PICLevel || CGM.getLangOpts().PIELevel) {
2804  llvm::GlobalVariable *IvarOffsetGV = new llvm::GlobalVariable(TheModule,
2805  Int32Ty, false,
2806  llvm::GlobalValue::PrivateLinkage, OffsetGuess, Name+".guess");
2807  IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
2808  IvarOffsetGV->getType(), false, llvm::GlobalValue::LinkOnceAnyLinkage,
2809  IvarOffsetGV, Name);
2810  } else {
2811  IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
2812  llvm::Type::getInt32PtrTy(VMContext), false,
2813  llvm::GlobalValue::ExternalLinkage, nullptr, Name);
2814  }
2815  }
2816  return IvarOffsetPointer;
2817 }
2818 
2819 LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF,
2820  QualType ObjectTy,
2821  llvm::Value *BaseValue,
2822  const ObjCIvarDecl *Ivar,
2823  unsigned CVRQualifiers) {
2824  const ObjCInterfaceDecl *ID =
2825  ObjectTy->getAs<ObjCObjectType>()->getInterface();
2826  return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
2827  EmitIvarOffset(CGF, ID, Ivar));
2828 }
2829 
2831  const ObjCInterfaceDecl *OID,
2832  const ObjCIvarDecl *OIVD) {
2833  for (const ObjCIvarDecl *next = OID->all_declared_ivar_begin(); next;
2834  next = next->getNextIvar()) {
2835  if (OIVD == next)
2836  return OID;
2837  }
2838 
2839  // Otherwise check in the super class.
2840  if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
2841  return FindIvarInterface(Context, Super, OIVD);
2842 
2843  return nullptr;
2844 }
2845 
2846 llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF,
2847  const ObjCInterfaceDecl *Interface,
2848  const ObjCIvarDecl *Ivar) {
2849  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2850  Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar);
2851  if (RuntimeVersion < 10)
2852  return CGF.Builder.CreateZExtOrBitCast(
2854  ObjCIvarOffsetVariable(Interface, Ivar),
2855  CGF.getPointerAlign(), "ivar")),
2856  PtrDiffTy);
2857  std::string name = "__objc_ivar_offset_value_" +
2858  Interface->getNameAsString() +"." + Ivar->getNameAsString();
2859  CharUnits Align = CGM.getIntAlign();
2860  llvm::Value *Offset = TheModule.getGlobalVariable(name);
2861  if (!Offset) {
2862  auto GV = new llvm::GlobalVariable(TheModule, IntTy,
2863  false, llvm::GlobalValue::LinkOnceAnyLinkage,
2864  llvm::Constant::getNullValue(IntTy), name);
2865  GV->setAlignment(Align.getQuantity());
2866  Offset = GV;
2867  }
2868  Offset = CGF.Builder.CreateAlignedLoad(Offset, Align);
2869  if (Offset->getType() != PtrDiffTy)
2870  Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
2871  return Offset;
2872  }
2873  uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar);
2874  return llvm::ConstantInt::get(PtrDiffTy, Offset, /*isSigned*/true);
2875 }
2876 
2877 CGObjCRuntime *
2879  switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
2880  case ObjCRuntime::GNUstep:
2881  return new CGObjCGNUstep(CGM);
2882 
2883  case ObjCRuntime::GCC:
2884  return new CGObjCGCC(CGM);
2885 
2886  case ObjCRuntime::ObjFW:
2887  return new CGObjCObjFW(CGM);
2888 
2889  case ObjCRuntime::FragileMacOSX:
2890  case ObjCRuntime::MacOSX:
2891  case ObjCRuntime::iOS:
2892  case ObjCRuntime::WatchOS:
2893  llvm_unreachable("these runtimes are not GNU runtimes");
2894  }
2895  llvm_unreachable("bad runtime");
2896 }
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:151
Defines the clang::ASTContext interface.
static std::string SymbolNameForMethod(StringRef ClassName, StringRef CategoryName, const Selector MethodName, bool isClassMethod)
Definition: CGObjCGNU.cpp:888
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:4778
static Selector GetNullarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing a nullary selector.
Definition: ASTContext.h:2571
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:50
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:169
protocol_range protocols() const
Definition: DeclObjC.h:1785
Smart pointer class that efficiently represents Objective-C method names.
A (possibly-)qualified type.
Definition: Type.h:575
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
#define va_end(ap)
Definition: stdarg.h:34
Defines the clang::FileManager interface and associated types.
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:164
PropertyControl getPropertyImplementation() const
Definition: DeclObjC.h:2575
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
Definition: CGValue.h:65
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateTempAlloca - This creates a alloca and inserts it into the entry block.
Definition: CGExpr.cpp:66
Implements runtime-specific code generation functions.
Definition: CGObjCRuntime.h:63
Defines the SourceManager interface.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:171
llvm::LoadInst * CreateDefaultAlignedLoad(llvm::Value *Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:135
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:77
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
Represents Objective-C's @throw statement.
Definition: StmtObjC.h:313
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:4861
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition: DeclBase.cpp:542
const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const
Get or compute information about the layout of the specified Objective-C implementation.
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
Defines the Objective-C statement AST node classes.
bool isVoidType() const
Definition: Type.h:5546
llvm::Constant * getPointer() const
Definition: Address.h:84
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
Definition: CGObjC.cpp:2794
This table allows us to fully hide how we implement multi-keyword caching.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
Represents a class type in Objective C.
Definition: Type.h:4557
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:91
bool isAnyPointerType() const
Definition: Type.h:5308
static const ObjCInterfaceDecl * FindIvarInterface(ASTContext &Context, const ObjCInterfaceDecl *OID, const ObjCIvarDecl *OIVD)
Definition: CGObjCGNU.cpp:2830
RValue EmitCall(const CGFunctionInfo &FnInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, CGCalleeInfo CalleeInfo=CGCalleeInfo(), llvm::Instruction **callOrInvoke=nullptr)
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:3159
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
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:84
Describes a module or submodule.
Definition: Basic/Module.h:47
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:696
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
uint32_t Offset
Definition: CacheTokens.cpp:44
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:4800
ObjCRuntime()
A bogus initialization of the runtime.
Definition: ObjCRuntime.h:65
std::string getNameAsString() const
getNameAsString - Get a human-readable name for the declaration, even if it is one of the special kin...
Definition: Decl.h:184
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
Definition: DeclObjC.h:1858
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1728
Represents an ObjC class declaration.
Definition: DeclObjC.h:853
propimpl_range property_impls() const
Definition: DeclObjC.h:2110
#define va_arg(ap, type)
Definition: stdarg.h:35
detail::InMemoryDirectory::const_iterator I
llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value * > args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition: CGCall.cpp:3111
void addFrom(const CallArgList &other)
Definition: CGCall.h:85
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
CGBlockInfo - Information to generate a block literal.
Definition: CGBlocks.h:153
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:38
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.
ASTContext * Context
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
SourceManager & SM
llvm::Value * getPointer() const
Definition: Address.h:38
Expr - This represents one expression.
Definition: Expr.h:104
StringRef getName() const
Return the actual identifier string.
bool isAggregate() const
Definition: CGValue.h:53
DeclContext * getDeclContext()
Definition: DeclBase.h:393
Represents Objective-C's @synchronized statement.
Definition: StmtObjC.h:262
void add(RValue rvalue, QualType type, bool needscopy=false)
Definition: CGCall.h:81
bool isObjCIdType() const
Definition: Type.h:5401
bool isInstanceMethod() const
Definition: DeclObjC.h:419
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:85
bool isa(CodeGen::Address addr)
Definition: Address.h:112
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)
Creates clause with a list of variables VL and a linear step Step.
'gnustep' is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:53
do v
Definition: arm_acle.h:77
ObjCCategoryDecl * getCategoryDecl() const
Definition: DeclObjC.cpp:1963
The l-value was considered opaque, so the alignment was determined from a type.
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:168
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5596
const char * getName() const
Definition: FileManager.h:84
ASTContext & getContext() const
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:174
const TemplateArgument * iterator
Definition: Type.h:4070
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:4766
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2401
SmallVector< llvm::Value *, 8 > ObjCEHValueStack
ObjCEHValueStack - Stack of Objective-C exception values, used for rethrows.
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:53
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Arrange the argument and result information for the declaration or definition of an Objective-C metho...
Definition: CGCall.cpp:312
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:1931
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2085
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
#define va_start(ap, param)
Definition: stdarg.h:33
An aligned address.
Definition: Address.h:25
const LangOptions & getLangOpts() const
std::string getAsString() const
Derive the full selector name (e.g.
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:2416
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:76
FileID getMainFileID() const
Returns the FileID of the main source file.
const char * getName() const
Definition: FileManager.h:45
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
Definition: ASTContext.h:1603
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1642
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:67
instmeth_range instance_methods() const
Definition: DeclObjC.h:744
This class organizes the cross-function state that is used while generating LLVM code.
bool isScalar() const
Definition: CGValue.h:51
prop_range properties() const
Definition: DeclObjC.h:716
return(x >> y)|(x<< (32-y))
std::string getNameAsString() const
Get the name of the class associated with this interface.
Definition: DeclObjC.h:2190
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:58
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:191
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:99
__builtin_va_list va_list
Definition: stdarg.h:30
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1440
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:78
StringRef getString() const
Definition: Expr.h:1500
Selector getSelector() const
Definition: DeclObjC.h:328
detail::InMemoryDirectory::const_iterator E
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:121
iterator begin() const
Definition: DeclObjC.h:65
Represents a pointer to an Objective C object.
Definition: Type.h:4821
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2220
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:2565
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:44
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:2568
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:120
bool isObjCQualifiedIdType() const
Definition: Type.h:5391
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
protocol_range protocols() const
Definition: DeclObjC.h:1040
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:367
bool getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, std::string &S, bool Extended=false) const
Emit the encoded type for the method declaration Decl into S.
Kind getKind() const
Definition: ObjCRuntime.h:75
classmeth_range class_methods() const
Definition: DeclObjC.h:759
BoundNodesTreeBuilder *const Builder
StringRef getName() const
getName - Get the name of identifier for the class interface associated with this implementation as a...
Definition: DeclObjC.h:2185
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:75
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1609
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:70
Represents Objective-C's @try ... @catch ... @finally statement.
Definition: StmtObjC.h:154
const Expr * getThrowExpr() const
Definition: StmtObjC.h:325
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1452
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:289
llvm::Value * LoadObjCSelf()
LoadObjCSelf - Load the value of self.
Definition: CGObjC.cpp:1443
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const
Check if the specified ScheduleKind is dynamic.
LValue - This represents an lvalue references.
Definition: CGValue.h:152
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1487
const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const
Get or compute information about the layout of the specified Objective-C interface.
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:93
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:56
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2139
This class handles loading and caching of source files into memory.
iterator end() const
Definition: DeclObjC.h:66
CGCalleeInfo - Class to encapsulate the information about a callee to be used during the generation o...
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2385
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:1998
CGObjCRuntime * CreateGNUObjCRuntime(CodeGenModule &CGM)
Creates an instance of an Objective-C runtime class.
Definition: CGObjCGNU.cpp:2878
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1293