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