CGObjCMac.cpp revision 62d5c1b5038cdaa4a887a03c37fe1e8d00166ea0 
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::Constant *getMessageSendFn(bool IsSuper, bool isStret);
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  const llvm::FunctionType *FTy =
532    CGM.getTypes().GetFunctionType(CGCallInfo(ResultType, ActualArgs),
533                                   false);
534  llvm::Constant *Fn =
535    ObjCTypes.getMessageSendFn(IsSuper, CGM.ReturnTypeUsesSret(ResultType));
536  Fn = llvm::ConstantExpr::getBitCast(Fn, llvm::PointerType::getUnqual(FTy));
537  return CGF.EmitCall(Fn, 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  std::string Name;
1349  GetNameForMethod(OMD, Name);
1350
1351  const llvm::FunctionType *MethodTy =
1352    CGM.getTypes().GetFunctionType(CGFunctionInfo(OMD, CGM.getContext()));
1353  llvm::Function *Method =
1354    llvm::Function::Create(MethodTy,
1355                           llvm::GlobalValue::InternalLinkage,
1356                           Name,
1357                           &CGM.getModule());
1358  MethodDefinitions.insert(std::make_pair(OMD, Method));
1359
1360  return Method;
1361}
1362
1363llvm::Function *CGObjCMac::ModuleInitFunction() {
1364  // Abuse this interface function as a place to finalize.
1365  FinishModule();
1366
1367  return NULL;
1368}
1369
1370llvm::Function *CGObjCMac::EnumerationMutationFunction()
1371{
1372  return ObjCTypes.EnumerationMutationFn;
1373}
1374
1375void CGObjCMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1376                            const ObjCAtTryStmt &S)
1377{
1378  // Allocate exception data.
1379  llvm::Value *ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
1380                                                    "exceptiondata.ptr");
1381
1382  // Allocate memory for the rethrow pointer.
1383  llvm::Value *RethrowPtr = CGF.CreateTempAlloca(ObjCTypes.ObjectPtrTy);
1384  CGF.Builder.CreateStore(llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy),
1385                          RethrowPtr);
1386
1387  // Enter a new try block and call setjmp.
1388  CGF.Builder.CreateCall(ObjCTypes.ExceptionTryEnterFn, ExceptionData);
1389  llvm::Value *JmpBufPtr = CGF.Builder.CreateStructGEP(ExceptionData, 0,
1390                                                       "jmpbufarray");
1391  JmpBufPtr = CGF.Builder.CreateStructGEP(JmpBufPtr, 0, "tmp");
1392  llvm::Value *SetJmpResult = CGF.Builder.CreateCall(ObjCTypes.SetJmpFn,
1393                                                     JmpBufPtr, "result");
1394
1395
1396  llvm::BasicBlock *FinallyBlock = llvm::BasicBlock::Create("finally");
1397
1398  llvm::BasicBlock *TryBlock = llvm::BasicBlock::Create("try");
1399  llvm::BasicBlock *ExceptionInTryBlock =
1400    llvm::BasicBlock::Create("exceptionintry");
1401
1402  // If setjmp returns 1, there was an exception in the @try block.
1403  llvm::Value *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
1404  llvm::Value *IsZero = CGF.Builder.CreateICmpEQ(SetJmpResult, Zero, "iszero");
1405  CGF.Builder.CreateCondBr(IsZero, TryBlock, ExceptionInTryBlock);
1406
1407  // Emit the @try block.
1408  CGF.EmitBlock(TryBlock);
1409  CGF.EmitStmt(S.getTryBody());
1410  CGF.Builder.CreateBr(FinallyBlock);
1411
1412  // Emit the "exception in @try" block.
1413  CGF.EmitBlock(ExceptionInTryBlock);
1414
1415  if (const ObjCAtCatchStmt* CatchStmt = S.getCatchStmts()) {
1416    // Allocate memory for the caught exception and extract it from the
1417    // exception data.
1418    llvm::Value *CaughtPtr = CGF.CreateTempAlloca(ObjCTypes.ObjectPtrTy);
1419    llvm::Value *Extract = CGF.Builder.CreateCall(ObjCTypes.ExceptionExtractFn,
1420                                                  ExceptionData);
1421    CGF.Builder.CreateStore(Extract, CaughtPtr);
1422
1423    // Enter a new exception try block
1424    // (in case a @catch block throws an exception).
1425    CGF.Builder.CreateCall(ObjCTypes.ExceptionTryEnterFn, ExceptionData);
1426
1427    llvm::Value *SetJmpResult = CGF.Builder.CreateCall(ObjCTypes.SetJmpFn,
1428                                                       JmpBufPtr, "result");
1429
1430
1431    llvm::Value *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
1432    llvm::Value *IsZero = CGF.Builder.CreateICmpEQ(SetJmpResult, Zero,
1433                                                   "iszero");
1434
1435    llvm::BasicBlock *CatchBlock = llvm::BasicBlock::Create("catch");
1436    llvm::BasicBlock *ExceptionInCatchBlock =
1437      llvm::BasicBlock::Create("exceptionincatch");
1438    CGF.Builder.CreateCondBr(IsZero, CatchBlock, ExceptionInCatchBlock);
1439
1440    CGF.EmitBlock(CatchBlock);
1441
1442    // Handle catch list
1443    for (; CatchStmt; CatchStmt = CatchStmt->getNextCatchStmt()) {
1444      llvm::BasicBlock *NextCatchBlock = llvm::BasicBlock::Create("nextcatch");
1445
1446      QualType T;
1447      bool MatchesAll = false;
1448
1449      // catch(...) always matches.
1450      if (CatchStmt->hasEllipsis())
1451        MatchesAll = true;
1452      else {
1453        const DeclStmt *DS = cast<DeclStmt>(CatchStmt->getCatchParamStmt());
1454        QualType PT = cast<ValueDecl>(DS->getDecl())->getType();
1455        T = PT->getAsPointerType()->getPointeeType();
1456
1457        // catch(id e) always matches.
1458        if (CGF.getContext().isObjCIdType(T))
1459          MatchesAll = true;
1460      }
1461
1462      if (MatchesAll) {
1463        CGF.EmitStmt(CatchStmt->getCatchBody());
1464        CGF.Builder.CreateBr(FinallyBlock);
1465
1466        CGF.EmitBlock(NextCatchBlock);
1467        break;
1468      }
1469
1470      const ObjCInterfaceType *ObjCType = T->getAsPointerToObjCInterfaceType();
1471      assert(ObjCType && "Catch parameter must have Objective-C type!");
1472
1473      // Check if the @catch block matches the exception object.
1474      llvm::Value *Class = EmitClassRef(CGF.Builder, ObjCType->getDecl());
1475
1476      llvm::Value *Caught = CGF.Builder.CreateLoad(CaughtPtr, "caught");
1477      llvm::Value *Match = CGF.Builder.CreateCall2(ObjCTypes.ExceptionMatchFn,
1478                                                   Class, Caught, "match");
1479
1480      llvm::Value *DidMatch = CGF.Builder.CreateICmpNE(Match, Zero, "iszero");
1481
1482      llvm::BasicBlock *MatchedBlock = llvm::BasicBlock::Create("matched");
1483
1484      CGF.Builder.CreateCondBr(DidMatch, MatchedBlock, NextCatchBlock);
1485
1486      // Emit the @catch block.
1487      CGF.EmitBlock(MatchedBlock);
1488      CGF.EmitStmt(CatchStmt->getCatchBody());
1489      CGF.Builder.CreateBr(FinallyBlock);
1490
1491      CGF.EmitBlock(NextCatchBlock);
1492    }
1493
1494    // None of the handlers caught the exception, so store it and rethrow
1495    // it later.
1496    llvm::Value *Caught = CGF.Builder.CreateLoad(CaughtPtr, "caught");
1497    CGF.Builder.CreateStore(Caught, RethrowPtr);
1498    CGF.Builder.CreateCall(ObjCTypes.ExceptionTryExitFn,
1499                           ExceptionData);
1500
1501    CGF.Builder.CreateBr(FinallyBlock);
1502
1503    CGF.EmitBlock(ExceptionInCatchBlock);
1504
1505    Extract = CGF.Builder.CreateCall(ObjCTypes.ExceptionExtractFn,
1506                                     ExceptionData);
1507    CGF.Builder.CreateStore(Extract, RethrowPtr);
1508  }
1509
1510  // Emit the @finally block.
1511  CGF.EmitBlock(FinallyBlock);
1512
1513  llvm::Value *Rethrow = CGF.Builder.CreateLoad(RethrowPtr);
1514  llvm::Value *ZeroPtr = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy);
1515
1516  llvm::Value *RethrowIsZero = CGF.Builder.CreateICmpEQ(Rethrow, ZeroPtr);
1517
1518  llvm::BasicBlock *TryExitBlock = llvm::BasicBlock::Create("tryexit");
1519  llvm::BasicBlock *AfterTryExitBlock =
1520    llvm::BasicBlock::Create("aftertryexit");
1521
1522  CGF.Builder.CreateCondBr(RethrowIsZero, TryExitBlock, AfterTryExitBlock);
1523  CGF.EmitBlock(TryExitBlock);
1524  CGF.Builder.CreateCall(ObjCTypes.ExceptionTryExitFn, ExceptionData);
1525  CGF.EmitBlock(AfterTryExitBlock);
1526
1527  if (const ObjCAtFinallyStmt* FinallyStmt = S.getFinallyStmt())
1528    CGF.EmitStmt(FinallyStmt->getFinallyBody());
1529
1530  llvm::Value *RethrowIsNotZero = CGF.Builder.CreateICmpNE(Rethrow, ZeroPtr);
1531
1532  llvm::BasicBlock *RethrowBlock = llvm::BasicBlock::Create("rethrow");
1533  llvm::BasicBlock *FinallyEndBlock = llvm::BasicBlock::Create("finallyend");
1534
1535  // If necessary, rethrow the exception.
1536  CGF.Builder.CreateCondBr(RethrowIsNotZero, RethrowBlock, FinallyEndBlock);
1537  CGF.EmitBlock(RethrowBlock);
1538  CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn, Rethrow);
1539  CGF.EmitBlock(FinallyEndBlock);
1540}
1541
1542void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
1543                              const ObjCAtThrowStmt &S)
1544{
1545  llvm::Value *ExceptionAsObject;
1546
1547  if (const Expr *ThrowExpr = S.getThrowExpr()) {
1548    llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr);
1549    ExceptionAsObject =
1550      CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp");
1551  } else {
1552    assert(0 && "FIXME: rethrows not supported!");
1553  }
1554
1555  CGF.Builder.CreateCall(ObjCTypes.ExceptionThrowFn, ExceptionAsObject);
1556  CGF.Builder.CreateUnreachable();
1557  CGF.EmitBlock(llvm::BasicBlock::Create("bb"));
1558}
1559
1560/* *** Private Interface *** */
1561
1562/// EmitImageInfo - Emit the image info marker used to encode some module
1563/// level information.
1564///
1565/// See: <rdr://4810609&4810587&4810587>
1566/// struct IMAGE_INFO {
1567///   unsigned version;
1568///   unsigned flags;
1569/// };
1570enum ImageInfoFlags {
1571  eImageInfo_FixAndContinue   = (1 << 0), // FIXME: Not sure what this implies
1572  eImageInfo_GarbageCollected = (1 << 1),
1573  eImageInfo_GCOnly           = (1 << 2)
1574};
1575
1576void CGObjCMac::EmitImageInfo() {
1577  unsigned version = 0; // Version is unused?
1578  unsigned flags = 0;
1579
1580  // FIXME: Fix and continue?
1581  if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC)
1582    flags |= eImageInfo_GarbageCollected;
1583  if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly)
1584    flags |= eImageInfo_GCOnly;
1585
1586  // Emitted as int[2];
1587  llvm::Constant *values[2] = {
1588    llvm::ConstantInt::get(llvm::Type::Int32Ty, version),
1589    llvm::ConstantInt::get(llvm::Type::Int32Ty, flags)
1590  };
1591  llvm::ArrayType *AT = llvm::ArrayType::get(llvm::Type::Int32Ty, 2);
1592  llvm::GlobalVariable *GV =
1593    new llvm::GlobalVariable(AT, true,
1594                             llvm::GlobalValue::InternalLinkage,
1595                             llvm::ConstantArray::get(AT, values, 2),
1596                             "\01L_OBJC_IMAGE_INFO",
1597                             &CGM.getModule());
1598
1599  if (ObjCABI == 1) {
1600    GV->setSection("__OBJC, __image_info,regular");
1601  } else {
1602    GV->setSection("__DATA, __objc_imageinfo, regular, no_dead_strip");
1603  }
1604
1605  UsedGlobals.push_back(GV);
1606}
1607
1608
1609// struct objc_module {
1610//   unsigned long version;
1611//   unsigned long size;
1612//   const char *name;
1613//   Symtab symtab;
1614// };
1615
1616// FIXME: Get from somewhere
1617static const int ModuleVersion = 7;
1618
1619void CGObjCMac::EmitModuleInfo() {
1620  uint64_t Size = CGM.getTargetData().getABITypeSize(ObjCTypes.ModuleTy);
1621
1622  std::vector<llvm::Constant*> Values(4);
1623  Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion);
1624  Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
1625  // This used to be the filename, now it is unused. <rdr://4327263>
1626  Values[2] = GetClassName(&CGM.getContext().Idents.get(""));
1627  Values[3] = EmitModuleSymbols();
1628
1629  llvm::GlobalVariable *GV =
1630    new llvm::GlobalVariable(ObjCTypes.ModuleTy, false,
1631                             llvm::GlobalValue::InternalLinkage,
1632                             llvm::ConstantStruct::get(ObjCTypes.ModuleTy,
1633                                                       Values),
1634                             "\01L_OBJC_MODULES",
1635                             &CGM.getModule());
1636  GV->setSection("__OBJC,__module_info,regular,no_dead_strip");
1637  UsedGlobals.push_back(GV);
1638}
1639
1640llvm::Constant *CGObjCMac::EmitModuleSymbols() {
1641  unsigned NumClasses = DefinedClasses.size();
1642  unsigned NumCategories = DefinedCategories.size();
1643
1644  // Return null if no symbols were defined.
1645  if (!NumClasses && !NumCategories)
1646    return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
1647
1648  std::vector<llvm::Constant*> Values(5);
1649  Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
1650  Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
1651  Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
1652  Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
1653
1654  // The runtime expects exactly the list of defined classes followed
1655  // by the list of defined categories, in a single array.
1656  std::vector<llvm::Constant*> Symbols(NumClasses + NumCategories);
1657  for (unsigned i=0; i<NumClasses; i++)
1658    Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
1659                                                ObjCTypes.Int8PtrTy);
1660  for (unsigned i=0; i<NumCategories; i++)
1661    Symbols[NumClasses + i] =
1662      llvm::ConstantExpr::getBitCast(DefinedCategories[i],
1663                                     ObjCTypes.Int8PtrTy);
1664
1665  Values[4] =
1666    llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
1667                                                  NumClasses + NumCategories),
1668                             Symbols);
1669
1670  llvm::Constant *Init = llvm::ConstantStruct::get(Values);
1671
1672  llvm::GlobalVariable *GV =
1673    new llvm::GlobalVariable(Init->getType(), false,
1674                             llvm::GlobalValue::InternalLinkage,
1675                             Init,
1676                             "\01L_OBJC_SYMBOLS",
1677                             &CGM.getModule());
1678  GV->setSection("__OBJC,__symbols,regular,no_dead_strip");
1679  UsedGlobals.push_back(GV);
1680  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
1681}
1682
1683llvm::Value *CGObjCMac::EmitClassRef(llvm::IRBuilder<> &Builder,
1684                                     const ObjCInterfaceDecl *ID) {
1685  LazySymbols.insert(ID->getIdentifier());
1686
1687  llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()];
1688
1689  if (!Entry) {
1690    llvm::Constant *Casted =
1691      llvm::ConstantExpr::getBitCast(GetClassName(ID->getIdentifier()),
1692                                     ObjCTypes.ClassPtrTy);
1693    Entry =
1694      new llvm::GlobalVariable(ObjCTypes.ClassPtrTy, false,
1695                               llvm::GlobalValue::InternalLinkage,
1696                               Casted, "\01L_OBJC_CLASS_REFERENCES_",
1697                               &CGM.getModule());
1698    Entry->setSection("__OBJC,__cls_refs,literal_pointers,no_dead_strip");
1699    UsedGlobals.push_back(Entry);
1700  }
1701
1702  return Builder.CreateLoad(Entry, false, "tmp");
1703}
1704
1705llvm::Value *CGObjCMac::EmitSelector(llvm::IRBuilder<> &Builder, Selector Sel) {
1706  llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
1707
1708  if (!Entry) {
1709    llvm::Constant *Casted =
1710      llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
1711                                     ObjCTypes.SelectorPtrTy);
1712    Entry =
1713      new llvm::GlobalVariable(ObjCTypes.SelectorPtrTy, false,
1714                               llvm::GlobalValue::InternalLinkage,
1715                               Casted, "\01L_OBJC_SELECTOR_REFERENCES_",
1716                               &CGM.getModule());
1717    Entry->setSection("__OBJC,__message_refs,literal_pointers,no_dead_strip");
1718    UsedGlobals.push_back(Entry);
1719  }
1720
1721  return Builder.CreateLoad(Entry, false, "tmp");
1722}
1723
1724llvm::Constant *CGObjCMac::GetClassName(IdentifierInfo *Ident) {
1725  llvm::GlobalVariable *&Entry = ClassNames[Ident];
1726
1727  if (!Entry) {
1728    llvm::Constant *C = llvm::ConstantArray::get(Ident->getName());
1729    Entry =
1730      new llvm::GlobalVariable(C->getType(), false,
1731                               llvm::GlobalValue::InternalLinkage,
1732                               C, "\01L_OBJC_CLASS_NAME_",
1733                               &CGM.getModule());
1734    Entry->setSection("__TEXT,__cstring,cstring_literals");
1735    UsedGlobals.push_back(Entry);
1736  }
1737
1738  return getConstantGEP(Entry, 0, 0);
1739}
1740
1741llvm::Constant *CGObjCMac::GetMethodVarName(Selector Sel) {
1742  llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
1743
1744  if (!Entry) {
1745    llvm::Constant *C = llvm::ConstantArray::get(Sel.getName());
1746    Entry =
1747      new llvm::GlobalVariable(C->getType(), false,
1748                               llvm::GlobalValue::InternalLinkage,
1749                               C, "\01L_OBJC_METH_VAR_NAME_",
1750                               &CGM.getModule());
1751    Entry->setSection("__TEXT,__cstring,cstring_literals");
1752    UsedGlobals.push_back(Entry);
1753  }
1754
1755  return getConstantGEP(Entry, 0, 0);
1756}
1757
1758// FIXME: Merge into a single cstring creation function.
1759llvm::Constant *CGObjCMac::GetMethodVarName(IdentifierInfo *ID) {
1760  return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
1761}
1762
1763// FIXME: Merge into a single cstring creation function.
1764llvm::Constant *CGObjCMac::GetMethodVarName(const std::string &Name) {
1765  return GetMethodVarName(&CGM.getContext().Idents.get(Name));
1766}
1767
1768llvm::Constant *CGObjCMac::GetMethodVarType(const std::string &Name) {
1769  llvm::GlobalVariable *&Entry = MethodVarTypes[Name];
1770
1771  if (!Entry) {
1772    llvm::Constant *C = llvm::ConstantArray::get(Name);
1773    Entry =
1774      new llvm::GlobalVariable(C->getType(), false,
1775                               llvm::GlobalValue::InternalLinkage,
1776                               C, "\01L_OBJC_METH_VAR_TYPE_",
1777                               &CGM.getModule());
1778    Entry->setSection("__TEXT,__cstring,cstring_literals");
1779    UsedGlobals.push_back(Entry);
1780  }
1781
1782  return getConstantGEP(Entry, 0, 0);
1783}
1784
1785// FIXME: Merge into a single cstring creation function.
1786llvm::Constant *CGObjCMac::GetMethodVarType(const ObjCMethodDecl *D) {
1787  std::string TypeStr;
1788  CGM.getContext().getObjCEncodingForMethodDecl(const_cast<ObjCMethodDecl*>(D),
1789                                                TypeStr);
1790  return GetMethodVarType(TypeStr);
1791}
1792
1793// FIXME: Merge into a single cstring creation function.
1794llvm::Constant *CGObjCMac::GetPropertyName(IdentifierInfo *Ident) {
1795  llvm::GlobalVariable *&Entry = PropertyNames[Ident];
1796
1797  if (!Entry) {
1798    llvm::Constant *C = llvm::ConstantArray::get(Ident->getName());
1799    Entry =
1800      new llvm::GlobalVariable(C->getType(), false,
1801                               llvm::GlobalValue::InternalLinkage,
1802                               C, "\01L_OBJC_PROP_NAME_ATTR_",
1803                               &CGM.getModule());
1804    Entry->setSection("__TEXT,__cstring,cstring_literals");
1805    UsedGlobals.push_back(Entry);
1806  }
1807
1808  return getConstantGEP(Entry, 0, 0);
1809}
1810
1811// FIXME: Merge into a single cstring creation function.
1812// FIXME: This Decl should be more precise.
1813llvm::Constant *CGObjCMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
1814                                                 const Decl *Container) {
1815  std::string TypeStr;
1816  CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
1817  return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
1818}
1819
1820void CGObjCMac::GetNameForMethod(const ObjCMethodDecl *D,
1821                                 std::string &NameOut) {
1822  // FIXME: Find the mangling GCC uses.
1823  std::stringstream s;
1824  s << (D->isInstance() ? "-" : "+");
1825  s << "[";
1826  s << D->getClassInterface()->getName();
1827  s << " ";
1828  s << D->getSelector().getName();
1829  s << "]";
1830  NameOut = s.str();
1831}
1832
1833void CGObjCMac::FinishModule() {
1834  EmitModuleInfo();
1835
1836  std::vector<llvm::Constant*> Used;
1837
1838  for (std::vector<llvm::GlobalVariable*>::iterator i = UsedGlobals.begin(),
1839         e = UsedGlobals.end(); i != e; ++i) {
1840    Used.push_back(llvm::ConstantExpr::getBitCast(*i, ObjCTypes.Int8PtrTy));
1841  }
1842
1843  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Used.size());
1844  llvm::GlobalValue *GV =
1845    new llvm::GlobalVariable(AT, false,
1846                             llvm::GlobalValue::AppendingLinkage,
1847                             llvm::ConstantArray::get(AT, Used),
1848                             "llvm.used",
1849                             &CGM.getModule());
1850
1851  GV->setSection("llvm.metadata");
1852
1853  // Add assembler directives to add lazy undefined symbol references
1854  // for classes which are referenced but not defined. This is
1855  // important for correct linker interaction.
1856
1857  // FIXME: Uh, this isn't particularly portable.
1858  std::stringstream s;
1859  for (std::set<IdentifierInfo*>::iterator i = LazySymbols.begin(),
1860         e = LazySymbols.end(); i != e; ++i) {
1861    s << "\t.lazy_reference .objc_class_name_" << (*i)->getName() << "\n";
1862  }
1863  for (std::set<IdentifierInfo*>::iterator i = DefinedSymbols.begin(),
1864         e = DefinedSymbols.end(); i != e; ++i) {
1865    s << "\t.objc_class_name_" << (*i)->getName() << "=0\n"
1866      << "\t.globl .objc_class_name_" << (*i)->getName() << "\n";
1867  }
1868  CGM.getModule().appendModuleInlineAsm(s.str());
1869}
1870
1871/* *** */
1872
1873ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
1874  : CGM(cgm)
1875{
1876  CodeGen::CodeGenTypes &Types = CGM.getTypes();
1877  ASTContext &Ctx = CGM.getContext();
1878
1879  ShortTy = Types.ConvertType(Ctx.ShortTy);
1880  IntTy = Types.ConvertType(Ctx.IntTy);
1881  LongTy = Types.ConvertType(Ctx.LongTy);
1882  Int8PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
1883
1884  ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType());
1885  SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType());
1886
1887  // FIXME: It would be nice to unify this with the opaque type, so
1888  // that the IR comes out a bit cleaner.
1889  const llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
1890  ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
1891
1892  MethodDescriptionTy =
1893    llvm::StructType::get(SelectorPtrTy,
1894                          Int8PtrTy,
1895                          NULL);
1896  CGM.getModule().addTypeName("struct._objc_method_description",
1897                              MethodDescriptionTy);
1898
1899  MethodDescriptionListTy =
1900    llvm::StructType::get(IntTy,
1901                          llvm::ArrayType::get(MethodDescriptionTy, 0),
1902                          NULL);
1903  CGM.getModule().addTypeName("struct._objc_method_description_list",
1904                              MethodDescriptionListTy);
1905  MethodDescriptionListPtrTy =
1906    llvm::PointerType::getUnqual(MethodDescriptionListTy);
1907
1908  PropertyTy = llvm::StructType::get(Int8PtrTy,
1909                                     Int8PtrTy,
1910                                     NULL);
1911  CGM.getModule().addTypeName("struct._objc_property",
1912                              PropertyTy);
1913
1914  PropertyListTy = llvm::StructType::get(IntTy,
1915                                         IntTy,
1916                                         llvm::ArrayType::get(PropertyTy, 0),
1917                                         NULL);
1918  CGM.getModule().addTypeName("struct._objc_property_list",
1919                              PropertyListTy);
1920  PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
1921
1922  // Protocol description structures
1923
1924  ProtocolExtensionTy =
1925    llvm::StructType::get(Types.ConvertType(Ctx.IntTy),
1926                          llvm::PointerType::getUnqual(MethodDescriptionListTy),
1927                          llvm::PointerType::getUnqual(MethodDescriptionListTy),
1928                          PropertyListPtrTy,
1929                          NULL);
1930  CGM.getModule().addTypeName("struct._objc_protocol_extension",
1931                              ProtocolExtensionTy);
1932  ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
1933
1934  // Handle recursive construction of Protocl and ProtocolList types
1935
1936  llvm::PATypeHolder ProtocolTyHolder = llvm::OpaqueType::get();
1937  llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get();
1938
1939  T = llvm::StructType::get(llvm::PointerType::getUnqual(ProtocolListTyHolder),
1940                            LongTy,
1941                            llvm::ArrayType::get(ProtocolTyHolder, 0),
1942                            NULL);
1943  cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(T);
1944
1945  T = llvm::StructType::get(llvm::PointerType::getUnqual(ProtocolExtensionTy),
1946                            Int8PtrTy,
1947                            llvm::PointerType::getUnqual(ProtocolListTyHolder),
1948                            MethodDescriptionListPtrTy,
1949                            MethodDescriptionListPtrTy,
1950                            NULL);
1951  cast<llvm::OpaqueType>(ProtocolTyHolder.get())->refineAbstractTypeTo(T);
1952
1953  ProtocolListTy = cast<llvm::StructType>(ProtocolListTyHolder.get());
1954  CGM.getModule().addTypeName("struct._objc_protocol_list",
1955                              ProtocolListTy);
1956  ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
1957
1958  ProtocolTy = cast<llvm::StructType>(ProtocolTyHolder.get());
1959  CGM.getModule().addTypeName("struct.__objc_protocol", ProtocolTy);
1960  ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
1961
1962  // Class description structures
1963
1964  IvarTy = llvm::StructType::get(Int8PtrTy,
1965                                 Int8PtrTy,
1966                                 IntTy,
1967                                 NULL);
1968  CGM.getModule().addTypeName("struct._objc_ivar", IvarTy);
1969
1970  IvarListTy = llvm::OpaqueType::get();
1971  CGM.getModule().addTypeName("struct._objc_ivar_list", IvarListTy);
1972  IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
1973
1974  MethodTy = llvm::StructType::get(SelectorPtrTy,
1975                                   Int8PtrTy,
1976                                   Int8PtrTy,
1977                                   NULL);
1978  CGM.getModule().addTypeName("struct._objc_method", MethodTy);
1979
1980  MethodListTy = llvm::OpaqueType::get();
1981  CGM.getModule().addTypeName("struct._objc_method_list", MethodListTy);
1982  MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
1983
1984  CacheTy = llvm::OpaqueType::get();
1985  CGM.getModule().addTypeName("struct._objc_cache", CacheTy);
1986  CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
1987
1988  ClassExtensionTy =
1989    llvm::StructType::get(IntTy,
1990                          Int8PtrTy,
1991                          PropertyListPtrTy,
1992                          NULL);
1993  CGM.getModule().addTypeName("struct._objc_class_extension", ClassExtensionTy);
1994  ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
1995
1996  llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get();
1997
1998  T = llvm::StructType::get(llvm::PointerType::getUnqual(ClassTyHolder),
1999                            llvm::PointerType::getUnqual(ClassTyHolder),
2000                            Int8PtrTy,
2001                            LongTy,
2002                            LongTy,
2003                            LongTy,
2004                            IvarListPtrTy,
2005                            MethodListPtrTy,
2006                            CachePtrTy,
2007                            ProtocolListPtrTy,
2008                            Int8PtrTy,
2009                            ClassExtensionPtrTy,
2010                            NULL);
2011  cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(T);
2012
2013  ClassTy = cast<llvm::StructType>(ClassTyHolder.get());
2014  CGM.getModule().addTypeName("struct._objc_class", ClassTy);
2015  ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
2016
2017  CategoryTy = llvm::StructType::get(Int8PtrTy,
2018                                     Int8PtrTy,
2019                                     MethodListPtrTy,
2020                                     MethodListPtrTy,
2021                                     ProtocolListPtrTy,
2022                                     IntTy,
2023                                     PropertyListPtrTy,
2024                                     NULL);
2025  CGM.getModule().addTypeName("struct._objc_category", CategoryTy);
2026
2027  // I'm not sure I like this. The implicit coordination is a bit
2028  // gross. We should solve this in a reasonable fashion because this
2029  // is a pretty common task (match some runtime data structure with
2030  // an LLVM data structure).
2031
2032  // FIXME: This is leaked.
2033  // FIXME: Merge with rewriter code?
2034  RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0,
2035                                      SourceLocation(),
2036                                      &Ctx.Idents.get("_objc_super"));
2037  FieldDecl *FieldDecls[2];
2038  FieldDecls[0] = FieldDecl::Create(Ctx, SourceLocation(), 0,
2039                                    Ctx.getObjCIdType());
2040  FieldDecls[1] = FieldDecl::Create(Ctx, SourceLocation(), 0,
2041                                    Ctx.getObjCClassType());
2042  RD->defineBody(Ctx, FieldDecls, 2);
2043
2044  SuperCTy = Ctx.getTagDeclType(RD);
2045  SuperPtrCTy = Ctx.getPointerType(SuperCTy);
2046
2047  SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
2048  SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
2049
2050  // Global metadata structures
2051
2052  SymtabTy = llvm::StructType::get(LongTy,
2053                                   SelectorPtrTy,
2054                                   ShortTy,
2055                                   ShortTy,
2056                                   llvm::ArrayType::get(Int8PtrTy, 0),
2057                                   NULL);
2058  CGM.getModule().addTypeName("struct._objc_symtab", SymtabTy);
2059  SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
2060
2061  ModuleTy =
2062    llvm::StructType::get(LongTy,
2063                          LongTy,
2064                          Int8PtrTy,
2065                          SymtabPtrTy,
2066                          NULL);
2067  CGM.getModule().addTypeName("struct._objc_module", ModuleTy);
2068
2069  // Message send functions
2070
2071  std::vector<const llvm::Type*> Params;
2072  Params.push_back(ObjectPtrTy);
2073  Params.push_back(SelectorPtrTy);
2074  MessageSendFn = llvm::Function::Create(llvm::FunctionType::get(ObjectPtrTy,
2075                                                                 Params,
2076                                                                 true),
2077                                         llvm::Function::ExternalLinkage,
2078                                         "objc_msgSend",
2079                                         &CGM.getModule());
2080
2081  Params.clear();
2082  Params.push_back(Int8PtrTy);
2083  Params.push_back(ObjectPtrTy);
2084  Params.push_back(SelectorPtrTy);
2085  MessageSendStretFn =
2086    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2087                                                   Params,
2088                                                   true),
2089                             llvm::Function::ExternalLinkage,
2090                             "objc_msgSend_stret",
2091                             &CGM.getModule());
2092
2093  Params.clear();
2094  Params.push_back(SuperPtrTy);
2095  Params.push_back(SelectorPtrTy);
2096  MessageSendSuperFn =
2097    llvm::Function::Create(llvm::FunctionType::get(ObjectPtrTy,
2098                                                   Params,
2099                                                   true),
2100                           llvm::Function::ExternalLinkage,
2101                           "objc_msgSendSuper",
2102                           &CGM.getModule());
2103
2104  Params.clear();
2105  Params.push_back(Int8PtrTy);
2106  Params.push_back(SuperPtrTy);
2107  Params.push_back(SelectorPtrTy);
2108  MessageSendSuperStretFn =
2109    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2110                                                   Params,
2111                                                   true),
2112                           llvm::Function::ExternalLinkage,
2113                           "objc_msgSendSuper_stret",
2114                           &CGM.getModule());
2115
2116  // Enumeration mutation.
2117
2118  Params.clear();
2119  Params.push_back(ObjectPtrTy);
2120  EnumerationMutationFn =
2121    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2122                                                   Params,
2123                                                   false),
2124                           llvm::Function::ExternalLinkage,
2125                           "objc_enumerationMutation",
2126                           &CGM.getModule());
2127
2128  // FIXME: This is the size of the setjmp buffer and should be
2129  // target specific. 18 is what's used on 32-bit X86.
2130  uint64_t SetJmpBufferSize = 18;
2131
2132  // Exceptions
2133  const llvm::Type *StackPtrTy =
2134    llvm::PointerType::getUnqual(llvm::ArrayType::get(llvm::Type::Int8Ty, 4));
2135
2136  ExceptionDataTy =
2137    llvm::StructType::get(llvm::ArrayType::get(llvm::Type::Int32Ty,
2138                                               SetJmpBufferSize),
2139                          StackPtrTy, NULL);
2140  CGM.getModule().addTypeName("struct._objc_exception_data",
2141                              ExceptionDataTy);
2142
2143  Params.clear();
2144  Params.push_back(ObjectPtrTy);
2145  ExceptionThrowFn =
2146   llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2147                                                   Params,
2148                                                   false),
2149                           llvm::Function::ExternalLinkage,
2150                           "objc_exception_throw",
2151                           &CGM.getModule());
2152
2153  Params.clear();
2154  Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
2155  ExceptionTryEnterFn =
2156   llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2157                                                   Params,
2158                                                   false),
2159                           llvm::Function::ExternalLinkage,
2160                           "objc_exception_try_enter",
2161                           &CGM.getModule());
2162  ExceptionTryExitFn =
2163    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::VoidTy,
2164                                                   Params,
2165                                                   false),
2166                           llvm::Function::ExternalLinkage,
2167                           "objc_exception_try_exit",
2168                           &CGM.getModule());
2169  ExceptionExtractFn =
2170    llvm::Function::Create(llvm::FunctionType::get(ObjectPtrTy,
2171                                                   Params,
2172                                                   false),
2173                           llvm::Function::ExternalLinkage,
2174                           "objc_exception_extract",
2175                           &CGM.getModule());
2176
2177  Params.clear();
2178  Params.push_back(ClassPtrTy);
2179  Params.push_back(ObjectPtrTy);
2180  ExceptionMatchFn =
2181    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::Int32Ty,
2182                                                   Params,
2183                                                   false),
2184                           llvm::Function::ExternalLinkage,
2185                           "objc_exception_match",
2186                           &CGM.getModule());
2187
2188  Params.clear();
2189  Params.push_back(llvm::PointerType::getUnqual(llvm::Type::Int32Ty));
2190  SetJmpFn =
2191    llvm::Function::Create(llvm::FunctionType::get(llvm::Type::Int32Ty,
2192                                                   Params,
2193                                                   false),
2194                           llvm::Function::ExternalLinkage,
2195                           "_setjmp",
2196                           &CGM.getModule());
2197
2198}
2199
2200ObjCTypesHelper::~ObjCTypesHelper() {
2201}
2202
2203llvm::Constant *ObjCTypesHelper::getMessageSendFn(bool IsSuper, bool IsStret) {
2204  if (IsStret) {
2205    return IsSuper ? MessageSendSuperStretFn : MessageSendStretFn;
2206  } else { // FIXME: floating point?
2207    return IsSuper ? MessageSendSuperFn : MessageSendFn;
2208  }
2209}
2210
2211/* *** */
2212
2213CodeGen::CGObjCRuntime *
2214CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
2215  return new CGObjCMac(CGM);
2216}
2217