CGObjCMac.cpp revision 2b1e311009cf682b7b5adb8ba97a0816f727bfb7 
1//===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
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 targetting the Apple runtime.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CGObjCRuntime.h"
15
16#include "CodeGenModule.h"
17#include "CodeGenFunction.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/Basic/LangOptions.h"
22
23#include "llvm/Module.h"
24#include "llvm/Support/IRBuilder.h"
25#include "llvm/Target/TargetData.h"
26#include <sstream>
27
28using namespace clang;
29using namespace CodeGen;
30
31namespace {
32
33  typedef std::vector<llvm::Constant*> ConstantVector;
34
35  // FIXME: We should find a nicer way to make the labels for
36  // metadata, string concatenation is lame.
37
38/// ObjCTypesHelper - Helper class that encapsulates lazy
39/// construction of varies types used during ObjC generation.
40class ObjCTypesHelper {
41private:
42  CodeGen::CodeGenModule &CGM;
43
44  llvm::Function *MessageSendFn, *MessageSendStretFn;
45  llvm::Function *MessageSendSuperFn, *MessageSendSuperStretFn;
46
47public:
48  const llvm::Type *ShortTy, *IntTy, *LongTy;
49  const llvm::Type *Int8PtrTy;
50
51  /// ObjectPtrTy - LLVM type for object handles (typeof(id))
52  const llvm::Type *ObjectPtrTy;
53  /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
54  const llvm::Type *SelectorPtrTy;
55  /// ProtocolPtrTy - LLVM type for external protocol handles
56  /// (typeof(Protocol))
57  const llvm::Type *ExternalProtocolPtrTy;
58
59  // SuperCTy - clang type for struct objc_super.
60  QualType SuperCTy;
61  // SuperPtrCTy - clang type for struct objc_super *.
62  QualType SuperPtrCTy;
63
64  /// SuperTy - LLVM type for struct objc_super.
65  const llvm::StructType *SuperTy;
66  /// SuperPtrTy - LLVM type for struct objc_super *.
67  const llvm::Type *SuperPtrTy;
68
69  /// SymtabTy - LLVM type for struct objc_symtab.
70  const llvm::StructType *SymtabTy;
71  /// SymtabPtrTy - LLVM type for struct objc_symtab *.
72  const llvm::Type *SymtabPtrTy;
73  /// ModuleTy - LLVM type for struct objc_module.
74  const llvm::StructType *ModuleTy;
75
76  /// ProtocolTy - LLVM type for struct objc_protocol.
77  const llvm::StructType *ProtocolTy;
78  /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
79  const llvm::Type *ProtocolPtrTy;
80  /// ProtocolExtensionTy - LLVM type for struct
81  /// objc_protocol_extension.
82  const llvm::StructType *ProtocolExtensionTy;
83  /// ProtocolExtensionTy - LLVM type for struct
84  /// objc_protocol_extension *.
85  const llvm::Type *ProtocolExtensionPtrTy;
86  /// MethodDescriptionTy - LLVM type for struct
87  /// objc_method_description.
88  const llvm::StructType *MethodDescriptionTy;
89  /// MethodDescriptionListTy - LLVM type for struct
90  /// objc_method_description_list.
91  const llvm::StructType *MethodDescriptionListTy;
92  /// MethodDescriptionListPtrTy - LLVM type for struct
93  /// objc_method_description_list *.
94  const llvm::Type *MethodDescriptionListPtrTy;
95  /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
96  /// in GCC parlance).
97  const llvm::StructType *PropertyTy;
98  /// PropertyListTy - LLVM type for struct objc_property_list
99  /// (_prop_list_t in GCC parlance).
100  const llvm::StructType *PropertyListTy;
101  /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
102  const llvm::Type *PropertyListPtrTy;
103  /// ProtocolListTy - LLVM type for struct objc_property_list.
104  const llvm::Type *ProtocolListTy;
105  /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
106  const llvm::Type *ProtocolListPtrTy;
107  /// CategoryTy - LLVM type for struct objc_category.
108  const llvm::StructType *CategoryTy;
109  /// ClassTy - LLVM type for struct objc_class.
110  const llvm::StructType *ClassTy;
111  /// ClassPtrTy - LLVM type for struct objc_class *.
112  const llvm::Type *ClassPtrTy;
113  /// ClassExtensionTy - LLVM type for struct objc_class_ext.
114  const llvm::StructType *ClassExtensionTy;
115  /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
116  const llvm::Type *ClassExtensionPtrTy;
117  /// CacheTy - LLVM type for struct objc_cache.
118  const llvm::Type *CacheTy;
119  /// CachePtrTy - LLVM type for struct objc_cache *.
120  const llvm::Type *CachePtrTy;
121  // IvarTy - LLVM type for struct objc_ivar.
122  const llvm::StructType *IvarTy;
123  /// IvarListTy - LLVM type for struct objc_ivar_list.
124  const llvm::Type *IvarListTy;
125  /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
126  const llvm::Type *IvarListPtrTy;
127  // MethodTy - LLVM type for struct objc_method.
128  const llvm::StructType *MethodTy;
129  /// MethodListTy - LLVM type for struct objc_method_list.
130  const llvm::Type *MethodListTy;
131  /// MethodListPtrTy - LLVM type for struct objc_method_list *.
132  const llvm::Type *MethodListPtrTy;
133
134  llvm::Function *EnumerationMutationFn;
135
136  /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
137  const llvm::Type *ExceptionDataTy;
138
139  /// ExceptionThrowFn - LLVM objc_exception_throw function.
140  llvm::Function *ExceptionThrowFn;
141
142  /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
143  llvm::Function *ExceptionTryEnterFn;
144
145  /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
146  llvm::Function *ExceptionTryExitFn;
147
148  /// ExceptionExtractFn - LLVM objc_exception_extract function.
149  llvm::Function *ExceptionExtractFn;
150
151  /// ExceptionMatchFn - LLVM objc_exception_match function.
152  llvm::Function *ExceptionMatchFn;
153
154  /// SetJmpFn - LLVM _setjmp function.
155  llvm::Function *SetJmpFn;
156
157public:
158  ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
159  ~ObjCTypesHelper();
160
161  llvm::Value *getMessageSendFn(bool IsSuper, const llvm::Type *ReturnTy);
162};
163
164class CGObjCMac : public CodeGen::CGObjCRuntime {
165private:
166  CodeGen::CodeGenModule &CGM;
167  ObjCTypesHelper ObjCTypes;
168  /// ObjCABI - FIXME: Not sure yet.
169  unsigned ObjCABI;
170
171  /// LazySymbols - Symbols to generate a lazy reference for. See
172  /// DefinedSymbols and FinishModule().
173  std::set<IdentifierInfo*> LazySymbols;
174
175  /// DefinedSymbols - External symbols which are defined by this
176  /// module. The symbols in this list and LazySymbols are used to add
177  /// special linker symbols which ensure that Objective-C modules are
178  /// linked properly.
179  std::set<IdentifierInfo*> DefinedSymbols;
180
181  /// ClassNames - uniqued class names.
182  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassNames;
183
184  /// MethodVarNames - uniqued method variable names.
185  llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
186
187  /// MethodVarTypes - uniqued method type signatures. We have to use
188  /// a StringMap here because have no other unique reference.
189  llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
190
191  /// MethodDefinitions - map of methods which have been defined in
192  /// this translation unit.
193  llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
194
195  /// PropertyNames - uniqued method variable names.
196  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
197
198  /// ClassReferences - uniqued class references.
199  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
200
201  /// SelectorReferences - uniqued selector references.
202  llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
203
204  /// Protocols - Protocols for which an objc_protocol structure has
205  /// been emitted. Forward declarations are handled by creating an
206  /// empty structure whose initializer is filled in when/if defined.
207  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
208
209  /// DefinedClasses - List of defined classes.
210  std::vector<llvm::GlobalValue*> DefinedClasses;
211
212  /// DefinedCategories - List of defined categories.
213  std::vector<llvm::GlobalValue*> DefinedCategories;
214
215  /// UsedGlobals - List of globals to pack into the llvm.used metadata
216  /// to prevent them from being clobbered.
217  std::vector<llvm::GlobalVariable*> UsedGlobals;
218
219  /// EmitImageInfo - Emit the image info marker used to encode some module
220  /// level information.
221  void EmitImageInfo();
222
223  /// EmitModuleInfo - Another marker encoding module level
224  /// information.
225  void EmitModuleInfo();
226
227  /// EmitModuleSymols - Emit module symbols, the list of defined
228  /// classes and categories. The result has type SymtabPtrTy.
229  llvm::Constant *EmitModuleSymbols();
230
231  /// FinishModule - Write out global data structures at the end of
232  /// processing a translation unit.
233  void FinishModule();
234
235  /// EmitClassExtension - Generate the class extension structure used
236  /// to store the weak ivar layout and properties. The return value
237  /// has type ClassExtensionPtrTy.
238  llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID);
239
240  /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
241  /// for the given class.
242  llvm::Value *EmitClassRef(llvm::IRBuilder<> &Builder,
243                            const ObjCInterfaceDecl *ID);
244
245  CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
246                                  QualType ResultType,
247                                  Selector Sel,
248                                  llvm::Value *Arg0,
249                                  QualType Arg0Ty,
250                                  bool IsSuper,
251                                  const CallArgList &CallArgs);
252
253  /// EmitIvarList - Emit the ivar list for the given
254  /// implementation. If ForClass is true the list of class ivars
255  /// (i.e. metaclass ivars) is emitted, otherwise the list of
256  /// interface ivars will be emitted. The return value has type
257  /// IvarListPtrTy.
258  llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
259                               bool ForClass,
260                               const llvm::Type *InterfaceTy);
261
262  /// EmitMetaClass - Emit a forward reference to the class structure
263  /// for the metaclass of the given interface. The return value has
264  /// type ClassPtrTy.
265  llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
266
267  /// EmitMetaClass - Emit a class structure for the metaclass of the
268  /// given implementation. The return value has type ClassPtrTy.
269  llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
270                                llvm::Constant *Protocols,
271                                const llvm::Type *InterfaceTy,
272                                const ConstantVector &Methods);
273
274  llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
275
276  llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
277
278  /// EmitMethodList - Emit the method list for the given
279  /// implementation. The return value has type MethodListPtrTy.
280  llvm::Constant *EmitMethodList(const std::string &Name,
281                                 const char *Section,
282                                 const ConstantVector &Methods);
283
284  /// EmitMethodDescList - Emit a method description list for a list of
285  /// method declarations.
286  ///  - TypeName: The name for the type containing the methods.
287  ///  - IsProtocol: True iff these methods are for a protocol.
288  ///  - ClassMethds: True iff these are class methods.
289  ///  - Required: When true, only "required" methods are
290  ///    listed. Similarly, when false only "optional" methods are
291  ///    listed. For classes this should always be true.
292  ///  - begin, end: The method list to output.
293  ///
294  /// The return value has type MethodDescriptionListPtrTy.
295  llvm::Constant *EmitMethodDescList(const std::string &Name,
296                                     const char *Section,
297                                     const ConstantVector &Methods);
298
299  /// EmitPropertyList - Emit the given property list. The return
300  /// value has type PropertyListPtrTy.
301  llvm::Constant *EmitPropertyList(const std::string &Name,
302                                   const Decl *Container,
303                                   ObjCPropertyDecl * const *begin,
304                                   ObjCPropertyDecl * const *end);
305
306  /// EmitProtocolExtension - Generate the protocol extension
307  /// structure used to store optional instance and class methods, and
308  /// protocol properties. The return value has type
309  /// ProtocolExtensionPtrTy.
310  llvm::Constant *
311  EmitProtocolExtension(const ObjCProtocolDecl *PD,
312                        const ConstantVector &OptInstanceMethods,
313                        const ConstantVector &OptClassMethods);
314
315  /// EmitProtocolList - Generate the list of referenced
316  /// protocols. The return value has type ProtocolListPtrTy.
317  llvm::Constant *EmitProtocolList(const std::string &Name,
318                                   ObjCProtocolDecl::protocol_iterator begin,
319                                   ObjCProtocolDecl::protocol_iterator end);
320
321  /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
322  /// for the given selector.
323  llvm::Value *EmitSelector(llvm::IRBuilder<> &Builder, Selector Sel);
324
325  /// GetProtocolRef - Return a reference to the internal protocol
326  /// description, creating an empty one if it has not been
327  /// defined. The return value has type pointer-to ProtocolTy.
328  llvm::GlobalVariable *GetProtocolRef(const ObjCProtocolDecl *PD);
329
330  /// GetClassName - Return a unique constant for the given selector's
331  /// name. The return value has type char *.
332  llvm::Constant *GetClassName(IdentifierInfo *Ident);
333
334  /// GetMethodVarName - Return a unique constant for the given
335  /// selector's name. The return value has type char *.
336  llvm::Constant *GetMethodVarName(Selector Sel);
337  llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
338  llvm::Constant *GetMethodVarName(const std::string &Name);
339
340  /// GetMethodVarType - Return a unique constant for the given
341  /// selector's name. The return value has type char *.
342
343  // FIXME: This is a horrible name.
344  llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D);
345  llvm::Constant *GetMethodVarType(const std::string &Name);
346
347  /// GetPropertyName - Return a unique constant for the given
348  /// name. The return value has type char *.
349  llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
350
351  // FIXME: This can be dropped once string functions are unified.
352  llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
353                                        const Decl *Container);
354
355  /// GetNameForMethod - Return a name for the given method.
356  /// \param[out] NameOut - The return value.
357  void GetNameForMethod(const ObjCMethodDecl *OMD,
358                        std::string &NameOut);
359
360public:
361  CGObjCMac(CodeGen::CodeGenModule &cgm);
362  virtual llvm::Constant *GenerateConstantString(const std::string &String);
363
364  virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
365                                              QualType ResultType,
366                                              Selector Sel,
367                                              llvm::Value *Receiver,
368                                              bool IsClassMessage,
369                                              const CallArgList &CallArgs);
370
371  virtual CodeGen::RValue
372  GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
373                           QualType ResultType,
374                           Selector Sel,
375                           const ObjCInterfaceDecl *Class,
376                           llvm::Value *Receiver,
377                           bool IsClassMessage,
378                           const CallArgList &CallArgs);
379
380  virtual llvm::Value *GetClass(llvm::IRBuilder<> &Builder,
381                                const ObjCInterfaceDecl *ID);
382
383  virtual llvm::Value *GetSelector(llvm::IRBuilder<> &Builder, Selector Sel);
384
385  virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD);
386
387  virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
388
389  virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
390
391  virtual llvm::Value *GenerateProtocolRef(llvm::IRBuilder<> &Builder,
392                                           const ObjCProtocolDecl *PD);
393
394  virtual void GenerateProtocol(const ObjCProtocolDecl *PD);
395
396  virtual llvm::Function *ModuleInitFunction();
397  virtual llvm::Function *EnumerationMutationFunction();
398
399  virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
400                           const ObjCAtTryStmt &S);
401  virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
402                             const ObjCAtThrowStmt &S);
403
404};
405} // end anonymous namespace
406
407/* *** Helper Functions *** */
408
409/// getConstantGEP() - Help routine to construct simple GEPs.
410static llvm::Constant *getConstantGEP(llvm::Constant *C,
411                                      unsigned idx0,
412                                      unsigned idx1) {
413  llvm::Value *Idxs[] = {
414    llvm::ConstantInt::get(llvm::Type::Int32Ty, idx0),
415    llvm::ConstantInt::get(llvm::Type::Int32Ty, idx1)
416  };
417  return llvm::ConstantExpr::getGetElementPtr(C, Idxs, 2);
418}
419
420/* *** CGObjCMac Public Interface *** */
421
422CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm)
423  : CGM(cgm),
424    ObjCTypes(cgm),
425    ObjCABI(1)
426{
427  // FIXME: How does this get set in GCC? And what does it even mean?
428  if (ObjCTypes.LongTy != CGM.getTypes().ConvertType(CGM.getContext().IntTy))
429      ObjCABI = 2;
430
431  EmitImageInfo();
432}
433
434/// GetClass - Return a reference to the class for the given interface
435/// decl.
436llvm::Value *CGObjCMac::GetClass(llvm::IRBuilder<> &Builder,
437                                 const ObjCInterfaceDecl *ID) {
438  return EmitClassRef(Builder, ID);
439}
440
441/// GetSelector - Return the pointer to the unique'd string for this selector.
442llvm::Value *CGObjCMac::GetSelector(llvm::IRBuilder<> &Builder, Selector Sel) {
443  return EmitSelector(Builder, Sel);
444}
445
446/// Generate a constant CFString object.
447/*
448   struct __builtin_CFString {
449     const int *isa; // point to __CFConstantStringClassReference
450     int flags;
451     const char *str;
452     long length;
453   };
454*/
455
456llvm::Constant *CGObjCMac::GenerateConstantString(const std::string &String) {
457  return CGM.GetAddrOfConstantCFString(String);
458}
459
460/// Generates a message send where the super is the receiver.  This is
461/// a message send to self with special delivery semantics indicating
462/// which class's method should be called.
463CodeGen::RValue
464CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
465                                    QualType ResultType,
466                                    Selector Sel,
467                                    const ObjCInterfaceDecl *Class,
468                                    llvm::Value *Receiver,
469                                    bool IsClassMessage,
470                                    const CodeGen::CallArgList &CallArgs) {
471  // Create and init a super structure; this is a (receiver, class)
472  // pair we will pass to objc_msgSendSuper.
473  llvm::Value *ObjCSuper =
474    CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super");
475  llvm::Value *ReceiverAsObject =
476    CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
477  CGF.Builder.CreateStore(ReceiverAsObject,
478                          CGF.Builder.CreateStructGEP(ObjCSuper, 0));
479
480  // If this is a class message the metaclass is passed as the target.
481  llvm::Value *Target;
482  if (IsClassMessage) {
483    llvm::Value *MetaClassPtr = EmitMetaClassRef(Class);
484    llvm::Value *SuperPtr = CGF.Builder.CreateStructGEP(MetaClassPtr, 1);
485    llvm::Value *Super = CGF.Builder.CreateLoad(SuperPtr);
486    Target = Super;
487  } else {
488    Target = EmitClassRef(CGF.Builder, Class->getSuperClass());
489  }
490  // FIXME: We shouldn't need to do this cast, rectify the ASTContext
491  // and ObjCTypes types.
492  const llvm::Type *ClassTy =
493    CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
494  Target = CGF.Builder.CreateBitCast(Target, ClassTy);
495  CGF.Builder.CreateStore(Target,
496                          CGF.Builder.CreateStructGEP(ObjCSuper, 1));
497
498  return EmitMessageSend(CGF, ResultType, Sel,
499                         ObjCSuper, ObjCTypes.SuperPtrCTy,
500                         true, CallArgs);
501}
502
503/// Generate code for a message send expression.
504CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
505                                               QualType ResultType,
506                                               Selector Sel,
507                                               llvm::Value *Receiver,
508                                               bool IsClassMessage,
509                                               const CallArgList &CallArgs) {
510  llvm::Value *Arg0 =
511    CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy, "tmp");
512  return EmitMessageSend(CGF, ResultType, Sel,
513                         Arg0, CGF.getContext().getObjCIdType(),
514                         false, CallArgs);
515}
516
517CodeGen::RValue CGObjCMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
518                                           QualType ResultType,
519                                           Selector Sel,
520                                           llvm::Value *Arg0,
521                                           QualType Arg0Ty,
522                                           bool IsSuper,
523                                           const CallArgList &CallArgs) {
524  CallArgList ActualArgs;
525  ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty));
526  ActualArgs.push_back(std::make_pair(RValue::get(EmitSelector(CGF.Builder,
527                                                               Sel)),
528                                      CGF.getContext().getObjCSelType()));
529  ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
530
531  // FIXME: This is a hack, we are implicitly coordinating with
532  // EmitCall, which will move the return type to the first parameter
533  // and set the structure return flag. See getMessageSendFn().
534
535  const llvm::Type *ReturnTy = CGM.getTypes().ConvertType(ResultType);
536  return CGF.EmitCall(ObjCTypes.getMessageSendFn(IsSuper, ReturnTy),
537                      ResultType, ActualArgs);
538}
539
540llvm::Value *CGObjCMac::GenerateProtocolRef(llvm::IRBuilder<> &Builder,
541                                            const ObjCProtocolDecl *PD) {
542  // FIXME: I don't understand why gcc generates this, or where it is
543  // resolved. Investigate. Its also wasteful to look this up over and
544  // over.
545  LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
546
547  return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
548                                        ObjCTypes.ExternalProtocolPtrTy);
549}
550
551/*
552     // APPLE LOCAL radar 4585769 - Objective-C 1.0 extensions
553  struct _objc_protocol {
554    struct _objc_protocol_extension *isa;
555    char *protocol_name;
556    struct _objc_protocol_list *protocol_list;
557    struct _objc__method_prototype_list *instance_methods;
558    struct _objc__method_prototype_list *class_methods
559  };
560
561  See EmitProtocolExtension().
562*/
563void CGObjCMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
564  // FIXME: I don't understand why gcc generates this, or where it is
565  // resolved. Investigate. Its also wasteful to look this up over and
566  // over.
567  LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
568
569  const char *ProtocolName = PD->getName();
570
571  // Construct method lists.
572  std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
573  std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
574  for (ObjCProtocolDecl::instmeth_iterator i = PD->instmeth_begin(),
575         e = PD->instmeth_end(); i != e; ++i) {
576    ObjCMethodDecl *MD = *i;
577    llvm::Constant *C = GetMethodDescriptionConstant(MD);
578    if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
579      OptInstanceMethods.push_back(C);
580    } else {
581      InstanceMethods.push_back(C);
582    }
583  }
584
585  for (ObjCProtocolDecl::classmeth_iterator i = PD->classmeth_begin(),
586         e = PD->classmeth_end(); i != e; ++i) {
587    ObjCMethodDecl *MD = *i;
588    llvm::Constant *C = GetMethodDescriptionConstant(MD);
589    if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
590      OptClassMethods.push_back(C);
591    } else {
592      ClassMethods.push_back(C);
593    }
594  }
595
596  std::vector<llvm::Constant*> Values(5);
597  Values[0] = EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods);
598  Values[1] = GetClassName(PD->getIdentifier());
599  Values[2] =
600    EmitProtocolList(std::string("\01L_OBJC_PROTOCOL_REFS_")+PD->getName(),
601                     PD->protocol_begin(),
602                     PD->protocol_end());
603  Values[3] =
604    EmitMethodDescList(std::string("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_")
605                       + PD->getName(),
606                       "__OBJC,__cat_inst_meth,regular,no_dead_strip",
607                       InstanceMethods);
608  Values[4] =
609    EmitMethodDescList(std::string("\01L_OBJC_PROTOCOL_CLASS_METHODS_")
610                       + PD->getName(),
611                       "__OBJC,__cat_cls_meth,regular,no_dead_strip",
612                       ClassMethods);
613  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
614                                                   Values);
615
616  llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
617  if (Entry) {
618    // Already created, just update the initializer
619    Entry->setInitializer(Init);
620  } else {
621    Entry =
622      new llvm::GlobalVariable(ObjCTypes.ProtocolTy, false,
623                               llvm::GlobalValue::InternalLinkage,
624                               Init,
625                               std::string("\01L_OBJC_PROTOCOL_")+ProtocolName,
626                               &CGM.getModule());
627    Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
628    UsedGlobals.push_back(Entry);
629    // FIXME: Is this necessary? Why only for protocol?
630    Entry->setAlignment(4);
631  }
632}
633
634llvm::GlobalVariable *CGObjCMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
635  llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
636
637  if (!Entry) {
638    std::vector<llvm::Constant*> Values(5);
639    Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
640    Values[1] = GetClassName(PD->getIdentifier());
641    Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
642    Values[3] = Values[4] =
643      llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
644    llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
645                                                     Values);
646
647    Entry =
648      new llvm::GlobalVariable(ObjCTypes.ProtocolTy, false,
649                               llvm::GlobalValue::InternalLinkage,
650                               Init,
651                               std::string("\01L_OBJC_PROTOCOL_")+PD->getName(),
652                               &CGM.getModule());
653    Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
654    UsedGlobals.push_back(Entry);
655    // FIXME: Is this necessary? Why only for protocol?
656    Entry->setAlignment(4);
657  }
658
659  return Entry;
660}
661
662/*
663  struct _objc_protocol_extension {
664    uint32_t size;
665    struct objc_method_description_list *optional_instance_methods;
666    struct objc_method_description_list *optional_class_methods;
667    struct objc_property_list *instance_properties;
668  };
669*/
670llvm::Constant *
671CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
672                                 const ConstantVector &OptInstanceMethods,
673                                 const ConstantVector &OptClassMethods) {
674  uint64_t Size =
675    CGM.getTargetData().getABITypeSize(ObjCTypes.ProtocolExtensionTy);
676  std::vector<llvm::Constant*> Values(4);
677  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
678  Values[1] =
679    EmitMethodDescList(std::string("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_OPT_")
680                       + PD->getName(),
681                       "__OBJC,__cat_inst_meth,regular,no_dead_strip",
682                       OptInstanceMethods);
683  Values[2] =
684    EmitMethodDescList(std::string("\01L_OBJC_PROTOCOL_CLASS_METHODS_OPT_")
685                       + PD->getName(),
686                       "__OBJC,__cat_cls_meth,regular,no_dead_strip",
687                       OptClassMethods);
688  Values[3] = EmitPropertyList(std::string("\01L_OBJC_$_PROP_PROTO_LIST_") +
689                               PD->getName(),
690                               0,
691                               PD->classprop_begin(),
692                               PD->classprop_end());
693
694  // Return null if no extension bits are used.
695  if (Values[1]->isNullValue() && Values[2]->isNullValue() &&
696      Values[3]->isNullValue())
697    return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
698
699  llvm::Constant *Init =
700    llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values);
701  llvm::GlobalVariable *GV =
702      new llvm::GlobalVariable(ObjCTypes.ProtocolExtensionTy, false,
703                               llvm::GlobalValue::InternalLinkage,
704                               Init,
705                               (std::string("\01L_OBJC_PROTOCOLEXT_") +
706                                PD->getName()),
707                               &CGM.getModule());
708  // No special section, but goes in llvm.used
709  UsedGlobals.push_back(GV);
710
711  return GV;
712}
713
714/*
715  struct objc_protocol_list {
716    struct objc_protocol_list *next;
717    long count;
718    Protocol *list[];
719  };
720*/
721llvm::Constant *
722CGObjCMac::EmitProtocolList(const std::string &Name,
723                            ObjCProtocolDecl::protocol_iterator begin,
724                            ObjCProtocolDecl::protocol_iterator end) {
725  std::vector<llvm::Constant*> ProtocolRefs;
726
727  for (; begin != end; ++begin)
728    ProtocolRefs.push_back(GetProtocolRef(*begin));
729
730  // Just return null for empty protocol lists
731  if (ProtocolRefs.empty())
732    return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
733
734  // This list is null terminated.
735  ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy));
736
737  std::vector<llvm::Constant*> Values(3);
738  // This field is only used by the runtime.
739  Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
740  Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1);
741  Values[2] =
742    llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy,
743                                                  ProtocolRefs.size()),
744                             ProtocolRefs);
745
746  llvm::Constant *Init = llvm::ConstantStruct::get(Values);
747  llvm::GlobalVariable *GV =
748    new llvm::GlobalVariable(Init->getType(), false,
749                             llvm::GlobalValue::InternalLinkage,
750                             Init,
751                             Name,
752                             &CGM.getModule());
753  GV->setSection("__OBJC,__cat_cls_meth,regular,no_dead_strip");
754  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
755}
756
757/*
758  struct _objc_property {
759    const char * const name;
760    const char * const attributes;
761  };
762
763  struct _objc_property_list {
764    uint32_t entsize; // sizeof (struct _objc_property)
765    uint32_t prop_count;
766    struct _objc_property[prop_count];
767  };
768*/
769llvm::Constant *CGObjCMac::EmitPropertyList(const std::string &Name,
770                                            const Decl *Container,
771                                            ObjCPropertyDecl * const *begin,
772                                            ObjCPropertyDecl * const *end) {
773  std::vector<llvm::Constant*> Properties, Prop(2);
774  for (; begin != end; ++begin) {
775    const ObjCPropertyDecl *PD = *begin;
776    Prop[0] = GetPropertyName(PD->getIdentifier());
777    Prop[1] = GetPropertyTypeString(PD, Container);
778    Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy,
779                                                   Prop));
780  }
781
782  // Return null for empty list.
783  if (Properties.empty())
784    return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
785
786  unsigned PropertySize =
787    CGM.getTargetData().getABITypeSize(ObjCTypes.PropertyTy);
788  std::vector<llvm::Constant*> Values(3);
789  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize);
790  Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size());
791  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy,
792                                             Properties.size());
793  Values[2] = llvm::ConstantArray::get(AT, Properties);
794  llvm::Constant *Init = llvm::ConstantStruct::get(Values);
795
796  llvm::GlobalVariable *GV =
797    new llvm::GlobalVariable(Init->getType(), false,
798                             llvm::GlobalValue::InternalLinkage,
799                             Init,
800                             Name,
801                             &CGM.getModule());
802  // No special section on property lists?
803  UsedGlobals.push_back(GV);
804  return llvm::ConstantExpr::getBitCast(GV,
805                                        ObjCTypes.PropertyListPtrTy);
806
807}
808
809/*
810  struct objc_method_description_list {
811    int count;
812    struct objc_method_description list[];
813  };
814*/
815llvm::Constant *
816CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
817  std::vector<llvm::Constant*> Desc(2);
818  Desc[0] = llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
819                                           ObjCTypes.SelectorPtrTy);
820  Desc[1] = GetMethodVarType(MD);
821  return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy,
822                                   Desc);
823}
824
825llvm::Constant *CGObjCMac::EmitMethodDescList(const std::string &Name,
826                                              const char *Section,
827                                              const ConstantVector &Methods) {
828  // Return null for empty list.
829  if (Methods.empty())
830    return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
831
832  std::vector<llvm::Constant*> Values(2);
833  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
834  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy,
835                                             Methods.size());
836  Values[1] = llvm::ConstantArray::get(AT, Methods);
837  llvm::Constant *Init = llvm::ConstantStruct::get(Values);
838
839  llvm::GlobalVariable *GV =
840    new llvm::GlobalVariable(Init->getType(), false,
841                             llvm::GlobalValue::InternalLinkage,
842                             Init, Name, &CGM.getModule());
843  GV->setSection(Section);
844  UsedGlobals.push_back(GV);
845  return llvm::ConstantExpr::getBitCast(GV,
846                                        ObjCTypes.MethodDescriptionListPtrTy);
847}
848
849/*
850  struct _objc_category {
851    char *category_name;
852    char *class_name;
853    struct _objc_method_list *instance_methods;
854    struct _objc_method_list *class_methods;
855    struct _objc_protocol_list *protocols;
856    uint32_t size; // <rdar://4585769>
857    struct _objc_property_list *instance_properties;
858  };
859 */
860void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
861  unsigned Size = CGM.getTargetData().getABITypeSize(ObjCTypes.CategoryTy);
862
863  // FIXME: This is poor design, the OCD should have a pointer to the
864  // category decl. Additionally, note that Category can be null for
865  // the @implementation w/o an @interface case. Sema should just
866  // create one for us as it does for @implementation so everyone else
867  // can live life under a clear blue sky.
868  const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
869  const ObjCCategoryDecl *Category =
870    Interface->FindCategoryDeclaration(OCD->getIdentifier());
871  std::string ExtName(std::string(Interface->getName()) +
872                      "_" +
873                      OCD->getName());
874
875  std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
876  for (ObjCCategoryImplDecl::instmeth_iterator i = OCD->instmeth_begin(),
877         e = OCD->instmeth_end(); i != e; ++i) {
878    // Instance methods should always be defined.
879    InstanceMethods.push_back(GetMethodConstant(*i));
880  }
881  for (ObjCCategoryImplDecl::classmeth_iterator i = OCD->classmeth_begin(),
882         e = OCD->classmeth_end(); i != e; ++i) {
883    // Class methods should always be defined.
884    ClassMethods.push_back(GetMethodConstant(*i));
885  }
886
887  std::vector<llvm::Constant*> Values(7);
888  Values[0] = GetClassName(OCD->getIdentifier());
889  Values[1] = GetClassName(Interface->getIdentifier());
890  Values[2] =
891    EmitMethodList(std::string("\01L_OBJC_CATEGORY_INSTANCE_METHODS_") +
892                   ExtName,
893                   "__OBJC,__cat_inst_meth,regular,no_dead_strip",
894                   InstanceMethods);
895  Values[3] =
896    EmitMethodList(std::string("\01L_OBJC_CATEGORY_CLASS_METHODS_") + ExtName,
897                   "__OBJC,__cat_class_meth,regular,no_dead_strip",
898                   ClassMethods);
899  if (Category) {
900    Values[4] =
901      EmitProtocolList(std::string("\01L_OBJC_CATEGORY_PROTOCOLS_") + ExtName,
902                       Category->protocol_begin(),
903                       Category->protocol_end());
904  } else {
905    Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
906  }
907  Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
908
909  // If there is no category @interface then there can be no properties.
910  if (Category) {
911    Values[6] = EmitPropertyList(std::string("\01L_OBJC_$_PROP_LIST_") + ExtName,
912                                 OCD,
913                                 Category->classprop_begin(),
914                                 Category->classprop_end());
915  } else {
916    Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
917  }
918
919  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy,
920                                                   Values);
921
922  llvm::GlobalVariable *GV =
923    new llvm::GlobalVariable(ObjCTypes.CategoryTy, false,
924                             llvm::GlobalValue::InternalLinkage,
925                             Init,
926                             std::string("\01L_OBJC_CATEGORY_")+ExtName,
927                             &CGM.getModule());
928  GV->setSection("__OBJC,__category,regular,no_dead_strip");
929  UsedGlobals.push_back(GV);
930  DefinedCategories.push_back(GV);
931}
932
933// FIXME: Get from somewhere?
934enum ClassFlags {
935  eClassFlags_Factory              = 0x00001,
936  eClassFlags_Meta                 = 0x00002,
937  // <rdr://5142207>
938  eClassFlags_HasCXXStructors      = 0x02000,
939  eClassFlags_Hidden               = 0x20000,
940  eClassFlags_ABI2_Hidden          = 0x00010,
941  eClassFlags_ABI2_HasCXXStructors = 0x00004   // <rdr://4923634>
942};
943
944// <rdr://5142207&4705298&4843145>
945static bool IsClassHidden(const ObjCInterfaceDecl *ID) {
946  if (const VisibilityAttr *attr = ID->getAttr<VisibilityAttr>()) {
947    // FIXME: Support -fvisibility
948    switch (attr->getVisibility()) {
949    default:
950      assert(0 && "Unknown visibility");
951      return false;
952    case VisibilityAttr::DefaultVisibility:
953    case VisibilityAttr::ProtectedVisibility:  // FIXME: What do we do here?
954      return false;
955    case VisibilityAttr::HiddenVisibility:
956      return true;
957    }
958  } else {
959    return false; // FIXME: Support -fvisibility
960  }
961}
962
963/*
964  struct _objc_class {
965    Class isa;
966    Class super_class;
967    const char *name;
968    long version;
969    long info;
970    long instance_size;
971    struct _objc_ivar_list *ivars;
972    struct _objc_method_list *methods;
973    struct _objc_cache *cache;
974    struct _objc_protocol_list *protocols;
975    // Objective-C 1.0 extensions (<rdr://4585769>)
976    const char *ivar_layout;
977    struct _objc_class_ext *ext;
978  };
979
980  See EmitClassExtension();
981 */
982void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
983  DefinedSymbols.insert(ID->getIdentifier());
984
985  const char *ClassName = ID->getName();
986  // FIXME: Gross
987  ObjCInterfaceDecl *Interface =
988    const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
989  llvm::Constant *Protocols =
990    EmitProtocolList(std::string("\01L_OBJC_CLASS_PROTOCOLS_") + ID->getName(),
991                     Interface->protocol_begin(),
992                     Interface->protocol_end());
993  const llvm::Type *InterfaceTy =
994   CGM.getTypes().ConvertType(CGM.getContext().getObjCInterfaceType(Interface));
995  unsigned Flags = eClassFlags_Factory;
996  unsigned Size = CGM.getTargetData().getABITypeSize(InterfaceTy);
997
998  // FIXME: Set CXX-structors flag.
999  if (IsClassHidden(ID->getClassInterface()))
1000    Flags |= eClassFlags_Hidden;
1001
1002  std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
1003  for (ObjCImplementationDecl::instmeth_iterator i = ID->instmeth_begin(),
1004         e = ID->instmeth_end(); i != e; ++i) {
1005    // Instance methods should always be defined.
1006    InstanceMethods.push_back(GetMethodConstant(*i));
1007  }
1008  for (ObjCImplementationDecl::classmeth_iterator i = ID->classmeth_begin(),
1009         e = ID->classmeth_end(); i != e; ++i) {
1010    // Class methods should always be defined.
1011    ClassMethods.push_back(GetMethodConstant(*i));
1012  }
1013
1014  for (ObjCImplementationDecl::propimpl_iterator i = ID->propimpl_begin(),
1015         e = ID->propimpl_end(); i != e; ++i) {
1016    ObjCPropertyImplDecl *PID = *i;
1017
1018    if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
1019      ObjCPropertyDecl *PD = PID->getPropertyDecl();
1020
1021      if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
1022        if (llvm::Constant *C = GetMethodConstant(MD))
1023          InstanceMethods.push_back(C);
1024      if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
1025        if (llvm::Constant *C = GetMethodConstant(MD))
1026          InstanceMethods.push_back(C);
1027    }
1028  }
1029
1030  std::vector<llvm::Constant*> Values(12);
1031  Values[ 0] = EmitMetaClass(ID, Protocols, InterfaceTy, ClassMethods);
1032  if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
1033    // Record a reference to the super class.
1034    LazySymbols.insert(Super->getIdentifier());
1035
1036    Values[ 1] =
1037      llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
1038                                     ObjCTypes.ClassPtrTy);
1039  } else {
1040    Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
1041  }
1042  Values[ 2] = GetClassName(ID->getIdentifier());
1043  // Version is always 0.
1044  Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
1045  Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
1046  Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
1047  Values[ 6] = EmitIvarList(ID, false, InterfaceTy);
1048  Values[ 7] =
1049    EmitMethodList(std::string("\01L_OBJC_INSTANCE_METHODS_") + ID->getName(),
1050                   "__OBJC,__inst_meth,regular,no_dead_strip",
1051                   InstanceMethods);
1052  // cache is always NULL.
1053  Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
1054  Values[ 9] = Protocols;
1055  // FIXME: Set ivar_layout
1056  Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
1057  Values[11] = EmitClassExtension(ID);
1058  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
1059                                                   Values);
1060
1061  llvm::GlobalVariable *GV =
1062    new llvm::GlobalVariable(ObjCTypes.ClassTy, false,
1063                             llvm::GlobalValue::InternalLinkage,
1064                             Init,
1065                             std::string("\01L_OBJC_CLASS_")+ClassName,
1066                             &CGM.getModule());
1067  GV->setSection("__OBJC,__class,regular,no_dead_strip");
1068  UsedGlobals.push_back(GV);
1069  // FIXME: Why?
1070  GV->setAlignment(32);
1071  DefinedClasses.push_back(GV);
1072}
1073
1074llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
1075                                         llvm::Constant *Protocols,
1076                                         const llvm::Type *InterfaceTy,
1077                                         const ConstantVector &Methods) {
1078  const char *ClassName = ID->getName();
1079  unsigned Flags = eClassFlags_Meta;
1080  unsigned Size = CGM.getTargetData().getABITypeSize(ObjCTypes.ClassTy);
1081
1082  if (IsClassHidden(ID->getClassInterface()))
1083    Flags |= eClassFlags_Hidden;
1084
1085  std::vector<llvm::Constant*> Values(12);
1086  // The isa for the metaclass is the root of the hierarchy.
1087  const ObjCInterfaceDecl *Root = ID->getClassInterface();
1088  while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
1089    Root = Super;
1090  Values[ 0] =
1091    llvm::ConstantExpr::getBitCast(GetClassName(Root->getIdentifier()),
1092                                   ObjCTypes.ClassPtrTy);
1093  // The super class for the metaclass is emitted as the name of the
1094  // super class. The runtime fixes this up to point to the
1095  // *metaclass* for the super class.
1096  if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
1097    Values[ 1] =
1098      llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
1099                                     ObjCTypes.ClassPtrTy);
1100  } else {
1101    Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
1102  }
1103  Values[ 2] = GetClassName(ID->getIdentifier());
1104  // Version is always 0.
1105  Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
1106  Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
1107  Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
1108  Values[ 6] = EmitIvarList(ID, true, InterfaceTy);
1109  Values[ 7] =
1110    EmitMethodList(std::string("\01L_OBJC_CLASS_METHODS_") + ID->getName(),
1111                   "__OBJC,__inst_meth,regular,no_dead_strip",
1112                   Methods);
1113  // cache is always NULL.
1114  Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
1115  Values[ 9] = Protocols;
1116  // ivar_layout for metaclass is always NULL.
1117  Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
1118  // The class extension is always unused for metaclasses.
1119  Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
1120  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
1121                                                   Values);
1122
1123  std::string Name("\01L_OBJC_METACLASS_");
1124  Name += ClassName;
1125
1126  // Check for a forward reference.
1127  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
1128  if (GV) {
1129    assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
1130           "Forward metaclass reference has incorrect type.");
1131    GV->setLinkage(llvm::GlobalValue::InternalLinkage);
1132    GV->setInitializer(Init);
1133  } else {
1134    GV = new llvm::GlobalVariable(ObjCTypes.ClassTy, false,
1135                                  llvm::GlobalValue::InternalLinkage,
1136                                  Init, Name,
1137                                  &CGM.getModule());
1138  }
1139  GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
1140  UsedGlobals.push_back(GV);
1141  // FIXME: Why?
1142  GV->setAlignment(32);
1143
1144  return GV;
1145}
1146
1147llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
1148  std::string Name("\01L_OBJC_METACLASS_");
1149  Name += ID->getName();
1150
1151  // FIXME: Should we look these up somewhere other than the
1152  // module. Its a bit silly since we only generate these while
1153  // processing an implementation, so exactly one pointer would work
1154  // if know when we entered/exitted an implementation block.
1155
1156  // Check for an existing forward reference.
1157  if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name)) {
1158    assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
1159           "Forward metaclass reference has incorrect type.");
1160    return GV;
1161  } else {
1162    // Generate as an external reference to keep a consistent
1163    // module. This will be patched up when we emit the metaclass.
1164    return new llvm::GlobalVariable(ObjCTypes.ClassTy, false,
1165                                    llvm::GlobalValue::ExternalLinkage,
1166                                    0,
1167                                    Name,
1168                                    &CGM.getModule());
1169  }
1170}
1171
1172/*
1173  struct objc_class_ext {
1174    uint32_t size;
1175    const char *weak_ivar_layout;
1176    struct _objc_property_list *properties;
1177  };
1178*/
1179llvm::Constant *
1180CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) {
1181  uint64_t Size =
1182    CGM.getTargetData().getABITypeSize(ObjCTypes.ClassExtensionTy);
1183
1184  std::vector<llvm::Constant*> Values(3);
1185  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
1186  // FIXME: Output weak_ivar_layout string.
1187  Values[1] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
1188  Values[2] = EmitPropertyList(std::string("\01L_OBJC_$_PROP_LIST_") +
1189                               ID->getName(),
1190                               ID,
1191                               ID->getClassInterface()->classprop_begin(),
1192                               ID->getClassInterface()->classprop_end());
1193
1194  // Return null if no extension bits are used.
1195  if (Values[1]->isNullValue() && Values[2]->isNullValue())
1196    return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
1197
1198  llvm::Constant *Init =
1199    llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values);
1200  llvm::GlobalVariable *GV =
1201    new llvm::GlobalVariable(ObjCTypes.ClassExtensionTy, false,
1202                             llvm::GlobalValue::InternalLinkage,
1203                             Init,
1204                             (std::string("\01L_OBJC_CLASSEXT_") +
1205                              ID->getName()),
1206                             &CGM.getModule());
1207  // No special section, but goes in llvm.used
1208  UsedGlobals.push_back(GV);
1209
1210  return GV;
1211}
1212
1213/*
1214  struct objc_ivar {
1215    char *ivar_name;
1216    char *ivar_type;
1217    int ivar_offset;
1218  };
1219
1220  struct objc_ivar_list {
1221    int ivar_count;
1222    struct objc_ivar list[count];
1223  };
1224 */
1225llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
1226                                        bool ForClass,
1227                                        const llvm::Type *InterfaceTy) {
1228  std::vector<llvm::Constant*> Ivars, Ivar(3);
1229
1230  // When emitting the root class GCC emits ivar entries for the
1231  // actual class structure. It is not clear if we need to follow this
1232  // behavior; for now lets try and get away with not doing it. If so,
1233  // the cleanest solution would be to make up an ObjCInterfaceDecl
1234  // for the class.
1235  if (ForClass)
1236    return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
1237
1238  const llvm::StructLayout *Layout =
1239    CGM.getTargetData().getStructLayout(cast<llvm::StructType>(InterfaceTy));
1240  for (ObjCInterfaceDecl::ivar_iterator
1241         i = ID->getClassInterface()->ivar_begin(),
1242         e = ID->getClassInterface()->ivar_end(); i != e; ++i) {
1243    ObjCIvarDecl *V = *i;
1244    unsigned Offset =
1245      Layout->getElementOffset(CGM.getTypes().getLLVMFieldNo(V));
1246    std::string TypeStr;
1247    llvm::SmallVector<const RecordType *, 8> EncodingRecordTypes;
1248    Ivar[0] = GetMethodVarName(V->getIdentifier());
1249    CGM.getContext().getObjCEncodingForType(V->getType(), TypeStr,
1250                                            EncodingRecordTypes);
1251    Ivar[1] = GetMethodVarType(TypeStr);
1252    Ivar[2] = llvm::ConstantInt::get(ObjCTypes.IntTy, Offset);
1253    Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy,
1254                                              Ivar));
1255  }
1256
1257  // Return null for empty list.
1258  if (Ivars.empty())
1259    return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
1260
1261  std::vector<llvm::Constant*> Values(2);
1262  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
1263  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy,
1264                                             Ivars.size());
1265  Values[1] = llvm::ConstantArray::get(AT, Ivars);
1266  llvm::Constant *Init = llvm::ConstantStruct::get(Values);
1267
1268  const char *Prefix = (ForClass ? "\01L_OBJC_CLASS_VARIABLES_" :
1269                        "\01L_OBJC_INSTANCE_VARIABLES_");
1270  llvm::GlobalVariable *GV =
1271    new llvm::GlobalVariable(Init->getType(), false,
1272                             llvm::GlobalValue::InternalLinkage,
1273                             Init,
1274                             std::string(Prefix) + ID->getName(),
1275                             &CGM.getModule());
1276  if (ForClass) {
1277    GV->setSection("__OBJC,__cls_vars,regular,no_dead_strip");
1278    // FIXME: Why is this only here?
1279    GV->setAlignment(32);
1280  } else {
1281    GV->setSection("__OBJC,__instance_vars,regular,no_dead_strip");
1282  }
1283  UsedGlobals.push_back(GV);
1284  return llvm::ConstantExpr::getBitCast(GV,
1285                                        ObjCTypes.IvarListPtrTy);
1286}
1287
1288/*
1289  struct objc_method {
1290    SEL method_name;
1291    char *method_types;
1292    void *method;
1293  };
1294
1295  struct objc_method_list {
1296    struct objc_method_list *obsolete;
1297    int count;
1298    struct objc_method methods_list[count];
1299  };
1300*/
1301
1302/// GetMethodConstant - Return a struct objc_method constant for the
1303/// given method if it has been defined. The result is null if the
1304/// method has not been defined. The return value has type MethodPtrTy.
1305llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) {
1306  // FIXME: Use DenseMap::lookup
1307  llvm::Function *Fn = MethodDefinitions[MD];
1308  if (!Fn)
1309    return 0;
1310
1311  std::vector<llvm::Constant*> Method(3);
1312  Method[0] =
1313    llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
1314                                   ObjCTypes.SelectorPtrTy);
1315  Method[1] = GetMethodVarType(MD);
1316  Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy);
1317  return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
1318}
1319
1320llvm::Constant *CGObjCMac::EmitMethodList(const std::string &Name,
1321                                          const char *Section,
1322                                          const ConstantVector &Methods) {
1323  // Return null for empty list.
1324  if (Methods.empty())
1325    return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy);
1326
1327  std::vector<llvm::Constant*> Values(3);
1328  Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
1329  Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
1330  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
1331                                             Methods.size());
1332  Values[2] = llvm::ConstantArray::get(AT, Methods);
1333  llvm::Constant *Init = llvm::ConstantStruct::get(Values);
1334
1335  llvm::GlobalVariable *GV =
1336    new llvm::GlobalVariable(Init->getType(), false,
1337                             llvm::GlobalValue::InternalLinkage,
1338                             Init,
1339                             Name,
1340                             &CGM.getModule());
1341  GV->setSection(Section);
1342  UsedGlobals.push_back(GV);
1343  return llvm::ConstantExpr::getBitCast(GV,
1344                                        ObjCTypes.MethodListPtrTy);
1345}
1346
1347llvm::Function *CGObjCMac::GenerateMethod(const ObjCMethodDecl *OMD) {
1348  const llvm::Type *ReturnTy =
1349    CGM.getTypes().ConvertReturnType(OMD->getResultType());
1350  const llvm::Type *SelfTy =
1351    CGM.getTypes().ConvertType(OMD->getSelfDecl()->getType());
1352
1353  std::vector<const llvm::Type*> ArgTys;
1354  ArgTys.reserve(1 + 2 + OMD->param_size());
1355
1356  // FIXME: This is not something we should have to be dealing with
1357  // here.
1358  bool useStructRet =
1359    CodeGen::CodeGenFunction::hasAggregateLLVMType(OMD->getResultType());
1360  if (useStructRet) {
1361    ArgTys.push_back(llvm::PointerType::getUnqual(ReturnTy));
1362    ReturnTy = llvm::Type::VoidTy;
1363  }
1364
1365  // Implicit arguments
1366  ArgTys.push_back(SelfTy);
1367  ArgTys.push_back(ObjCTypes.SelectorPtrTy);
1368
1369  for (ObjCMethodDecl::param_const_iterator
1370         i = OMD->param_begin(), e = OMD->param_end();
1371       i != e; ++i) {
1372    const llvm::Type *Ty = CGM.getTypes().ConvertType((*i)->getType());
1373    if (Ty->isSingleValueType()) {
1374      ArgTys.push_back(Ty);
1375    } else {
1376      ArgTys.push_back(llvm::PointerType::getUnqual(Ty));
1377    }
1378  }
1379
1380  std::string Name;
1381  GetNameForMethod(OMD, Name);
1382
1383  llvm::Function *Method =
1384    llvm::Function::Create(llvm::FunctionType::get(ReturnTy,
1385                                                   ArgTys,
1386                                                   OMD->isVariadic()),
1387                           llvm::GlobalValue::InternalLinkage,
1388                           Name,
1389                           &CGM.getModule());
1390  MethodDefinitions.insert(std::make_pair(OMD, Method));
1391
1392  unsigned Offset = 3; // Return plus self and selector implicit args.
1393  if (useStructRet) {
1394    Method->addParamAttr(1, llvm::ParamAttr::StructRet);
1395    ++Offset;
1396  }
1397
1398  // FIXME: This is horrible, we need to be reusing the machinery in
1399  // CodeGenModule.cpp (SetFunctionAttributes).
1400  for (ObjCMethodDecl::param_const_iterator
1401         i = OMD->param_begin(), e = OMD->param_end();
1402       i != e; ++i, ++Offset) {
1403    const llvm::Type *Ty = CGM.getTypes().ConvertType((*i)->getType());
1404    if (!Ty->isSingleValueType())
1405      Method->addParamAttr(Offset, llvm::ParamAttr::ByVal);
1406  }
1407
1408  return Method;
1409}
1410
1411llvm::Function *CGObjCMac::ModuleInitFunction() {
1412  // Abuse this interface function as a place to finalize.
1413  FinishModule();
1414
1415  return NULL;
1416}
1417
1418llvm::Function *CGObjCMac::EnumerationMutationFunction()
1419{
1420  return ObjCTypes.EnumerationMutationFn;
1421}
1422
1423void CGObjCMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1424                            const ObjCAtTryStmt &S)
1425{
1426  CGF.ErrorUnsupported(&S, "@try statement");
1427}
1428
1429void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
1430                              const ObjCAtThrowStmt &S)
1431{
1432  llvm::Value *ExceptionAsObject;
1433
1434  if (const Expr *ThrowExpr = S.getThrowExpr()) {
1435    llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr);
1436    ExceptionAsObject =
1437      CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp");
1438  } else {
1439    assert(0 && "FIXME: rethrows not supported!");
1440  }
1441
1442  CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn, ExceptionAsObject);
1443
1444}
1445
1446/* *** Private Interface *** */
1447
1448/// EmitImageInfo - Emit the image info marker used to encode some module
1449/// level information.
1450///
1451/// See: <rdr://4810609&4810587&4810587>
1452/// struct IMAGE_INFO {
1453///   unsigned version;
1454///   unsigned flags;
1455/// };
1456enum ImageInfoFlags {
1457  eImageInfo_FixAndContinue   = (1 << 0), // FIXME: Not sure what this implies
1458  eImageInfo_GarbageCollected = (1 << 1),
1459  eImageInfo_GCOnly           = (1 << 2)
1460};
1461
1462void CGObjCMac::EmitImageInfo() {
1463  unsigned version = 0; // Version is unused?
1464  unsigned flags = 0;
1465
1466  // FIXME: Fix and continue?
1467  if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC)
1468    flags |= eImageInfo_GarbageCollected;
1469  if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly)
1470    flags |= eImageInfo_GCOnly;
1471
1472  // Emitted as int[2];
1473  llvm::Constant *values[2] = {
1474    llvm::ConstantInt::get(llvm::Type::Int32Ty, version),
1475    llvm::ConstantInt::get(llvm::Type::Int32Ty, flags)
1476  };
1477  llvm::ArrayType *AT = llvm::ArrayType::get(llvm::Type::Int32Ty, 2);
1478  llvm::GlobalVariable *GV =
1479    new llvm::GlobalVariable(AT, true,
1480                             llvm::GlobalValue::InternalLinkage,
1481                             llvm::ConstantArray::get(AT, values, 2),
1482                             "\01L_OBJC_IMAGE_INFO",
1483                             &CGM.getModule());
1484
1485  if (ObjCABI == 1) {
1486    GV->setSection("__OBJC, __image_info,regular");
1487  } else {
1488    GV->setSection("__DATA, __objc_imageinfo, regular, no_dead_strip");
1489  }
1490
1491  UsedGlobals.push_back(GV);
1492}
1493
1494
1495// struct objc_module {
1496//   unsigned long version;
1497//   unsigned long size;
1498//   const char *name;
1499//   Symtab symtab;
1500// };
1501
1502// FIXME: Get from somewhere
1503static const int ModuleVersion = 7;
1504
1505void CGObjCMac::EmitModuleInfo() {
1506  uint64_t Size = CGM.getTargetData().getABITypeSize(ObjCTypes.ModuleTy);
1507
1508  std::vector<llvm::Constant*> Values(4);
1509  Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion);
1510  Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
1511  // This used to be the filename, now it is unused. <rdr://4327263>
1512  Values[2] = GetClassName(&CGM.getContext().Idents.get(""));
1513  Values[3] = EmitModuleSymbols();
1514
1515  llvm::GlobalVariable *GV =
1516    new llvm::GlobalVariable(ObjCTypes.ModuleTy, false,
1517                             llvm::GlobalValue::InternalLinkage,
1518                             llvm::ConstantStruct::get(ObjCTypes.ModuleTy,
1519                                                       Values),
1520                             "\01L_OBJC_MODULES",
1521                             &CGM.getModule());
1522  GV->setSection("__OBJC,__module_info,regular,no_dead_strip");
1523  UsedGlobals.push_back(GV);
1524}
1525
1526llvm::Constant *CGObjCMac::EmitModuleSymbols() {
1527  unsigned NumClasses = DefinedClasses.size();
1528  unsigned NumCategories = DefinedCategories.size();
1529
1530  // Return null if no symbols were defined.
1531  if (!NumClasses && !NumCategories)
1532    return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
1533
1534  std::vector<llvm::Constant*> Values(5);
1535  Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
1536  Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
1537  Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
1538  Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
1539
1540  // The runtime expects exactly the list of defined classes followed
1541  // by the list of defined categories, in a single array.
1542  std::vector<llvm::Constant*> Symbols(NumClasses + NumCategories);
1543  for (unsigned i=0; i<NumClasses; i++)
1544    Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
1545                                                ObjCTypes.Int8PtrTy);
1546  for (unsigned i=0; i<NumCategories; i++)
1547    Symbols[NumClasses + i] =
1548      llvm::ConstantExpr::getBitCast(DefinedCategories[i],
1549                                     ObjCTypes.Int8PtrTy);
1550
1551  Values[4] =
1552    llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
1553                                                  NumClasses + NumCategories),
1554                             Symbols);
1555
1556  llvm::Constant *Init = llvm::ConstantStruct::get(Values);
1557
1558  llvm::GlobalVariable *GV =
1559    new llvm::GlobalVariable(Init->getType(), false,
1560                             llvm::GlobalValue::InternalLinkage,
1561                             Init,
1562                             "\01L_OBJC_SYMBOLS",
1563                             &CGM.getModule());
1564  GV->setSection("__OBJC,__symbols,regular,no_dead_strip");
1565  UsedGlobals.push_back(GV);
1566  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
1567}
1568
1569llvm::Value *CGObjCMac::EmitClassRef(llvm::IRBuilder<> &Builder,
1570                                     const ObjCInterfaceDecl *ID) {
1571  LazySymbols.insert(ID->getIdentifier());
1572
1573  llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()];
1574
1575  if (!Entry) {
1576    llvm::Constant *Casted =
1577      llvm::ConstantExpr::getBitCast(GetClassName(ID->getIdentifier()),
1578                                     ObjCTypes.ClassPtrTy);
1579    Entry =
1580      new llvm::GlobalVariable(ObjCTypes.ClassPtrTy, false,
1581                               llvm::GlobalValue::InternalLinkage,
1582                               Casted, "\01L_OBJC_CLASS_REFERENCES_",
1583                               &CGM.getModule());
1584    Entry->setSection("__OBJC,__cls_refs,literal_pointers,no_dead_strip");
1585    UsedGlobals.push_back(Entry);
1586  }
1587
1588  return Builder.CreateLoad(Entry, false, "tmp");
1589}
1590
1591llvm::Value *CGObjCMac::EmitSelector(llvm::IRBuilder<> &Builder, Selector Sel) {
1592  llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
1593
1594  if (!Entry) {
1595    llvm::Constant *Casted =
1596      llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
1597                                     ObjCTypes.SelectorPtrTy);
1598    Entry =
1599      new llvm::GlobalVariable(ObjCTypes.SelectorPtrTy, false,
1600                               llvm::GlobalValue::InternalLinkage,
1601                               Casted, "\01L_OBJC_SELECTOR_REFERENCES_",
1602                               &CGM.getModule());
1603    Entry->setSection("__OBJC,__message_refs,literal_pointers,no_dead_strip");
1604    UsedGlobals.push_back(Entry);
1605  }
1606
1607  return Builder.CreateLoad(Entry, false, "tmp");
1608}
1609
1610llvm::Constant *CGObjCMac::GetClassName(IdentifierInfo *Ident) {
1611  llvm::GlobalVariable *&Entry = ClassNames[Ident];
1612
1613  if (!Entry) {
1614    llvm::Constant *C = llvm::ConstantArray::get(Ident->getName());
1615    Entry =
1616      new llvm::GlobalVariable(C->getType(), false,
1617                               llvm::GlobalValue::InternalLinkage,
1618                               C, "\01L_OBJC_CLASS_NAME_",
1619                               &CGM.getModule());
1620    Entry->setSection("__TEXT,__cstring,cstring_literals");
1621    UsedGlobals.push_back(Entry);
1622  }
1623
1624  return getConstantGEP(Entry, 0, 0);
1625}
1626
1627llvm::Constant *CGObjCMac::GetMethodVarName(Selector Sel) {
1628  llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
1629
1630  if (!Entry) {
1631    llvm::Constant *C = llvm::ConstantArray::get(Sel.getName());
1632    Entry =
1633      new llvm::GlobalVariable(C->getType(), false,
1634                               llvm::GlobalValue::InternalLinkage,
1635                               C, "\01L_OBJC_METH_VAR_NAME_",
1636                               &CGM.getModule());
1637    Entry->setSection("__TEXT,__cstring,cstring_literals");
1638    UsedGlobals.push_back(Entry);
1639  }
1640
1641  return getConstantGEP(Entry, 0, 0);
1642}
1643
1644// FIXME: Merge into a single cstring creation function.
1645llvm::Constant *CGObjCMac::GetMethodVarName(IdentifierInfo *ID) {
1646  return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
1647}
1648
1649// FIXME: Merge into a single cstring creation function.
1650llvm::Constant *CGObjCMac::GetMethodVarName(const std::string &Name) {
1651  return GetMethodVarName(&CGM.getContext().Idents.get(Name));
1652}
1653
1654llvm::Constant *CGObjCMac::GetMethodVarType(const std::string &Name) {
1655  llvm::GlobalVariable *&Entry = MethodVarTypes[Name];
1656
1657  if (!Entry) {
1658    llvm::Constant *C = llvm::ConstantArray::get(Name);
1659    Entry =
1660      new llvm::GlobalVariable(C->getType(), false,
1661                               llvm::GlobalValue::InternalLinkage,
1662                               C, "\01L_OBJC_METH_VAR_TYPE_",
1663                               &CGM.getModule());
1664    Entry->setSection("__TEXT,__cstring,cstring_literals");
1665    UsedGlobals.push_back(Entry);
1666  }
1667
1668  return getConstantGEP(Entry, 0, 0);
1669}
1670
1671// FIXME: Merge into a single cstring creation function.
1672llvm::Constant *CGObjCMac::GetMethodVarType(const ObjCMethodDecl *D) {
1673  std::string TypeStr;
1674  CGM.getContext().getObjCEncodingForMethodDecl(const_cast<ObjCMethodDecl*>(D),
1675                                                TypeStr);
1676  return GetMethodVarType(TypeStr);
1677}
1678
1679// FIXME: Merge into a single cstring creation function.
1680llvm::Constant *CGObjCMac::GetPropertyName(IdentifierInfo *Ident) {
1681  llvm::GlobalVariable *&Entry = PropertyNames[Ident];
1682
1683  if (!Entry) {
1684    llvm::Constant *C = llvm::ConstantArray::get(Ident->getName());
1685    Entry =
1686      new llvm::GlobalVariable(C->getType(), false,
1687                               llvm::GlobalValue::InternalLinkage,
1688                               C, "\01L_OBJC_PROP_NAME_ATTR_",
1689                               &CGM.getModule());
1690    Entry->setSection("__TEXT,__cstring,cstring_literals");
1691    UsedGlobals.push_back(Entry);
1692  }
1693
1694  return getConstantGEP(Entry, 0, 0);
1695}
1696
1697// FIXME: Merge into a single cstring creation function.
1698// FIXME: This Decl should be more precise.
1699llvm::Constant *CGObjCMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
1700                                                 const Decl *Container) {
1701  std::string TypeStr;
1702  CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
1703  return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
1704}
1705
1706void CGObjCMac::GetNameForMethod(const ObjCMethodDecl *D,
1707                                 std::string &NameOut) {
1708  // FIXME: Find the mangling GCC uses.
1709  std::stringstream s;
1710  s << (D->isInstance() ? "-" : "+");
1711  s << "[";
1712  s << D->getClassInterface()->getName();
1713  s << " ";
1714  s << D->getSelector().getName();
1715  s << "]";
1716  NameOut = s.str();
1717}
1718
1719void CGObjCMac::FinishModule() {
1720  EmitModuleInfo();
1721
1722  std::vector<llvm::Constant*> Used;
1723
1724  for (std::vector<llvm::GlobalVariable*>::iterator i = UsedGlobals.begin(),
1725         e = UsedGlobals.end(); i != e; ++i) {
1726    Used.push_back(llvm::ConstantExpr::getBitCast(*i, ObjCTypes.Int8PtrTy));
1727  }
1728
1729  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Used.size());
1730  llvm::GlobalValue *GV =
1731    new llvm::GlobalVariable(AT, false,
1732                             llvm::GlobalValue::AppendingLinkage,
1733                             llvm::ConstantArray::get(AT, Used),
1734                             "llvm.used",
1735                             &CGM.getModule());
1736
1737  GV->setSection("llvm.metadata");
1738
1739  // Add assembler directives to add lazy undefined symbol references
1740  // for classes which are referenced but not defined. This is
1741  // important for correct linker interaction.
1742
1743  // FIXME: Uh, this isn't particularly portable.
1744  std::stringstream s;
1745  for (std::set<IdentifierInfo*>::iterator i = LazySymbols.begin(),
1746         e = LazySymbols.end(); i != e; ++i) {
1747    s << "\t.lazy_reference .objc_class_name_" << (*i)->getName() << "\n";
1748  }
1749  for (std::set<IdentifierInfo*>::iterator i = DefinedSymbols.begin(),
1750         e = DefinedSymbols.end(); i != e; ++i) {
1751    s << "\t.objc_class_name_" << (*i)->getName() << "=0\n"
1752      << "\t.globl .objc_class_name_" << (*i)->getName() << "\n";
1753  }
1754  CGM.getModule().appendModuleInlineAsm(s.str());
1755}
1756
1757/* *** */
1758
1759ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
1760  : CGM(cgm)
1761{
1762  CodeGen::CodeGenTypes &Types = CGM.getTypes();
1763  ASTContext &Ctx = CGM.getContext();
1764
1765  ShortTy = Types.ConvertType(Ctx.ShortTy);
1766  IntTy = Types.ConvertType(Ctx.IntTy);
1767  LongTy = Types.ConvertType(Ctx.LongTy);
1768  Int8PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
1769
1770  ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType());
1771  SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType());
1772
1773  // FIXME: It would be nice to unify this with the opaque type, so
1774  // that the IR comes out a bit cleaner.
1775  const llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
1776  ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
1777
1778  MethodDescriptionTy =
1779    llvm::StructType::get(SelectorPtrTy,
1780                          Int8PtrTy,
1781                          NULL);
1782  CGM.getModule().addTypeName("struct._objc_method_description",
1783                              MethodDescriptionTy);
1784
1785  MethodDescriptionListTy =
1786    llvm::StructType::get(IntTy,
1787                          llvm::ArrayType::get(MethodDescriptionTy, 0),
1788                          NULL);
1789  CGM.getModule().addTypeName("struct._objc_method_description_list",
1790                              MethodDescriptionListTy);
1791  MethodDescriptionListPtrTy =
1792    llvm::PointerType::getUnqual(MethodDescriptionListTy);
1793
1794  PropertyTy = llvm::StructType::get(Int8PtrTy,
1795                                     Int8PtrTy,
1796                                     NULL);
1797  CGM.getModule().addTypeName("struct._objc_property",
1798                              PropertyTy);
1799
1800  PropertyListTy = llvm::StructType::get(IntTy,
1801                                         IntTy,
1802                                         llvm::ArrayType::get(PropertyTy, 0),
1803                                         NULL);
1804  CGM.getModule().addTypeName("struct._objc_property_list",
1805                              PropertyListTy);
1806  PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
1807
1808  // Protocol description structures
1809
1810  ProtocolExtensionTy =
1811    llvm::StructType::get(Types.ConvertType(Ctx.IntTy),
1812                          llvm::PointerType::getUnqual(MethodDescriptionListTy),
1813                          llvm::PointerType::getUnqual(MethodDescriptionListTy),
1814                          PropertyListPtrTy,
1815                          NULL);
1816  CGM.getModule().addTypeName("struct._objc_protocol_extension",
1817                              ProtocolExtensionTy);
1818  ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
1819
1820  // Handle recursive construction of Protocl and ProtocolList types
1821
1822  llvm::PATypeHolder ProtocolTyHolder = llvm::OpaqueType::get();
1823  llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get();
1824
1825  T = llvm::StructType::get(llvm::PointerType::getUnqual(ProtocolListTyHolder),
1826                            LongTy,
1827                            llvm::ArrayType::get(ProtocolTyHolder, 0),
1828                            NULL);
1829  cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(T);
1830
1831  T = llvm::StructType::get(llvm::PointerType::getUnqual(ProtocolExtensionTy),
1832                            Int8PtrTy,
1833                            llvm::PointerType::getUnqual(ProtocolListTyHolder),
1834                            MethodDescriptionListPtrTy,
1835                            MethodDescriptionListPtrTy,
1836                            NULL);
1837  cast<llvm::OpaqueType>(ProtocolTyHolder.get())->refineAbstractTypeTo(T);
1838
1839  ProtocolListTy = cast<llvm::StructType>(ProtocolListTyHolder.get());
1840  CGM.getModule().addTypeName("struct._objc_protocol_list",
1841                              ProtocolListTy);
1842  ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
1843
1844  ProtocolTy = cast<llvm::StructType>(ProtocolTyHolder.get());
1845  CGM.getModule().addTypeName("struct.__objc_protocol", ProtocolTy);
1846  ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
1847
1848  // Class description structures
1849
1850  IvarTy = llvm::StructType::get(Int8PtrTy,
1851                                 Int8PtrTy,
1852                                 IntTy,
1853                                 NULL);
1854  CGM.getModule().addTypeName("struct._objc_ivar", IvarTy);
1855
1856  IvarListTy = llvm::OpaqueType::get();
1857  CGM.getModule().addTypeName("struct._objc_ivar_list", IvarListTy);
1858  IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
1859
1860  MethodTy = llvm::StructType::get(SelectorPtrTy,
1861                                   Int8PtrTy,
1862                                   Int8PtrTy,
1863                                   NULL);
1864  CGM.getModule().addTypeName("struct._objc_method", MethodTy);
1865
1866  MethodListTy = llvm::OpaqueType::get();
1867  CGM.getModule().addTypeName("struct._objc_method_list", MethodListTy);
1868  MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
1869
1870  CacheTy = llvm::OpaqueType::get();
1871  CGM.getModule().addTypeName("struct._objc_cache", CacheTy);
1872  CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
1873
1874  ClassExtensionTy =
1875    llvm::StructType::get(IntTy,
1876                          Int8PtrTy,
1877                          PropertyListPtrTy,
1878                          NULL);
1879  CGM.getModule().addTypeName("struct._objc_class_extension", ClassExtensionTy);
1880  ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
1881
1882  llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get();
1883
1884  T = llvm::StructType::get(llvm::PointerType::getUnqual(ClassTyHolder),
1885                            llvm::PointerType::getUnqual(ClassTyHolder),
1886                            Int8PtrTy,
1887                            LongTy,
1888                            LongTy,
1889                            LongTy,
1890                            IvarListPtrTy,
1891                            MethodListPtrTy,
1892                            CachePtrTy,
1893                            ProtocolListPtrTy,
1894                            Int8PtrTy,
1895                            ClassExtensionPtrTy,
1896                            NULL);
1897  cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(T);
1898
1899  ClassTy = cast<llvm::StructType>(ClassTyHolder.get());
1900  CGM.getModule().addTypeName("struct._objc_class", ClassTy);
1901  ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
1902
1903  CategoryTy = llvm::StructType::get(Int8PtrTy,
1904                                     Int8PtrTy,
1905                                     MethodListPtrTy,
1906                                     MethodListPtrTy,
1907                                     ProtocolListPtrTy,
1908                                     IntTy,
1909                                     PropertyListPtrTy,
1910                                     NULL);
1911  CGM.getModule().addTypeName("struct._objc_category", CategoryTy);
1912
1913  // I'm not sure I like this. The implicit coordination is a bit
1914  // gross. We should solve this in a reasonable fashion because this
1915  // is a pretty common task (match some runtime data structure with
1916  // an LLVM data structure).
1917
1918  // FIXME: This is leaked.
1919  // FIXME: Merge with rewriter code?
1920  RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0,
1921                                      SourceLocation(),
1922                                      &Ctx.Idents.get("_objc_super"));
1923  FieldDecl *FieldDecls[2];
1924  FieldDecls[0] = FieldDecl::Create(Ctx, SourceLocation(), 0,
1925                                    Ctx.getObjCIdType());
1926  FieldDecls[1] = FieldDecl::Create(Ctx, SourceLocation(), 0,
1927                                    Ctx.getObjCClassType());
1928  RD->defineBody(Ctx, FieldDecls, 2);
1929
1930  SuperCTy = Ctx.getTagDeclType(RD);
1931  SuperPtrCTy = Ctx.getPointerType(SuperCTy);
1932
1933  SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
1934  SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
1935
1936  // Global metadata structures
1937
1938  SymtabTy = llvm::StructType::get(LongTy,
1939                                   SelectorPtrTy,
1940                                   ShortTy,
1941                                   ShortTy,
1942                                   llvm::ArrayType::get(Int8PtrTy, 0),
1943                                   NULL);
1944  CGM.getModule().addTypeName("struct._objc_symtab", SymtabTy);
1945  SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
1946
1947  ModuleTy =
1948    llvm::StructType::get(LongTy,
1949                          LongTy,
1950                          Int8PtrTy,
1951                          SymtabPtrTy,
1952                          NULL);
1953  CGM.getModule().addTypeName("struct._objc_module", ModuleTy);
1954
1955  // Message send functions
1956
1957  std::vector<const llvm::Type*> Params;
1958  Params.push_back(ObjectPtrTy);
1959  Params.push_back(SelectorPtrTy);
1960  MessageSendFn = llvm::Function::Create(llvm::FunctionType::get(ObjectPtrTy,
1961                                                                 Params,
1962                                                                 true),
1963                                         llvm::Function::ExternalLinkage,
1964                                         "objc_msgSend",
1965                                         &CGM.getModule());
1966
1967  Params.clear();
1968  Params.push_back(Int8PtrTy);
1969  Params.push_back(ObjectPtrTy);
1970  Params.push_back(SelectorPtrTy);
1971  MessageSendStretFn =
1972    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
1973                                                   Params,
1974                                                   true),
1975                             llvm::Function::ExternalLinkage,
1976                             "objc_msgSend_stret",
1977                             &CGM.getModule());
1978
1979  Params.clear();
1980  Params.push_back(SuperPtrTy);
1981  Params.push_back(SelectorPtrTy);
1982  MessageSendSuperFn =
1983    llvm::Function::Create(llvm::FunctionType::get(ObjectPtrTy,
1984                                                   Params,
1985                                                   true),
1986                           llvm::Function::ExternalLinkage,
1987                           "objc_msgSendSuper",
1988                           &CGM.getModule());
1989
1990  Params.clear();
1991  Params.push_back(Int8PtrTy);
1992  Params.push_back(SuperPtrTy);
1993  Params.push_back(SelectorPtrTy);
1994  MessageSendSuperStretFn =
1995    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
1996                                                   Params,
1997                                                   true),
1998                           llvm::Function::ExternalLinkage,
1999                           "objc_msgSendSuper_stret",
2000                           &CGM.getModule());
2001
2002  // Enumeration mutation.
2003
2004  Params.clear();
2005  Params.push_back(ObjectPtrTy);
2006  EnumerationMutationFn =
2007    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2008                                                   Params,
2009                                                   false),
2010                           llvm::Function::ExternalLinkage,
2011                           "objc_enumerationMutation",
2012                           &CGM.getModule());
2013
2014  // FIXME: This is the size of the setjmp buffer and should be
2015  // target specific. 18 is what's used on 32-bit X86.
2016  uint64_t SetJmpBufferSize = 18;
2017
2018  // Exceptions
2019  const llvm::Type *StackPtrTy =
2020    llvm::PointerType::getUnqual(llvm::ArrayType::get(llvm::Type::Int8Ty, 4));
2021
2022  ExceptionDataTy =
2023    llvm::StructType::get(llvm::ArrayType::get(llvm::Type::Int32Ty,
2024                                               SetJmpBufferSize),
2025                          StackPtrTy, NULL);
2026  CGM.getModule().addTypeName("struct._objc_exception_data",
2027                              ExceptionDataTy);
2028
2029  Params.clear();
2030  Params.push_back(ObjectPtrTy);
2031  ExceptionThrowFn =
2032   llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2033                                                   Params,
2034                                                   false),
2035                           llvm::Function::ExternalLinkage,
2036                           "objc_exception_throw",
2037                           &CGM.getModule());
2038
2039  Params.clear();
2040  Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
2041  ExceptionTryEnterFn =
2042   llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2043                                                   Params,
2044                                                   false),
2045                           llvm::Function::ExternalLinkage,
2046                           "objc_exception_try_enter",
2047                           &CGM.getModule());
2048  ExceptionTryExitFn =
2049    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2050                                                   Params,
2051                                                   false),
2052                           llvm::Function::ExternalLinkage,
2053                           "objc_exception_try_exit",
2054                           &CGM.getModule());
2055  ExceptionExtractFn =
2056    llvm::Function::Create(llvm::FunctionType::get(ObjectPtrTy,
2057                                                   Params,
2058                                                   false),
2059                           llvm::Function::ExternalLinkage,
2060                           "objc_exception_extract",
2061                           &CGM.getModule());
2062
2063  Params.clear();
2064  Params.push_back(ClassPtrTy);
2065  Params.push_back(ObjectPtrTy);
2066  ExceptionMatchFn =
2067    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::Int32Ty,
2068                                                   Params,
2069                                                   false),
2070                           llvm::Function::ExternalLinkage,
2071                           "objc_exception_match",
2072                           &CGM.getModule());
2073
2074  Params.clear();
2075  Params.push_back(llvm::PointerType::getUnqual(llvm::Type::Int32Ty));
2076  SetJmpFn =
2077    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::Int32Ty,
2078                                                   Params,
2079                                                   false),
2080                           llvm::Function::ExternalLinkage,
2081                           "_setjmp",
2082                           &CGM.getModule());
2083
2084}
2085
2086ObjCTypesHelper::~ObjCTypesHelper() {
2087}
2088
2089llvm::Value *ObjCTypesHelper::getMessageSendFn(bool IsSuper,
2090                                               const llvm::Type *ReturnTy) {
2091  llvm::Function *F;
2092  llvm::FunctionType *CallFTy;
2093
2094  // FIXME: Should we be caching any of this?
2095  if (!ReturnTy->isSingleValueType()) {
2096    F = IsSuper ? MessageSendSuperStretFn : MessageSendStretFn;
2097    std::vector<const llvm::Type*> Params(3);
2098    Params[0] = llvm::PointerType::getUnqual(ReturnTy);
2099    Params[1] = IsSuper ? SuperPtrTy : ObjectPtrTy;
2100    Params[2] = SelectorPtrTy;
2101    CallFTy = llvm::FunctionType::get(llvm::Type::VoidTy, Params, true);
2102  } else { // FIXME: floating point?
2103    F = IsSuper ? MessageSendSuperFn : MessageSendFn;
2104    std::vector<const llvm::Type*> Params(2);
2105    Params[0] = IsSuper ? SuperPtrTy : ObjectPtrTy;
2106    Params[1] = SelectorPtrTy;
2107    CallFTy = llvm::FunctionType::get(ReturnTy, Params, true);
2108  }
2109
2110  return llvm::ConstantExpr::getBitCast(F,
2111                                        llvm::PointerType::getUnqual(CallFTy));
2112}
2113
2114/* *** */
2115
2116CodeGen::CGObjCRuntime *
2117CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
2118  return new CGObjCMac(CGM);
2119}
2120