CGObjCGNU.cpp revision a2120039ed08a5d5d6096e2560fd32c6128e951a
14afac18fd4cae1b93907d7db03c5fdb7f2f66d64Misha Brukman//===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman//
3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//                     The LLVM Compiler Infrastructure
4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//
54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source
64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details.
7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman//
8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===//
9edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman//
10bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// This provides Objective-C code generation targeting the GNU runtime.  The
11bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// class in this file generates structures used by the GNU Objective-C runtime
12bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// library.  These structures are defined in objc/objc.h and objc/objc-api.h in
13bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// the GNU runtime distribution.
14bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner//
153785fad56eb90284d4e930d40e9306391630deb1Chris Lattner//===----------------------------------------------------------------------===//
160d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin
1713a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo#include "CGObjCRuntime.h"
18d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "CodeGenModule.h"
19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "CodeGenFunction.h"
20fd13129bdf7324b2e8181a653897269aaaecc4e8Chris Lattner#include "CGCleanup.h"
210b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth
220b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "clang/AST/ASTContext.h"
230b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "clang/AST/Decl.h"
240b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "clang/AST/DeclObjC.h"
250b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "clang/AST/RecordLayout.h"
26551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "clang/AST/StmtObjC.h"
27d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "clang/Basic/SourceManager.h"
2831e2466f159a887fed9139067a676f65adf2a8c3Torok Edwin#include "clang/Basic/FileManager.h"
29d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth
30e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner#include "llvm/Intrinsics.h"
31d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Module.h"
320d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin#include "llvm/LLVMContext.h"
337d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/ADT/SmallVector.h"
34c5b28580a94e247300e5d3ccf532e153f2ae6f12Dylan Noblesmith#include "llvm/ADT/StringMap.h"
35ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov#include "llvm/Support/CallSite.h"
36ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov#include "llvm/Support/Compiler.h"
37c2ee9b9c7a6517f959aea31fa2c61631fe2f2903Chris Lattner#include "llvm/Target/TargetData.h"
38bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner
3936343735cb23680c8f8675deafbbf825d46fd868Chris Lattner#include <stdarg.h>
4036343735cb23680c8f8675deafbbf825d46fd868Chris Lattner
41bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner
424688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskinusing namespace clang;
434688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskinusing namespace CodeGen;
444688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskinusing llvm::dyn_cast;
454688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskin
464688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskin
47c5b28580a94e247300e5d3ccf532e153f2ae6f12Dylan Noblesmithnamespace {
486d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel Dunbar/// Class that lazily initialises the runtime function.  Avoids inserting the
496d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel Dunbar/// types and the function declaration into a module if they're not used, and
506d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel Dunbar/// avoids constructing the type more than once if it's used more than once.
5113a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizloclass LazyRuntimeFunction {
526d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel Dunbar  CodeGenModule *CGM;
53c5b28580a94e247300e5d3ccf532e153f2ae6f12Dylan Noblesmith  std::vector<const llvm::Type*> ArgTys;
54f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  const char *FunctionName;
554b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  llvm::Function *Function;
562fe4bb06c6c40d16b7a5ae9cdf6bb6fe94d51be0Chris Lattner  public:
57f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin    /// Constructor leaves this class uninitialized, because it is intended to
584c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin    /// be used as a field in another class and not all of the types that are
59b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands    /// used as arguments will necessarily be available at construction time.
6048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    LazyRuntimeFunction() : CGM(0), FunctionName(0), Function(0) {}
61b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands
62dc85724f703bddf6988b6b3f20203beab775f32bJeffrey Yasskin    /// Initialises the lazy function with the name, return type, and the types
63446531e7bb4355117b070493ca8e81e4b123ef18Evan Cheng    /// of the arguments.
641b088f33107798c544e0a872df4cc1921581eb66Evan Cheng    END_WITH_NULL
65f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin    void init(CodeGenModule *Mod, const char *name,
66f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin        const llvm::Type *RetTy, ...) {
6719684164a7b695b9dc22d879675e8d2b286ef7e5Misha Brukman       CGM =Mod;
6819684164a7b695b9dc22d879675e8d2b286ef7e5Misha Brukman       FunctionName = name;
698e539488816c9e52bde0af475f72cd3e6407d558Brian Gaeke       Function = 0;
70d4c0e62413ac4c81467ce59025c81210ea431752Reid Spencer       ArgTys.clear();
71fe854034677f59baca1e38075e71f6efca247a03Chris Lattner       va_list Args;
72fe854034677f59baca1e38075e71f6efca247a03Chris Lattner       va_start(Args, RetTy);
738e539488816c9e52bde0af475f72cd3e6407d558Brian Gaeke         while (const llvm::Type *ArgTy = va_arg(Args, const llvm::Type*))
748e539488816c9e52bde0af475f72cd3e6407d558Brian Gaeke           ArgTys.push_back(ArgTy);
75b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands       va_end(Args);
76b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands       // Push the return type on at the end so we can pop it off easily
77515c67ee77f8d9c417efc0fe04615d269bfb70e4Eric Christopher       ArgTys.push_back(RetTy);
78515c67ee77f8d9c417efc0fe04615d269bfb70e4Eric Christopher   }
79515c67ee77f8d9c417efc0fe04615d269bfb70e4Eric Christopher   /// Overloaded cast operator, allows the class to be implicitly cast to an
80515c67ee77f8d9c417efc0fe04615d269bfb70e4Eric Christopher   /// LLVM constant.
81b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands   operator llvm::Function*() {
82b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands     if (!Function) {
83b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands       if (0 == FunctionName) return 0;
84b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands       // We put the return type on the end of the vector, so pop it back off
8547b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin       const llvm::Type *RetTy = ArgTys.back();
8648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar       ArgTys.pop_back();
8748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar       llvm::FunctionType *FTy = llvm::FunctionType::get(RetTy, ArgTys, false);
8847b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin       Function =
8947b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin         cast<llvm::Function>(CGM->CreateRuntimeFunction(FTy, FunctionName));
9047b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin       // We won't need to use the types again, so we may as well clean up the
9147b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin       // vector now
9247b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin       ArgTys.resize(0);
9348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar     }
9448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar     return Function;
953574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow   }
96db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner};
9747b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin
9847b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin
993574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow/// GNU Objective-C runtime code generation.  This class implements the parts of
10047b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin/// Objective-C support that are specific to the GNU family of runtimes (GCC and
10147b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin/// GNUstep).
10247b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskinclass CGObjCGNU : public CGObjCRuntime {
10347b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskinprotected:
10447b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  /// The module that is using this class
10547b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  CodeGenModule &CGM;
10647b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  /// The LLVM module into which output is inserted
10747b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  llvm::Module &TheModule;
10847b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  /// strut objc_super.  Used for sending messages to super.  This structure
10947b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  /// contains the receiver (object) and the expected class.
11047b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  const llvm::StructType *ObjCSuperTy;
11147b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  /// struct objc_super*.  The type of the argument to the superclass message
11247b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  /// lookup functions.
11347b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  const llvm::PointerType *PtrToObjCSuperTy;
11447b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  /// LLVM type for selectors.  Opaque pointer (i8*) unless a header declaring
11547b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin  /// SEL is included in a header somewhere, in which case it will be whatever
11648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// type is declared in that header, most likely {i8*, i8*}.
1173574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow  const llvm::PointerType *SelectorTy;
11846fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray  /// LLVM i8 type.  Cached here to avoid repeatedly getting it in all of the
11946fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray  /// places where it's used
120f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  const llvm::IntegerType *Int8Ty;
1216227d5c690504c7ada5780c00a635b282c46e275Craig Topper  /// Pointer to i8 - LLVM type of char*, for all of the places where the
12273d0e211a39650fc7562e0f15ed21440dde2243aDevang Patel  /// runtime needs to deal with C strings.
123f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  const llvm::PointerType *PtrToInt8Ty;
124f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  /// Instance Method Pointer type.  This is a pointer to a function that takes,
12573d0e211a39650fc7562e0f15ed21440dde2243aDevang Patel  /// at a minimum, an object and a selector, and is the generic type for
126f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  /// Objective-C methods.  Due to differences between variadic / non-variadic
127f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  /// calling conventions, it must always be cast to the correct type before
12860789e419e04c260e36af9a1add5ad316313e490Nate Begeman  /// actually being used.
12960789e419e04c260e36af9a1add5ad316313e490Nate Begeman  const llvm::PointerType *IMPTy;
130f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  /// Type of an untyped Objective-C object.  Clang treats id as a built-in type
13160789e419e04c260e36af9a1add5ad316313e490Nate Begeman  /// when compiling Objective-C code, so this may be an opaque pointer (i8*),
13260789e419e04c260e36af9a1add5ad316313e490Nate Begeman  /// but if the runtime header declaring it is included then it may be a
133fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  /// pointer to a structure.
134fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  const llvm::PointerType *IdTy;
135f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  /// Pointer to a pointer to an Objective-C object.  Used in the new ABI
136fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  /// message lookup function and some GC-related functions.
137fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  const llvm::PointerType *PtrToIdTy;
138fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  /// The clang type of id.  Used when using the clang CGCall infrastructure to
139fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  /// call Objective-C methods.
140fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  CanQualType ASTIdTy;
141fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  /// LLVM type for C int type.
14248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  const llvm::IntegerType *IntTy;
14348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// LLVM type for an opaque pointer.  This is identical to PtrToInt8Ty, but is
14423e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  /// used in the code to document the difference between i8* meaning a pointer
145c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  /// to a C string and i8* meaning a pointer to some opaque type.
14648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  const llvm::PointerType *PtrTy;
14748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// LLVM type for C long type.  The runtime uses this in a lot of places where
14848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// it should be using intptr_t, but we can't fix this without breaking
149c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  /// compatibility with GCC...
150c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  const llvm::IntegerType *LongTy;
151c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  /// LLVM type for C size_t.  Used in various runtime data structures.
152c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  const llvm::IntegerType *SizeTy;
153c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  /// LLVM type for C ptrdiff_t.  Mainly used in property accessor functions.
154c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  const llvm::IntegerType *PtrDiffTy;
155c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  /// LLVM type for C int*.  Used for GCC-ABI-compatible non-fragile instance
156c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  /// variables.
157c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  const llvm::PointerType *PtrToIntTy;
158c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  /// LLVM type for Objective-C BOOL type.
159c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin  const llvm::Type *BoolTy;
160e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// Metadata kind used to tie method lookups to message sends.  The GNUstep
161e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// runtime provides some LLVM passes that can use this to do things like
162bc4707a2554ac04ba006bf70035e7bc7270236a9Evan Cheng  /// automatic IMP caching and speculative inlining.
16348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  unsigned msgSendMDKind;
16493b67e40de356569493c285b86b138a3f11b5035Daniel Dunbar  /// Helper function that generates a constant string and returns a pointer to
16523e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  /// the start of the string.  The result of this function can be used anywhere
166e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// where the C code specifies const char*.
167e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  llvm::Constant *MakeConstantString(const std::string &Str,
16848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                     const std::string &Name="") {
16948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    llvm::Constant *ConstStr = CGM.GetAddrOfConstantCString(Str, Name.c_str());
1704c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin    return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
1710d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin  }
1724c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  /// Emits a linkonce_odr string, whose name is the prefix followed by the
173e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// string value.  This allows the linker to combine the strings between
174e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// different modules.  Used for EH typeinfo names, selector strings, and a
175e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// few other things.
176e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  llvm::Constant *ExportUniqueString(const std::string &Str,
177e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner                                     const std::string prefix) {
178e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner    std::string name = prefix + Str;
179e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner    llvm::Constant *ConstStr = TheModule.getGlobalVariable(name);
18048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    if (!ConstStr) {
1814c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin      llvm::Constant *value = llvm::ConstantArray::get(VMContext, Str, true);
1824c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin      ConstStr = new llvm::GlobalVariable(TheModule, value->getType(), true,
183e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner              llvm::GlobalValue::LinkOnceODRLinkage, value, prefix + Str);
184e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner    }
185f049e07eb8930214941c72f8e4409df394de1567Nate Begeman    return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
186f049e07eb8930214941c72f8e4409df394de1567Nate Begeman  }
18748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Generates a global structure, initialized by the elements in the vector.
18848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// The element types must match the types of the structure elements in the
1894c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  /// first argument.
19048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::GlobalVariable *MakeGlobal(const llvm::StructType *Ty,
19148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                   std::vector<llvm::Constant*> &V,
1924c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin                                   llvm::StringRef Name="",
193f049e07eb8930214941c72f8e4409df394de1567Nate Begeman                                   llvm::GlobalValue::LinkageTypes linkage
194f049e07eb8930214941c72f8e4409df394de1567Nate Begeman                                         =llvm::GlobalValue::InternalLinkage) {
195f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner    llvm::Constant *C = llvm::ConstantStruct::get(Ty, V);
196e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner    return new llvm::GlobalVariable(TheModule, Ty, false,
197f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner        linkage, C, Name);
19823e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  }
1994c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  /// Generates a global array.  The vector must contain the same number of
200f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner  /// elements that the array type declares, of the type specified as the array
201e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// element type.
20248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::GlobalVariable *MakeGlobal(const llvm::ArrayType *Ty,
2034c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin                                   std::vector<llvm::Constant*> &V,
20448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                   llvm::StringRef Name="",
20523e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin                                   llvm::GlobalValue::LinkageTypes linkage
206f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner                                         =llvm::GlobalValue::InternalLinkage) {
207f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner    llvm::Constant *C = llvm::ConstantArray::get(Ty, V);
2084c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin    return new llvm::GlobalVariable(TheModule, Ty, false,
2094c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin                                    linkage, C, Name);
210e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  }
21148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Generates a global array, inferring the array type from the specified
21248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// element type and the size of the initialiser.
2134c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  llvm::GlobalVariable *MakeGlobalArray(const llvm::Type *Ty,
2140d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin                                        std::vector<llvm::Constant*> &V,
2154c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin                                        llvm::StringRef Name="",
216e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner                                        llvm::GlobalValue::LinkageTypes linkage
217e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner                                         =llvm::GlobalValue::InternalLinkage) {
218e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner    llvm::ArrayType *ArrayTy = llvm::ArrayType::get(Ty, V.size());
219f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner    return MakeGlobal(ArrayTy, V, Name, linkage);
220e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  }
221e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// Ensures that the value has the required type, by inserting a bitcast if
222e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// required.  This function lets us avoid inserting bitcasts that are
223e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  /// redundant.
22448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::Value* EnforceType(CGBuilderTy B, llvm::Value *V, const llvm::Type *Ty){
22523e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin    if (V->getType() == Ty) return V;
22623e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin    return B.CreateBitCast(V, Ty);
2274c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  }
228e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  // Some zeros used for GEPs in lots of places.
229e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner  llvm::Constant *Zeros[2];
23055d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner  /// Null pointer value.  Mainly used as a terminator in various arrays.
231ee448630bdf7eb6037fe2c50518d32010c433ca3Reid Spencer  llvm::Constant *NULLPtr;
232ee448630bdf7eb6037fe2c50518d32010c433ca3Reid Spencer  /// LLVM context.
23355d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner  llvm::LLVMContext &VMContext;
2344c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskinprivate:
23523e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  /// Placeholder for the class.  Lots of things refer to the class before we've
2364c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  /// actually emitted it.  We use this alias as a placeholder, and then replace
2374c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  /// it with a pointer to the class structure before finally emitting the
238ab19da4bc087e79550ebe448d9edd4d8ed248388Daniel Dunbar  /// module.
239ab19da4bc087e79550ebe448d9edd4d8ed248388Daniel Dunbar  llvm::GlobalAlias *ClassPtrAlias;
24055d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner  /// Placeholder for the metaclass.  Lots of things refer to the class before
24155d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner  /// we've / actually emitted it.  We use this alias as a placeholder, and then
2420d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin  /// replace / it with a pointer to the metaclass structure before finally
2434c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  /// emitting the / module.
2444c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  llvm::GlobalAlias *MetaClassPtrAlias;
24555d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner  /// All of the classes that have been generated for this compilation units.
24687f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  std::vector<llvm::Constant*> Classes;
247b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// All of the categories that have been generated for this compilation units.
248b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  std::vector<llvm::Constant*> Categories;
249b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// All of the Objective-C constant strings that have been generated for this
250b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// compilation units.
251b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  std::vector<llvm::Constant*> ConstantStrings;
252b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// Map from string values to Objective-C constant strings in the output.
253b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// Used to prevent emitting Objective-C strings more than once.  This should
254b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// not be required at all - CodeGenModule should manage this list.
255b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  llvm::StringMap<llvm::Constant*> ObjCStrings;
256b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// All of the protocols that have been declared.
257b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  llvm::StringMap<llvm::Constant*> ExistingProtocols;
258b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// For each variant of a selector, we store the type encoding and a
259b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// placeholder value.  For an untyped selector, the type will be the empty
260b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// string.  Selector references are all done via the module's selector table,
261b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// so we create an alias as a placeholder and then replace it with the real
262b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// value later.
263b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector;
264b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// Type of the selector map.  This is roughly equivalent to the structure
265b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// used in the GNUstep runtime, which maintains a list of all of the valid
266b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// types for a selector in a table.
267b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  typedef llvm::DenseMap<Selector, llvm::SmallVector<TypedSelector, 2> >
268b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin    SelectorMap;
269b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// A map from selectors to selector types.  This allows us to emit all
270b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// selectors of the same name and type together.
271426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth  SelectorMap SelectorTable;
272b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin
27387f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// Selectors related to memory management.  When compiling in GC mode, we
274b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// omit these.
275db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner  Selector RetainSel, ReleaseSel, AutoreleaseSel;
27687f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// Runtime functions used for memory management in GC mode.  Note that clang
27787f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// supports code generation for calling these functions, but neither GNU
27887f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// runtime actually supports this API properly yet.
27987f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn,
280b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin    WeakAssignFn, GlobalAssignFn;
281ae7c59a01286a3babbc6245dcb1049c7bcde2573David Greene
282edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukmanprotected:
28387f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// Function used for throwing Objective-C exceptions.
28487f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  LazyRuntimeFunction ExceptionThrowFn;
285edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman  /// Function used for rethrowing exceptions, used at the end of @finally or
286b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// @synchronize blocks.
287b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  LazyRuntimeFunction ExceptionReThrowFn;
28887f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// Function called when entering a catch function.  This is required for
28987f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// differentiating Objective-C exceptions and foreign exceptions.
29087f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  LazyRuntimeFunction EnterCatchFn;
29187f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// Function called when exiting from a catch block.  Used to do exception
29287f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// cleanup.
293b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  LazyRuntimeFunction ExitCatchFn;
29487f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// Function called when entering an @synchronize block.  Acquires the lock.
295b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  LazyRuntimeFunction SyncEnterFn;
29687f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// Function called when exiting an @synchronize block.  Releases the lock.
29787f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  LazyRuntimeFunction SyncExitFn;
298fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner
299fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattnerprivate:
3009ca6cdaee91fddcd3ea57dedcd624c14c7a40f65Chris Lattner
30148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Function called if fast enumeration detects that the collection is
30248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// modified during the update.
30348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  LazyRuntimeFunction EnumerationMutationFn;
30448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Function for implementing synthesized property getters that return an
30548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// object.
30648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  LazyRuntimeFunction GetPropertyFn;
30748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Function for implementing synthesized property setters that return an
30848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// object.
309a040d47c74341327997a50e88bb8ad4ceda6989fNick Lewycky  LazyRuntimeFunction SetPropertyFn;
31048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Function used for non-object declared property getters.
3111ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  LazyRuntimeFunction GetStructPropertyFn;
3121ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  /// Function used for non-object declared property setters.
3135ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky  LazyRuntimeFunction SetStructPropertyFn;
31448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar
3151ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  /// The version of the runtime that this class targets.  Must match the
3161ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  /// version in the runtime.
31748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  int RuntimeVersion;
31848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// The version of the protocol class.  Used to differentiate between ObjC1
31948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// and ObjC2 protocols.  Objective-C 1 protocols can not contain optional
3205ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky  /// components and can not contain declared properties.  We always emit
32148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Objective-C 2 property structures, but we have to pretend that they're
32248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Objective-C 1 property structures when targeting the GCC runtime or it
32348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// will abort.
32448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  const int ProtocolVersion;
32548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarprivate:
32648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Generates an instance variable list structure.  This is a structure
32748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// containing a size and an array of structures containing instance variable
32848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// metadata.  This is used purely for introspection in the fragile ABI.  In
32948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// the non-fragile ABI, it's used for instance variable fixup.
33048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::Constant *GenerateIvarList(
33148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
33248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
33348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets);
33448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Generates a method list structure.  This is a structure containing a size
33518314dc741ab7dc4db02b199af77f43bd8551fd2Evan Cheng  /// and an array of structures containing method metadata.
33618314dc741ab7dc4db02b199af77f43bd8551fd2Evan Cheng  ///
33718314dc741ab7dc4db02b199af77f43bd8551fd2Evan Cheng  /// This structure is used by both classes and categories, and contains a next
33818314dc741ab7dc4db02b199af77f43bd8551fd2Evan Cheng  /// pointer allowing them to be chained together in a linked list.
33948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::Constant *GenerateMethodList(const llvm::StringRef &ClassName,
34048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      const llvm::StringRef &CategoryName,
3419ca6cdaee91fddcd3ea57dedcd624c14c7a40f65Chris Lattner      const llvm::SmallVectorImpl<Selector>  &MethodSels,
3429ca6cdaee91fddcd3ea57dedcd624c14c7a40f65Chris Lattner      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes,
343b6e3d6ce709e9ed57df055b026e55d19e50df772Dan Gohman      bool isClassMethodList);
3448a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  /// Emits an empty protocol.  This is used for @protocol() where no protocol
3458a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  /// is found.  The runtime will (hopefully) fix up the pointer to refer to the
346426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth  /// real protocol.
3478a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::Constant *GenerateEmptyProtocol(const std::string &ProtocolName);
3488a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  /// Generates a list of property metadata structures.  This follows the same
3498a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  /// pattern as method and instance variable metadata lists.
3508a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::Constant *GeneratePropertyList(const ObjCImplementationDecl *OID,
3518a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands        llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
352b6e3d6ce709e9ed57df055b026e55d19e50df772Dan Gohman        llvm::SmallVectorImpl<llvm::Constant*> &InstanceMethodTypes);
3538a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  /// Generates a list of referenced protocols.  Classes, categories, and
35487f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// protocols all use this structure.
35587f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  llvm::Constant *GenerateProtocolList(
35687f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner      const llvm::SmallVectorImpl<std::string> &Protocols);
35787f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// To ensure that all protocols are seen by the runtime, we add a category on
35887f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// a class defined in the runtime, declaring no methods, but adopting the
3598fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer  /// protocols.  This is a horribly ugly hack, but it allows us to collect all
360499d8f0c3b212819515cdbcb98146fff6f9d877bAnton Korobeynikov  /// of the protocols without changing the ABI.
361499d8f0c3b212819515cdbcb98146fff6f9d877bAnton Korobeynikov  void GenerateProtocolHolderCategory(void);
362f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  /// Generates a class structure.
363db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner  llvm::Constant *GenerateClassStructure(
364db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner      llvm::Constant *MetaClass,
36548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::Constant *SuperClass,
36648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      unsigned info,
36748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      const char *Name,
36848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::Constant *Version,
36948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::Constant *InstanceSize,
37048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::Constant *IVars,
37148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::Constant *Methods,
37248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::Constant *Protocols,
37348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::Constant *IvarOffsets,
37448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::Constant *Properties,
37548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      bool isMeta=false);
37648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// Generates a method list.  This is used by protocols to define the required
37748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  /// and optional methods.
37848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::Constant *GenerateProtocolMethodList(
379b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
380b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes);
381f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  /// Returns a selector with the specified type encoding.  An empty string is
382f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  /// used to return an untyped selector (with the types field set to NULL).
383f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
3841d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson    const std::string &TypeEncoding, bool lval);
385b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// Returns the variable used to store the offset of an instance variable.
3868a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
387f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner      const ObjCIvarDecl *Ivar);
388f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  /// Emits a reference to a class.  This allows the linker to object if there
389f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  /// is no class of the matching name.
390f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  void EmitClassRef(const std::string &className);
391f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattnerprotected:
3921d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson  /// Looks up the method for sending a message to the specified object.  This
393b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin  /// mechanism differs between the GCC and GNU runtimes, so this method must be
394f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  /// overridden in subclasses.
395f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner  virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
396f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner                                 llvm::Value *&Receiver,
39748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                 llvm::Value *cmd,
3988fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer                                 llvm::MDNode *node) = 0;
39987f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// Looks up the method for sending a message to a superclass.  This mechanism
40087f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner  /// differs between the GCC and GNU runtimes, so this method must be
401f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  /// overridden in subclasses.
402d4c0e62413ac4c81467ce59025c81210ea431752Reid Spencer  virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
403502f20b17ede40de84503010b7699b328a4f2867Evan Cheng                                      llvm::Value *ObjCSuper,
404489393d7b92107cc3de17d8dbe7dd11ab7395fdcJeffrey Yasskin                                      llvm::Value *cmd) = 0;
405489393d7b92107cc3de17d8dbe7dd11ab7395fdcJeffrey Yasskinpublic:
4068e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
4074b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner      unsigned protocolClassVersion);
4084b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner
4094b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  virtual llvm::Constant *GenerateConstantString(const StringLiteral *);
4104b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner
4114b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  virtual RValue
4128e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  GenerateMessageSend(CodeGenFunction &CGF,
4138e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson                      ReturnValueSlot Return,
4148e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson                      QualType ResultType,
4154b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner                      Selector Sel,
4164b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner                      llvm::Value *Receiver,
417f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                      const CallArgList &CallArgs,
418f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                      const ObjCInterfaceDecl *Class,
419f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                      const ObjCMethodDecl *Method);
420f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  virtual RValue
421f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  GenerateMessageSendSuper(CodeGenFunction &CGF,
422f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                           ReturnValueSlot Return,
423d95e67dac029d48984b72889a96a1bb389b8ac71Dylan Noblesmith                           QualType ResultType,
424f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                           Selector Sel,
425439661395fd2a2a832dba01c65bc88718528313cEvan Cheng                           const ObjCInterfaceDecl *Class,
426f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                           bool isCategoryImpl,
427f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                           llvm::Value *Receiver,
428f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                           bool IsClassMessage,
429f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                           const CallArgList &CallArgs,
430f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                           const ObjCMethodDecl *Method);
431f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  virtual llvm::Value *GetClass(CGBuilderTy &Builder,
432f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                                const ObjCInterfaceDecl *OID);
433f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
434f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith                                   bool lval = false);
4358e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  virtual llvm::Value *GetSelector(CGBuilderTy &Builder, const ObjCMethodDecl
4368e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson      *Method);
4378e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  virtual llvm::Constant *GetEHType(QualType T);
4388e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson
4398e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
4408e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson                                         const ObjCContainerDecl *CD);
4418e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
4428e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
443f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
444d40e103ea5bca8a223fc8261b3322b9454e9af12Peter Collingbourne                                           const ObjCProtocolDecl *PD);
4458e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  virtual void GenerateProtocol(const ObjCProtocolDecl *PD);
446f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  virtual llvm::Function *ModuleInitFunction();
447f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  virtual llvm::Function *GetPropertyGetFunction();
4489ea47179e647e806a2c67639bfead9d254514e59Dylan Noblesmith  virtual llvm::Function *GetPropertySetFunction();
449f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  virtual llvm::Function *GetSetStructFunction();
450f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith  virtual llvm::Function *GetGetStructFunction();
4518e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  virtual llvm::Constant *EnumerationMutationFunction();
4520f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer
4530f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer  virtual void EmitTryStmt(CodeGenFunction &CGF,
4546456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky                           const ObjCAtTryStmt &S);
4556456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky  virtual void EmitSynchronizedStmt(CodeGenFunction &CGF,
4566456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky                                    const ObjCAtSynchronizedStmt &S);
4576456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky  virtual void EmitThrowStmt(CodeGenFunction &CGF,
4586456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky                             const ObjCAtThrowStmt &S);
45913a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo  virtual llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF,
46013a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo                                         llvm::Value *AddrWeakObj);
4614b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  virtual void EmitObjCWeakAssign(CodeGenFunction &CGF,
4624b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner                                  llvm::Value *src, llvm::Value *dst);
4634b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  virtual void EmitObjCGlobalAssign(CodeGenFunction &CGF,
46413a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo                                    llvm::Value *src, llvm::Value *dest,
465fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner                                    bool threadlocal=false);
4664b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  virtual void EmitObjCIvarAssign(CodeGenFunction &CGF,
467fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner                                    llvm::Value *src, llvm::Value *dest,
468c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner                                    llvm::Value *ivarOffset);
469c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner  virtual void EmitObjCStrongCastAssign(CodeGenFunction &CGF,
470fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner                                        llvm::Value *src, llvm::Value *dest);
4714b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  virtual void EmitGCMemmoveCollectable(CodeGenFunction &CGF,
4724b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner                                        llvm::Value *DestPtr,
47313a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo                                        llvm::Value *SrcPtr,
47413a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo                                        llvm::Value *Size);
47513a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo  virtual LValue EmitObjCValueForIvar(CodeGenFunction &CGF,
47613a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo                                      QualType ObjectTy,
47713a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo                                      llvm::Value *BaseValue,
47813a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo                                      const ObjCIvarDecl *Ivar,
47913a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo                                      unsigned CVRQualifiers);
48013a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo  virtual llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
48182d8277ad5862b54341808812bb4016e52347060Brian Gaeke                                      const ObjCInterfaceDecl *Interface,
4824b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner                                      const ObjCIvarDecl *Ivar);
4834b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  virtual llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM,
4840f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer                                             const CGBlockInfo &blockInfo) {
4859ea47179e647e806a2c67639bfead9d254514e59Dylan Noblesmith    return NULLPtr;
4868e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  }
4878e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson
4888e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  virtual llvm::GlobalVariable *GetClassGlobal(const std::string &Name) {
4898e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson    return 0;
4908e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  }
4919ea47179e647e806a2c67639bfead9d254514e59Dylan Noblesmith};
4928e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson/// Class representing the legacy GCC Objective-C ABI.  This is the default when
4938e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson/// -fobjc-nonfragile-abi is not specified.
49413a3cf192887233fb9452ec5b7f841e4652c33c7Filip Pizlo///
4950f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer/// The GCC ABI target actually generates code that is approximately compatible
4968e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson/// with the new GNUstep runtime ABI, but refrains from using any features that
4978e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson/// would not work with the GCC runtime.  For example, clang always generates
4988e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson/// the extended form of the class structure, and the extra fields are simply
4998e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson/// ignored by GCC libobjc.
5000f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramerclass CGObjCGCC : public CGObjCGNU {
5018e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson  /// The GCC ABI message lookup function.  Returns an IMP pointing to the
502fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner  /// method implementation for this message.
5034b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  LazyRuntimeFunction MsgLookupFn;
50482d8277ad5862b54341808812bb4016e52347060Brian Gaeke  /// The GCC ABI superclass message lookup function.  Takes a pointer to a
5054b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  /// structure describing the receiver and the class, and a selector as
5064b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner  /// arguments.  Returns the IMP for the corresponding method.
507fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner  LazyRuntimeFunction MsgLookupSuperFn;
508fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattnerprotected:
509f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
510c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner                                 llvm::Value *&Receiver,
511c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner                                 llvm::Value *cmd,
512fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner                                 llvm::MDNode *node) {
5134b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner    CGBuilderTy &Builder = CGF.Builder;
514c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner    llvm::Value *imp = Builder.CreateCall2(MsgLookupFn,
5158005bcd5e0c923881d82afcb813a7e537cd1b241Jim Grosbach            EnforceType(Builder, Receiver, IdTy),
5168005bcd5e0c923881d82afcb813a7e537cd1b241Jim Grosbach            EnforceType(Builder, cmd, SelectorTy));
517c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner    cast<llvm::CallInst>(imp)->setMetadata(msgSendMDKind, node);
518c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner    return imp;
51948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  }
52048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
521fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner                                      llvm::Value *ObjCSuper,
5228b5295b7bb8bf44f13df7fc8e38069d1218b1f94Chris Lattner                                      llvm::Value *cmd) {
5238b5295b7bb8bf44f13df7fc8e38069d1218b1f94Chris Lattner      CGBuilderTy &Builder = CGF.Builder;
524bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper,
52537df460874e8d9d28e6833e5fb66a9aa8e1ef50aBrian Gaeke          PtrToObjCSuperTy), cmd};
526bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      return Builder.CreateCall(MsgLookupSuperFn, lookupArgs, lookupArgs+2);
527bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner    }
528ee448630bdf7eb6037fe2c50518d32010c433ca3Reid Spencer  public:
52948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) {
53048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      // IMP objc_msg_lookup(id, SEL);
53168835dd5119150383938c701fc223077d2bc1e25Jeff Cohen      MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy, NULL);
53268835dd5119150383938c701fc223077d2bc1e25Jeff Cohen      // IMP objc_msg_lookup_super(struct objc_super*, SEL);
53368835dd5119150383938c701fc223077d2bc1e25Jeff Cohen      MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
53468835dd5119150383938c701fc223077d2bc1e25Jeff Cohen              PtrToObjCSuperTy, SelectorTy, NULL);
53568835dd5119150383938c701fc223077d2bc1e25Jeff Cohen    }
53668835dd5119150383938c701fc223077d2bc1e25Jeff Cohen};
537c23197a26f34f559ea9797de51e187087c039c42Torok Edwin/// Class used when targeting the new GNUstep runtime ABI.
53848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarclass CGObjCGNUstep : public CGObjCGNU {
53923e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin    /// The slot lookup function.  Returns a pointer to a cacheable structure
540bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner    /// that contains (among other things) the IMP.
541bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner    LazyRuntimeFunction SlotLookupFn;
54248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    /// The GNUstep ABI superclass message lookup function.  Takes a pointer to
54348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    /// a structure describing the receiver and the class, and a selector as
544bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner    /// arguments.  Returns the slot for the corresponding method.  Superclass
5453da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer    /// message lookup rarely changes, so this is a good caching opportunity.
5465b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad    LazyRuntimeFunction SlotLookupSuperFn;
5475b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad    /// Type of an slot structure pointer.  This is returned by the various
5485b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad    /// lookup functions.
549953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    llvm::Type *SlotTy;
550953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  protected:
5515b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad    virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
5525b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad                                   llvm::Value *&Receiver,
5535b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad                                   llvm::Value *cmd,
5545b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad                                   llvm::MDNode *node) {
5555b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad      CGBuilderTy &Builder = CGF.Builder;
5565b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad      llvm::Function *LookupFn = SlotLookupFn;
5575b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad
5585b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad      // Store the receiver on the stack so that we can reload it later
559953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      llvm::Value *ReceiverPtr = CGF.CreateTempAlloca(Receiver->getType());
560953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      Builder.CreateStore(Receiver, ReceiverPtr);
561953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
562953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      llvm::Value *self;
563953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
564953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) {
565953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem        self = CGF.LoadObjCSelf();
566953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      } else {
567953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem        self = llvm::ConstantPointerNull::get(IdTy);
568953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      }
5695b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad
5705b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad      // The lookup function is guaranteed not to capture the receiver pointer.
5715b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad      LookupFn->setDoesNotCapture(1);
5725b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad
573d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner      llvm::CallInst *slot =
57448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar          Builder.CreateCall3(LookupFn,
5753da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer              EnforceType(Builder, ReceiverPtr, PtrToIdTy),
576bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer              EnforceType(Builder, cmd, SelectorTy),
577d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner              EnforceType(Builder, self, IdTy));
578d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner      slot->setOnlyReadsMemory();
57948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      slot->setMetadata(msgSendMDKind, node);
580bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
58198281a20503896349bd152e2dfe87435d3a6aadaNuno Lopes      // Load the imp from the slot
58298281a20503896349bd152e2dfe87435d3a6aadaNuno Lopes      llvm::Value *imp = Builder.CreateLoad(Builder.CreateStructGEP(slot, 4));
583edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman
5848fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer      // The lookup function may have changed the receiver, so make sure we use
58598281a20503896349bd152e2dfe87435d3a6aadaNuno Lopes      // the new one.
586d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner      Receiver = Builder.CreateLoad(ReceiverPtr, true);
587d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner      return imp;
588bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    }
589bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
590bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer                                        llvm::Value *ObjCSuper,
591bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer                                        llvm::Value *cmd) {
5923da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer      CGBuilderTy &Builder = CGF.Builder;
5933da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer      llvm::Value *lookupArgs[] = {ObjCSuper, cmd};
594bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
595bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      llvm::CallInst *slot = Builder.CreateCall(SlotLookupSuperFn, lookupArgs,
596bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer          lookupArgs+2);
597bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      slot->setOnlyReadsMemory();
598bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
599bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      return Builder.CreateLoad(Builder.CreateStructGEP(slot, 4));
600bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    }
601bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  public:
602bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNU(Mod, 9, 3) {
603bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      llvm::StructType *SlotStructTy = llvm::StructType::get(VMContext, PtrTy,
604bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer          PtrTy, PtrTy, IntTy, IMPTy, NULL);
605bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      SlotTy = llvm::PointerType::getUnqual(SlotStructTy);
606bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      // Slot_t objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
6071abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen      SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy,
608bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer          SelectorTy, IdTy, NULL);
609bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      // Slot_t objc_msg_lookup_super(struct objc_super*, SEL);
610bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy,
611bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer              PtrToObjCSuperTy, SelectorTy, NULL);
612bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      // If we're in ObjC++ mode, then we want to make
6131abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen      if (CGM.getLangOptions().CPlusPlus) {
614bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        const llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
615bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        // void *__cxa_begin_catch(void *e)
616bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy, NULL);
617bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        // void __cxa_end_catch(void)
618bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        EnterCatchFn.init(&CGM, "__cxa_end_catch", VoidTy, NULL);
619bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        // void _Unwind_Resume_or_Rethrow(void*)
620cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner        ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy, PtrTy, NULL);
621bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      }
622cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner    }
623bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer};
624cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner
6253069cbf7b3ef9a31bbb8e434686b7259052c364aBenjamin Kramer} // end anonymous namespace
62648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar
627628240649267597f3f27a51ab046b5841c24a953Dan Gohman
628628240649267597f3f27a51ab046b5841c24a953Dan Gohman/// Emits a reference to a dummy variable which is emitted with each class.
6297111b02c734c992b8c97d9918118768026dad79eDale Johannesen/// This ensures that a linker error will be generated when trying to link
6301abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen/// together modules where a referenced class is not defined.
631bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencervoid CGObjCGNU::EmitClassRef(const std::string &className) {
632bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  std::string symbolRef = "__objc_class_ref_" + className;
633bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // Don't emit two copies of the same symbol
634bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  if (TheModule.getGlobalVariable(symbolRef))
635cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner    return;
636bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  std::string symbolName = "__objc_class_name_" + className;
637cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner  llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);
638bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  if (!ClassSymbol) {
639cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner    ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
6403069cbf7b3ef9a31bbb8e434686b7259052c364aBenjamin Kramer        llvm::GlobalValue::ExternalLinkage, 0, symbolName);
64148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  }
642628240649267597f3f27a51ab046b5841c24a953Dan Gohman  new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true,
643628240649267597f3f27a51ab046b5841c24a953Dan Gohman    llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);
6447111b02c734c992b8c97d9918118768026dad79eDale Johannesen}
6451abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen
646bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencerstatic std::string SymbolNameForMethod(const llvm::StringRef &ClassName,
647bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    const llvm::StringRef &CategoryName, const Selector MethodName,
648bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    bool isClassMethod) {
649bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  std::string MethodNameColonStripped = MethodName.getAsString();
650bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  std::replace(MethodNameColonStripped.begin(), MethodNameColonStripped.end(),
651bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      ':', '_');
652cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner  return (llvm::Twine(isClassMethod ? "_c_" : "_i_") + ClassName + "_" +
653bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    CategoryName + "_" + MethodNameColonStripped).str();
654cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner}
655bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
656cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris LattnerCGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
6570a29cb045444c13160e90fe7942a9d7c720185edTim Northover    unsigned protocolClassVersion)
6581abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  : CGM(cgm), TheModule(CGM.getModule()), VMContext(cgm.getLLVMContext()),
65923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen  ClassPtrAlias(0), MetaClassPtrAlias(0), RuntimeVersion(runtimeABIVersion),
6601abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  ProtocolVersion(protocolClassVersion) {
66148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar
66223a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen  msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend");
6631abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen
6641abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  CodeGenTypes &Types = CGM.getTypes();
665bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  IntTy = cast<llvm::IntegerType>(
666bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      Types.ConvertType(CGM.getContext().IntTy));
667bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  LongTy = cast<llvm::IntegerType>(
668bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      Types.ConvertType(CGM.getContext().LongTy));
669bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman  SizeTy = cast<llvm::IntegerType>(
670bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman      Types.ConvertType(CGM.getContext().getSizeType()));
671bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  PtrDiffTy = cast<llvm::IntegerType>(
672bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman      Types.ConvertType(CGM.getContext().getPointerDiffType()));
673bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman  BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
674bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
6753da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer  Int8Ty = llvm::Type::getInt8Ty(VMContext);
6763da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer  // C string type.  Used in lots of places.
677bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
678b52fb876171e3670e7307fda4459ca005d49d9f5Micah Villmow
679bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman  Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
680bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  Zeros[1] = Zeros[0];
681bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);
682bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // Get the selector Type.
683bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  QualType selTy = CGM.getContext().getObjCSelType();
684bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  if (QualType() == selTy) {
685bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    SelectorTy = PtrToInt8Ty;
686db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner  } else {
687bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
688c23197a26f34f559ea9797de51e187087c039c42Torok Edwin  }
689bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
690b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands  PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
691cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner  PtrTy = PtrToInt8Ty;
692bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
693cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner  // Object type
694bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  QualType UnqualIdTy = CGM.getContext().getObjCIdType();
695bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  ASTIdTy = CanQualType();
69648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  if (UnqualIdTy != QualType()) {
697b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands    ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy);
698e4d19c9eb22899c9a555395d446a9ceef3bea7ebJay Foad    IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
699bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  } else {
700bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    IdTy = PtrToInt8Ty;
701b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands  }
702e4d19c9eb22899c9a555395d446a9ceef3bea7ebJay Foad  PtrToIdTy = llvm::PointerType::getUnqual(IdTy);
703bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
704bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  ObjCSuperTy = llvm::StructType::get(VMContext, IdTy, IdTy, NULL);
7051df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands  PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy);
706bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
707bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  const llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
708bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
709d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner  // void objc_exception_throw(id);
7109a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner  ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy, NULL);
711ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman  ExceptionReThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy, NULL);
712bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // int objc_sync_enter(id);
713ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman  SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy, NULL);
714bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // int objc_sync_exit(id);
715ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman  SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy, NULL);
716bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
717bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // void objc_enumerationMutation (id)
718bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy,
719bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      IdTy, NULL);
720bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
721bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // id objc_getProperty(id, SEL, ptrdiff_t, BOOL)
722bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy,
723bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      PtrDiffTy, BoolTy, NULL);
724bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, BOOL)
725bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy,
7265f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner      PtrDiffTy, IdTy, BoolTy, BoolTy, NULL);
727c23197a26f34f559ea9797de51e187087c039c42Torok Edwin  // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
728a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer  GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy,
729bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      PtrDiffTy, BoolTy, BoolTy, NULL);
730c23197a26f34f559ea9797de51e187087c039c42Torok Edwin  // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
731bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy,
732bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer      PtrDiffTy, BoolTy, BoolTy, NULL);
733bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
734bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // IMP type
735bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  std::vector<const llvm::Type*> IMPArgs;
736bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  IMPArgs.push_back(IdTy);
737bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  IMPArgs.push_back(SelectorTy);
738bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,
739bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer              true));
740bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
741bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  // Don't bother initialising the GC stuff unless we're compiling in GC mode
7425f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner  if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) {
7435f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner    // This is a bit of an hack.  We should sort this out by having a proper
744bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    // CGObjCGNUstep subclass for GC, but we may want to really support the old
745c23197a26f34f559ea9797de51e187087c039c42Torok Edwin    // ABI and GC added in ObjectiveC2.framework, so we fudge it a bit for now
746ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman    RuntimeVersion = 10;
747bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    // Get selectors needed in GC mode
748ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman    RetainSel = GetNullarySelector("retain", CGM.getContext());
749bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    ReleaseSel = GetNullarySelector("release", CGM.getContext());
750ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman    AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext());
751bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
75248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    // Get functions needed in GC mode
753bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer
75448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    // id objc_assign_ivar(id, id, ptrdiff_t);
75587565c1d779a1903d10ddd11d886c0f79ee430b5Chris Lattner    IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy,
756bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        NULL);
7575f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner    // id objc_assign_strongCast (id, id*)
7585f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner    StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy,
759bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        PtrToIdTy, NULL);
760c23197a26f34f559ea9797de51e187087c039c42Torok Edwin    // id objc_assign_global(id, id*);
761ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman    GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy,
762bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer        NULL);
763ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman    // id objc_assign_weak(id, id*);
764bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy, NULL);
765ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman    // id objc_read_weak(id*);
766bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy, NULL);
76748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    // void *objc_memmove_collectable(void*, void *, size_t);
768bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy,
76948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar        SizeTy, NULL);
77087565c1d779a1903d10ddd11d886c0f79ee430b5Chris Lattner  }
771bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer}
7725f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner
7731abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen// This has to perform the lookup every time, since posing and related
7741abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen// techniques can modify the name -> class mapping.
7751abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesenllvm::Value *CGObjCGNU::GetClass(CGBuilderTy &Builder,
7760a29cb045444c13160e90fe7942a9d7c720185edTim Northover                                 const ObjCInterfaceDecl *OID) {
7770a29cb045444c13160e90fe7942a9d7c720185edTim Northover  llvm::Value *ClassName = CGM.GetAddrOfConstantCString(OID->getNameAsString());
7781abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  // With the incompatible ABI, this will need to be replaced with a direct
779ab19da4bc087e79550ebe448d9edd4d8ed248388Daniel Dunbar  // reference to the class symbol.  For the compatible nonfragile ABI we are
780ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman  // still performing this lookup at run time but emitting the symbol for the
7810a29cb045444c13160e90fe7942a9d7c720185edTim Northover  // class externally so that we can make the switch later.
7827111b02c734c992b8c97d9918118768026dad79eDale Johannesen  EmitClassRef(OID->getNameAsString());
7831abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  ClassName = Builder.CreateStructGEP(ClassName, 0);
784ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman
7850a29cb045444c13160e90fe7942a9d7c720185edTim Northover  std::vector<const llvm::Type*> Params(1, PtrToInt8Ty);
7860a29cb045444c13160e90fe7942a9d7c720185edTim Northover  llvm::Constant *ClassLookupFn =
7877111b02c734c992b8c97d9918118768026dad79eDale Johannesen    CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy,
7881abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen                                                      Params,
789ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman                                                      true),
7900a29cb045444c13160e90fe7942a9d7c720185edTim Northover                              "objc_lookup_class");
7910a29cb045444c13160e90fe7942a9d7c720185edTim Northover  return Builder.CreateCall(ClassLookupFn, ClassName);
7927111b02c734c992b8c97d9918118768026dad79eDale Johannesen}
7931abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen
79448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarllvm::Value *CGObjCGNU::GetSelector(CGBuilderTy &Builder, Selector Sel,
7950a29cb045444c13160e90fe7942a9d7c720185edTim Northover    const std::string &TypeEncoding, bool lval) {
7960a29cb045444c13160e90fe7942a9d7c720185edTim Northover
7977111b02c734c992b8c97d9918118768026dad79eDale Johannesen  llvm::SmallVector<TypedSelector, 2> &Types = SelectorTable[Sel];
7981abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  llvm::GlobalAlias *SelValue = 0;
79948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar
8000a29cb045444c13160e90fe7942a9d7c720185edTim Northover
8010a29cb045444c13160e90fe7942a9d7c720185edTim Northover  for (llvm::SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
8027111b02c734c992b8c97d9918118768026dad79eDale Johannesen      e = Types.end() ; i!=e ; i++) {
8031abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen    if (i->first == TypeEncoding) {
8041abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen      SelValue = i->second;
8051abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen      break;
8061abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen    }
8075f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner  }
808bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  if (0 == SelValue) {
809bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer    SelValue = new llvm::GlobalAlias(SelectorTy,
8109a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner                                     llvm::GlobalValue::PrivateLinkage,
8119a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner                                     ".objc_selector_"+Sel.getAsString(), NULL,
8129a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner                                     &TheModule);
81348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    Types.push_back(TypedSelector(TypeEncoding, SelValue));
81448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  }
81548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar
81648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  if (lval) {
81748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    llvm::Value *tmp = Builder.CreateAlloca(SelValue->getType());
8189a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner    Builder.CreateStore(SelValue, tmp);
819edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman    return tmp;
82048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  }
821bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer  return SelValue;
822f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner}
82348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar
82448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarllvm::Value *CGObjCGNU::GetSelector(CGBuilderTy &Builder, Selector Sel,
8258fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer                                    bool lval) {
8268fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer  return GetSelector(Builder, Sel, std::string(), lval);
82743421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen}
8288fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer
8291abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesenllvm::Value *CGObjCGNU::GetSelector(CGBuilderTy &Builder, const ObjCMethodDecl
8301abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen    *Method) {
8311abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  std::string SelTypes;
8327111b02c734c992b8c97d9918118768026dad79eDale Johannesen  CGM.getContext().getObjCEncodingForMethodDecl(Method, SelTypes);
8331abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  return GetSelector(Builder, Method->getSelector(), SelTypes, false);
8348fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer}
8358fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer
836a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerllvm::Constant *CGObjCGNU::GetEHType(QualType T) {
837bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner  if (!CGM.getLangOptions().CPlusPlus) {
83840cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer      if (T->isObjCIdType()
839bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner          || T->isObjCQualifiedIdType()) {
84040cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer        // With the old ABI, there was only one kind of catchall, which broke
84140cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer        // foreign exceptions.  With the new ABI, we use __objc_id_typeinfo as
842f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner        // a pointer indicating object catchalls, and NULL to indicate real
84340cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer        // catchalls
844f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner        if (CGM.getLangOptions().ObjCNonFragileABI) {
845f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner          return MakeConstantString("@id");
846f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner        } else {
84740cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer          return 0;
848c23197a26f34f559ea9797de51e187087c039c42Torok Edwin        }
849bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      }
850953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
851953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      // All other types should be Objective-C interface pointer types.
852953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      const ObjCObjectPointerType *OPT =
853953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem        T->getAs<ObjCObjectPointerType>();
854953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      assert(OPT && "Invalid @catch type.");
855953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      const ObjCInterfaceDecl *IDecl =
856953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem        OPT->getObjectType()->getInterface();
857953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      assert(IDecl && "Invalid @catch type.");
858953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      return MakeConstantString(IDecl->getIdentifier()->getName());
859953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  }
860953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // For Objective-C++, we want to provide the ability to catch both C++ and
861953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // Objective-C objects in the same function.
862953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
863953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // There's a particular fixed type info for 'id'.
864953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  if (T->isObjCIdType() ||
865953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      T->isObjCQualifiedIdType()) {
866953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    llvm::Constant *IDEHType =
867953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      CGM.getModule().getGlobalVariable("__objc_id_type_info");
868953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    if (!IDEHType)
869953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      IDEHType =
870953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem        new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty,
871953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem                                 false,
872953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem                                 llvm::GlobalValue::ExternalLinkage,
873953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem                                 0, "__objc_id_type_info");
874953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    return llvm::ConstantExpr::getBitCast(IDEHType, PtrToInt8Ty);
875953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  }
876953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
877953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  const ObjCObjectPointerType *PT =
878953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    T->getAs<ObjCObjectPointerType>();
879953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  assert(PT && "Invalid @catch type.");
880953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  const ObjCInterfaceType *IT = PT->getInterfaceType();
881953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  assert(IT && "Invalid @catch type.");
882953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  std::string className = IT->getDecl()->getIdentifier()->getName();
883953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
884953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  std::string typeinfoName = "__objc_eh_typeinfo_" + className;
885953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
886953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // Return the existing typeinfo if it exists
887953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName);
888953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  if (typeinfo) return typeinfo;
889953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
890953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // Otherwise create it.
891953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
892953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // vtable for gnustep::libobjc::__objc_class_type_info
893953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // It's quite ugly hard-coding this.  Ideally we'd generate it using the host
894953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // platform's name mangling.
895953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE";
896953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::Constant *Vtable = TheModule.getGlobalVariable(vtableName);
897953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  if (!Vtable) {
898953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true,
899953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem            llvm::GlobalValue::ExternalLinkage, 0, vtableName);
900953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  }
901953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);
902953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  Vtable = llvm::ConstantExpr::getGetElementPtr(Vtable, &Two, 1);
903953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  Vtable = llvm::ConstantExpr::getBitCast(Vtable, PtrToInt8Ty);
904953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
905953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::Constant *typeName =
906953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    ExportUniqueString(className, "__objc_eh_typename_");
907953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
908953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  std::vector<llvm::Constant*> fields;
909953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  fields.push_back(Vtable);
910953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  fields.push_back(typeName);
911953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::Constant *TI =
912953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      MakeGlobal(llvm::StructType::get(VMContext, PtrToInt8Ty, PtrToInt8Ty,
913953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem              NULL), fields, "__objc_eh_typeinfo_" + className,
914953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem          llvm::GlobalValue::LinkOnceODRLinkage);
915953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  return llvm::ConstantExpr::getBitCast(TI, PtrToInt8Ty);
916953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem}
917953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
918953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem/// Generate an NSConstantString object.
919953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotemllvm::Constant *CGObjCGNU::GenerateConstantString(const StringLiteral *SL) {
920953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
921953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  std::string Str = SL->getString().str();
922953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
923953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // Look for an existing one
924953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
925953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  if (old != ObjCStrings.end())
926953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    return old->getValue();
927953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
928953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  std::vector<llvm::Constant*> Ivars;
929953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  Ivars.push_back(NULLPtr);
930953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  Ivars.push_back(MakeConstantString(Str));
931953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  Ivars.push_back(llvm::ConstantInt::get(IntTy, Str.size()));
932953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::Constant *ObjCStr = MakeGlobal(
933953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    llvm::StructType::get(VMContext, PtrToInt8Ty, PtrToInt8Ty, IntTy, NULL),
934953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    Ivars, ".objc_str");
935953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty);
936953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  ObjCStrings[Str] = ObjCStr;
937953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  ConstantStrings.push_back(ObjCStr);
938953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  return ObjCStr;
939953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem}
940953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
941953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem///Generates a message send where the super is the receiver.  This is a message
942953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem///send to self with special delivery semantics indicating which class's method
943953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem///should be called.
944953783e00c9934bc41077108fffeb1e2a17b00dfNadav RotemRValue
945bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris LattnerCGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF,
94648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                    ReturnValueSlot Return,
94748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                    QualType ResultType,
94848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                    Selector Sel,
94948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                    const ObjCInterfaceDecl *Class,
950bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner                                    bool isCategoryImpl,
95148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar                                    llvm::Value *Receiver,
952bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner                                    bool IsClassMessage,
953bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner                                    const CallArgList &CallArgs,
954bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner                                    const ObjCMethodDecl *Method) {
9558a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) {
9568a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    if (Sel == RetainSel || Sel == AutoreleaseSel) {
9578a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands      return RValue::get(Receiver);
9588a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    }
9598a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    if (Sel == ReleaseSel) {
96059324297650c12a8dccf1a7ad650a9e895fdc17eRoman Divacky      return RValue::get(0);
9618a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    }
96221a01d1ea89dba97c4f9e1f9f41485729a4046bcRafael Espindola  }
9638a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
9648a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  CGBuilderTy &Builder = CGF.Builder;
9658a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::Value *cmd = GetSelector(Builder, Sel);
96648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar
9678a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
9688a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  CallArgList ActualArgs;
9698a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
9708a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);
9718a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
9728a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
9738a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
9748a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  CodeGenTypes &Types = CGM.getTypes();
9758a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs,
9768a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands                                                       FunctionType::ExtInfo());
9778a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
9788a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::Value *ReceiverClass = 0;
9798a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  if (isCategoryImpl) {
9808a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    llvm::Constant *classLookupFunction = 0;
98189687e3e4ac4aa602de7cce4a7fbc5f514e86615Evan Cheng    std::vector<const llvm::Type*> Params;
982db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner    Params.push_back(PtrTy);
9833574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow    if (IsClassMessage)  {
9841eff70451fbb079c1d5b8f45ff8c8a2b8f74d7baDuncan Sands      classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
9858a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands            IdTy, Params, true), "objc_get_meta_class");
986953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    } else {
987953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
988953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem            IdTy, Params, true), "objc_get_class");
9898a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    }
9908a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    ReceiverClass = Builder.CreateCall(classLookupFunction,
9918fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer        MakeConstantString(Class->getNameAsString()));
9928fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer  } else {
9938fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer    // Set up global aliases for the metaclass or class pointer if they do not
9948fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer    // already exist.  These will are forward-references which will be set to
9958fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer    // pointers to the class and metaclass structure created for the runtime
9968fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer    // load function.  To send a message to super, we look up the value of the
9978fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer    // super_class pointer from either the class or metaclass structure.
9981f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen    if (IsClassMessage)  {
9991f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen      if (!MetaClassPtrAlias) {
10001f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen        MetaClassPtrAlias = new llvm::GlobalAlias(IdTy,
10018a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands            llvm::GlobalValue::InternalLinkage, ".objc_metaclass_ref" +
10028a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands            Class->getNameAsString(), NULL, &TheModule);
10038a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands      }
100480d9e072625bc49dab4fa2da6c21bdd202509ee3Chandler Carruth      ReceiverClass = MetaClassPtrAlias;
10058a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    } else {
10068fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer      if (!ClassPtrAlias) {
10078fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer        ClassPtrAlias = new llvm::GlobalAlias(IdTy,
1008953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem            llvm::GlobalValue::InternalLinkage, ".objc_class_ref" +
1009953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem            Class->getNameAsString(), NULL, &TheModule);
1010953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      }
1011953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      ReceiverClass = ClassPtrAlias;
1012953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    }
1013953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  }
1014953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // Cast the pointer to a simplified version of the class structure
1015953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  ReceiverClass = Builder.CreateBitCast(ReceiverClass,
1016953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      llvm::PointerType::getUnqual(
1017953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem        llvm::StructType::get(VMContext, IdTy, IdTy, NULL)));
1018953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // Get the superclass pointer
1019953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  ReceiverClass = Builder.CreateStructGEP(ReceiverClass, 1);
1020953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  // Load the superclass pointer
1021bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner  ReceiverClass = Builder.CreateLoad(ReceiverClass);
10228a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  // Construct the structure used to look up the IMP
102321a01d1ea89dba97c4f9e1f9f41485729a4046bcRafael Espindola  llvm::StructType *ObjCSuperTy = llvm::StructType::get(VMContext,
10248a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands      Receiver->getType(), IdTy, NULL);
10258a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::Value *ObjCSuper = Builder.CreateAlloca(ObjCSuperTy);
10268a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
10278a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
10288a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
10298a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
10308a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  ObjCSuper = EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy);
10318a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  const llvm::FunctionType *impType =
1032c2680bef3b4994017d83293bc1337b26be54ac77David Greene    Types.GetFunctionType(FnInfo, Method ? Method->isVariadic() : false);
1033c2680bef3b4994017d83293bc1337b26be54ac77David Greene
10348a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  // Get the IMP
103521a01d1ea89dba97c4f9e1f9f41485729a4046bcRafael Espindola  llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd);
10368a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  imp = EnforceType(Builder, imp, llvm::PointerType::getUnqual(impType));
10378a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
10388a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::Value *impMD[] = {
10398a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands      llvm::MDString::get(VMContext, Sel.getAsString()),
10408a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands      llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()),
10418a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands      llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), IsClassMessage)
10428a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands   };
10438a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
10448a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
10458a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  llvm::Instruction *call;
10468a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  RValue msgRet = CGF.EmitCall(FnInfo, imp, Return, ActualArgs,
10478a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands      0, &call);
10488a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  call->setMetadata(msgSendMDKind, node);
10498a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  return msgRet;
10508a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands}
10518a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands
10528a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands/// Generate code for a message send expression.
1053bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris LattnerRValue
1054bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris LattnerCGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF,
10554afac18fd4cae1b93907d7db03c5fdb7f2f66d64Misha Brukman                               ReturnValueSlot Return,
10564afac18fd4cae1b93907d7db03c5fdb7f2f66d64Misha Brukman                               QualType ResultType,
10578a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands                               Selector Sel,
105808bfe26f5a06bf9b0d6f8d2ceb5cb991d0d61842Duncan Sands                               llvm::Value *Receiver,
1059db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner                               const CallArgList &CallArgs,
10603574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow                               const ObjCInterfaceDecl *Class,
10618a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands                               const ObjCMethodDecl *Method) {
10628a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  // Strip out message sends to retain / release in GC mode
10638a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) {
10641eff70451fbb079c1d5b8f45ff8c8a2b8f74d7baDuncan Sands    if (Sel == RetainSel || Sel == AutoreleaseSel) {
10658a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands      return RValue::get(Receiver);
10668a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands    }
10678fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer    if (Sel == ReleaseSel) {
10688fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer      return RValue::get(0);
10698fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer    }
10708fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer  }
10718fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer
10728a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  CGBuilderTy &Builder = CGF.Builder;
10738fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer
10748a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands  // If the return type is something that goes in an integer register, the
10758fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer  // runtime will handle 0 returns.  For other cases, we fill in the 0 value
10768fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer  // ourselves.
10771abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  //
10781abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  // The language spec says the result of this kind of message send is
10799e4635a5b8f56db607df2aca9cae1fc8d5a8bd36Duncan Sands  // undefined, but lots of people seem to have forgotten to read that
10801f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen  // paragraph and insist on sending messages to nil that have structure
10811f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen  // returns.  With GCC, this generates a random return value (whatever happens
10823ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin  // to be on the stack / in those registers at the time) on most platforms,
10831abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  // and generates an illegal instruction trap on SPARC.  With LLVM it corrupts
10841abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen  // the stack.
1085953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  bool isPointerSizedReturn = (ResultType->isAnyPointerType() ||
1086953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem      ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType());
1087953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
1088953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::BasicBlock *startBB = 0;
1089953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::BasicBlock *messageBB = 0;
1090953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::BasicBlock *continueBB = 0;
1091953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
1092953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  if (!isPointerSizedReturn) {
1093953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    startBB = Builder.GetInsertBlock();
1094953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    messageBB = CGF.createBasicBlock("msgSend");
1095953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    continueBB = CGF.createBasicBlock("continue");
1096953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
1097953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,
1098953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem            llvm::Constant::getNullValue(Receiver->getType()));
1099953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    Builder.CreateCondBr(isNil, continueBB, messageBB);
1100953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    CGF.EmitBlock(messageBB);
1101953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  }
1102953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem
1103953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
1104953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  llvm::Value *cmd;
1105953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  if (Method)
1106953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    cmd = GetSelector(Builder, Method);
1107953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  else
1108953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem    cmd = GetSelector(Builder, Sel);
1109953783e00c9934bc41077108fffeb1e2a17b00dfNadav Rotem  cmd = EnforceType(Builder, cmd, SelectorTy);
11108fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer  Receiver = EnforceType(Builder, Receiver, IdTy);
111148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar
111248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::Value *impMD[] = {
111348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar        llvm::MDString::get(VMContext, Sel.getAsString()),
111448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar        llvm::MDString::get(VMContext, Class ? Class->getNameAsString() :""),
1115f88b9a639770327196b2a00f365155b954dd1d30Chris Lattner        llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), Class!=0)
1116f88b9a639770327196b2a00f365155b954dd1d30Chris Lattner   };
1117f88b9a639770327196b2a00f365155b954dd1d30Chris Lattner  llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
1118bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner
1119ae7c59a01286a3babbc6245dcb1049c7bcde2573David Greene  // Get the IMP to call
1120dd947ea3c5e020c33c58a31939561265b980a3adDale Johannesen  llvm::Value *imp = LookupIMP(CGF, Receiver, cmd, node);
11211ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner
1122bd1d382cc47dfc43ee758714bc22ab5a750bad15Chris Lattner  CallArgList ActualArgs;
11231ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  ActualArgs.add(RValue::get(Receiver), ASTIdTy);
11241ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
11257c2b7c7c75a3549b2d6933edf3110294a33ff2d4Robert Bocchino  ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
11263574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow
11277c2b7c7c75a3549b2d6933edf3110294a33ff2d4Robert Bocchino  CodeGenTypes &Types = CGM.getTypes();
11287c2b7c7c75a3549b2d6933edf3110294a33ff2d4Robert Bocchino  const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs,
11297c2b7c7c75a3549b2d6933edf3110294a33ff2d4Robert Bocchino                                                       FunctionType::ExtInfo());
11301ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  const llvm::FunctionType *impType =
11311ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner    Types.GetFunctionType(FnInfo, Method ? Method->isVariadic() : false);
11321ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  imp = EnforceType(Builder, imp, llvm::PointerType::getUnqual(impType));
11333574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow
1134b6e1dd70750d9b761779a00512e69c64a06ddfdeChris Lattner
11351ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  // For sender-aware dispatch, we pass the sender as the third argument to a
11361ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  // lookup function.  When sending messages from C code, the sender is nil.
11371ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  // objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
1138edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman  llvm::Instruction *call;
11393574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow  RValue msgRet = CGF.EmitCall(FnInfo, imp, Return, ActualArgs,
114015876bb28c9c0983279c30a123c13224648574c1Alkis Evlogimenos      0, &call);
114115876bb28c9c0983279c30a123c13224648574c1Alkis Evlogimenos  call->setMetadata(msgSendMDKind, node);
1142bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner
11431ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner
11441ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner  if (!isPointerSizedReturn) {
11451ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner    messageBB = CGF.Builder.GetInsertBlock();
1146bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner    CGF.Builder.CreateBr(continueBB);
11473574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow    CGF.EmitBlock(continueBB);
114815876bb28c9c0983279c30a123c13224648574c1Alkis Evlogimenos    if (msgRet.isScalar()) {
1149b1919e2f08ecb37140af676fd2916f8d5ed7df3dChris Lattner      llvm::Value *v = msgRet.getScalarVal();
1150bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
11511ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner      phi->addIncoming(v, messageBB);
11521ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner      phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB);
11531ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner      msgRet = RValue::get(phi);
11541ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner    } else if (msgRet.isAggregate()) {
11551ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner      llvm::Value *v = msgRet.getAggregateAddr();
11561ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner      llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
11571ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner      const llvm::PointerType *RetTy = cast<llvm::PointerType>(v->getType());
11581ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner      llvm::AllocaInst *NullVal =
11591ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner          CGF.CreateTempAlloca(RetTy->getElementType(), "null");
11601ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner      CGF.InitTempAlloca(NullVal,
11611ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner          llvm::Constant::getNullValue(RetTy->getElementType()));
1162638e378f2cb62c34f306f8eadd43039e20caede4Dan Gohman      phi->addIncoming(v, messageBB);
1163638e378f2cb62c34f306f8eadd43039e20caede4Dan Gohman      phi->addIncoming(NullVal, startBB);
1164638e378f2cb62c34f306f8eadd43039e20caede4Dan Gohman      msgRet = RValue::getAggregate(phi);
1165bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner    } else /* isComplex() */ {
1166bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal();
116748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2);
1168c23197a26f34f559ea9797de51e187087c039c42Torok Edwin      phi->addIncoming(v.first, messageBB);
1169bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
1170bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner          startBB);
1171bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2);
1172bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      phi2->addIncoming(v.second, messageBB);
1173bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
1174bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner          startBB);
1175bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner      msgRet = RValue::getComplex(phi, phi2);
1176fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    }
1177fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  }
1178db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner  return msgRet;
1179fe854034677f59baca1e38075e71f6efca247a03Chris Lattner}
1180fe854034677f59baca1e38075e71f6efca247a03Chris Lattner
1181fe854034677f59baca1e38075e71f6efca247a03Chris Lattner/// Generates a MethodList.  Used in construction of a objc_class and
1182fe854034677f59baca1e38075e71f6efca247a03Chris Lattner/// objc_category structures.
1183f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskinllvm::Constant *CGObjCGNU::GenerateMethodList(const llvm::StringRef &ClassName,
1184fe854034677f59baca1e38075e71f6efca247a03Chris Lattner                                              const llvm::StringRef &CategoryName,
1185fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    const llvm::SmallVectorImpl<Selector> &MethodSels,
1186fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes,
1187bb46f52027416598a662dc1c58f48d9d56b1a65bRafael Espindola    bool isClassMethodList) {
1188fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  if (MethodSels.empty())
1189fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    return NULLPtr;
119048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  // Get the method structure type.
119148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::StructType *ObjCMethodTy = llvm::StructType::get(VMContext,
1192fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    PtrToInt8Ty, // Really a selector, but the runtime creates it us.
1193fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    PtrToInt8Ty, // Method types
1194fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    IMPTy, //Method pointer
1195fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    NULL);
1196fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  std::vector<llvm::Constant*> Methods;
1197fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  std::vector<llvm::Constant*> Elements;
1198fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  for (unsigned int i = 0, e = MethodTypes.size(); i < e; ++i) {
1199fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    Elements.clear();
120048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    llvm::Constant *Method =
1201fe854034677f59baca1e38075e71f6efca247a03Chris Lattner      TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
1202b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov                                                MethodSels[i],
1203b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov                                                isClassMethodList));
1204b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov    assert(Method && "Can't generate metadata for method that doesn't exist");
1205fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    llvm::Constant *C = MakeConstantString(MethodSels[i].getAsString());
120648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    Elements.push_back(C);
1207fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    Elements.push_back(MethodTypes[i]);
1208aafce77b17d340aace52bcd49d1944109d82f14aDale Johannesen    Method = llvm::ConstantExpr::getBitCast(Method,
120978ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov        IMPTy);
1210fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    Elements.push_back(Method);
1211d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner    Methods.push_back(llvm::ConstantStruct::get(ObjCMethodTy, Elements));
1212bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner  }
1213fe854034677f59baca1e38075e71f6efca247a03Chris Lattner
121448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  // Array of method structures
1215fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodTy,
1216fe854034677f59baca1e38075e71f6efca247a03Chris Lattner                                                            Methods.size());
1217f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin  llvm::Constant *MethodArray = llvm::ConstantArray::get(ObjCMethodArrayTy,
1218fe854034677f59baca1e38075e71f6efca247a03Chris Lattner                                                         Methods);
1219fe854034677f59baca1e38075e71f6efca247a03Chris Lattner
1220fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  // Structure containing list pointer, array and array count
1221fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  llvm::SmallVector<const llvm::Type*, 16> ObjCMethodListFields;
122248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  llvm::PATypeHolder OpaqueNextTy = llvm::OpaqueType::get(VMContext);
1223fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  llvm::Type *NextPtrTy = llvm::PointerType::getUnqual(OpaqueNextTy);
1224fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  llvm::StructType *ObjCMethodListTy = llvm::StructType::get(VMContext,
1225fe854034677f59baca1e38075e71f6efca247a03Chris Lattner      NextPtrTy,
1226fe854034677f59baca1e38075e71f6efca247a03Chris Lattner      IntTy,
1227fe854034677f59baca1e38075e71f6efca247a03Chris Lattner      ObjCMethodArrayTy,
1228fe854034677f59baca1e38075e71f6efca247a03Chris Lattner      NULL);
1229fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  // Refine next pointer type to concrete type
1230fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  llvm::cast<llvm::OpaqueType>(
123148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      OpaqueNextTy.get())->refineAbstractTypeTo(ObjCMethodListTy);
12325cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer  ObjCMethodListTy = llvm::cast<llvm::StructType>(OpaqueNextTy.get());
123346fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray
1234fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  Methods.clear();
1235fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  Methods.push_back(llvm::ConstantPointerNull::get(
1236fe854034677f59baca1e38075e71f6efca247a03Chris Lattner        llvm::PointerType::getUnqual(ObjCMethodListTy)));
1237fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  Methods.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
1238fbee579ed46016166d88b4defb81a2e7e253062dDaniel Dunbar        MethodTypes.size()));
1239fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  Methods.push_back(MethodArray);
1240fe854034677f59baca1e38075e71f6efca247a03Chris Lattner
124175361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner  // Create an instance of the structure
124231e2466f159a887fed9139067a676f65adf2a8c3Torok Edwin  return MakeGlobal(ObjCMethodListTy, Methods, ".objc_method_list");
1243fe854034677f59baca1e38075e71f6efca247a03Chris Lattner}
1244fe854034677f59baca1e38075e71f6efca247a03Chris Lattner
1245fe854034677f59baca1e38075e71f6efca247a03Chris Lattner/// Generates an IvarList.  Used in construction of a objc_class.
124648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarllvm::Constant *CGObjCGNU::GenerateIvarList(
1247fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
1248fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
1249fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets) {
1250fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  if (IvarNames.size() == 0)
1251fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    return NULLPtr;
1252fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  // Get the method structure type.
1253fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  llvm::StructType *ObjCIvarTy = llvm::StructType::get(VMContext,
1254fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    PtrToInt8Ty,
1255fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    PtrToInt8Ty,
1256c8ed902298b79e8a740e4f707f13089cf5ce1295Nuno Lopes    IntTy,
1257fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    NULL);
1258fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  std::vector<llvm::Constant*> Ivars;
125948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  std::vector<llvm::Constant*> Elements;
126048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
1261a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer    Elements.clear();
1262fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    Elements.push_back(IvarNames[i]);
1263fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    Elements.push_back(IvarTypes[i]);
12645cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer    Elements.push_back(IvarOffsets[i]);
1265fe854034677f59baca1e38075e71f6efca247a03Chris Lattner    Ivars.push_back(llvm::ConstantStruct::get(ObjCIvarTy, Elements));
126648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  }
1267fe854034677f59baca1e38075e71f6efca247a03Chris Lattner
1268fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  // Array of method structures
1269fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  llvm::ArrayType *ObjCIvarArrayTy = llvm::ArrayType::get(ObjCIvarTy,
1270fe854034677f59baca1e38075e71f6efca247a03Chris Lattner      IvarNames.size());
1271fe854034677f59baca1e38075e71f6efca247a03Chris Lattner
1272fe854034677f59baca1e38075e71f6efca247a03Chris Lattner
1273fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  Elements.clear();
1274fe854034677f59baca1e38075e71f6efca247a03Chris Lattner  Elements.push_back(llvm::ConstantInt::get(IntTy, (int)IvarNames.size()));
127524b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner  Elements.push_back(llvm::ConstantArray::get(ObjCIvarArrayTy, Ivars));
127624b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner  // Structure containing array and array count
127724b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner  llvm::StructType *ObjCIvarListTy = llvm::StructType::get(VMContext, IntTy,
127824b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner    ObjCIvarArrayTy,
127924b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner    NULL);
1280c07ed1387503d25c0b93fcf617f69329d73fc589Chris Lattner
128155d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner  // Create an instance of the structure
128223c472436940aa7fc82ff99e8cca6788d08a8105Chris Lattner  return MakeGlobal(ObjCIvarListTy, Elements, ".objc_ivar_list");
128324b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner}
128424b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner
128546fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray/// Generate a class structure
128655d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattnerllvm::Constant *CGObjCGNU::GenerateClassStructure(
128724b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner    llvm::Constant *MetaClass,
128848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    llvm::Constant *SuperClass,
128946fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray    unsigned info,
129046fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray    const char *Name,
129146fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray    llvm::Constant *Version,
129248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar    llvm::Constant *InstanceSize,
1293db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner    llvm::Constant *IVars,
12943574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow    llvm::Constant *Methods,
1295813c8152825db530a6ef4ee86e8038bbee16deb3Chris Lattner    llvm::Constant *Protocols,
129624b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner    llvm::Constant *IvarOffsets,
1297bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner    llvm::Constant *Properties,
12984c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin    bool isMeta) {
129923e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  // Set up the class structure
130023e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  // Note:  Several of these are char*s when they should be ids.  This is
130123e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  // because the runtime performs this translation on load.
13024c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin  //
130348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  // Fields marked New ABI are part of the GNUstep runtime.  We emit them
130448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar  // anyway; the classes will still work with the GNU runtime, they will just
130523e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  // be ignored.
130623e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin  llvm::StructType *ClassTy = llvm::StructType::get(VMContext,
130748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      PtrToInt8Ty,        // class_pointer
130848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      PtrToInt8Ty,        // super_class
130948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      PtrToInt8Ty,        // name
131023e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin      LongTy,             // version
131123e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin      LongTy,             // info
13124c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin      LongTy,             // instance_size
13134c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin      IVars->getType(),   // ivars
131448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      Methods->getType(), // methods
131548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      // These are all filled in by the runtime, so we pretend
131648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar      PtrTy,              // dtable
1317858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper      PtrTy,              // subclass_list
1318858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper      PtrTy,              // sibling_class
13194c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin      PtrTy,              // protocols
1320      PtrTy,              // gc_object_type
1321      // New ABI:
1322      LongTy,                 // abi_version
1323      IvarOffsets->getType(), // ivar_offsets
1324      Properties->getType(),  // properties
1325      NULL);
1326  llvm::Constant *Zero = llvm::ConstantInt::get(LongTy, 0);
1327  // Fill in the structure
1328  std::vector<llvm::Constant*> Elements;
1329  Elements.push_back(llvm::ConstantExpr::getBitCast(MetaClass, PtrToInt8Ty));
1330  Elements.push_back(SuperClass);
1331  Elements.push_back(MakeConstantString(Name, ".class_name"));
1332  Elements.push_back(Zero);
1333  Elements.push_back(llvm::ConstantInt::get(LongTy, info));
1334  if (isMeta) {
1335    llvm::TargetData td(&TheModule);
1336    Elements.push_back(
1337        llvm::ConstantInt::get(LongTy,
1338                               td.getTypeSizeInBits(ClassTy) /
1339                                 CGM.getContext().getCharWidth()));
1340  } else
1341    Elements.push_back(InstanceSize);
1342  Elements.push_back(IVars);
1343  Elements.push_back(Methods);
1344  Elements.push_back(NULLPtr);
1345  Elements.push_back(NULLPtr);
1346  Elements.push_back(NULLPtr);
1347  Elements.push_back(llvm::ConstantExpr::getBitCast(Protocols, PtrTy));
1348  Elements.push_back(NULLPtr);
1349  Elements.push_back(Zero);
1350  Elements.push_back(IvarOffsets);
1351  Elements.push_back(Properties);
1352  // Create an instance of the structure
1353  // This is now an externally visible symbol, so that we can speed up class
1354  // messages in the next ABI.
1355  return MakeGlobal(ClassTy, Elements, (isMeta ? "_OBJC_METACLASS_":
1356      "_OBJC_CLASS_") + std::string(Name), llvm::GlobalValue::ExternalLinkage);
1357}
1358
1359llvm::Constant *CGObjCGNU::GenerateProtocolMethodList(
1360    const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
1361    const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes) {
1362  // Get the method structure type.
1363  llvm::StructType *ObjCMethodDescTy = llvm::StructType::get(VMContext,
1364    PtrToInt8Ty, // Really a selector, but the runtime does the casting for us.
1365    PtrToInt8Ty,
1366    NULL);
1367  std::vector<llvm::Constant*> Methods;
1368  std::vector<llvm::Constant*> Elements;
1369  for (unsigned int i = 0, e = MethodTypes.size() ; i < e ; i++) {
1370    Elements.clear();
1371    Elements.push_back(MethodNames[i]);
1372    Elements.push_back(MethodTypes[i]);
1373    Methods.push_back(llvm::ConstantStruct::get(ObjCMethodDescTy, Elements));
1374  }
1375  llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodDescTy,
1376      MethodNames.size());
1377  llvm::Constant *Array = llvm::ConstantArray::get(ObjCMethodArrayTy,
1378                                                   Methods);
1379  llvm::StructType *ObjCMethodDescListTy = llvm::StructType::get(VMContext,
1380      IntTy, ObjCMethodArrayTy, NULL);
1381  Methods.clear();
1382  Methods.push_back(llvm::ConstantInt::get(IntTy, MethodNames.size()));
1383  Methods.push_back(Array);
1384  return MakeGlobal(ObjCMethodDescListTy, Methods, ".objc_method_list");
1385}
1386
1387// Create the protocol list structure used in classes, categories and so on
1388llvm::Constant *CGObjCGNU::GenerateProtocolList(
1389    const llvm::SmallVectorImpl<std::string> &Protocols) {
1390  llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
1391      Protocols.size());
1392  llvm::StructType *ProtocolListTy = llvm::StructType::get(VMContext,
1393      PtrTy, //Should be a recurisve pointer, but it's always NULL here.
1394      SizeTy,
1395      ProtocolArrayTy,
1396      NULL);
1397  std::vector<llvm::Constant*> Elements;
1398  for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
1399      iter != endIter ; iter++) {
1400    llvm::Constant *protocol = 0;
1401    llvm::StringMap<llvm::Constant*>::iterator value =
1402      ExistingProtocols.find(*iter);
1403    if (value == ExistingProtocols.end()) {
1404      protocol = GenerateEmptyProtocol(*iter);
1405    } else {
1406      protocol = value->getValue();
1407    }
1408    llvm::Constant *Ptr = llvm::ConstantExpr::getBitCast(protocol,
1409                                                           PtrToInt8Ty);
1410    Elements.push_back(Ptr);
1411  }
1412  llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1413      Elements);
1414  Elements.clear();
1415  Elements.push_back(NULLPtr);
1416  Elements.push_back(llvm::ConstantInt::get(LongTy, Protocols.size()));
1417  Elements.push_back(ProtocolArray);
1418  return MakeGlobal(ProtocolListTy, Elements, ".objc_protocol_list");
1419}
1420
1421llvm::Value *CGObjCGNU::GenerateProtocolRef(CGBuilderTy &Builder,
1422                                            const ObjCProtocolDecl *PD) {
1423  llvm::Value *protocol = ExistingProtocols[PD->getNameAsString()];
1424  const llvm::Type *T =
1425    CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType());
1426  return Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
1427}
1428
1429llvm::Constant *CGObjCGNU::GenerateEmptyProtocol(
1430  const std::string &ProtocolName) {
1431  llvm::SmallVector<std::string, 0> EmptyStringVector;
1432  llvm::SmallVector<llvm::Constant*, 0> EmptyConstantVector;
1433
1434  llvm::Constant *ProtocolList = GenerateProtocolList(EmptyStringVector);
1435  llvm::Constant *MethodList =
1436    GenerateProtocolMethodList(EmptyConstantVector, EmptyConstantVector);
1437  // Protocols are objects containing lists of the methods implemented and
1438  // protocols adopted.
1439  llvm::StructType *ProtocolTy = llvm::StructType::get(VMContext, IdTy,
1440      PtrToInt8Ty,
1441      ProtocolList->getType(),
1442      MethodList->getType(),
1443      MethodList->getType(),
1444      MethodList->getType(),
1445      MethodList->getType(),
1446      NULL);
1447  std::vector<llvm::Constant*> Elements;
1448  // The isa pointer must be set to a magic number so the runtime knows it's
1449  // the correct layout.
1450  Elements.push_back(llvm::ConstantExpr::getIntToPtr(
1451        llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
1452          ProtocolVersion), IdTy));
1453  Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
1454  Elements.push_back(ProtocolList);
1455  Elements.push_back(MethodList);
1456  Elements.push_back(MethodList);
1457  Elements.push_back(MethodList);
1458  Elements.push_back(MethodList);
1459  return MakeGlobal(ProtocolTy, Elements, ".objc_protocol");
1460}
1461
1462void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
1463  ASTContext &Context = CGM.getContext();
1464  std::string ProtocolName = PD->getNameAsString();
1465  llvm::SmallVector<std::string, 16> Protocols;
1466  for (ObjCProtocolDecl::protocol_iterator PI = PD->protocol_begin(),
1467       E = PD->protocol_end(); PI != E; ++PI)
1468    Protocols.push_back((*PI)->getNameAsString());
1469  llvm::SmallVector<llvm::Constant*, 16> InstanceMethodNames;
1470  llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
1471  llvm::SmallVector<llvm::Constant*, 16> OptionalInstanceMethodNames;
1472  llvm::SmallVector<llvm::Constant*, 16> OptionalInstanceMethodTypes;
1473  for (ObjCProtocolDecl::instmeth_iterator iter = PD->instmeth_begin(),
1474       E = PD->instmeth_end(); iter != E; iter++) {
1475    std::string TypeStr;
1476    Context.getObjCEncodingForMethodDecl(*iter, TypeStr);
1477    if ((*iter)->getImplementationControl() == ObjCMethodDecl::Optional) {
1478      InstanceMethodNames.push_back(
1479          MakeConstantString((*iter)->getSelector().getAsString()));
1480      InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1481    } else {
1482      OptionalInstanceMethodNames.push_back(
1483          MakeConstantString((*iter)->getSelector().getAsString()));
1484      OptionalInstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1485    }
1486  }
1487  // Collect information about class methods:
1488  llvm::SmallVector<llvm::Constant*, 16> ClassMethodNames;
1489  llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
1490  llvm::SmallVector<llvm::Constant*, 16> OptionalClassMethodNames;
1491  llvm::SmallVector<llvm::Constant*, 16> OptionalClassMethodTypes;
1492  for (ObjCProtocolDecl::classmeth_iterator
1493         iter = PD->classmeth_begin(), endIter = PD->classmeth_end();
1494       iter != endIter ; iter++) {
1495    std::string TypeStr;
1496    Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
1497    if ((*iter)->getImplementationControl() == ObjCMethodDecl::Optional) {
1498      ClassMethodNames.push_back(
1499          MakeConstantString((*iter)->getSelector().getAsString()));
1500      ClassMethodTypes.push_back(MakeConstantString(TypeStr));
1501    } else {
1502      OptionalClassMethodNames.push_back(
1503          MakeConstantString((*iter)->getSelector().getAsString()));
1504      OptionalClassMethodTypes.push_back(MakeConstantString(TypeStr));
1505    }
1506  }
1507
1508  llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
1509  llvm::Constant *InstanceMethodList =
1510    GenerateProtocolMethodList(InstanceMethodNames, InstanceMethodTypes);
1511  llvm::Constant *ClassMethodList =
1512    GenerateProtocolMethodList(ClassMethodNames, ClassMethodTypes);
1513  llvm::Constant *OptionalInstanceMethodList =
1514    GenerateProtocolMethodList(OptionalInstanceMethodNames,
1515            OptionalInstanceMethodTypes);
1516  llvm::Constant *OptionalClassMethodList =
1517    GenerateProtocolMethodList(OptionalClassMethodNames,
1518            OptionalClassMethodTypes);
1519
1520  // Property metadata: name, attributes, isSynthesized, setter name, setter
1521  // types, getter name, getter types.
1522  // The isSynthesized value is always set to 0 in a protocol.  It exists to
1523  // simplify the runtime library by allowing it to use the same data
1524  // structures for protocol metadata everywhere.
1525  llvm::StructType *PropertyMetadataTy = llvm::StructType::get(VMContext,
1526          PtrToInt8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty,
1527          PtrToInt8Ty, NULL);
1528  std::vector<llvm::Constant*> Properties;
1529  std::vector<llvm::Constant*> OptionalProperties;
1530
1531  // Add all of the property methods need adding to the method list and to the
1532  // property metadata list.
1533  for (ObjCContainerDecl::prop_iterator
1534         iter = PD->prop_begin(), endIter = PD->prop_end();
1535       iter != endIter ; iter++) {
1536    std::vector<llvm::Constant*> Fields;
1537    ObjCPropertyDecl *property = (*iter);
1538
1539    Fields.push_back(MakeConstantString(property->getNameAsString()));
1540    Fields.push_back(llvm::ConstantInt::get(Int8Ty,
1541                property->getPropertyAttributes()));
1542    Fields.push_back(llvm::ConstantInt::get(Int8Ty, 0));
1543    if (ObjCMethodDecl *getter = property->getGetterMethodDecl()) {
1544      std::string TypeStr;
1545      Context.getObjCEncodingForMethodDecl(getter,TypeStr);
1546      llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1547      InstanceMethodTypes.push_back(TypeEncoding);
1548      Fields.push_back(MakeConstantString(getter->getSelector().getAsString()));
1549      Fields.push_back(TypeEncoding);
1550    } else {
1551      Fields.push_back(NULLPtr);
1552      Fields.push_back(NULLPtr);
1553    }
1554    if (ObjCMethodDecl *setter = property->getSetterMethodDecl()) {
1555      std::string TypeStr;
1556      Context.getObjCEncodingForMethodDecl(setter,TypeStr);
1557      llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1558      InstanceMethodTypes.push_back(TypeEncoding);
1559      Fields.push_back(MakeConstantString(setter->getSelector().getAsString()));
1560      Fields.push_back(TypeEncoding);
1561    } else {
1562      Fields.push_back(NULLPtr);
1563      Fields.push_back(NULLPtr);
1564    }
1565    if (property->getPropertyImplementation() == ObjCPropertyDecl::Optional) {
1566      OptionalProperties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1567    } else {
1568      Properties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1569    }
1570  }
1571  llvm::Constant *PropertyArray = llvm::ConstantArray::get(
1572      llvm::ArrayType::get(PropertyMetadataTy, Properties.size()), Properties);
1573  llvm::Constant* PropertyListInitFields[] =
1574    {llvm::ConstantInt::get(IntTy, Properties.size()), NULLPtr, PropertyArray};
1575
1576  llvm::Constant *PropertyListInit =
1577      llvm::ConstantStruct::get(VMContext, PropertyListInitFields, 3, false);
1578  llvm::Constant *PropertyList = new llvm::GlobalVariable(TheModule,
1579      PropertyListInit->getType(), false, llvm::GlobalValue::InternalLinkage,
1580      PropertyListInit, ".objc_property_list");
1581
1582  llvm::Constant *OptionalPropertyArray =
1583      llvm::ConstantArray::get(llvm::ArrayType::get(PropertyMetadataTy,
1584          OptionalProperties.size()) , OptionalProperties);
1585  llvm::Constant* OptionalPropertyListInitFields[] = {
1586      llvm::ConstantInt::get(IntTy, OptionalProperties.size()), NULLPtr,
1587      OptionalPropertyArray };
1588
1589  llvm::Constant *OptionalPropertyListInit =
1590      llvm::ConstantStruct::get(VMContext, OptionalPropertyListInitFields, 3, false);
1591  llvm::Constant *OptionalPropertyList = new llvm::GlobalVariable(TheModule,
1592          OptionalPropertyListInit->getType(), false,
1593          llvm::GlobalValue::InternalLinkage, OptionalPropertyListInit,
1594          ".objc_property_list");
1595
1596  // Protocols are objects containing lists of the methods implemented and
1597  // protocols adopted.
1598  llvm::StructType *ProtocolTy = llvm::StructType::get(VMContext, IdTy,
1599      PtrToInt8Ty,
1600      ProtocolList->getType(),
1601      InstanceMethodList->getType(),
1602      ClassMethodList->getType(),
1603      OptionalInstanceMethodList->getType(),
1604      OptionalClassMethodList->getType(),
1605      PropertyList->getType(),
1606      OptionalPropertyList->getType(),
1607      NULL);
1608  std::vector<llvm::Constant*> Elements;
1609  // The isa pointer must be set to a magic number so the runtime knows it's
1610  // the correct layout.
1611  Elements.push_back(llvm::ConstantExpr::getIntToPtr(
1612        llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
1613          ProtocolVersion), IdTy));
1614  Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
1615  Elements.push_back(ProtocolList);
1616  Elements.push_back(InstanceMethodList);
1617  Elements.push_back(ClassMethodList);
1618  Elements.push_back(OptionalInstanceMethodList);
1619  Elements.push_back(OptionalClassMethodList);
1620  Elements.push_back(PropertyList);
1621  Elements.push_back(OptionalPropertyList);
1622  ExistingProtocols[ProtocolName] =
1623    llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolTy, Elements,
1624          ".objc_protocol"), IdTy);
1625}
1626void CGObjCGNU::GenerateProtocolHolderCategory(void) {
1627  // Collect information about instance methods
1628  llvm::SmallVector<Selector, 1> MethodSels;
1629  llvm::SmallVector<llvm::Constant*, 1> MethodTypes;
1630
1631  std::vector<llvm::Constant*> Elements;
1632  const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack";
1633  const std::string CategoryName = "AnotherHack";
1634  Elements.push_back(MakeConstantString(CategoryName));
1635  Elements.push_back(MakeConstantString(ClassName));
1636  // Instance method list
1637  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1638          ClassName, CategoryName, MethodSels, MethodTypes, false), PtrTy));
1639  // Class method list
1640  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1641          ClassName, CategoryName, MethodSels, MethodTypes, true), PtrTy));
1642  // Protocol list
1643  llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrTy,
1644      ExistingProtocols.size());
1645  llvm::StructType *ProtocolListTy = llvm::StructType::get(VMContext,
1646      PtrTy, //Should be a recurisve pointer, but it's always NULL here.
1647      SizeTy,
1648      ProtocolArrayTy,
1649      NULL);
1650  std::vector<llvm::Constant*> ProtocolElements;
1651  for (llvm::StringMapIterator<llvm::Constant*> iter =
1652       ExistingProtocols.begin(), endIter = ExistingProtocols.end();
1653       iter != endIter ; iter++) {
1654    llvm::Constant *Ptr = llvm::ConstantExpr::getBitCast(iter->getValue(),
1655            PtrTy);
1656    ProtocolElements.push_back(Ptr);
1657  }
1658  llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1659      ProtocolElements);
1660  ProtocolElements.clear();
1661  ProtocolElements.push_back(NULLPtr);
1662  ProtocolElements.push_back(llvm::ConstantInt::get(LongTy,
1663              ExistingProtocols.size()));
1664  ProtocolElements.push_back(ProtocolArray);
1665  Elements.push_back(llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolListTy,
1666                  ProtocolElements, ".objc_protocol_list"), PtrTy));
1667  Categories.push_back(llvm::ConstantExpr::getBitCast(
1668        MakeGlobal(llvm::StructType::get(VMContext, PtrToInt8Ty, PtrToInt8Ty,
1669            PtrTy, PtrTy, PtrTy, NULL), Elements), PtrTy));
1670}
1671
1672void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
1673  std::string ClassName = OCD->getClassInterface()->getNameAsString();
1674  std::string CategoryName = OCD->getNameAsString();
1675  // Collect information about instance methods
1676  llvm::SmallVector<Selector, 16> InstanceMethodSels;
1677  llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
1678  for (ObjCCategoryImplDecl::instmeth_iterator
1679         iter = OCD->instmeth_begin(), endIter = OCD->instmeth_end();
1680       iter != endIter ; iter++) {
1681    InstanceMethodSels.push_back((*iter)->getSelector());
1682    std::string TypeStr;
1683    CGM.getContext().getObjCEncodingForMethodDecl(*iter,TypeStr);
1684    InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1685  }
1686
1687  // Collect information about class methods
1688  llvm::SmallVector<Selector, 16> ClassMethodSels;
1689  llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
1690  for (ObjCCategoryImplDecl::classmeth_iterator
1691         iter = OCD->classmeth_begin(), endIter = OCD->classmeth_end();
1692       iter != endIter ; iter++) {
1693    ClassMethodSels.push_back((*iter)->getSelector());
1694    std::string TypeStr;
1695    CGM.getContext().getObjCEncodingForMethodDecl(*iter,TypeStr);
1696    ClassMethodTypes.push_back(MakeConstantString(TypeStr));
1697  }
1698
1699  // Collect the names of referenced protocols
1700  llvm::SmallVector<std::string, 16> Protocols;
1701  const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl();
1702  const ObjCList<ObjCProtocolDecl> &Protos = CatDecl->getReferencedProtocols();
1703  for (ObjCList<ObjCProtocolDecl>::iterator I = Protos.begin(),
1704       E = Protos.end(); I != E; ++I)
1705    Protocols.push_back((*I)->getNameAsString());
1706
1707  std::vector<llvm::Constant*> Elements;
1708  Elements.push_back(MakeConstantString(CategoryName));
1709  Elements.push_back(MakeConstantString(ClassName));
1710  // Instance method list
1711  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1712          ClassName, CategoryName, InstanceMethodSels, InstanceMethodTypes,
1713          false), PtrTy));
1714  // Class method list
1715  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1716          ClassName, CategoryName, ClassMethodSels, ClassMethodTypes, true),
1717        PtrTy));
1718  // Protocol list
1719  Elements.push_back(llvm::ConstantExpr::getBitCast(
1720        GenerateProtocolList(Protocols), PtrTy));
1721  Categories.push_back(llvm::ConstantExpr::getBitCast(
1722        MakeGlobal(llvm::StructType::get(VMContext, PtrToInt8Ty, PtrToInt8Ty,
1723            PtrTy, PtrTy, PtrTy, NULL), Elements), PtrTy));
1724}
1725
1726llvm::Constant *CGObjCGNU::GeneratePropertyList(const ObjCImplementationDecl *OID,
1727        llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
1728        llvm::SmallVectorImpl<llvm::Constant*> &InstanceMethodTypes) {
1729  ASTContext &Context = CGM.getContext();
1730  //
1731  // Property metadata: name, attributes, isSynthesized, setter name, setter
1732  // types, getter name, getter types.
1733  llvm::StructType *PropertyMetadataTy = llvm::StructType::get(VMContext,
1734          PtrToInt8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty,
1735          PtrToInt8Ty, NULL);
1736  std::vector<llvm::Constant*> Properties;
1737
1738
1739  // Add all of the property methods need adding to the method list and to the
1740  // property metadata list.
1741  for (ObjCImplDecl::propimpl_iterator
1742         iter = OID->propimpl_begin(), endIter = OID->propimpl_end();
1743       iter != endIter ; iter++) {
1744    std::vector<llvm::Constant*> Fields;
1745    ObjCPropertyDecl *property = (*iter)->getPropertyDecl();
1746    ObjCPropertyImplDecl *propertyImpl = *iter;
1747    bool isSynthesized = (propertyImpl->getPropertyImplementation() ==
1748        ObjCPropertyImplDecl::Synthesize);
1749
1750    Fields.push_back(MakeConstantString(property->getNameAsString()));
1751    Fields.push_back(llvm::ConstantInt::get(Int8Ty,
1752                property->getPropertyAttributes()));
1753    Fields.push_back(llvm::ConstantInt::get(Int8Ty, isSynthesized));
1754    if (ObjCMethodDecl *getter = property->getGetterMethodDecl()) {
1755      std::string TypeStr;
1756      Context.getObjCEncodingForMethodDecl(getter,TypeStr);
1757      llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1758      if (isSynthesized) {
1759        InstanceMethodTypes.push_back(TypeEncoding);
1760        InstanceMethodSels.push_back(getter->getSelector());
1761      }
1762      Fields.push_back(MakeConstantString(getter->getSelector().getAsString()));
1763      Fields.push_back(TypeEncoding);
1764    } else {
1765      Fields.push_back(NULLPtr);
1766      Fields.push_back(NULLPtr);
1767    }
1768    if (ObjCMethodDecl *setter = property->getSetterMethodDecl()) {
1769      std::string TypeStr;
1770      Context.getObjCEncodingForMethodDecl(setter,TypeStr);
1771      llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1772      if (isSynthesized) {
1773        InstanceMethodTypes.push_back(TypeEncoding);
1774        InstanceMethodSels.push_back(setter->getSelector());
1775      }
1776      Fields.push_back(MakeConstantString(setter->getSelector().getAsString()));
1777      Fields.push_back(TypeEncoding);
1778    } else {
1779      Fields.push_back(NULLPtr);
1780      Fields.push_back(NULLPtr);
1781    }
1782    Properties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1783  }
1784  llvm::ArrayType *PropertyArrayTy =
1785      llvm::ArrayType::get(PropertyMetadataTy, Properties.size());
1786  llvm::Constant *PropertyArray = llvm::ConstantArray::get(PropertyArrayTy,
1787          Properties);
1788  llvm::Constant* PropertyListInitFields[] =
1789    {llvm::ConstantInt::get(IntTy, Properties.size()), NULLPtr, PropertyArray};
1790
1791  llvm::Constant *PropertyListInit =
1792      llvm::ConstantStruct::get(VMContext, PropertyListInitFields, 3, false);
1793  return new llvm::GlobalVariable(TheModule, PropertyListInit->getType(), false,
1794          llvm::GlobalValue::InternalLinkage, PropertyListInit,
1795          ".objc_property_list");
1796}
1797
1798void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
1799  ASTContext &Context = CGM.getContext();
1800
1801  // Get the superclass name.
1802  const ObjCInterfaceDecl * SuperClassDecl =
1803    OID->getClassInterface()->getSuperClass();
1804  std::string SuperClassName;
1805  if (SuperClassDecl) {
1806    SuperClassName = SuperClassDecl->getNameAsString();
1807    EmitClassRef(SuperClassName);
1808  }
1809
1810  // Get the class name
1811  ObjCInterfaceDecl *ClassDecl =
1812    const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
1813  std::string ClassName = ClassDecl->getNameAsString();
1814  // Emit the symbol that is used to generate linker errors if this class is
1815  // referenced in other modules but not declared.
1816  std::string classSymbolName = "__objc_class_name_" + ClassName;
1817  if (llvm::GlobalVariable *symbol =
1818      TheModule.getGlobalVariable(classSymbolName)) {
1819    symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
1820  } else {
1821    new llvm::GlobalVariable(TheModule, LongTy, false,
1822    llvm::GlobalValue::ExternalLinkage, llvm::ConstantInt::get(LongTy, 0),
1823    classSymbolName);
1824  }
1825
1826  // Get the size of instances.
1827  int instanceSize =
1828    Context.getASTObjCImplementationLayout(OID).getSize().getQuantity();
1829
1830  // Collect information about instance variables.
1831  llvm::SmallVector<llvm::Constant*, 16> IvarNames;
1832  llvm::SmallVector<llvm::Constant*, 16> IvarTypes;
1833  llvm::SmallVector<llvm::Constant*, 16> IvarOffsets;
1834
1835  std::vector<llvm::Constant*> IvarOffsetValues;
1836
1837  int superInstanceSize = !SuperClassDecl ? 0 :
1838    Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
1839  // For non-fragile ivars, set the instance size to 0 - {the size of just this
1840  // class}.  The runtime will then set this to the correct value on load.
1841  if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
1842    instanceSize = 0 - (instanceSize - superInstanceSize);
1843  }
1844
1845  // Collect declared and synthesized ivars.
1846  llvm::SmallVector<ObjCIvarDecl*, 16> OIvars;
1847  CGM.getContext().ShallowCollectObjCIvars(ClassDecl, OIvars);
1848
1849  for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
1850      ObjCIvarDecl *IVD = OIvars[i];
1851      // Store the name
1852      IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));
1853      // Get the type encoding for this ivar
1854      std::string TypeStr;
1855      Context.getObjCEncodingForType(IVD->getType(), TypeStr);
1856      IvarTypes.push_back(MakeConstantString(TypeStr));
1857      // Get the offset
1858      uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
1859      uint64_t Offset = BaseOffset;
1860      if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
1861        Offset = BaseOffset - superInstanceSize;
1862      }
1863      IvarOffsets.push_back(
1864          llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Offset));
1865      IvarOffsetValues.push_back(new llvm::GlobalVariable(TheModule, IntTy,
1866          false, llvm::GlobalValue::ExternalLinkage,
1867          llvm::ConstantInt::get(IntTy, Offset),
1868          "__objc_ivar_offset_value_" + ClassName +"." +
1869          IVD->getNameAsString()));
1870  }
1871  llvm::GlobalVariable *IvarOffsetArray =
1872    MakeGlobalArray(PtrToIntTy, IvarOffsetValues, ".ivar.offsets");
1873
1874
1875  // Collect information about instance methods
1876  llvm::SmallVector<Selector, 16> InstanceMethodSels;
1877  llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
1878  for (ObjCImplementationDecl::instmeth_iterator
1879         iter = OID->instmeth_begin(), endIter = OID->instmeth_end();
1880       iter != endIter ; iter++) {
1881    InstanceMethodSels.push_back((*iter)->getSelector());
1882    std::string TypeStr;
1883    Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
1884    InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1885  }
1886
1887  llvm::Constant *Properties = GeneratePropertyList(OID, InstanceMethodSels,
1888          InstanceMethodTypes);
1889
1890
1891  // Collect information about class methods
1892  llvm::SmallVector<Selector, 16> ClassMethodSels;
1893  llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
1894  for (ObjCImplementationDecl::classmeth_iterator
1895         iter = OID->classmeth_begin(), endIter = OID->classmeth_end();
1896       iter != endIter ; iter++) {
1897    ClassMethodSels.push_back((*iter)->getSelector());
1898    std::string TypeStr;
1899    Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
1900    ClassMethodTypes.push_back(MakeConstantString(TypeStr));
1901  }
1902  // Collect the names of referenced protocols
1903  llvm::SmallVector<std::string, 16> Protocols;
1904  const ObjCList<ObjCProtocolDecl> &Protos =ClassDecl->getReferencedProtocols();
1905  for (ObjCList<ObjCProtocolDecl>::iterator I = Protos.begin(),
1906       E = Protos.end(); I != E; ++I)
1907    Protocols.push_back((*I)->getNameAsString());
1908
1909
1910
1911  // Get the superclass pointer.
1912  llvm::Constant *SuperClass;
1913  if (!SuperClassName.empty()) {
1914    SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
1915  } else {
1916    SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);
1917  }
1918  // Empty vector used to construct empty method lists
1919  llvm::SmallVector<llvm::Constant*, 1>  empty;
1920  // Generate the method and instance variable lists
1921  llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
1922      InstanceMethodSels, InstanceMethodTypes, false);
1923  llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
1924      ClassMethodSels, ClassMethodTypes, true);
1925  llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
1926      IvarOffsets);
1927  // Irrespective of whether we are compiling for a fragile or non-fragile ABI,
1928  // we emit a symbol containing the offset for each ivar in the class.  This
1929  // allows code compiled for the non-Fragile ABI to inherit from code compiled
1930  // for the legacy ABI, without causing problems.  The converse is also
1931  // possible, but causes all ivar accesses to be fragile.
1932
1933  // Offset pointer for getting at the correct field in the ivar list when
1934  // setting up the alias.  These are: The base address for the global, the
1935  // ivar array (second field), the ivar in this list (set for each ivar), and
1936  // the offset (third field in ivar structure)
1937  const llvm::Type *IndexTy = llvm::Type::getInt32Ty(VMContext);
1938  llvm::Constant *offsetPointerIndexes[] = {Zeros[0],
1939      llvm::ConstantInt::get(IndexTy, 1), 0,
1940      llvm::ConstantInt::get(IndexTy, 2) };
1941
1942
1943  for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
1944      ObjCIvarDecl *IVD = OIvars[i];
1945      const std::string Name = "__objc_ivar_offset_" + ClassName + '.'
1946          + IVD->getNameAsString();
1947      offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, i);
1948      // Get the correct ivar field
1949      llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(
1950              IvarList, offsetPointerIndexes, 4);
1951      // Get the existing variable, if one exists.
1952      llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);
1953      if (offset) {
1954          offset->setInitializer(offsetValue);
1955          // If this is the real definition, change its linkage type so that
1956          // different modules will use this one, rather than their private
1957          // copy.
1958          offset->setLinkage(llvm::GlobalValue::ExternalLinkage);
1959      } else {
1960          // Add a new alias if there isn't one already.
1961          offset = new llvm::GlobalVariable(TheModule, offsetValue->getType(),
1962                  false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);
1963      }
1964  }
1965  //Generate metaclass for class methods
1966  llvm::Constant *MetaClassStruct = GenerateClassStructure(NULLPtr,
1967      NULLPtr, 0x12L, ClassName.c_str(), 0, Zeros[0], GenerateIvarList(
1968        empty, empty, empty), ClassMethodList, NULLPtr, NULLPtr, NULLPtr, true);
1969
1970  // Generate the class structure
1971  llvm::Constant *ClassStruct =
1972    GenerateClassStructure(MetaClassStruct, SuperClass, 0x11L,
1973                           ClassName.c_str(), 0,
1974      llvm::ConstantInt::get(LongTy, instanceSize), IvarList,
1975      MethodList, GenerateProtocolList(Protocols), IvarOffsetArray,
1976      Properties);
1977
1978  // Resolve the class aliases, if they exist.
1979  if (ClassPtrAlias) {
1980    ClassPtrAlias->replaceAllUsesWith(
1981        llvm::ConstantExpr::getBitCast(ClassStruct, IdTy));
1982    ClassPtrAlias->eraseFromParent();
1983    ClassPtrAlias = 0;
1984  }
1985  if (MetaClassPtrAlias) {
1986    MetaClassPtrAlias->replaceAllUsesWith(
1987        llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy));
1988    MetaClassPtrAlias->eraseFromParent();
1989    MetaClassPtrAlias = 0;
1990  }
1991
1992  // Add class structure to list to be added to the symtab later
1993  ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
1994  Classes.push_back(ClassStruct);
1995}
1996
1997
1998llvm::Function *CGObjCGNU::ModuleInitFunction() {
1999  // Only emit an ObjC load function if no Objective-C stuff has been called
2000  if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
2001      ExistingProtocols.empty() && SelectorTable.empty())
2002    return NULL;
2003
2004  // Add all referenced protocols to a category.
2005  GenerateProtocolHolderCategory();
2006
2007  const llvm::StructType *SelStructTy = dyn_cast<llvm::StructType>(
2008          SelectorTy->getElementType());
2009  const llvm::Type *SelStructPtrTy = SelectorTy;
2010  if (SelStructTy == 0) {
2011    SelStructTy = llvm::StructType::get(VMContext, PtrToInt8Ty,
2012                                        PtrToInt8Ty, NULL);
2013    SelStructPtrTy = llvm::PointerType::getUnqual(SelStructTy);
2014  }
2015
2016  // Name the ObjC types to make the IR a bit easier to read
2017  TheModule.addTypeName(".objc_selector", SelStructPtrTy);
2018  TheModule.addTypeName(".objc_id", IdTy);
2019  TheModule.addTypeName(".objc_imp", IMPTy);
2020
2021  std::vector<llvm::Constant*> Elements;
2022  llvm::Constant *Statics = NULLPtr;
2023  // Generate statics list:
2024  if (ConstantStrings.size()) {
2025    llvm::ArrayType *StaticsArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
2026        ConstantStrings.size() + 1);
2027    ConstantStrings.push_back(NULLPtr);
2028
2029    llvm::StringRef StringClass = CGM.getLangOptions().ObjCConstantStringClass;
2030
2031    if (StringClass.empty()) StringClass = "NXConstantString";
2032
2033    Elements.push_back(MakeConstantString(StringClass,
2034                ".objc_static_class_name"));
2035    Elements.push_back(llvm::ConstantArray::get(StaticsArrayTy,
2036       ConstantStrings));
2037    llvm::StructType *StaticsListTy =
2038      llvm::StructType::get(VMContext, PtrToInt8Ty, StaticsArrayTy, NULL);
2039    llvm::Type *StaticsListPtrTy =
2040      llvm::PointerType::getUnqual(StaticsListTy);
2041    Statics = MakeGlobal(StaticsListTy, Elements, ".objc_statics");
2042    llvm::ArrayType *StaticsListArrayTy =
2043      llvm::ArrayType::get(StaticsListPtrTy, 2);
2044    Elements.clear();
2045    Elements.push_back(Statics);
2046    Elements.push_back(llvm::Constant::getNullValue(StaticsListPtrTy));
2047    Statics = MakeGlobal(StaticsListArrayTy, Elements, ".objc_statics_ptr");
2048    Statics = llvm::ConstantExpr::getBitCast(Statics, PtrTy);
2049  }
2050  // Array of classes, categories, and constant objects
2051  llvm::ArrayType *ClassListTy = llvm::ArrayType::get(PtrToInt8Ty,
2052      Classes.size() + Categories.size()  + 2);
2053  llvm::StructType *SymTabTy = llvm::StructType::get(VMContext,
2054                                                     LongTy, SelStructPtrTy,
2055                                                     llvm::Type::getInt16Ty(VMContext),
2056                                                     llvm::Type::getInt16Ty(VMContext),
2057                                                     ClassListTy, NULL);
2058
2059  Elements.clear();
2060  // Pointer to an array of selectors used in this module.
2061  std::vector<llvm::Constant*> Selectors;
2062  std::vector<llvm::GlobalAlias*> SelectorAliases;
2063  for (SelectorMap::iterator iter = SelectorTable.begin(),
2064      iterEnd = SelectorTable.end(); iter != iterEnd ; ++iter) {
2065
2066    std::string SelNameStr = iter->first.getAsString();
2067    llvm::Constant *SelName = ExportUniqueString(SelNameStr, ".objc_sel_name");
2068
2069    llvm::SmallVectorImpl<TypedSelector> &Types = iter->second;
2070    for (llvm::SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
2071        e = Types.end() ; i!=e ; i++) {
2072
2073      llvm::Constant *SelectorTypeEncoding = NULLPtr;
2074      if (!i->first.empty())
2075        SelectorTypeEncoding = MakeConstantString(i->first, ".objc_sel_types");
2076
2077      Elements.push_back(SelName);
2078      Elements.push_back(SelectorTypeEncoding);
2079      Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
2080      Elements.clear();
2081
2082      // Store the selector alias for later replacement
2083      SelectorAliases.push_back(i->second);
2084    }
2085  }
2086  unsigned SelectorCount = Selectors.size();
2087  // NULL-terminate the selector list.  This should not actually be required,
2088  // because the selector list has a length field.  Unfortunately, the GCC
2089  // runtime decides to ignore the length field and expects a NULL terminator,
2090  // and GCC cooperates with this by always setting the length to 0.
2091  Elements.push_back(NULLPtr);
2092  Elements.push_back(NULLPtr);
2093  Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
2094  Elements.clear();
2095
2096  // Number of static selectors
2097  Elements.push_back(llvm::ConstantInt::get(LongTy, SelectorCount));
2098  llvm::Constant *SelectorList = MakeGlobalArray(SelStructTy, Selectors,
2099          ".objc_selector_list");
2100  Elements.push_back(llvm::ConstantExpr::getBitCast(SelectorList,
2101    SelStructPtrTy));
2102
2103  // Now that all of the static selectors exist, create pointers to them.
2104  for (unsigned int i=0 ; i<SelectorCount ; i++) {
2105
2106    llvm::Constant *Idxs[] = {Zeros[0],
2107      llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), i), Zeros[0]};
2108    // FIXME: We're generating redundant loads and stores here!
2109    llvm::Constant *SelPtr = llvm::ConstantExpr::getGetElementPtr(SelectorList,
2110        Idxs, 2);
2111    // If selectors are defined as an opaque type, cast the pointer to this
2112    // type.
2113    SelPtr = llvm::ConstantExpr::getBitCast(SelPtr, SelectorTy);
2114    SelectorAliases[i]->replaceAllUsesWith(SelPtr);
2115    SelectorAliases[i]->eraseFromParent();
2116  }
2117
2118  // Number of classes defined.
2119  Elements.push_back(llvm::ConstantInt::get(llvm::Type::getInt16Ty(VMContext),
2120        Classes.size()));
2121  // Number of categories defined
2122  Elements.push_back(llvm::ConstantInt::get(llvm::Type::getInt16Ty(VMContext),
2123        Categories.size()));
2124  // Create an array of classes, then categories, then static object instances
2125  Classes.insert(Classes.end(), Categories.begin(), Categories.end());
2126  //  NULL-terminated list of static object instances (mainly constant strings)
2127  Classes.push_back(Statics);
2128  Classes.push_back(NULLPtr);
2129  llvm::Constant *ClassList = llvm::ConstantArray::get(ClassListTy, Classes);
2130  Elements.push_back(ClassList);
2131  // Construct the symbol table
2132  llvm::Constant *SymTab= MakeGlobal(SymTabTy, Elements);
2133
2134  // The symbol table is contained in a module which has some version-checking
2135  // constants
2136  llvm::StructType * ModuleTy = llvm::StructType::get(VMContext, LongTy, LongTy,
2137      PtrToInt8Ty, llvm::PointerType::getUnqual(SymTabTy),
2138      (CGM.getLangOptions().getGCMode() == LangOptions::NonGC) ? NULL : IntTy,
2139      NULL);
2140  Elements.clear();
2141  // Runtime version, used for ABI compatibility checking.
2142  Elements.push_back(llvm::ConstantInt::get(LongTy, RuntimeVersion));
2143  // sizeof(ModuleTy)
2144  llvm::TargetData td(&TheModule);
2145  Elements.push_back(
2146    llvm::ConstantInt::get(LongTy,
2147                           td.getTypeSizeInBits(ModuleTy) /
2148                             CGM.getContext().getCharWidth()));
2149
2150  // The path to the source file where this module was declared
2151  SourceManager &SM = CGM.getContext().getSourceManager();
2152  const FileEntry *mainFile = SM.getFileEntryForID(SM.getMainFileID());
2153  std::string path =
2154    std::string(mainFile->getDir()->getName()) + '/' + mainFile->getName();
2155  Elements.push_back(MakeConstantString(path, ".objc_source_file_name"));
2156  Elements.push_back(SymTab);
2157
2158  switch (CGM.getLangOptions().getGCMode()) {
2159    case LangOptions::GCOnly:
2160        Elements.push_back(llvm::ConstantInt::get(IntTy, 2));
2161    case LangOptions::NonGC:
2162        break;
2163    case LangOptions::HybridGC:
2164        Elements.push_back(llvm::ConstantInt::get(IntTy, 1));
2165  }
2166
2167  llvm::Value *Module = MakeGlobal(ModuleTy, Elements);
2168
2169  // Create the load function calling the runtime entry point with the module
2170  // structure
2171  llvm::Function * LoadFunction = llvm::Function::Create(
2172      llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
2173      llvm::GlobalValue::InternalLinkage, ".objc_load_function",
2174      &TheModule);
2175  llvm::BasicBlock *EntryBB =
2176      llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
2177  CGBuilderTy Builder(VMContext);
2178  Builder.SetInsertPoint(EntryBB);
2179
2180  std::vector<const llvm::Type*> Params(1,
2181      llvm::PointerType::getUnqual(ModuleTy));
2182  llvm::Value *Register = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
2183        llvm::Type::getVoidTy(VMContext), Params, true), "__objc_exec_class");
2184  Builder.CreateCall(Register, Module);
2185  Builder.CreateRetVoid();
2186
2187  return LoadFunction;
2188}
2189
2190llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
2191                                          const ObjCContainerDecl *CD) {
2192  const ObjCCategoryImplDecl *OCD =
2193    dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext());
2194  llvm::StringRef CategoryName = OCD ? OCD->getName() : "";
2195  llvm::StringRef ClassName = CD->getName();
2196  Selector MethodName = OMD->getSelector();
2197  bool isClassMethod = !OMD->isInstanceMethod();
2198
2199  CodeGenTypes &Types = CGM.getTypes();
2200  const llvm::FunctionType *MethodTy =
2201    Types.GetFunctionType(Types.getFunctionInfo(OMD), OMD->isVariadic());
2202  std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
2203      MethodName, isClassMethod);
2204
2205  llvm::Function *Method
2206    = llvm::Function::Create(MethodTy,
2207                             llvm::GlobalValue::InternalLinkage,
2208                             FunctionName,
2209                             &TheModule);
2210  return Method;
2211}
2212
2213llvm::Function *CGObjCGNU::GetPropertyGetFunction() {
2214  return GetPropertyFn;
2215}
2216
2217llvm::Function *CGObjCGNU::GetPropertySetFunction() {
2218  return SetPropertyFn;
2219}
2220
2221llvm::Function *CGObjCGNU::GetGetStructFunction() {
2222  return GetStructPropertyFn;
2223}
2224llvm::Function *CGObjCGNU::GetSetStructFunction() {
2225  return SetStructPropertyFn;
2226}
2227
2228llvm::Constant *CGObjCGNU::EnumerationMutationFunction() {
2229  return EnumerationMutationFn;
2230}
2231
2232void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF,
2233                                     const ObjCAtSynchronizedStmt &S) {
2234  EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn);
2235}
2236
2237
2238void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF,
2239                            const ObjCAtTryStmt &S) {
2240  // Unlike the Apple non-fragile runtimes, which also uses
2241  // unwind-based zero cost exceptions, the GNU Objective C runtime's
2242  // EH support isn't a veneer over C++ EH.  Instead, exception
2243  // objects are created by __objc_exception_throw and destroyed by
2244  // the personality function; this avoids the need for bracketing
2245  // catch handlers with calls to __blah_begin_catch/__blah_end_catch
2246  // (or even _Unwind_DeleteException), but probably doesn't
2247  // interoperate very well with foreign exceptions.
2248  //
2249  // In Objective-C++ mode, we actually emit something equivalent to the C++
2250  // exception handler.
2251  EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn);
2252  return ;
2253}
2254
2255void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF,
2256                              const ObjCAtThrowStmt &S) {
2257  llvm::Value *ExceptionAsObject;
2258
2259  if (const Expr *ThrowExpr = S.getThrowExpr()) {
2260    llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr);
2261    ExceptionAsObject = Exception;
2262  } else {
2263    assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
2264           "Unexpected rethrow outside @catch block.");
2265    ExceptionAsObject = CGF.ObjCEHValueStack.back();
2266  }
2267  ExceptionAsObject =
2268      CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy, "tmp");
2269
2270  // Note: This may have to be an invoke, if we want to support constructs like:
2271  // @try {
2272  //  @throw(obj);
2273  // }
2274  // @catch(id) ...
2275  //
2276  // This is effectively turning @throw into an incredibly-expensive goto, but
2277  // it may happen as a result of inlining followed by missed optimizations, or
2278  // as a result of stupidity.
2279  llvm::BasicBlock *UnwindBB = CGF.getInvokeDest();
2280  if (!UnwindBB) {
2281    CGF.Builder.CreateCall(ExceptionThrowFn, ExceptionAsObject);
2282    CGF.Builder.CreateUnreachable();
2283  } else {
2284    CGF.Builder.CreateInvoke(ExceptionThrowFn, UnwindBB, UnwindBB, &ExceptionAsObject,
2285        &ExceptionAsObject+1);
2286  }
2287  // Clear the insertion point to indicate we are in unreachable code.
2288  CGF.Builder.ClearInsertionPoint();
2289}
2290
2291llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF,
2292                                          llvm::Value *AddrWeakObj) {
2293  CGBuilderTy B = CGF.Builder;
2294  AddrWeakObj = EnforceType(B, AddrWeakObj, IdTy);
2295  return B.CreateCall(WeakReadFn, AddrWeakObj);
2296}
2297
2298void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF,
2299                                   llvm::Value *src, llvm::Value *dst) {
2300  CGBuilderTy B = CGF.Builder;
2301  src = EnforceType(B, src, IdTy);
2302  dst = EnforceType(B, dst, PtrToIdTy);
2303  B.CreateCall2(WeakAssignFn, src, dst);
2304}
2305
2306void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF,
2307                                     llvm::Value *src, llvm::Value *dst,
2308                                     bool threadlocal) {
2309  CGBuilderTy B = CGF.Builder;
2310  src = EnforceType(B, src, IdTy);
2311  dst = EnforceType(B, dst, PtrToIdTy);
2312  if (!threadlocal)
2313    B.CreateCall2(GlobalAssignFn, src, dst);
2314  else
2315    // FIXME. Add threadloca assign API
2316    assert(false && "EmitObjCGlobalAssign - Threal Local API NYI");
2317}
2318
2319void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF,
2320                                   llvm::Value *src, llvm::Value *dst,
2321                                   llvm::Value *ivarOffset) {
2322  CGBuilderTy B = CGF.Builder;
2323  src = EnforceType(B, src, IdTy);
2324  dst = EnforceType(B, dst, PtrToIdTy);
2325  B.CreateCall3(IvarAssignFn, src, dst, ivarOffset);
2326}
2327
2328void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF,
2329                                         llvm::Value *src, llvm::Value *dst) {
2330  CGBuilderTy B = CGF.Builder;
2331  src = EnforceType(B, src, IdTy);
2332  dst = EnforceType(B, dst, PtrToIdTy);
2333  B.CreateCall2(StrongCastAssignFn, src, dst);
2334}
2335
2336void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF,
2337                                         llvm::Value *DestPtr,
2338                                         llvm::Value *SrcPtr,
2339                                         llvm::Value *Size) {
2340  CGBuilderTy B = CGF.Builder;
2341  DestPtr = EnforceType(B, DestPtr, IdTy);
2342  SrcPtr = EnforceType(B, SrcPtr, PtrToIdTy);
2343
2344  B.CreateCall3(MemMoveFn, DestPtr, SrcPtr, Size);
2345}
2346
2347llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(
2348                              const ObjCInterfaceDecl *ID,
2349                              const ObjCIvarDecl *Ivar) {
2350  const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
2351    + '.' + Ivar->getNameAsString();
2352  // Emit the variable and initialize it with what we think the correct value
2353  // is.  This allows code compiled with non-fragile ivars to work correctly
2354  // when linked against code which isn't (most of the time).
2355  llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
2356  if (!IvarOffsetPointer) {
2357    // This will cause a run-time crash if we accidentally use it.  A value of
2358    // 0 would seem more sensible, but will silently overwrite the isa pointer
2359    // causing a great deal of confusion.
2360    uint64_t Offset = -1;
2361    // We can't call ComputeIvarBaseOffset() here if we have the
2362    // implementation, because it will create an invalid ASTRecordLayout object
2363    // that we are then stuck with forever, so we only initialize the ivar
2364    // offset variable with a guess if we only have the interface.  The
2365    // initializer will be reset later anyway, when we are generating the class
2366    // description.
2367    if (!CGM.getContext().getObjCImplementation(
2368              const_cast<ObjCInterfaceDecl *>(ID)))
2369      Offset = ComputeIvarBaseOffset(CGM, ID, Ivar);
2370
2371    llvm::ConstantInt *OffsetGuess =
2372      llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Offset, "ivar");
2373    // Don't emit the guess in non-PIC code because the linker will not be able
2374    // to replace it with the real version for a library.  In non-PIC code you
2375    // must compile with the fragile ABI if you want to use ivars from a
2376    // GCC-compiled class.
2377    if (CGM.getLangOptions().PICLevel) {
2378      llvm::GlobalVariable *IvarOffsetGV = new llvm::GlobalVariable(TheModule,
2379            llvm::Type::getInt32Ty(VMContext), false,
2380            llvm::GlobalValue::PrivateLinkage, OffsetGuess, Name+".guess");
2381      IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
2382            IvarOffsetGV->getType(), false, llvm::GlobalValue::LinkOnceAnyLinkage,
2383            IvarOffsetGV, Name);
2384    } else {
2385      IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
2386              llvm::Type::getInt32PtrTy(VMContext), false,
2387              llvm::GlobalValue::ExternalLinkage, 0, Name);
2388    }
2389  }
2390  return IvarOffsetPointer;
2391}
2392
2393LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF,
2394                                       QualType ObjectTy,
2395                                       llvm::Value *BaseValue,
2396                                       const ObjCIvarDecl *Ivar,
2397                                       unsigned CVRQualifiers) {
2398  const ObjCInterfaceDecl *ID =
2399    ObjectTy->getAs<ObjCObjectType>()->getInterface();
2400  return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
2401                                  EmitIvarOffset(CGF, ID, Ivar));
2402}
2403
2404static const ObjCInterfaceDecl *FindIvarInterface(ASTContext &Context,
2405                                                  const ObjCInterfaceDecl *OID,
2406                                                  const ObjCIvarDecl *OIVD) {
2407  llvm::SmallVector<ObjCIvarDecl*, 16> Ivars;
2408  Context.ShallowCollectObjCIvars(OID, Ivars);
2409  for (unsigned k = 0, e = Ivars.size(); k != e; ++k) {
2410    if (OIVD == Ivars[k])
2411      return OID;
2412  }
2413
2414  // Otherwise check in the super class.
2415  if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
2416    return FindIvarInterface(Context, Super, OIVD);
2417
2418  return 0;
2419}
2420
2421llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF,
2422                         const ObjCInterfaceDecl *Interface,
2423                         const ObjCIvarDecl *Ivar) {
2424  if (CGM.getLangOptions().ObjCNonFragileABI) {
2425    Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar);
2426    return CGF.Builder.CreateZExtOrBitCast(
2427        CGF.Builder.CreateLoad(CGF.Builder.CreateLoad(
2428                ObjCIvarOffsetVariable(Interface, Ivar), false, "ivar")),
2429        PtrDiffTy);
2430  }
2431  uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar);
2432  return llvm::ConstantInt::get(PtrDiffTy, Offset, "ivar");
2433}
2434
2435CGObjCRuntime *
2436clang::CodeGen::CreateGNUObjCRuntime(CodeGenModule &CGM) {
2437  if (CGM.getLangOptions().ObjCNonFragileABI)
2438    return new CGObjCGNUstep(CGM);
2439  return new CGObjCGCC(CGM);
2440}
2441