CGObjCGNU.cpp revision 4e0b2641d8aa8da8eb001b959940a9ec68f45f0d 
1//===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This provides Objective-C code generation targetting the GNU runtime.  The
11// class in this file generates structures used by the GNU Objective-C runtime
12// library.  These structures are defined in objc/objc.h and objc/objc-api.h in
13// the GNU runtime distribution.
14//
15//===----------------------------------------------------------------------===//
16
17#include "CGObjCRuntime.h"
18#include "llvm/Module.h"
19#include "llvm/Support/Compiler.h"
20#include "llvm/Support/IRBuilder.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/StringMap.h"
23#include <map>
24
25using llvm::dyn_cast;
26
27// The version of the runtime that this class targets.  Must match the version
28// in the runtime.
29static const int RuntimeVersion = 8;
30static const int ProtocolVersion = 2;
31
32namespace {
33class CGObjCGNU : public clang::CodeGen::CGObjCRuntime {
34private:
35  llvm::Module &TheModule;
36  const llvm::StructType *SelStructTy;
37  const llvm::Type *SelectorTy;
38  const llvm::Type *PtrToInt8Ty;
39  const llvm::Type *IMPTy;
40  const llvm::Type *IdTy;
41  const llvm::Type *IntTy;
42  const llvm::Type *PtrTy;
43  const llvm::Type *LongTy;
44  const llvm::Type *PtrToIntTy;
45  std::vector<llvm::Constant*> Classes;
46  std::vector<llvm::Constant*> Categories;
47  std::vector<llvm::Constant*> ConstantStrings;
48  llvm::Function *LoadFunction;
49  llvm::StringMap<llvm::Constant*> ExistingProtocols;
50  typedef std::pair<std::string, std::string> TypedSelector;
51  std::map<TypedSelector, llvm::GlobalAlias*> TypedSelectors;
52  llvm::StringMap<llvm::GlobalAlias*> UntypedSelectors;
53  // Some zeros used for GEPs in lots of places.
54  llvm::Constant *Zeros[2];
55  llvm::Constant *NULLPtr;
56private:
57  llvm::Constant *GenerateIvarList(
58      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
59      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
60      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets);
61  llvm::Constant *GenerateMethodList(const std::string &ClassName,
62      const std::string &CategoryName,
63      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
64      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes,
65      bool isClassMethodList);
66  llvm::Constant *GenerateProtocolList(
67      const llvm::SmallVectorImpl<std::string> &Protocols);
68  llvm::Constant *GenerateClassStructure(
69      llvm::Constant *MetaClass,
70      llvm::Constant *SuperClass,
71      unsigned info,
72      llvm::Constant *Name,
73      llvm::Constant *Version,
74      llvm::Constant *InstanceSize,
75      llvm::Constant *IVars,
76      llvm::Constant *Methods,
77      llvm::Constant *Protocols);
78  llvm::Constant *GenerateProtocolMethodList(
79      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
80      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes);
81  llvm::Constant *MakeConstantString(const std::string &Str, const std::string
82      &Name="");
83  llvm::Constant *MakeGlobal(const llvm::StructType *Ty,
84      std::vector<llvm::Constant*> &V, const std::string &Name="");
85  llvm::Constant *MakeGlobal(const llvm::ArrayType *Ty,
86      std::vector<llvm::Constant*> &V, const std::string &Name="");
87public:
88  CGObjCGNU(llvm::Module &Mp,
89    const llvm::Type *LLVMIntType,
90    const llvm::Type *LLVMLongType);
91  virtual llvm::Constant *GenerateConstantString(const char *String,
92      const size_t length);
93  virtual llvm::Value *GenerateMessageSend(llvm::IRBuilder &Builder,
94                                           const llvm::Type *ReturnTy,
95                                           llvm::Value *Sender,
96                                           llvm::Value *Receiver,
97                                           llvm::Value *Selector,
98                                           llvm::Value** ArgV,
99                                           unsigned ArgC);
100  virtual llvm::Value *GenerateMessageSendSuper(llvm::IRBuilder &Builder,
101                                            const llvm::Type *ReturnTy,
102                                            llvm::Value *Sender,
103                                            const char *SuperClassName,
104                                            llvm::Value *Receiver,
105                                            llvm::Value *Selector,
106                                            llvm::Value** ArgV,
107                                            unsigned ArgC);
108  virtual llvm::Value *LookupClass(llvm::IRBuilder &Builder, llvm::Value
109      *ClassName);
110  virtual llvm::Value *GetSelector(llvm::IRBuilder &Builder,
111      llvm::Value *SelName,
112      llvm::Value *SelTypes);
113  virtual llvm::Function *MethodPreamble(
114                                         const std::string &ClassName,
115                                         const std::string &CategoryName,
116                                         const std::string &MethodName,
117                                         const llvm::Type *ReturnTy,
118                                         const llvm::Type *SelfTy,
119                                         const llvm::Type **ArgTy,
120                                         unsigned ArgC,
121                                         bool isClassMethod,
122                                         bool isVarArg);
123  virtual void GenerateCategory(const char *ClassName, const char *CategoryName,
124           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
125           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
126           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
127           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
128           const llvm::SmallVectorImpl<std::string> &Protocols);
129  virtual void GenerateClass(
130           const char *ClassName,
131           const char *SuperClassName,
132           const int instanceSize,
133           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
134           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
135           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets,
136           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
137           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
138           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
139           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
140           const llvm::SmallVectorImpl<std::string> &Protocols);
141  virtual llvm::Value *GenerateProtocolRef(llvm::IRBuilder &Builder, const char
142      *ProtocolName);
143  virtual void GenerateProtocol(const char *ProtocolName,
144      const llvm::SmallVectorImpl<std::string> &Protocols,
145      const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
146      const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
147      const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
148      const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes);
149  virtual llvm::Function *ModuleInitFunction();
150};
151} // end anonymous namespace
152
153
154
155static std::string SymbolNameForClass(const std::string &ClassName) {
156  return ".objc_class_" + ClassName;
157}
158
159static std::string SymbolNameForMethod(const std::string &ClassName, const
160  std::string &CategoryName, const std::string &MethodName, bool isClassMethod)
161{
162  return "._objc_method_" + ClassName +"("+CategoryName+")"+
163            (isClassMethod ? "+" : "-") + MethodName;
164}
165
166CGObjCGNU::CGObjCGNU(llvm::Module &M,
167    const llvm::Type *LLVMIntType,
168    const llvm::Type *LLVMLongType) :
169  TheModule(M),
170  IntTy(LLVMIntType),
171  LongTy(LLVMLongType)
172{
173  Zeros[0] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
174  Zeros[1] = Zeros[0];
175  NULLPtr = llvm::ConstantPointerNull::get(
176    llvm::PointerType::getUnqual(llvm::Type::Int8Ty));
177  // C string type.  Used in lots of places.
178  PtrToInt8Ty =
179    llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
180  // Get the selector Type.
181  SelStructTy = llvm::StructType::get(
182      PtrToInt8Ty,
183      PtrToInt8Ty,
184      NULL);
185  SelectorTy = llvm::PointerType::getUnqual(SelStructTy);
186  PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
187  PtrTy = PtrToInt8Ty;
188
189  // Object type
190  llvm::PATypeHolder OpaqueObjTy = llvm::OpaqueType::get();
191  llvm::Type *OpaqueIdTy = llvm::PointerType::getUnqual(OpaqueObjTy);
192  IdTy = llvm::StructType::get(OpaqueIdTy, NULL);
193  llvm::cast<llvm::OpaqueType>(OpaqueObjTy.get())->refineAbstractTypeTo(IdTy);
194  IdTy = llvm::cast<llvm::StructType>(OpaqueObjTy.get());
195  IdTy = llvm::PointerType::getUnqual(IdTy);
196
197  // IMP type
198  std::vector<const llvm::Type*> IMPArgs;
199  IMPArgs.push_back(IdTy);
200  IMPArgs.push_back(SelectorTy);
201  IMPTy = llvm::FunctionType::get(IdTy, IMPArgs, true);
202}
203// This has to perform the lookup every time, since posing and related
204// techniques can modify the name -> class mapping.
205llvm::Value *CGObjCGNU::LookupClass(llvm::IRBuilder &Builder,
206    llvm::Value *ClassName) {
207  llvm::Constant *ClassLookupFn =
208    TheModule.getOrInsertFunction("objc_lookup_class", IdTy, PtrToInt8Ty,
209        NULL);
210  return Builder.CreateCall(ClassLookupFn, ClassName);
211}
212
213/// Looks up the selector for the specified name / type pair.
214// FIXME: Selectors should be statically cached, not looked up on every call.
215llvm::Value *CGObjCGNU::GetSelector(llvm::IRBuilder &Builder,
216    llvm::Value *SelName,
217    llvm::Value *SelTypes) {
218  // For static selectors, we return an alias for now then store them all in a
219  // list that the runtime will initialise later.
220  if (llvm::Constant *CName = dyn_cast<llvm::Constant>(SelName)) {
221    // Untyped selector
222    if (SelTypes == 0) {
223      // If it's already cached, return it.
224      if (UntypedSelectors[CName->getStringValue()]) {
225        // FIXME: Volatility
226        return Builder.CreateLoad(UntypedSelectors[CName->getStringValue()]);
227      }
228      // If it isn't, cache it.
229      llvm::GlobalAlias *Sel = new llvm::GlobalAlias(
230          llvm::PointerType::getUnqual(SelectorTy),
231          llvm::GlobalValue::InternalLinkage, ".objc_untyped_selector_alias",
232          NULL, &TheModule);
233      UntypedSelectors[CName->getStringValue()] = Sel;
234      // FIXME: Volatility
235      return Builder.CreateLoad(Sel);
236    }
237    // Typed selectors
238    if (llvm::Constant *CTypes = dyn_cast<llvm::Constant>(SelTypes)) {
239      TypedSelector Selector = TypedSelector(CName->getStringValue(),
240          CTypes->getStringValue());
241      // If it's already cached, return it.
242      if (TypedSelectors[Selector]) {
243        // FIXME: Volatility
244        return Builder.CreateLoad(TypedSelectors[Selector]);
245      }
246      // If it isn't, cache it.
247      llvm::GlobalAlias *Sel = new llvm::GlobalAlias(
248          llvm::PointerType::getUnqual(SelectorTy),
249          llvm::GlobalValue::InternalLinkage, ".objc_typed_selector_alias",
250          NULL, &TheModule);
251      TypedSelectors[Selector] = Sel;
252      // FIXME: Volatility
253      return Builder.CreateLoad(Sel);
254    }
255  }
256  // Dynamically look up selectors from non-constant sources
257  llvm::Value *cmd;
258  if (SelTypes == 0) {
259    llvm::Constant *SelFunction = TheModule.getOrInsertFunction("sel_get_uid",
260        SelectorTy,
261        PtrToInt8Ty,
262        NULL);
263    cmd = Builder.CreateCall(SelFunction, SelName);
264  }
265  else {
266    llvm::Constant *SelFunction =
267      TheModule.getOrInsertFunction("sel_get_typed_uid",
268          SelectorTy,
269          PtrToInt8Ty,
270          PtrToInt8Ty,
271          NULL);
272    cmd = Builder.CreateCall2(SelFunction, SelName, SelTypes);
273  }
274  return cmd;
275}
276
277
278llvm::Constant *CGObjCGNU::MakeConstantString(const std::string &Str, const
279    std::string &Name) {
280  llvm::Constant * ConstStr = llvm::ConstantArray::get(Str);
281  ConstStr = new llvm::GlobalVariable(ConstStr->getType(), true,
282                               llvm::GlobalValue::InternalLinkage,
283                               ConstStr, Name, &TheModule);
284  return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
285}
286llvm::Constant *CGObjCGNU::MakeGlobal(const llvm::StructType *Ty,
287    std::vector<llvm::Constant*> &V, const std::string &Name) {
288  llvm::Constant *C = llvm::ConstantStruct::get(Ty, V);
289  return new llvm::GlobalVariable(Ty, false,
290      llvm::GlobalValue::InternalLinkage, C, Name, &TheModule);
291}
292llvm::Constant *CGObjCGNU::MakeGlobal(const llvm::ArrayType *Ty,
293    std::vector<llvm::Constant*> &V, const std::string &Name) {
294  llvm::Constant *C = llvm::ConstantArray::get(Ty, V);
295  return new llvm::GlobalVariable(Ty, false,
296      llvm::GlobalValue::InternalLinkage, C, Name, &TheModule);
297}
298
299/// Generate an NSConstantString object.
300//TODO: In case there are any crazy people still using the GNU runtime without
301//an OpenStep implementation, this should let them select their own class for
302//constant strings.
303llvm::Constant *CGObjCGNU::GenerateConstantString(const char *String, const
304    size_t length) {
305  std::string Str(String, String +length);
306  std::vector<llvm::Constant*> Ivars;
307  Ivars.push_back(NULLPtr);
308  Ivars.push_back(MakeConstantString(Str));
309  Ivars.push_back(llvm::ConstantInt::get(IntTy, length));
310  llvm::Constant *ObjCStr = MakeGlobal(
311    llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy, NULL),
312    Ivars, ".objc_str");
313  ConstantStrings.push_back(
314      llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty));
315  return ObjCStr;
316}
317
318///Generates a message send where the super is the receiver.  This is a message
319///send to self with special delivery semantics indicating which class's method
320///should be called.
321llvm::Value *CGObjCGNU::GenerateMessageSendSuper(llvm::IRBuilder &Builder,
322                                            const llvm::Type *ReturnTy,
323                                            llvm::Value *Sender,
324                                            const char *SuperClassName,
325                                            llvm::Value *Receiver,
326                                            llvm::Value *Selector,
327                                            llvm::Value** ArgV,
328                                            unsigned ArgC) {
329  // TODO: This should be cached, not looked up every time.
330  llvm::Value *ReceiverClass = LookupClass(Builder,
331      MakeConstantString(SuperClassName));
332  llvm::Value *cmd = GetSelector(Builder, Selector, 0);
333  std::vector<const llvm::Type*> impArgTypes;
334  impArgTypes.push_back(Receiver->getType());
335  impArgTypes.push_back(SelectorTy);
336
337  // Avoid an explicit cast on the IMP by getting a version that has the right
338  // return type.
339  llvm::FunctionType *impType = llvm::FunctionType::get(ReturnTy, impArgTypes,
340                                                        true);
341  // Construct the structure used to look up the IMP
342  llvm::StructType *ObjCSuperTy = llvm::StructType::get(Receiver->getType(),
343      IdTy, NULL);
344  llvm::Value *ObjCSuper = Builder.CreateAlloca(ObjCSuperTy);
345  // FIXME: volatility
346  Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
347  Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
348
349  // Get the IMP
350  llvm::Constant *lookupFunction =
351     TheModule.getOrInsertFunction("objc_msg_lookup_super",
352                                   llvm::PointerType::getUnqual(impType),
353                                   llvm::PointerType::getUnqual(ObjCSuperTy),
354                                   SelectorTy, NULL);
355  llvm::Value *lookupArgs[] = {ObjCSuper, cmd};
356  llvm::Value *imp = Builder.CreateCall(lookupFunction, lookupArgs,
357      lookupArgs+2);
358
359  // Call the method
360  llvm::SmallVector<llvm::Value*, 8> callArgs;
361  callArgs.push_back(Receiver);
362  callArgs.push_back(cmd);
363  callArgs.insert(callArgs.end(), ArgV, ArgV+ArgC);
364  return Builder.CreateCall(imp, callArgs.begin(), callArgs.end());
365}
366
367/// Generate code for a message send expression.
368llvm::Value *CGObjCGNU::GenerateMessageSend(llvm::IRBuilder &Builder,
369                                            const llvm::Type *ReturnTy,
370                                            llvm::Value *Sender,
371                                            llvm::Value *Receiver,
372                                            llvm::Value *Selector,
373                                            llvm::Value** ArgV,
374                                            unsigned ArgC) {
375  llvm::Value *cmd = GetSelector(Builder, Selector, 0);
376
377  // Look up the method implementation.
378  std::vector<const llvm::Type*> impArgTypes;
379  const llvm::Type *RetTy;
380  //TODO: Revisit this when LLVM supports aggregate return types.
381  if (ReturnTy->isSingleValueType() && ReturnTy != llvm::Type::VoidTy) {
382    RetTy = ReturnTy;
383  } else {
384    // For struct returns allocate the space in the caller and pass it up to
385    // the sender.
386    RetTy = llvm::Type::VoidTy;
387    impArgTypes.push_back(llvm::PointerType::getUnqual(ReturnTy));
388  }
389  impArgTypes.push_back(Receiver->getType());
390  impArgTypes.push_back(SelectorTy);
391
392  // Avoid an explicit cast on the IMP by getting a version that has the right
393  // return type.
394  llvm::FunctionType *impType = llvm::FunctionType::get(RetTy, impArgTypes,
395                                                        true);
396
397  llvm::Constant *lookupFunction =
398     TheModule.getOrInsertFunction("objc_msg_lookup",
399                                   llvm::PointerType::getUnqual(impType),
400                                   Receiver->getType(), SelectorTy, NULL);
401  llvm::Value *imp = Builder.CreateCall2(lookupFunction, Receiver, cmd);
402
403  // Call the method.
404  llvm::SmallVector<llvm::Value*, 16> Args;
405  if (!ReturnTy->isSingleValueType()) {
406    llvm::Value *Return = Builder.CreateAlloca(ReturnTy);
407    Args.push_back(Return);
408    return Return;
409  }
410  Args.push_back(Receiver);
411  Args.push_back(cmd);
412  Args.insert(Args.end(), ArgV, ArgV+ArgC);
413  return Builder.CreateCall(imp, Args.begin(), Args.end());
414}
415
416/// Generates a MethodList.  Used in construction of a objc_class and
417/// objc_category structures.
418llvm::Constant *CGObjCGNU::GenerateMethodList(const std::string &ClassName,
419    const std::string &CategoryName,
420    const llvm::SmallVectorImpl<llvm::Constant *> &MethodNames,
421    const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes,
422    bool isClassMethodList) {
423  // Get the method structure type.
424  llvm::StructType *ObjCMethodTy = llvm::StructType::get(
425    PtrToInt8Ty, // Really a selector, but the runtime creates it us.
426    PtrToInt8Ty, // Method types
427    llvm::PointerType::getUnqual(IMPTy), //Method pointer
428    NULL);
429  std::vector<llvm::Constant*> Methods;
430  std::vector<llvm::Constant*> Elements;
431  for (unsigned int i = 0, e = MethodTypes.size(); i < e; ++i) {
432    Elements.clear();
433    Elements.push_back( llvm::ConstantExpr::getGetElementPtr(MethodNames[i],
434          Zeros, 2));
435    Elements.push_back(
436          llvm::ConstantExpr::getGetElementPtr(MethodTypes[i], Zeros, 2));
437    llvm::Constant *Method =
438      TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
439            MethodNames[i]->getStringValue(), isClassMethodList));
440    Method = llvm::ConstantExpr::getBitCast(Method,
441        llvm::PointerType::getUnqual(IMPTy));
442    Elements.push_back(Method);
443    Methods.push_back(llvm::ConstantStruct::get(ObjCMethodTy, Elements));
444  }
445
446  // Array of method structures
447  llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodTy,
448      MethodNames.size());
449  llvm::Constant *MethodArray = llvm::ConstantArray::get(ObjCMethodArrayTy,
450      Methods);
451
452  // Structure containing list pointer, array and array count
453  llvm::SmallVector<const llvm::Type*, 16> ObjCMethodListFields;
454  llvm::PATypeHolder OpaqueNextTy = llvm::OpaqueType::get();
455  llvm::Type *NextPtrTy = llvm::PointerType::getUnqual(OpaqueNextTy);
456  llvm::StructType *ObjCMethodListTy = llvm::StructType::get(NextPtrTy,
457      IntTy,
458      ObjCMethodArrayTy,
459      NULL);
460  // Refine next pointer type to concrete type
461  llvm::cast<llvm::OpaqueType>(
462      OpaqueNextTy.get())->refineAbstractTypeTo(ObjCMethodListTy);
463  ObjCMethodListTy = llvm::cast<llvm::StructType>(OpaqueNextTy.get());
464
465  Methods.clear();
466  Methods.push_back(llvm::ConstantPointerNull::get(
467        llvm::PointerType::getUnqual(ObjCMethodListTy)));
468  Methods.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty,
469        MethodTypes.size()));
470  Methods.push_back(MethodArray);
471
472  // Create an instance of the structure
473  return MakeGlobal(ObjCMethodListTy, Methods, ".objc_method_list");
474}
475
476/// Generates an IvarList.  Used in construction of a objc_class.
477llvm::Constant *CGObjCGNU::GenerateIvarList(
478    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
479    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
480    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets) {
481  // Get the method structure type.
482  llvm::StructType *ObjCIvarTy = llvm::StructType::get(
483    PtrToInt8Ty,
484    PtrToInt8Ty,
485    IntTy,
486    NULL);
487  std::vector<llvm::Constant*> Ivars;
488  std::vector<llvm::Constant*> Elements;
489  for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
490    Elements.clear();
491    Elements.push_back( llvm::ConstantExpr::getGetElementPtr(IvarNames[i],
492          Zeros, 2));
493    Elements.push_back( llvm::ConstantExpr::getGetElementPtr(IvarTypes[i],
494          Zeros, 2));
495    Elements.push_back(IvarOffsets[i]);
496    Ivars.push_back(llvm::ConstantStruct::get(ObjCIvarTy, Elements));
497  }
498
499  // Array of method structures
500  llvm::ArrayType *ObjCIvarArrayTy = llvm::ArrayType::get(ObjCIvarTy,
501      IvarNames.size());
502
503
504  Elements.clear();
505  Elements.push_back(llvm::ConstantInt::get(
506        llvm::cast<llvm::IntegerType>(IntTy), (int)IvarNames.size()));
507  Elements.push_back(llvm::ConstantArray::get(ObjCIvarArrayTy, Ivars));
508  // Structure containing array and array count
509  llvm::StructType *ObjCIvarListTy = llvm::StructType::get(IntTy,
510    ObjCIvarArrayTy,
511    NULL);
512
513  // Create an instance of the structure
514  return MakeGlobal(ObjCIvarListTy, Elements, ".objc_ivar_list");
515}
516
517/// Generate a class structure
518llvm::Constant *CGObjCGNU::GenerateClassStructure(
519    llvm::Constant *MetaClass,
520    llvm::Constant *SuperClass,
521    unsigned info,
522    llvm::Constant *Name,
523    llvm::Constant *Version,
524    llvm::Constant *InstanceSize,
525    llvm::Constant *IVars,
526    llvm::Constant *Methods,
527    llvm::Constant *Protocols) {
528  // Set up the class structure
529  // Note:  Several of these are char*s when they should be ids.  This is
530  // because the runtime performs this translation on load.
531  llvm::StructType *ClassTy = llvm::StructType::get(
532      PtrToInt8Ty,        // class_pointer
533      PtrToInt8Ty,        // super_class
534      PtrToInt8Ty,        // name
535      LongTy,             // version
536      LongTy,             // info
537      LongTy,             // instance_size
538      IVars->getType(),   // ivars
539      Methods->getType(), // methods
540      // These are all filled in by the runtime, so we pretend
541      PtrTy,              // dtable
542      PtrTy,              // subclass_list
543      PtrTy,              // sibling_class
544      PtrTy,              // protocols
545      PtrTy,              // gc_object_type
546      NULL);
547  llvm::Constant *Zero = llvm::ConstantInt::get(LongTy, 0);
548  llvm::Constant *NullP =
549    llvm::ConstantPointerNull::get(llvm::cast<llvm::PointerType>(PtrTy));
550  // Fill in the structure
551  std::vector<llvm::Constant*> Elements;
552  Elements.push_back(llvm::ConstantExpr::getBitCast(MetaClass, PtrToInt8Ty));
553  Elements.push_back(SuperClass);
554  Elements.push_back(Name);
555  Elements.push_back(Zero);
556  Elements.push_back(llvm::ConstantInt::get(LongTy, info));
557  Elements.push_back(InstanceSize);
558  Elements.push_back(IVars);
559  Elements.push_back(Methods);
560  Elements.push_back(NullP);
561  Elements.push_back(NullP);
562  Elements.push_back(NullP);
563  Elements.push_back(llvm::ConstantExpr::getBitCast(Protocols, PtrTy));
564  Elements.push_back(NullP);
565  // Create an instance of the structure
566  return MakeGlobal(ClassTy, Elements,
567      SymbolNameForClass(Name->getStringValue()));
568}
569
570llvm::Constant *CGObjCGNU::GenerateProtocolMethodList(
571    const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
572    const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes) {
573  // Get the method structure type.
574  llvm::StructType *ObjCMethodDescTy = llvm::StructType::get(
575    PtrToInt8Ty, // Really a selector, but the runtime does the casting for us.
576    PtrToInt8Ty,
577    NULL);
578  std::vector<llvm::Constant*> Methods;
579  std::vector<llvm::Constant*> Elements;
580  for (unsigned int i = 0, e = MethodTypes.size() ; i < e ; i++) {
581    Elements.clear();
582    Elements.push_back( llvm::ConstantExpr::getGetElementPtr(MethodNames[i],
583          Zeros, 2));
584    Elements.push_back(
585          llvm::ConstantExpr::getGetElementPtr(MethodTypes[i], Zeros, 2));
586    Methods.push_back(llvm::ConstantStruct::get(ObjCMethodDescTy, Elements));
587  }
588  llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodDescTy,
589      MethodNames.size());
590  llvm::Constant *Array = llvm::ConstantArray::get(ObjCMethodArrayTy, Methods);
591  llvm::StructType *ObjCMethodDescListTy = llvm::StructType::get(
592      IntTy, ObjCMethodArrayTy, NULL);
593  Methods.clear();
594  Methods.push_back(llvm::ConstantInt::get(IntTy, MethodNames.size()));
595  Methods.push_back(Array);
596  return MakeGlobal(ObjCMethodDescListTy, Methods, ".objc_method_list");
597}
598// Create the protocol list structure used in classes, categories and so on
599llvm::Constant *CGObjCGNU::GenerateProtocolList(
600    const llvm::SmallVectorImpl<std::string> &Protocols) {
601  llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
602      Protocols.size());
603  llvm::StructType *ProtocolListTy = llvm::StructType::get(
604      PtrTy, //Should be a recurisve pointer, but it's always NULL here.
605      LongTy,//FIXME: Should be size_t
606      ProtocolArrayTy,
607      NULL);
608  std::vector<llvm::Constant*> Elements;
609  for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
610      iter != endIter ; iter++) {
611    llvm::Constant *Ptr =
612      llvm::ConstantExpr::getBitCast(ExistingProtocols[*iter], PtrToInt8Ty);
613    Elements.push_back(Ptr);
614  }
615  llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
616      Elements);
617  Elements.clear();
618  Elements.push_back(NULLPtr);
619  Elements.push_back(llvm::ConstantInt::get(
620        llvm::cast<llvm::IntegerType>(LongTy), Protocols.size()));
621  Elements.push_back(ProtocolArray);
622  return MakeGlobal(ProtocolListTy, Elements, ".objc_protocol_list");
623}
624
625llvm::Value *CGObjCGNU::GenerateProtocolRef(llvm::IRBuilder &Builder, const
626    char *ProtocolName) {
627  return ExistingProtocols[ProtocolName];
628}
629
630void CGObjCGNU::GenerateProtocol(const char *ProtocolName,
631    const llvm::SmallVectorImpl<std::string> &Protocols,
632    const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
633    const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
634    const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
635    const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes) {
636
637  llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
638  llvm::Constant *InstanceMethodList =
639    GenerateProtocolMethodList(InstanceMethodNames, InstanceMethodTypes);
640  llvm::Constant *ClassMethodList =
641    GenerateProtocolMethodList(ClassMethodNames, ClassMethodTypes);
642  // Protocols are objects containing lists of the methods implemented and
643  // protocols adopted.
644  llvm::StructType *ProtocolTy = llvm::StructType::get(IdTy,
645      PtrToInt8Ty,
646      ProtocolList->getType(),
647      InstanceMethodList->getType(),
648      ClassMethodList->getType(),
649      NULL);
650  std::vector<llvm::Constant*> Elements;
651  // The isa pointer must be set to a magic number so the runtime knows it's
652  // the correct layout.
653  Elements.push_back(llvm::ConstantExpr::getIntToPtr(
654        llvm::ConstantInt::get(llvm::Type::Int32Ty, ProtocolVersion), IdTy));
655  Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
656  Elements.push_back(ProtocolList);
657  Elements.push_back(InstanceMethodList);
658  Elements.push_back(ClassMethodList);
659  ExistingProtocols[ProtocolName] =
660    llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolTy, Elements,
661          ".objc_protocol"), IdTy);
662}
663
664void CGObjCGNU::GenerateCategory(
665           const char *ClassName,
666           const char *CategoryName,
667           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
668           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
669           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
670           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
671           const llvm::SmallVectorImpl<std::string> &Protocols) {
672  std::vector<llvm::Constant*> Elements;
673  Elements.push_back(MakeConstantString(CategoryName));
674  Elements.push_back(MakeConstantString(ClassName));
675  // Instance method list
676  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
677          ClassName, CategoryName, InstanceMethodNames, InstanceMethodTypes,
678          false), PtrTy));
679  // Class method list
680  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
681          ClassName, CategoryName, ClassMethodNames, ClassMethodTypes, true),
682        PtrTy));
683  // Protocol list
684  Elements.push_back(llvm::ConstantExpr::getBitCast(
685        GenerateProtocolList(Protocols), PtrTy));
686  Categories.push_back(llvm::ConstantExpr::getBitCast(
687        MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, PtrTy,
688            PtrTy, PtrTy, NULL), Elements), PtrTy));
689}
690void CGObjCGNU::GenerateClass(
691           const char *ClassName,
692           const char *SuperClassName,
693           const int instanceSize,
694           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
695           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
696           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets,
697           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
698           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
699           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
700           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
701           const llvm::SmallVectorImpl<std::string> &Protocols) {
702  // Get the superclass pointer.
703  llvm::Constant *SuperClass;
704  if (SuperClassName) {
705    SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
706  } else {
707    SuperClass = llvm::ConstantPointerNull::get(
708        llvm::cast<llvm::PointerType>(PtrToInt8Ty));
709  }
710  llvm::Constant * Name = MakeConstantString(ClassName, ".class_name");
711  // Empty vector used to construct empty method lists
712  llvm::SmallVector<llvm::Constant*, 1>  empty;
713  // Generate the method and instance variable lists
714  llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
715      InstanceMethodNames, InstanceMethodTypes, false);
716  llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
717      ClassMethodNames, ClassMethodTypes, true);
718  llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
719      IvarOffsets);
720  //Generate metaclass for class methods
721  llvm::Constant *MetaClassStruct = GenerateClassStructure(NULLPtr,
722      NULLPtr, 0x2L, NULLPtr, 0, Zeros[0], GenerateIvarList(
723        empty, empty, empty), ClassMethodList, NULLPtr);
724  // Generate the class structure
725  llvm::Constant *ClassStruct = GenerateClassStructure(MetaClassStruct,
726      SuperClass, 0x1L, Name, 0,
727      llvm::ConstantInt::get(llvm::Type::Int32Ty, instanceSize), IvarList,
728      MethodList, GenerateProtocolList(Protocols));
729  // Add class structure to list to be added to the symtab later
730  ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
731  Classes.push_back(ClassStruct);
732}
733
734llvm::Function *CGObjCGNU::ModuleInitFunction() {
735  // Only emit an ObjC load function if no Objective-C stuff has been called
736  if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
737      ExistingProtocols.empty() && TypedSelectors.empty() &&
738      UntypedSelectors.empty())
739    return NULL;
740
741  // Name the ObjC types to make the IR a bit easier to read
742  TheModule.addTypeName(".objc_selector", SelectorTy);
743  TheModule.addTypeName(".objc_id", IdTy);
744  TheModule.addTypeName(".objc_imp", IMPTy);
745
746  std::vector<llvm::Constant*> Elements;
747  // Generate statics list:
748  llvm::ArrayType *StaticsArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
749      ConstantStrings.size() + 1);
750  ConstantStrings.push_back(NULLPtr);
751  Elements.push_back(MakeConstantString("NSConstantString",
752        ".objc_static_class_name"));
753  Elements.push_back(llvm::ConstantArray::get(StaticsArrayTy, ConstantStrings));
754  llvm::StructType *StaticsListTy =
755    llvm::StructType::get(PtrToInt8Ty, StaticsArrayTy, NULL);
756  llvm::Constant *Statics =
757    MakeGlobal(StaticsListTy, Elements, ".objc_statics");
758  llvm::ArrayType *StaticsListArrayTy =
759    llvm::ArrayType::get(llvm::PointerType::getUnqual(StaticsListTy), 2);
760  Elements.clear();
761  Elements.push_back(Statics);
762  Elements.push_back(llvm::ConstantPointerNull::get(llvm::PointerType::getUnqual(StaticsListTy)));
763  Statics = MakeGlobal(StaticsListArrayTy, Elements, ".objc_statics_ptr");
764  Statics = llvm::ConstantExpr::getBitCast(Statics, PtrTy);
765  // Array of classes, categories, and constant objects
766  llvm::ArrayType *ClassListTy = llvm::ArrayType::get(PtrToInt8Ty,
767      Classes.size() + Categories.size()  + 2);
768  llvm::StructType *SymTabTy = llvm::StructType::get(
769      LongTy,
770      SelectorTy,
771      llvm::Type::Int16Ty,
772      llvm::Type::Int16Ty,
773      ClassListTy,
774      NULL);
775
776  Elements.clear();
777  // Pointer to an array of selectors used in this module.
778  std::vector<llvm::Constant*> Selectors;
779  for (std::map<TypedSelector, llvm::GlobalAlias*>::iterator
780     iter = TypedSelectors.begin(), iterEnd = TypedSelectors.end();
781     iter != iterEnd ; ++iter) {
782    Elements.push_back(MakeConstantString((*iter).first.first,
783          ".objc_sel_name"));
784    Elements.push_back(MakeConstantString((*iter).first.second,
785          ".objc_sel_types"));
786    Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
787    Elements.clear();
788  }
789  for (llvm::StringMap<llvm::GlobalAlias*>::iterator
790      iter = UntypedSelectors.begin(), iterEnd = UntypedSelectors.end();
791      iter != iterEnd; iter++) {
792    Elements.push_back(
793        MakeConstantString((*iter).getKeyData(), ".objc_sel_name"));
794    Elements.push_back(NULLPtr);
795    Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
796    Elements.clear();
797  }
798  Elements.push_back(NULLPtr);
799  Elements.push_back(NULLPtr);
800  Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
801  Elements.clear();
802  // Number of static selectors
803  Elements.push_back(llvm::ConstantInt::get(LongTy, Selectors.size() ));
804  llvm::Constant *SelectorList = MakeGlobal(
805          llvm::ArrayType::get(SelStructTy, Selectors.size()), Selectors,
806          ".objc_selector_list");
807  Elements.push_back(llvm::ConstantExpr::getBitCast(SelectorList, SelectorTy));
808
809  // Now that all of the static selectors exist, create pointers to them.
810  int index = 0;
811  for (std::map<TypedSelector, llvm::GlobalAlias*>::iterator
812     iter=TypedSelectors.begin(), iterEnd =TypedSelectors.end();
813     iter != iterEnd; ++iter) {
814    llvm::Constant *Idxs[] = {Zeros[0],
815      llvm::ConstantInt::get(llvm::Type::Int32Ty, index++), Zeros[0]};
816    llvm::GlobalVariable *SelPtr = new llvm::GlobalVariable(SelectorTy, true,
817        llvm::GlobalValue::InternalLinkage,
818        llvm::ConstantExpr::getGetElementPtr(SelectorList, Idxs, 2),
819        ".objc_sel_ptr", &TheModule);
820    (*iter).second->setAliasee(SelPtr);
821  }
822  for (llvm::StringMap<llvm::GlobalAlias*>::iterator
823      iter=UntypedSelectors.begin(), iterEnd = UntypedSelectors.end();
824      iter != iterEnd; iter++) {
825    llvm::Constant *Idxs[] = {Zeros[0],
826      llvm::ConstantInt::get(llvm::Type::Int32Ty, index++), Zeros[0]};
827    llvm::GlobalVariable *SelPtr = new llvm::GlobalVariable(SelectorTy, true,
828        llvm::GlobalValue::InternalLinkage,
829        llvm::ConstantExpr::getGetElementPtr(SelectorList, Idxs, 2),
830        ".objc_sel_ptr", &TheModule);
831    (*iter).second->setAliasee(SelPtr);
832  }
833  // Number of classes defined.
834  Elements.push_back(llvm::ConstantInt::get(llvm::Type::Int16Ty,
835        Classes.size()));
836  // Number of categories defined
837  Elements.push_back(llvm::ConstantInt::get(llvm::Type::Int16Ty,
838        Categories.size()));
839  // Create an array of classes, then categories, then static object instances
840  Classes.insert(Classes.end(), Categories.begin(), Categories.end());
841  //  NULL-terminated list of static object instances (mainly constant strings)
842  Classes.push_back(Statics);
843  Classes.push_back(NULLPtr);
844  llvm::Constant *ClassList = llvm::ConstantArray::get(ClassListTy, Classes);
845  Elements.push_back(ClassList);
846  // Construct the symbol table
847  llvm::Constant *SymTab= MakeGlobal(SymTabTy, Elements);
848
849  // The symbol table is contained in a module which has some version-checking
850  // constants
851  llvm::StructType * ModuleTy = llvm::StructType::get(LongTy, LongTy,
852      PtrToInt8Ty, llvm::PointerType::getUnqual(SymTabTy), NULL);
853  Elements.clear();
854  // Runtime version used for compatibility checking.
855  Elements.push_back(llvm::ConstantInt::get(LongTy, RuntimeVersion));
856  //FIXME: Should be sizeof(ModuleTy)
857  Elements.push_back(llvm::ConstantInt::get(LongTy, 16));
858  //FIXME: Should be the path to the file where this module was declared
859  Elements.push_back(NULLPtr);
860  Elements.push_back(SymTab);
861  llvm::Value *Module = MakeGlobal(ModuleTy, Elements);
862
863  // Create the load function calling the runtime entry point with the module
864  // structure
865  std::vector<const llvm::Type*> VoidArgs;
866  llvm::Function * LoadFunction = llvm::Function::Create(
867      llvm::FunctionType::get(llvm::Type::VoidTy, VoidArgs, false),
868      llvm::GlobalValue::InternalLinkage, ".objc_load_function",
869      &TheModule);
870  llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", LoadFunction);
871  llvm::IRBuilder Builder;
872  Builder.SetInsertPoint(EntryBB);
873  llvm::Value *Register = TheModule.getOrInsertFunction("__objc_exec_class",
874      llvm::Type::VoidTy, llvm::PointerType::getUnqual(ModuleTy), NULL);
875  Builder.CreateCall(Register, Module);
876  Builder.CreateRetVoid();
877  return LoadFunction;
878}
879llvm::Function *CGObjCGNU::MethodPreamble(
880                                         const std::string &ClassName,
881                                         const std::string &CategoryName,
882                                         const std::string &MethodName,
883                                         const llvm::Type *ReturnTy,
884                                         const llvm::Type *SelfTy,
885                                         const llvm::Type **ArgTy,
886                                         unsigned ArgC,
887                                         bool isClassMethod,
888                                         bool isVarArg) {
889  std::vector<const llvm::Type*> Args;
890  if (!ReturnTy->isFirstClassType() && ReturnTy != llvm::Type::VoidTy) {
891    Args.push_back(llvm::PointerType::getUnqual(ReturnTy));
892    ReturnTy = llvm::Type::VoidTy;
893  }
894  Args.push_back(SelfTy);
895  Args.push_back(SelectorTy);
896  Args.insert(Args.end(), ArgTy, ArgTy+ArgC);
897
898  llvm::FunctionType *MethodTy = llvm::FunctionType::get(ReturnTy,
899      Args,
900      isVarArg);
901  std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
902      MethodName, isClassMethod);
903
904  llvm::Function *Method = llvm::Function::Create(MethodTy,
905      llvm::GlobalValue::InternalLinkage,
906      FunctionName,
907      &TheModule);
908  llvm::Function::arg_iterator AI = Method->arg_begin();
909  // Name the struct return argument.
910  // FIXME: This is probably the wrong test.
911  if (!ReturnTy->isFirstClassType() && ReturnTy != llvm::Type::VoidTy) {
912    AI->setName("agg.result");
913    ++AI;
914  }
915  AI->setName("self");
916  ++AI;
917  AI->setName("_cmd");
918  return Method;
919}
920
921clang::CodeGen::CGObjCRuntime *clang::CodeGen::CreateObjCRuntime(
922    llvm::Module &M,
923    const llvm::Type *LLVMIntType,
924    const llvm::Type *LLVMLongType) {
925  return new CGObjCGNU(M, LLVMIntType, LLVMLongType);
926}
927