blob: 7fd2d361224df9c1c94839abcb94d82c53dbeef8 [file] [log] [blame]
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001//===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
Chris Lattner0f984262008-03-01 08:50:34 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000010// This provides Objective-C code generation targetting the GNU runtime. The
11// class in this file generates structures used by the GNU Objective-C runtime
12// library. These structures are defined in objc/objc.h and objc/objc-api.h in
13// the GNU runtime distribution.
Chris Lattner0f984262008-03-01 08:50:34 +000014//
15//===----------------------------------------------------------------------===//
16
17#include "CGObjCRuntime.h"
Chris Lattnerdce14062008-06-26 04:19:03 +000018#include "CodeGenModule.h"
Daniel Dunbar8f2926b2008-08-23 03:46:30 +000019#include "CodeGenFunction.h"
John McCallf1549f62010-07-06 01:34:17 +000020#include "CGException.h"
Chris Lattner5dc08672009-05-08 00:11:50 +000021
Chris Lattnerdce14062008-06-26 04:19:03 +000022#include "clang/AST/ASTContext.h"
Daniel Dunbare91593e2008-08-11 04:54:23 +000023#include "clang/AST/Decl.h"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000024#include "clang/AST/DeclObjC.h"
Anders Carlsson19cc4ab2009-07-18 19:43:29 +000025#include "clang/AST/RecordLayout.h"
Chris Lattner16f00492009-04-26 01:32:48 +000026#include "clang/AST/StmtObjC.h"
Chris Lattner5dc08672009-05-08 00:11:50 +000027
28#include "llvm/Intrinsics.h"
Chris Lattner0f984262008-03-01 08:50:34 +000029#include "llvm/Module.h"
David Chisnallc6cd5fd2010-04-28 19:33:36 +000030#include "llvm/LLVMContext.h"
Chris Lattner0f984262008-03-01 08:50:34 +000031#include "llvm/ADT/SmallVector.h"
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000032#include "llvm/ADT/StringMap.h"
Daniel Dunbar7ded7f42008-08-15 22:20:32 +000033#include "llvm/Support/Compiler.h"
Daniel Dunbar7ded7f42008-08-15 22:20:32 +000034#include "llvm/Target/TargetData.h"
Chris Lattner5dc08672009-05-08 00:11:50 +000035
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000036#include <map>
Chris Lattnere160c9b2009-01-27 05:06:01 +000037
38
Chris Lattnerdce14062008-06-26 04:19:03 +000039using namespace clang;
Daniel Dunbar46f45b92008-09-09 01:06:48 +000040using namespace CodeGen;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000041using llvm::dyn_cast;
42
43// The version of the runtime that this class targets. Must match the version
44// in the runtime.
45static const int RuntimeVersion = 8;
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +000046static const int NonFragileRuntimeVersion = 9;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000047static const int ProtocolVersion = 2;
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +000048static const int NonFragileProtocolVersion = 3;
Chris Lattner0f984262008-03-01 08:50:34 +000049
Chris Lattner0f984262008-03-01 08:50:34 +000050namespace {
Chris Lattnerdce14062008-06-26 04:19:03 +000051class CGObjCGNU : public CodeGen::CGObjCRuntime {
Chris Lattner0f984262008-03-01 08:50:34 +000052private:
Chris Lattnerdce14062008-06-26 04:19:03 +000053 CodeGen::CodeGenModule &CGM;
Chris Lattner0f984262008-03-01 08:50:34 +000054 llvm::Module &TheModule;
Chris Lattnere160c9b2009-01-27 05:06:01 +000055 const llvm::PointerType *SelectorTy;
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +000056 const llvm::IntegerType *Int8Ty;
Chris Lattnere160c9b2009-01-27 05:06:01 +000057 const llvm::PointerType *PtrToInt8Ty;
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +000058 const llvm::FunctionType *IMPTy;
Chris Lattnere160c9b2009-01-27 05:06:01 +000059 const llvm::PointerType *IdTy;
David Chisnallef6e0f32010-02-03 15:59:02 +000060 const llvm::PointerType *PtrToIdTy;
John McCallead608a2010-02-26 00:48:12 +000061 CanQualType ASTIdTy;
Chris Lattnere160c9b2009-01-27 05:06:01 +000062 const llvm::IntegerType *IntTy;
63 const llvm::PointerType *PtrTy;
64 const llvm::IntegerType *LongTy;
65 const llvm::PointerType *PtrToIntTy;
Daniel Dunbar5efccb12009-05-04 15:31:17 +000066 llvm::GlobalAlias *ClassPtrAlias;
67 llvm::GlobalAlias *MetaClassPtrAlias;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000068 std::vector<llvm::Constant*> Classes;
69 std::vector<llvm::Constant*> Categories;
70 std::vector<llvm::Constant*> ConstantStrings;
David Chisnall48272a02010-01-27 12:49:23 +000071 llvm::StringMap<llvm::Constant*> ObjCStrings;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000072 llvm::Function *LoadFunction;
73 llvm::StringMap<llvm::Constant*> ExistingProtocols;
74 typedef std::pair<std::string, std::string> TypedSelector;
75 std::map<TypedSelector, llvm::GlobalAlias*> TypedSelectors;
76 llvm::StringMap<llvm::GlobalAlias*> UntypedSelectors;
David Chisnallef6e0f32010-02-03 15:59:02 +000077 // Selectors that we don't emit in GC mode
78 Selector RetainSel, ReleaseSel, AutoreleaseSel;
79 // Functions used for GC.
80 llvm::Constant *IvarAssignFn, *StrongCastAssignFn, *MemMoveFn, *WeakReadFn,
81 *WeakAssignFn, *GlobalAssignFn;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000082 // Some zeros used for GEPs in lots of places.
83 llvm::Constant *Zeros[2];
84 llvm::Constant *NULLPtr;
Owen Andersona1cf15f2009-07-14 23:10:40 +000085 llvm::LLVMContext &VMContext;
David Chisnallc6cd5fd2010-04-28 19:33:36 +000086 /// Metadata kind used to tie method lookups to message sends.
87 unsigned msgSendMDKind;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000088private:
89 llvm::Constant *GenerateIvarList(
90 const llvm::SmallVectorImpl<llvm::Constant *> &IvarNames,
91 const llvm::SmallVectorImpl<llvm::Constant *> &IvarTypes,
92 const llvm::SmallVectorImpl<llvm::Constant *> &IvarOffsets);
93 llvm::Constant *GenerateMethodList(const std::string &ClassName,
94 const std::string &CategoryName,
Mike Stump1eb44332009-09-09 15:08:12 +000095 const llvm::SmallVectorImpl<Selector> &MethodSels,
96 const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000097 bool isClassMethodList);
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +000098 llvm::Constant *GenerateEmptyProtocol(const std::string &ProtocolName);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +000099 llvm::Constant *GeneratePropertyList(const ObjCImplementationDecl *OID,
100 llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
101 llvm::SmallVectorImpl<llvm::Constant*> &InstanceMethodTypes);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000102 llvm::Constant *GenerateProtocolList(
103 const llvm::SmallVectorImpl<std::string> &Protocols);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000104 // To ensure that all protocols are seen by the runtime, we add a category on
105 // a class defined in the runtime, declaring no methods, but adopting the
106 // protocols.
107 void GenerateProtocolHolderCategory(void);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000108 llvm::Constant *GenerateClassStructure(
109 llvm::Constant *MetaClass,
110 llvm::Constant *SuperClass,
111 unsigned info,
Chris Lattnerd002cc62008-06-26 04:47:04 +0000112 const char *Name,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000113 llvm::Constant *Version,
114 llvm::Constant *InstanceSize,
115 llvm::Constant *IVars,
116 llvm::Constant *Methods,
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000117 llvm::Constant *Protocols,
118 llvm::Constant *IvarOffsets,
David Chisnall8c757f92010-04-28 14:29:56 +0000119 llvm::Constant *Properties,
120 bool isMeta=false);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000121 llvm::Constant *GenerateProtocolMethodList(
122 const llvm::SmallVectorImpl<llvm::Constant *> &MethodNames,
123 const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes);
124 llvm::Constant *MakeConstantString(const std::string &Str, const std::string
125 &Name="");
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000126 llvm::Constant *ExportUniqueString(const std::string &Str, const std::string
127 prefix);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000128 llvm::Constant *MakeGlobal(const llvm::StructType *Ty,
Benjamin Kramer74a8bbf2010-02-09 19:31:24 +0000129 std::vector<llvm::Constant*> &V, llvm::StringRef Name="",
David Chisnall41d63ed2010-01-08 00:14:31 +0000130 llvm::GlobalValue::LinkageTypes linkage=llvm::GlobalValue::InternalLinkage);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000131 llvm::Constant *MakeGlobal(const llvm::ArrayType *Ty,
Benjamin Kramer74a8bbf2010-02-09 19:31:24 +0000132 std::vector<llvm::Constant*> &V, llvm::StringRef Name="",
David Chisnall41d63ed2010-01-08 00:14:31 +0000133 llvm::GlobalValue::LinkageTypes linkage=llvm::GlobalValue::InternalLinkage);
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +0000134 llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
135 const ObjCIvarDecl *Ivar);
Chris Lattner2a8e4e12009-06-15 01:09:11 +0000136 void EmitClassRef(const std::string &className);
David Chisnallef6e0f32010-02-03 15:59:02 +0000137 llvm::Value* EnforceType(CGBuilderTy B, llvm::Value *V, const llvm::Type *Ty){
138 if (V->getType() == Ty) return V;
139 return B.CreateBitCast(V, Ty);
140 }
Chris Lattner0f984262008-03-01 08:50:34 +0000141public:
Chris Lattnerdce14062008-06-26 04:19:03 +0000142 CGObjCGNU(CodeGen::CodeGenModule &cgm);
David Chisnall0d13f6f2010-01-23 02:40:42 +0000143 virtual llvm::Constant *GenerateConstantString(const StringLiteral *);
Mike Stump1eb44332009-09-09 15:08:12 +0000144 virtual CodeGen::RValue
Daniel Dunbar8f2926b2008-08-23 03:46:30 +0000145 GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +0000146 ReturnValueSlot Return,
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000147 QualType ResultType,
148 Selector Sel,
Daniel Dunbarf56f1912008-08-25 08:19:24 +0000149 llvm::Value *Receiver,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000150 const CallArgList &CallArgs,
David Chisnallc6cd5fd2010-04-28 19:33:36 +0000151 const ObjCInterfaceDecl *Class,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000152 const ObjCMethodDecl *Method);
Mike Stump1eb44332009-09-09 15:08:12 +0000153 virtual CodeGen::RValue
Daniel Dunbar8f2926b2008-08-23 03:46:30 +0000154 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +0000155 ReturnValueSlot Return,
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000156 QualType ResultType,
157 Selector Sel,
Daniel Dunbarf56f1912008-08-25 08:19:24 +0000158 const ObjCInterfaceDecl *Class,
Fariborz Jahanian7ce77922009-02-28 20:07:56 +0000159 bool isCategoryImpl,
Daniel Dunbarf56f1912008-08-25 08:19:24 +0000160 llvm::Value *Receiver,
Daniel Dunbar19cd87e2008-08-30 03:02:31 +0000161 bool IsClassMessage,
Daniel Dunbard6c93d72009-09-17 04:01:22 +0000162 const CallArgList &CallArgs,
163 const ObjCMethodDecl *Method);
Daniel Dunbar45d196b2008-11-01 01:53:16 +0000164 virtual llvm::Value *GetClass(CGBuilderTy &Builder,
Daniel Dunbarddb2a3d2008-08-16 00:25:02 +0000165 const ObjCInterfaceDecl *OID);
Fariborz Jahanian03b29602010-06-17 19:56:20 +0000166 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
167 bool lval = false);
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +0000168 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, const ObjCMethodDecl
169 *Method);
Mike Stump1eb44332009-09-09 15:08:12 +0000170
171 virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
Fariborz Jahanian679a5022009-01-10 21:06:09 +0000172 const ObjCContainerDecl *CD);
Daniel Dunbar7ded7f42008-08-15 22:20:32 +0000173 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
174 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
Daniel Dunbar45d196b2008-11-01 01:53:16 +0000175 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +0000176 const ObjCProtocolDecl *PD);
177 virtual void GenerateProtocol(const ObjCProtocolDecl *PD);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000178 virtual llvm::Function *ModuleInitFunction();
Daniel Dunbar49f66022008-09-24 03:38:44 +0000179 virtual llvm::Function *GetPropertyGetFunction();
180 virtual llvm::Function *GetPropertySetFunction();
Fariborz Jahanian6cc59062010-04-12 18:18:10 +0000181 virtual llvm::Function *GetCopyStructFunction();
Daniel Dunbar309a4362009-07-24 07:40:24 +0000182 virtual llvm::Constant *EnumerationMutationFunction();
Mike Stump1eb44332009-09-09 15:08:12 +0000183
John McCallf1549f62010-07-06 01:34:17 +0000184 virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
185 const ObjCAtTryStmt &S);
186 virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
187 const ObjCAtSynchronizedStmt &S);
Anders Carlsson64d5d6c2008-09-09 10:04:29 +0000188 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
189 const ObjCAtThrowStmt &S);
Fariborz Jahanian3e283e32008-11-18 22:37:34 +0000190 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6dc23172008-11-18 21:45:40 +0000191 llvm::Value *AddrWeakObj);
Fariborz Jahanian3e283e32008-11-18 22:37:34 +0000192 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
193 llvm::Value *src, llvm::Value *dst);
Fariborz Jahanian58626502008-11-19 00:59:10 +0000194 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian021a7a62010-07-20 20:30:03 +0000195 llvm::Value *src, llvm::Value *dest,
196 bool threadlocal=false);
Fariborz Jahanian7eda8362008-11-20 19:23:36 +0000197 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000198 llvm::Value *src, llvm::Value *dest,
199 llvm::Value *ivarOffset);
Fariborz Jahanian58626502008-11-19 00:59:10 +0000200 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
201 llvm::Value *src, llvm::Value *dest);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +0000202 virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +0000203 llvm::Value *DestPtr,
Fariborz Jahanian082b02e2009-07-08 01:18:33 +0000204 llvm::Value *SrcPtr,
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000205 llvm::Value *Size);
Fariborz Jahanian598d3f62009-02-03 19:03:09 +0000206 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
207 QualType ObjectTy,
208 llvm::Value *BaseValue,
209 const ObjCIvarDecl *Ivar,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +0000210 unsigned CVRQualifiers);
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +0000211 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar2a031922009-04-22 05:08:15 +0000212 const ObjCInterfaceDecl *Interface,
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +0000213 const ObjCIvarDecl *Ivar);
Chris Lattner0f984262008-03-01 08:50:34 +0000214};
215} // end anonymous namespace
216
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000217
Chris Lattner2a8e4e12009-06-15 01:09:11 +0000218/// Emits a reference to a dummy variable which is emitted with each class.
219/// This ensures that a linker error will be generated when trying to link
220/// together modules where a referenced class is not defined.
Mike Stumpbb1c8602009-07-31 21:31:32 +0000221void CGObjCGNU::EmitClassRef(const std::string &className) {
Chris Lattner2a8e4e12009-06-15 01:09:11 +0000222 std::string symbolRef = "__objc_class_ref_" + className;
223 // Don't emit two copies of the same symbol
Mike Stumpbb1c8602009-07-31 21:31:32 +0000224 if (TheModule.getGlobalVariable(symbolRef))
225 return;
Chris Lattner2a8e4e12009-06-15 01:09:11 +0000226 std::string symbolName = "__objc_class_name_" + className;
227 llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);
228 if (!ClassSymbol) {
Owen Anderson1c431b32009-07-08 19:05:04 +0000229 ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
230 llvm::GlobalValue::ExternalLinkage, 0, symbolName);
Chris Lattner2a8e4e12009-06-15 01:09:11 +0000231 }
Owen Anderson1c431b32009-07-08 19:05:04 +0000232 new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true,
Chris Lattnerf35271b2009-08-05 05:25:18 +0000233 llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);
Chris Lattner2a8e4e12009-06-15 01:09:11 +0000234}
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000235
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000236static std::string SymbolNameForMethod(const std::string &ClassName, const
237 std::string &CategoryName, const std::string &MethodName, bool isClassMethod)
238{
David Chisnalld3467362010-01-14 14:08:19 +0000239 std::string MethodNameColonStripped = MethodName;
240 std::replace(MethodNameColonStripped.begin(), MethodNameColonStripped.end(),
241 ':', '_');
242 return std::string(isClassMethod ? "_c_" : "_i_") + ClassName + "_" +
243 CategoryName + "_" + MethodNameColonStripped;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000244}
David Chisnall87935a82010-05-08 20:58:05 +0000245static std::string MangleSelectorTypes(const std::string &TypeString) {
246 std::string Mangled = TypeString;
David Chisnall22b88272010-05-09 01:01:43 +0000247 // Simple mangling to avoid breaking when we mix JIT / static code.
248 // Not part of the ABI, subject to change without notice.
David Chisnall87935a82010-05-08 20:58:05 +0000249 std::replace(Mangled.begin(), Mangled.end(), '@', '_');
David Chisnall22b88272010-05-09 01:01:43 +0000250 std::replace(Mangled.begin(), Mangled.end(), ':', 'J');
251 std::replace(Mangled.begin(), Mangled.end(), '*', 'e');
252 std::replace(Mangled.begin(), Mangled.end(), '#', 'E');
253 std::replace(Mangled.begin(), Mangled.end(), ':', 'j');
254 std::replace(Mangled.begin(), Mangled.end(), '(', 'g');
255 std::replace(Mangled.begin(), Mangled.end(), ')', 'G');
256 std::replace(Mangled.begin(), Mangled.end(), '[', 'h');
257 std::replace(Mangled.begin(), Mangled.end(), ']', 'H');
David Chisnall87935a82010-05-08 20:58:05 +0000258 return Mangled;
259}
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000260
Chris Lattnerdce14062008-06-26 04:19:03 +0000261CGObjCGNU::CGObjCGNU(CodeGen::CodeGenModule &cgm)
Daniel Dunbar5efccb12009-05-04 15:31:17 +0000262 : CGM(cgm), TheModule(CGM.getModule()), ClassPtrAlias(0),
Owen Andersona1cf15f2009-07-14 23:10:40 +0000263 MetaClassPtrAlias(0), VMContext(cgm.getLLVMContext()) {
David Chisnallc6cd5fd2010-04-28 19:33:36 +0000264
265 msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend");
266
Chris Lattnere160c9b2009-01-27 05:06:01 +0000267 IntTy = cast<llvm::IntegerType>(
268 CGM.getTypes().ConvertType(CGM.getContext().IntTy));
269 LongTy = cast<llvm::IntegerType>(
270 CGM.getTypes().ConvertType(CGM.getContext().LongTy));
Mike Stump1eb44332009-09-09 15:08:12 +0000271
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000272 Int8Ty = llvm::Type::getInt8Ty(VMContext);
273 // C string type. Used in lots of places.
274 PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
275
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000276 Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000277 Zeros[1] = Zeros[0];
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000278 NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);
Chris Lattner391d77a2008-03-30 23:03:07 +0000279 // Get the selector Type.
David Chisnall0d13f6f2010-01-23 02:40:42 +0000280 QualType selTy = CGM.getContext().getObjCSelType();
281 if (QualType() == selTy) {
282 SelectorTy = PtrToInt8Ty;
283 } else {
284 SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
285 }
Chris Lattnere160c9b2009-01-27 05:06:01 +0000286
Owen Anderson96e0fc72009-07-29 22:16:19 +0000287 PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
Chris Lattner391d77a2008-03-30 23:03:07 +0000288 PtrTy = PtrToInt8Ty;
Mike Stump1eb44332009-09-09 15:08:12 +0000289
Chris Lattner391d77a2008-03-30 23:03:07 +0000290 // Object type
John McCallead608a2010-02-26 00:48:12 +0000291 ASTIdTy = CGM.getContext().getCanonicalType(CGM.getContext().getObjCIdType());
David Chisnall0d13f6f2010-01-23 02:40:42 +0000292 if (QualType() == ASTIdTy) {
293 IdTy = PtrToInt8Ty;
294 } else {
295 IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
296 }
David Chisnallef6e0f32010-02-03 15:59:02 +0000297 PtrToIdTy = llvm::PointerType::getUnqual(IdTy);
Mike Stump1eb44332009-09-09 15:08:12 +0000298
Chris Lattner391d77a2008-03-30 23:03:07 +0000299 // IMP type
300 std::vector<const llvm::Type*> IMPArgs;
301 IMPArgs.push_back(IdTy);
302 IMPArgs.push_back(SelectorTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000303 IMPTy = llvm::FunctionType::get(IdTy, IMPArgs, true);
David Chisnallef6e0f32010-02-03 15:59:02 +0000304
305 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) {
306 // Get selectors needed in GC mode
307 RetainSel = GetNullarySelector("retain", CGM.getContext());
308 ReleaseSel = GetNullarySelector("release", CGM.getContext());
309 AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext());
310
311 // Get functions needed in GC mode
312
313 // id objc_assign_ivar(id, id, ptrdiff_t);
314 std::vector<const llvm::Type*> Args(1, IdTy);
315 Args.push_back(PtrToIdTy);
316 // FIXME: ptrdiff_t
317 Args.push_back(LongTy);
318 llvm::FunctionType *FTy = llvm::FunctionType::get(IdTy, Args, false);
319 IvarAssignFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
320 // id objc_assign_strongCast (id, id*)
321 Args.pop_back();
322 FTy = llvm::FunctionType::get(IdTy, Args, false);
323 StrongCastAssignFn =
324 CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
325 // id objc_assign_global(id, id*);
326 FTy = llvm::FunctionType::get(IdTy, Args, false);
327 GlobalAssignFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
328 // id objc_assign_weak(id, id*);
329 FTy = llvm::FunctionType::get(IdTy, Args, false);
330 WeakAssignFn = CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
331 // id objc_read_weak(id*);
332 Args.clear();
333 Args.push_back(PtrToIdTy);
334 FTy = llvm::FunctionType::get(IdTy, Args, false);
335 WeakReadFn = CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
336 // void *objc_memmove_collectable(void*, void *, size_t);
337 Args.clear();
338 Args.push_back(PtrToInt8Ty);
339 Args.push_back(PtrToInt8Ty);
340 // FIXME: size_t
341 Args.push_back(LongTy);
342 FTy = llvm::FunctionType::get(IdTy, Args, false);
343 MemMoveFn = CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
344 }
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000345}
Mike Stumpbb1c8602009-07-31 21:31:32 +0000346
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000347// This has to perform the lookup every time, since posing and related
348// techniques can modify the name -> class mapping.
Daniel Dunbar45d196b2008-11-01 01:53:16 +0000349llvm::Value *CGObjCGNU::GetClass(CGBuilderTy &Builder,
Daniel Dunbarddb2a3d2008-08-16 00:25:02 +0000350 const ObjCInterfaceDecl *OID) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000351 llvm::Value *ClassName = CGM.GetAddrOfConstantCString(OID->getNameAsString());
David Chisnall41d63ed2010-01-08 00:14:31 +0000352 // With the incompatible ABI, this will need to be replaced with a direct
353 // reference to the class symbol. For the compatible nonfragile ABI we are
354 // still performing this lookup at run time but emitting the symbol for the
355 // class externally so that we can make the switch later.
Chris Lattner2a8e4e12009-06-15 01:09:11 +0000356 EmitClassRef(OID->getNameAsString());
Daniel Dunbarddb2a3d2008-08-16 00:25:02 +0000357 ClassName = Builder.CreateStructGEP(ClassName, 0);
358
Fariborz Jahanian26c82942009-03-30 18:02:14 +0000359 std::vector<const llvm::Type*> Params(1, PtrToInt8Ty);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000360 llvm::Constant *ClassLookupFn =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000361 CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy,
Fariborz Jahanian26c82942009-03-30 18:02:14 +0000362 Params,
363 true),
364 "objc_lookup_class");
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000365 return Builder.CreateCall(ClassLookupFn, ClassName);
Chris Lattner391d77a2008-03-30 23:03:07 +0000366}
367
Fariborz Jahanian03b29602010-06-17 19:56:20 +0000368llvm::Value *CGObjCGNU::GetSelector(CGBuilderTy &Builder, Selector Sel,
369 bool lval) {
Chris Lattner077bf5e2008-11-24 03:33:13 +0000370 llvm::GlobalAlias *&US = UntypedSelectors[Sel.getAsString()];
Chris Lattner8e67b632008-06-26 04:37:12 +0000371 if (US == 0)
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +0000372 US = new llvm::GlobalAlias(llvm::PointerType::getUnqual(SelectorTy),
David Chisnall0f436562009-08-17 16:35:33 +0000373 llvm::GlobalValue::PrivateLinkage,
374 ".objc_untyped_selector_alias"+Sel.getAsString(),
Chris Lattner8e67b632008-06-26 04:37:12 +0000375 NULL, &TheModule);
Fariborz Jahanian03b29602010-06-17 19:56:20 +0000376 if (lval)
377 return US;
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +0000378 return Builder.CreateLoad(US);
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000379}
380
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +0000381llvm::Value *CGObjCGNU::GetSelector(CGBuilderTy &Builder, const ObjCMethodDecl
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000382 *Method) {
383
384 std::string SelName = Method->getSelector().getAsString();
385 std::string SelTypes;
386 CGM.getContext().getObjCEncodingForMethodDecl(Method, SelTypes);
387 // Typed selectors
388 TypedSelector Selector = TypedSelector(SelName,
389 SelTypes);
390
391 // If it's already cached, return it.
Mike Stumpbb1c8602009-07-31 21:31:32 +0000392 if (TypedSelectors[Selector]) {
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +0000393 return Builder.CreateLoad(TypedSelectors[Selector]);
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000394 }
395
396 // If it isn't, cache it.
397 llvm::GlobalAlias *Sel = new llvm::GlobalAlias(
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +0000398 llvm::PointerType::getUnqual(SelectorTy),
David Chisnall0f436562009-08-17 16:35:33 +0000399 llvm::GlobalValue::PrivateLinkage, ".objc_selector_alias" + SelName,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000400 NULL, &TheModule);
401 TypedSelectors[Selector] = Sel;
402
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +0000403 return Builder.CreateLoad(Sel);
Chris Lattner8e67b632008-06-26 04:37:12 +0000404}
405
Chris Lattner5e7dcc62008-06-26 04:44:19 +0000406llvm::Constant *CGObjCGNU::MakeConstantString(const std::string &Str,
407 const std::string &Name) {
David Chisnall8a5a9aa2009-08-31 16:41:57 +0000408 llvm::Constant *ConstStr = CGM.GetAddrOfConstantCString(Str, Name.c_str());
Owen Anderson3c4972d2009-07-29 18:54:39 +0000409 return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000410}
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000411llvm::Constant *CGObjCGNU::ExportUniqueString(const std::string &Str,
412 const std::string prefix) {
413 std::string name = prefix + Str;
414 llvm::Constant *ConstStr = TheModule.getGlobalVariable(name);
415 if (!ConstStr) {
416 llvm::Constant *value = llvm::ConstantArray::get(VMContext, Str, true);
417 ConstStr = new llvm::GlobalVariable(TheModule, value->getType(), true,
418 llvm::GlobalValue::LinkOnceODRLinkage, value, prefix + Str);
419 }
420 return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
421}
Mike Stumpbb1c8602009-07-31 21:31:32 +0000422
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000423llvm::Constant *CGObjCGNU::MakeGlobal(const llvm::StructType *Ty,
Benjamin Kramer74a8bbf2010-02-09 19:31:24 +0000424 std::vector<llvm::Constant*> &V, llvm::StringRef Name,
David Chisnall41d63ed2010-01-08 00:14:31 +0000425 llvm::GlobalValue::LinkageTypes linkage) {
Owen Anderson08e25242009-07-27 22:29:56 +0000426 llvm::Constant *C = llvm::ConstantStruct::get(Ty, V);
Owen Anderson1c431b32009-07-08 19:05:04 +0000427 return new llvm::GlobalVariable(TheModule, Ty, false,
428 llvm::GlobalValue::InternalLinkage, C, Name);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000429}
Mike Stumpbb1c8602009-07-31 21:31:32 +0000430
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000431llvm::Constant *CGObjCGNU::MakeGlobal(const llvm::ArrayType *Ty,
Benjamin Kramer74a8bbf2010-02-09 19:31:24 +0000432 std::vector<llvm::Constant*> &V, llvm::StringRef Name,
David Chisnall41d63ed2010-01-08 00:14:31 +0000433 llvm::GlobalValue::LinkageTypes linkage) {
Owen Anderson7db6d832009-07-28 18:33:04 +0000434 llvm::Constant *C = llvm::ConstantArray::get(Ty, V);
Owen Anderson1c431b32009-07-08 19:05:04 +0000435 return new llvm::GlobalVariable(TheModule, Ty, false,
Mike Stumpbb1c8602009-07-31 21:31:32 +0000436 llvm::GlobalValue::InternalLinkage, C, Name);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000437}
438
439/// Generate an NSConstantString object.
David Chisnall0d13f6f2010-01-23 02:40:42 +0000440llvm::Constant *CGObjCGNU::GenerateConstantString(const StringLiteral *SL) {
David Chisnall48272a02010-01-27 12:49:23 +0000441
David Chisnall0d13f6f2010-01-23 02:40:42 +0000442 std::string Str(SL->getStrData(), SL->getByteLength());
443
David Chisnall48272a02010-01-27 12:49:23 +0000444 // Look for an existing one
445 llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
446 if (old != ObjCStrings.end())
447 return old->getValue();
448
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000449 std::vector<llvm::Constant*> Ivars;
450 Ivars.push_back(NULLPtr);
Chris Lattner13fd7e52008-06-21 21:44:18 +0000451 Ivars.push_back(MakeConstantString(Str));
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000452 Ivars.push_back(llvm::ConstantInt::get(IntTy, Str.size()));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000453 llvm::Constant *ObjCStr = MakeGlobal(
Owen Anderson47a434f2009-08-05 23:18:46 +0000454 llvm::StructType::get(VMContext, PtrToInt8Ty, PtrToInt8Ty, IntTy, NULL),
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000455 Ivars, ".objc_str");
David Chisnall48272a02010-01-27 12:49:23 +0000456 ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty);
457 ObjCStrings[Str] = ObjCStr;
458 ConstantStrings.push_back(ObjCStr);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000459 return ObjCStr;
460}
461
462///Generates a message send where the super is the receiver. This is a message
463///send to self with special delivery semantics indicating which class's method
464///should be called.
Daniel Dunbar8f2926b2008-08-23 03:46:30 +0000465CodeGen::RValue
466CGObjCGNU::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +0000467 ReturnValueSlot Return,
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000468 QualType ResultType,
469 Selector Sel,
Daniel Dunbarf56f1912008-08-25 08:19:24 +0000470 const ObjCInterfaceDecl *Class,
Fariborz Jahanian7ce77922009-02-28 20:07:56 +0000471 bool isCategoryImpl,
Daniel Dunbarf56f1912008-08-25 08:19:24 +0000472 llvm::Value *Receiver,
Daniel Dunbar19cd87e2008-08-30 03:02:31 +0000473 bool IsClassMessage,
Daniel Dunbard6c93d72009-09-17 04:01:22 +0000474 const CallArgList &CallArgs,
475 const ObjCMethodDecl *Method) {
David Chisnallef6e0f32010-02-03 15:59:02 +0000476 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) {
477 if (Sel == RetainSel || Sel == AutoreleaseSel) {
478 return RValue::get(Receiver);
479 }
480 if (Sel == ReleaseSel) {
481 return RValue::get(0);
482 }
483 }
David Chisnalldb831942010-05-01 12:37:16 +0000484
485 CGBuilderTy &Builder = CGF.Builder;
486 llvm::Value *cmd = GetSelector(Builder, Sel);
487
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +0000488
489 CallArgList ActualArgs;
490
491 ActualArgs.push_back(
David Chisnalldb831942010-05-01 12:37:16 +0000492 std::make_pair(RValue::get(Builder.CreateBitCast(Receiver, IdTy)),
David Chisnall0f436562009-08-17 16:35:33 +0000493 ASTIdTy));
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +0000494 ActualArgs.push_back(std::make_pair(RValue::get(cmd),
495 CGF.getContext().getObjCSelType()));
496 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
497
498 CodeGenTypes &Types = CGM.getTypes();
John McCall04a67a62010-02-05 21:31:56 +0000499 const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs,
Rafael Espindola264ba482010-03-30 20:24:48 +0000500 FunctionType::ExtInfo());
Daniel Dunbar67939662009-09-17 04:01:40 +0000501 const llvm::FunctionType *impType =
502 Types.GetFunctionType(FnInfo, Method ? Method->isVariadic() : false);
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +0000503
Daniel Dunbar5efccb12009-05-04 15:31:17 +0000504 llvm::Value *ReceiverClass = 0;
Chris Lattner48e6e7e2009-05-08 15:39:58 +0000505 if (isCategoryImpl) {
506 llvm::Constant *classLookupFunction = 0;
507 std::vector<const llvm::Type*> Params;
508 Params.push_back(PtrTy);
509 if (IsClassMessage) {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000510 classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
Chris Lattner48e6e7e2009-05-08 15:39:58 +0000511 IdTy, Params, true), "objc_get_meta_class");
512 } else {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000513 classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
Chris Lattner48e6e7e2009-05-08 15:39:58 +0000514 IdTy, Params, true), "objc_get_class");
Daniel Dunbar5efccb12009-05-04 15:31:17 +0000515 }
David Chisnalldb831942010-05-01 12:37:16 +0000516 ReceiverClass = Builder.CreateCall(classLookupFunction,
Chris Lattner48e6e7e2009-05-08 15:39:58 +0000517 MakeConstantString(Class->getNameAsString()));
Daniel Dunbar5efccb12009-05-04 15:31:17 +0000518 } else {
Chris Lattner48e6e7e2009-05-08 15:39:58 +0000519 // Set up global aliases for the metaclass or class pointer if they do not
520 // already exist. These will are forward-references which will be set to
Mike Stumpbb1c8602009-07-31 21:31:32 +0000521 // pointers to the class and metaclass structure created for the runtime
522 // load function. To send a message to super, we look up the value of the
Chris Lattner48e6e7e2009-05-08 15:39:58 +0000523 // super_class pointer from either the class or metaclass structure.
524 if (IsClassMessage) {
525 if (!MetaClassPtrAlias) {
526 MetaClassPtrAlias = new llvm::GlobalAlias(IdTy,
527 llvm::GlobalValue::InternalLinkage, ".objc_metaclass_ref" +
528 Class->getNameAsString(), NULL, &TheModule);
529 }
530 ReceiverClass = MetaClassPtrAlias;
531 } else {
532 if (!ClassPtrAlias) {
533 ClassPtrAlias = new llvm::GlobalAlias(IdTy,
534 llvm::GlobalValue::InternalLinkage, ".objc_class_ref" +
535 Class->getNameAsString(), NULL, &TheModule);
536 }
537 ReceiverClass = ClassPtrAlias;
Daniel Dunbar5efccb12009-05-04 15:31:17 +0000538 }
Chris Lattner71238f62009-04-25 23:19:45 +0000539 }
Daniel Dunbar5efccb12009-05-04 15:31:17 +0000540 // Cast the pointer to a simplified version of the class structure
David Chisnalldb831942010-05-01 12:37:16 +0000541 ReceiverClass = Builder.CreateBitCast(ReceiverClass,
Owen Anderson96e0fc72009-07-29 22:16:19 +0000542 llvm::PointerType::getUnqual(
Owen Anderson47a434f2009-08-05 23:18:46 +0000543 llvm::StructType::get(VMContext, IdTy, IdTy, NULL)));
Daniel Dunbar5efccb12009-05-04 15:31:17 +0000544 // Get the superclass pointer
David Chisnalldb831942010-05-01 12:37:16 +0000545 ReceiverClass = Builder.CreateStructGEP(ReceiverClass, 1);
Daniel Dunbar5efccb12009-05-04 15:31:17 +0000546 // Load the superclass pointer
David Chisnalldb831942010-05-01 12:37:16 +0000547 ReceiverClass = Builder.CreateLoad(ReceiverClass);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000548 // Construct the structure used to look up the IMP
Owen Anderson47a434f2009-08-05 23:18:46 +0000549 llvm::StructType *ObjCSuperTy = llvm::StructType::get(VMContext,
550 Receiver->getType(), IdTy, NULL);
David Chisnalldb831942010-05-01 12:37:16 +0000551 llvm::Value *ObjCSuper = Builder.CreateAlloca(ObjCSuperTy);
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +0000552
David Chisnalldb831942010-05-01 12:37:16 +0000553 Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
554 Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000555
556 // Get the IMP
Fariborz Jahanian26c82942009-03-30 18:02:14 +0000557 std::vector<const llvm::Type*> Params;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000558 Params.push_back(llvm::PointerType::getUnqual(ObjCSuperTy));
Fariborz Jahanian26c82942009-03-30 18:02:14 +0000559 Params.push_back(SelectorTy);
David Chisnalldb831942010-05-01 12:37:16 +0000560
561 llvm::Value *lookupArgs[] = {ObjCSuper, cmd};
562 llvm::Value *imp;
563
564 if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
565 // The lookup function returns a slot, which can be safely cached.
566 llvm::Type *SlotTy = llvm::StructType::get(VMContext, PtrTy, PtrTy, PtrTy,
567 IntTy, llvm::PointerType::getUnqual(impType), NULL);
568
569 llvm::Constant *lookupFunction =
570 CGM.CreateRuntimeFunction(llvm::FunctionType::get(
571 llvm::PointerType::getUnqual(SlotTy), Params, true),
572 "objc_slot_lookup_super");
573
574 llvm::CallInst *slot = Builder.CreateCall(lookupFunction, lookupArgs,
575 lookupArgs+2);
576 slot->setOnlyReadsMemory();
577
578 imp = Builder.CreateLoad(Builder.CreateStructGEP(slot, 4));
579 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000580 llvm::Constant *lookupFunction =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000581 CGM.CreateRuntimeFunction(llvm::FunctionType::get(
582 llvm::PointerType::getUnqual(impType), Params, true),
Fariborz Jahanian26c82942009-03-30 18:02:14 +0000583 "objc_msg_lookup_super");
David Chisnalldb831942010-05-01 12:37:16 +0000584 imp = Builder.CreateCall(lookupFunction, lookupArgs, lookupArgs+2);
585 }
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000586
David Chisnalldd5c98f2010-05-01 11:15:56 +0000587 llvm::Value *impMD[] = {
588 llvm::MDString::get(VMContext, Sel.getAsString()),
589 llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()),
590 llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), IsClassMessage)
591 };
592 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD, 3);
593
David Chisnall4b02afc2010-05-02 13:41:58 +0000594 llvm::Instruction *call;
John McCallef072fd2010-05-22 01:48:05 +0000595 RValue msgRet = CGF.EmitCall(FnInfo, imp, Return, ActualArgs,
David Chisnall4b02afc2010-05-02 13:41:58 +0000596 0, &call);
597 call->setMetadata(msgSendMDKind, node);
598 return msgRet;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000599}
600
Mike Stump1eb44332009-09-09 15:08:12 +0000601/// Generate code for a message send expression.
Daniel Dunbar8f2926b2008-08-23 03:46:30 +0000602CodeGen::RValue
603CGObjCGNU::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +0000604 ReturnValueSlot Return,
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000605 QualType ResultType,
606 Selector Sel,
Daniel Dunbarf56f1912008-08-25 08:19:24 +0000607 llvm::Value *Receiver,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000608 const CallArgList &CallArgs,
David Chisnallc6cd5fd2010-04-28 19:33:36 +0000609 const ObjCInterfaceDecl *Class,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000610 const ObjCMethodDecl *Method) {
David Chisnall664b7c72010-04-27 15:08:48 +0000611 // Strip out message sends to retain / release in GC mode
David Chisnallef6e0f32010-02-03 15:59:02 +0000612 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC) {
613 if (Sel == RetainSel || Sel == AutoreleaseSel) {
614 return RValue::get(Receiver);
615 }
616 if (Sel == ReleaseSel) {
617 return RValue::get(0);
618 }
619 }
David Chisnall664b7c72010-04-27 15:08:48 +0000620
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000621 CGBuilderTy &Builder = CGF.Builder;
David Chisnall664b7c72010-04-27 15:08:48 +0000622
623 // If the return type is something that goes in an integer register, the
624 // runtime will handle 0 returns. For other cases, we fill in the 0 value
625 // ourselves.
626 //
627 // The language spec says the result of this kind of message send is
628 // undefined, but lots of people seem to have forgotten to read that
629 // paragraph and insist on sending messages to nil that have structure
630 // returns. With GCC, this generates a random return value (whatever happens
631 // to be on the stack / in those registers at the time) on most platforms,
632 // and generates a SegV on SPARC. With LLVM it corrupts the stack.
633 bool isPointerSizedReturn = false;
Douglas Gregor9d3347a2010-06-16 00:35:25 +0000634 if (ResultType->isAnyPointerType() ||
635 ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType())
David Chisnall664b7c72010-04-27 15:08:48 +0000636 isPointerSizedReturn = true;
637
638 llvm::BasicBlock *startBB = 0;
639 llvm::BasicBlock *messageBB = 0;
David Chisnalla54da052010-05-20 13:45:48 +0000640 llvm::BasicBlock *continueBB = 0;
David Chisnall664b7c72010-04-27 15:08:48 +0000641
642 if (!isPointerSizedReturn) {
643 startBB = Builder.GetInsertBlock();
644 messageBB = CGF.createBasicBlock("msgSend");
David Chisnalla54da052010-05-20 13:45:48 +0000645 continueBB = CGF.createBasicBlock("continue");
David Chisnall664b7c72010-04-27 15:08:48 +0000646
647 llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,
648 llvm::Constant::getNullValue(Receiver->getType()));
David Chisnalla54da052010-05-20 13:45:48 +0000649 Builder.CreateCondBr(isNil, continueBB, messageBB);
David Chisnall664b7c72010-04-27 15:08:48 +0000650 CGF.EmitBlock(messageBB);
651 }
652
David Chisnall0f436562009-08-17 16:35:33 +0000653 IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000654 llvm::Value *cmd;
655 if (Method)
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000656 cmd = GetSelector(Builder, Method);
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +0000657 else
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000658 cmd = GetSelector(Builder, Sel);
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +0000659 CallArgList ActualArgs;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000660
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000661 Receiver = Builder.CreateBitCast(Receiver, IdTy);
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +0000662 ActualArgs.push_back(
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000663 std::make_pair(RValue::get(Receiver), ASTIdTy));
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +0000664 ActualArgs.push_back(std::make_pair(RValue::get(cmd),
665 CGF.getContext().getObjCSelType()));
666 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
667
668 CodeGenTypes &Types = CGM.getTypes();
John McCall04a67a62010-02-05 21:31:56 +0000669 const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs,
Rafael Espindola264ba482010-03-30 20:24:48 +0000670 FunctionType::ExtInfo());
Daniel Dunbar67939662009-09-17 04:01:40 +0000671 const llvm::FunctionType *impType =
672 Types.GetFunctionType(FnInfo, Method ? Method->isVariadic() : false);
Fariborz Jahanianb3716ef2009-02-04 20:31:19 +0000673
David Chisnall63e742b2010-05-01 12:56:56 +0000674 llvm::Value *impMD[] = {
675 llvm::MDString::get(VMContext, Sel.getAsString()),
676 llvm::MDString::get(VMContext, Class ? Class->getNameAsString() :""),
677 llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), Class!=0)
678 };
679 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD, 3);
680
681
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000682 llvm::Value *imp;
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000683 // For sender-aware dispatch, we pass the sender as the third argument to a
684 // lookup function. When sending messages from C code, the sender is nil.
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000685 // objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
686 if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
687
688 std::vector<const llvm::Type*> Params;
689 llvm::Value *ReceiverPtr = CGF.CreateTempAlloca(Receiver->getType());
690 Builder.CreateStore(Receiver, ReceiverPtr);
691 Params.push_back(ReceiverPtr->getType());
692 Params.push_back(SelectorTy);
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000693 llvm::Value *self;
Fariborz Jahanian26c82942009-03-30 18:02:14 +0000694
David Chisnallf69ea952010-07-21 15:28:28 +0000695 if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) {
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000696 self = CGF.LoadObjCSelf();
697 } else {
Owen Anderson03e20502009-07-30 23:11:26 +0000698 self = llvm::ConstantPointerNull::get(IdTy);
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000699 }
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000700
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000701 Params.push_back(self->getType());
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000702
703 // The lookup function returns a slot, which can be safely cached.
704 llvm::Type *SlotTy = llvm::StructType::get(VMContext, PtrTy, PtrTy, PtrTy,
705 IntTy, llvm::PointerType::getUnqual(impType), NULL);
Mike Stump1eb44332009-09-09 15:08:12 +0000706 llvm::Constant *lookupFunction =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000707 CGM.CreateRuntimeFunction(llvm::FunctionType::get(
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000708 llvm::PointerType::getUnqual(SlotTy), Params, true),
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000709 "objc_msg_lookup_sender");
710
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000711 // The lookup function is guaranteed not to capture the receiver pointer.
712 if (llvm::Function *LookupFn = dyn_cast<llvm::Function>(lookupFunction)) {
713 LookupFn->setDoesNotCapture(1);
714 }
715
David Chisnall866163b2010-04-30 13:36:12 +0000716 llvm::CallInst *slot =
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000717 Builder.CreateCall3(lookupFunction, ReceiverPtr, cmd, self);
David Chisnall866163b2010-04-30 13:36:12 +0000718 slot->setOnlyReadsMemory();
David Chisnall63e742b2010-05-01 12:56:56 +0000719 slot->setMetadata(msgSendMDKind, node);
David Chisnall866163b2010-04-30 13:36:12 +0000720
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000721 imp = Builder.CreateLoad(Builder.CreateStructGEP(slot, 4));
David Chisnallc6cd5fd2010-04-28 19:33:36 +0000722
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000723 // The lookup function may have changed the receiver, so make sure we use
724 // the new one.
David Chisnall41d0c7a2010-07-21 12:55:25 +0000725 ActualArgs[0] = std::make_pair(RValue::get(
726 Builder.CreateLoad(ReceiverPtr, true)), ASTIdTy);
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000727 } else {
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000728 std::vector<const llvm::Type*> Params;
729 Params.push_back(Receiver->getType());
730 Params.push_back(SelectorTy);
Mike Stump1eb44332009-09-09 15:08:12 +0000731 llvm::Constant *lookupFunction =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000732 CGM.CreateRuntimeFunction(llvm::FunctionType::get(
733 llvm::PointerType::getUnqual(impType), Params, true),
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000734 "objc_msg_lookup");
735
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000736 imp = Builder.CreateCall2(lookupFunction, Receiver, cmd);
David Chisnall63e742b2010-05-01 12:56:56 +0000737 cast<llvm::CallInst>(imp)->setMetadata(msgSendMDKind, node);
Fariborz Jahanian34e65772009-05-22 20:17:16 +0000738 }
David Chisnall4b02afc2010-05-02 13:41:58 +0000739 llvm::Instruction *call;
John McCallef072fd2010-05-22 01:48:05 +0000740 RValue msgRet = CGF.EmitCall(FnInfo, imp, Return, ActualArgs,
David Chisnall4b02afc2010-05-02 13:41:58 +0000741 0, &call);
742 call->setMetadata(msgSendMDKind, node);
David Chisnall664b7c72010-04-27 15:08:48 +0000743
David Chisnalla54da052010-05-20 13:45:48 +0000744
David Chisnall664b7c72010-04-27 15:08:48 +0000745 if (!isPointerSizedReturn) {
David Chisnalla54da052010-05-20 13:45:48 +0000746 messageBB = CGF.Builder.GetInsertBlock();
747 CGF.Builder.CreateBr(continueBB);
748 CGF.EmitBlock(continueBB);
David Chisnall664b7c72010-04-27 15:08:48 +0000749 if (msgRet.isScalar()) {
750 llvm::Value *v = msgRet.getScalarVal();
751 llvm::PHINode *phi = Builder.CreatePHI(v->getType());
752 phi->addIncoming(v, messageBB);
753 phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB);
754 msgRet = RValue::get(phi);
755 } else if (msgRet.isAggregate()) {
756 llvm::Value *v = msgRet.getAggregateAddr();
757 llvm::PHINode *phi = Builder.CreatePHI(v->getType());
758 const llvm::PointerType *RetTy = cast<llvm::PointerType>(v->getType());
David Chisnall866163b2010-04-30 13:36:12 +0000759 llvm::AllocaInst *NullVal =
760 CGF.CreateTempAlloca(RetTy->getElementType(), "null");
David Chisnall664b7c72010-04-27 15:08:48 +0000761 CGF.InitTempAlloca(NullVal,
762 llvm::Constant::getNullValue(RetTy->getElementType()));
763 phi->addIncoming(v, messageBB);
764 phi->addIncoming(NullVal, startBB);
765 msgRet = RValue::getAggregate(phi);
766 } else /* isComplex() */ {
767 std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal();
768 llvm::PHINode *phi = Builder.CreatePHI(v.first->getType());
769 phi->addIncoming(v.first, messageBB);
770 phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
771 startBB);
772 llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType());
773 phi2->addIncoming(v.second, messageBB);
774 phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
775 startBB);
776 msgRet = RValue::getComplex(phi, phi2);
777 }
778 }
779 return msgRet;
Chris Lattner0f984262008-03-01 08:50:34 +0000780}
781
Mike Stump1eb44332009-09-09 15:08:12 +0000782/// Generates a MethodList. Used in construction of a objc_class and
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000783/// objc_category structures.
784llvm::Constant *CGObjCGNU::GenerateMethodList(const std::string &ClassName,
Mike Stump1eb44332009-09-09 15:08:12 +0000785 const std::string &CategoryName,
786 const llvm::SmallVectorImpl<Selector> &MethodSels,
787 const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000788 bool isClassMethodList) {
David Chisnall0f436562009-08-17 16:35:33 +0000789 if (MethodSels.empty())
790 return NULLPtr;
Mike Stump1eb44332009-09-09 15:08:12 +0000791 // Get the method structure type.
Owen Anderson47a434f2009-08-05 23:18:46 +0000792 llvm::StructType *ObjCMethodTy = llvm::StructType::get(VMContext,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000793 PtrToInt8Ty, // Really a selector, but the runtime creates it us.
794 PtrToInt8Ty, // Method types
Owen Anderson96e0fc72009-07-29 22:16:19 +0000795 llvm::PointerType::getUnqual(IMPTy), //Method pointer
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000796 NULL);
797 std::vector<llvm::Constant*> Methods;
798 std::vector<llvm::Constant*> Elements;
799 for (unsigned int i = 0, e = MethodTypes.size(); i < e; ++i) {
800 Elements.clear();
Fariborz Jahanian1e64a952009-05-17 16:49:27 +0000801 if (llvm::Constant *Method =
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000802 TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
Chris Lattner077bf5e2008-11-24 03:33:13 +0000803 MethodSels[i].getAsString(),
Fariborz Jahanian1e64a952009-05-17 16:49:27 +0000804 isClassMethodList))) {
David Chisnall8a5a9aa2009-08-31 16:41:57 +0000805 llvm::Constant *C = MakeConstantString(MethodSels[i].getAsString());
806 Elements.push_back(C);
807 Elements.push_back(MethodTypes[i]);
Owen Anderson3c4972d2009-07-29 18:54:39 +0000808 Method = llvm::ConstantExpr::getBitCast(Method,
Owen Anderson96e0fc72009-07-29 22:16:19 +0000809 llvm::PointerType::getUnqual(IMPTy));
Fariborz Jahanian1e64a952009-05-17 16:49:27 +0000810 Elements.push_back(Method);
Owen Anderson08e25242009-07-27 22:29:56 +0000811 Methods.push_back(llvm::ConstantStruct::get(ObjCMethodTy, Elements));
Fariborz Jahanian1e64a952009-05-17 16:49:27 +0000812 }
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000813 }
814
815 // Array of method structures
Owen Anderson96e0fc72009-07-29 22:16:19 +0000816 llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodTy,
Fariborz Jahanian1e64a952009-05-17 16:49:27 +0000817 Methods.size());
Owen Anderson7db6d832009-07-28 18:33:04 +0000818 llvm::Constant *MethodArray = llvm::ConstantArray::get(ObjCMethodArrayTy,
Chris Lattnerfba67632008-06-26 04:52:29 +0000819 Methods);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000820
821 // Structure containing list pointer, array and array count
822 llvm::SmallVector<const llvm::Type*, 16> ObjCMethodListFields;
Owen Anderson8c8f69e2009-08-13 23:27:53 +0000823 llvm::PATypeHolder OpaqueNextTy = llvm::OpaqueType::get(VMContext);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000824 llvm::Type *NextPtrTy = llvm::PointerType::getUnqual(OpaqueNextTy);
Owen Anderson47a434f2009-08-05 23:18:46 +0000825 llvm::StructType *ObjCMethodListTy = llvm::StructType::get(VMContext,
Mike Stump1eb44332009-09-09 15:08:12 +0000826 NextPtrTy,
827 IntTy,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000828 ObjCMethodArrayTy,
829 NULL);
830 // Refine next pointer type to concrete type
831 llvm::cast<llvm::OpaqueType>(
832 OpaqueNextTy.get())->refineAbstractTypeTo(ObjCMethodListTy);
833 ObjCMethodListTy = llvm::cast<llvm::StructType>(OpaqueNextTy.get());
834
835 Methods.clear();
Owen Anderson03e20502009-07-30 23:11:26 +0000836 Methods.push_back(llvm::ConstantPointerNull::get(
Owen Anderson96e0fc72009-07-29 22:16:19 +0000837 llvm::PointerType::getUnqual(ObjCMethodListTy)));
Owen Anderson0032b272009-08-13 21:57:51 +0000838 Methods.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000839 MethodTypes.size()));
840 Methods.push_back(MethodArray);
Mike Stump1eb44332009-09-09 15:08:12 +0000841
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000842 // Create an instance of the structure
843 return MakeGlobal(ObjCMethodListTy, Methods, ".objc_method_list");
844}
845
846/// Generates an IvarList. Used in construction of a objc_class.
847llvm::Constant *CGObjCGNU::GenerateIvarList(
848 const llvm::SmallVectorImpl<llvm::Constant *> &IvarNames,
849 const llvm::SmallVectorImpl<llvm::Constant *> &IvarTypes,
850 const llvm::SmallVectorImpl<llvm::Constant *> &IvarOffsets) {
David Chisnall18044632009-11-16 19:05:54 +0000851 if (IvarNames.size() == 0)
852 return NULLPtr;
Mike Stump1eb44332009-09-09 15:08:12 +0000853 // Get the method structure type.
Owen Anderson47a434f2009-08-05 23:18:46 +0000854 llvm::StructType *ObjCIvarTy = llvm::StructType::get(VMContext,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000855 PtrToInt8Ty,
856 PtrToInt8Ty,
857 IntTy,
858 NULL);
859 std::vector<llvm::Constant*> Ivars;
860 std::vector<llvm::Constant*> Elements;
861 for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
862 Elements.clear();
David Chisnall8a5a9aa2009-08-31 16:41:57 +0000863 Elements.push_back(IvarNames[i]);
864 Elements.push_back(IvarTypes[i]);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000865 Elements.push_back(IvarOffsets[i]);
Owen Anderson08e25242009-07-27 22:29:56 +0000866 Ivars.push_back(llvm::ConstantStruct::get(ObjCIvarTy, Elements));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000867 }
868
869 // Array of method structures
Owen Anderson96e0fc72009-07-29 22:16:19 +0000870 llvm::ArrayType *ObjCIvarArrayTy = llvm::ArrayType::get(ObjCIvarTy,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000871 IvarNames.size());
872
Mike Stump1eb44332009-09-09 15:08:12 +0000873
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000874 Elements.clear();
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000875 Elements.push_back(llvm::ConstantInt::get(IntTy, (int)IvarNames.size()));
Owen Anderson7db6d832009-07-28 18:33:04 +0000876 Elements.push_back(llvm::ConstantArray::get(ObjCIvarArrayTy, Ivars));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000877 // Structure containing array and array count
Owen Anderson47a434f2009-08-05 23:18:46 +0000878 llvm::StructType *ObjCIvarListTy = llvm::StructType::get(VMContext, IntTy,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000879 ObjCIvarArrayTy,
880 NULL);
881
882 // Create an instance of the structure
883 return MakeGlobal(ObjCIvarListTy, Elements, ".objc_ivar_list");
884}
885
886/// Generate a class structure
887llvm::Constant *CGObjCGNU::GenerateClassStructure(
888 llvm::Constant *MetaClass,
889 llvm::Constant *SuperClass,
890 unsigned info,
Chris Lattnerd002cc62008-06-26 04:47:04 +0000891 const char *Name,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000892 llvm::Constant *Version,
893 llvm::Constant *InstanceSize,
894 llvm::Constant *IVars,
895 llvm::Constant *Methods,
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000896 llvm::Constant *Protocols,
897 llvm::Constant *IvarOffsets,
David Chisnall8c757f92010-04-28 14:29:56 +0000898 llvm::Constant *Properties,
899 bool isMeta) {
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000900 // Set up the class structure
901 // Note: Several of these are char*s when they should be ids. This is
902 // because the runtime performs this translation on load.
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000903 //
904 // Fields marked New ABI are part of the GNUstep runtime. We emit them
905 // anyway; the classes will still work with the GNU runtime, they will just
906 // be ignored.
Owen Anderson47a434f2009-08-05 23:18:46 +0000907 llvm::StructType *ClassTy = llvm::StructType::get(VMContext,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000908 PtrToInt8Ty, // class_pointer
909 PtrToInt8Ty, // super_class
910 PtrToInt8Ty, // name
911 LongTy, // version
912 LongTy, // info
913 LongTy, // instance_size
914 IVars->getType(), // ivars
915 Methods->getType(), // methods
Mike Stump1eb44332009-09-09 15:08:12 +0000916 // These are all filled in by the runtime, so we pretend
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000917 PtrTy, // dtable
918 PtrTy, // subclass_list
919 PtrTy, // sibling_class
920 PtrTy, // protocols
921 PtrTy, // gc_object_type
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000922 // New ABI:
923 LongTy, // abi_version
924 IvarOffsets->getType(), // ivar_offsets
925 Properties->getType(), // properties
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000926 NULL);
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000927 llvm::Constant *Zero = llvm::ConstantInt::get(LongTy, 0);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000928 // Fill in the structure
929 std::vector<llvm::Constant*> Elements;
Owen Anderson3c4972d2009-07-29 18:54:39 +0000930 Elements.push_back(llvm::ConstantExpr::getBitCast(MetaClass, PtrToInt8Ty));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000931 Elements.push_back(SuperClass);
Chris Lattnerd002cc62008-06-26 04:47:04 +0000932 Elements.push_back(MakeConstantString(Name, ".class_name"));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000933 Elements.push_back(Zero);
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000934 Elements.push_back(llvm::ConstantInt::get(LongTy, info));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000935 Elements.push_back(InstanceSize);
936 Elements.push_back(IVars);
937 Elements.push_back(Methods);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000938 Elements.push_back(NULLPtr);
939 Elements.push_back(NULLPtr);
940 Elements.push_back(NULLPtr);
Owen Anderson3c4972d2009-07-29 18:54:39 +0000941 Elements.push_back(llvm::ConstantExpr::getBitCast(Protocols, PtrTy));
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +0000942 Elements.push_back(NULLPtr);
943 Elements.push_back(Zero);
944 Elements.push_back(IvarOffsets);
945 Elements.push_back(Properties);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000946 // Create an instance of the structure
David Chisnall41d63ed2010-01-08 00:14:31 +0000947 // This is now an externally visible symbol, so that we can speed up class
948 // messages in the next ABI.
David Chisnall8c757f92010-04-28 14:29:56 +0000949 return MakeGlobal(ClassTy, Elements, (isMeta ? "_OBJC_METACLASS_":
950 "_OBJC_CLASS_") + std::string(Name), llvm::GlobalValue::ExternalLinkage);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000951}
952
953llvm::Constant *CGObjCGNU::GenerateProtocolMethodList(
954 const llvm::SmallVectorImpl<llvm::Constant *> &MethodNames,
955 const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes) {
Mike Stump1eb44332009-09-09 15:08:12 +0000956 // Get the method structure type.
Owen Anderson47a434f2009-08-05 23:18:46 +0000957 llvm::StructType *ObjCMethodDescTy = llvm::StructType::get(VMContext,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000958 PtrToInt8Ty, // Really a selector, but the runtime does the casting for us.
959 PtrToInt8Ty,
960 NULL);
961 std::vector<llvm::Constant*> Methods;
962 std::vector<llvm::Constant*> Elements;
963 for (unsigned int i = 0, e = MethodTypes.size() ; i < e ; i++) {
964 Elements.clear();
Mike Stump1eb44332009-09-09 15:08:12 +0000965 Elements.push_back(MethodNames[i]);
David Chisnall8a5a9aa2009-08-31 16:41:57 +0000966 Elements.push_back(MethodTypes[i]);
Owen Anderson08e25242009-07-27 22:29:56 +0000967 Methods.push_back(llvm::ConstantStruct::get(ObjCMethodDescTy, Elements));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000968 }
Owen Anderson96e0fc72009-07-29 22:16:19 +0000969 llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodDescTy,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000970 MethodNames.size());
Owen Anderson7db6d832009-07-28 18:33:04 +0000971 llvm::Constant *Array = llvm::ConstantArray::get(ObjCMethodArrayTy,
Mike Stumpbb1c8602009-07-31 21:31:32 +0000972 Methods);
Owen Anderson47a434f2009-08-05 23:18:46 +0000973 llvm::StructType *ObjCMethodDescListTy = llvm::StructType::get(VMContext,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000974 IntTy, ObjCMethodArrayTy, NULL);
975 Methods.clear();
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000976 Methods.push_back(llvm::ConstantInt::get(IntTy, MethodNames.size()));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000977 Methods.push_back(Array);
978 return MakeGlobal(ObjCMethodDescListTy, Methods, ".objc_method_list");
979}
Mike Stumpbb1c8602009-07-31 21:31:32 +0000980
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000981// Create the protocol list structure used in classes, categories and so on
982llvm::Constant *CGObjCGNU::GenerateProtocolList(
983 const llvm::SmallVectorImpl<std::string> &Protocols) {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000984 llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000985 Protocols.size());
Owen Anderson47a434f2009-08-05 23:18:46 +0000986 llvm::StructType *ProtocolListTy = llvm::StructType::get(VMContext,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000987 PtrTy, //Should be a recurisve pointer, but it's always NULL here.
988 LongTy,//FIXME: Should be size_t
989 ProtocolArrayTy,
990 NULL);
Mike Stump1eb44332009-09-09 15:08:12 +0000991 std::vector<llvm::Constant*> Elements;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +0000992 for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
993 iter != endIter ; iter++) {
David Chisnallff80fab2009-11-20 14:50:59 +0000994 llvm::Constant *protocol = 0;
995 llvm::StringMap<llvm::Constant*>::iterator value =
996 ExistingProtocols.find(*iter);
997 if (value == ExistingProtocols.end()) {
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +0000998 protocol = GenerateEmptyProtocol(*iter);
David Chisnallff80fab2009-11-20 14:50:59 +0000999 } else {
1000 protocol = value->getValue();
1001 }
Owen Anderson3c4972d2009-07-29 18:54:39 +00001002 llvm::Constant *Ptr = llvm::ConstantExpr::getBitCast(protocol,
Owen Andersona1cf15f2009-07-14 23:10:40 +00001003 PtrToInt8Ty);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001004 Elements.push_back(Ptr);
1005 }
Owen Anderson7db6d832009-07-28 18:33:04 +00001006 llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001007 Elements);
1008 Elements.clear();
1009 Elements.push_back(NULLPtr);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001010 Elements.push_back(llvm::ConstantInt::get(LongTy, Protocols.size()));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001011 Elements.push_back(ProtocolArray);
1012 return MakeGlobal(ProtocolListTy, Elements, ".objc_protocol_list");
1013}
1014
Mike Stump1eb44332009-09-09 15:08:12 +00001015llvm::Value *CGObjCGNU::GenerateProtocolRef(CGBuilderTy &Builder,
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001016 const ObjCProtocolDecl *PD) {
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001017 llvm::Value *protocol = ExistingProtocols[PD->getNameAsString()];
Mike Stump1eb44332009-09-09 15:08:12 +00001018 const llvm::Type *T =
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001019 CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType());
Owen Anderson96e0fc72009-07-29 22:16:19 +00001020 return Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001021}
1022
1023llvm::Constant *CGObjCGNU::GenerateEmptyProtocol(
1024 const std::string &ProtocolName) {
1025 llvm::SmallVector<std::string, 0> EmptyStringVector;
1026 llvm::SmallVector<llvm::Constant*, 0> EmptyConstantVector;
1027
1028 llvm::Constant *ProtocolList = GenerateProtocolList(EmptyStringVector);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001029 llvm::Constant *MethodList =
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001030 GenerateProtocolMethodList(EmptyConstantVector, EmptyConstantVector);
1031 // Protocols are objects containing lists of the methods implemented and
1032 // protocols adopted.
Owen Anderson47a434f2009-08-05 23:18:46 +00001033 llvm::StructType *ProtocolTy = llvm::StructType::get(VMContext, IdTy,
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001034 PtrToInt8Ty,
1035 ProtocolList->getType(),
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001036 MethodList->getType(),
1037 MethodList->getType(),
1038 MethodList->getType(),
1039 MethodList->getType(),
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001040 NULL);
Mike Stump1eb44332009-09-09 15:08:12 +00001041 std::vector<llvm::Constant*> Elements;
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001042 // The isa pointer must be set to a magic number so the runtime knows it's
1043 // the correct layout.
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001044 int Version = CGM.getContext().getLangOptions().ObjCNonFragileABI ?
1045 NonFragileProtocolVersion : ProtocolVersion;
Owen Anderson3c4972d2009-07-29 18:54:39 +00001046 Elements.push_back(llvm::ConstantExpr::getIntToPtr(
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001047 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Version), IdTy));
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001048 Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
1049 Elements.push_back(ProtocolList);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001050 Elements.push_back(MethodList);
1051 Elements.push_back(MethodList);
1052 Elements.push_back(MethodList);
1053 Elements.push_back(MethodList);
Fariborz Jahanianf8c4f542009-03-31 18:27:22 +00001054 return MakeGlobal(ProtocolTy, Elements, ".objc_protocol");
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001055}
1056
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001057void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
1058 ASTContext &Context = CGM.getContext();
Chris Lattner8ec03f52008-11-24 03:54:41 +00001059 std::string ProtocolName = PD->getNameAsString();
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001060 llvm::SmallVector<std::string, 16> Protocols;
1061 for (ObjCProtocolDecl::protocol_iterator PI = PD->protocol_begin(),
1062 E = PD->protocol_end(); PI != E; ++PI)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001063 Protocols.push_back((*PI)->getNameAsString());
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001064 llvm::SmallVector<llvm::Constant*, 16> InstanceMethodNames;
1065 llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001066 llvm::SmallVector<llvm::Constant*, 16> OptionalInstanceMethodNames;
1067 llvm::SmallVector<llvm::Constant*, 16> OptionalInstanceMethodTypes;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001068 for (ObjCProtocolDecl::instmeth_iterator iter = PD->instmeth_begin(),
1069 E = PD->instmeth_end(); iter != E; iter++) {
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001070 std::string TypeStr;
1071 Context.getObjCEncodingForMethodDecl(*iter, TypeStr);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001072 if ((*iter)->getImplementationControl() == ObjCMethodDecl::Optional) {
1073 InstanceMethodNames.push_back(
1074 MakeConstantString((*iter)->getSelector().getAsString()));
1075 InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1076 } else {
1077 OptionalInstanceMethodNames.push_back(
1078 MakeConstantString((*iter)->getSelector().getAsString()));
1079 OptionalInstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1080 }
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001081 }
1082 // Collect information about class methods:
1083 llvm::SmallVector<llvm::Constant*, 16> ClassMethodNames;
1084 llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001085 llvm::SmallVector<llvm::Constant*, 16> OptionalClassMethodNames;
1086 llvm::SmallVector<llvm::Constant*, 16> OptionalClassMethodTypes;
Mike Stump1eb44332009-09-09 15:08:12 +00001087 for (ObjCProtocolDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001088 iter = PD->classmeth_begin(), endIter = PD->classmeth_end();
1089 iter != endIter ; iter++) {
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001090 std::string TypeStr;
1091 Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001092 if ((*iter)->getImplementationControl() == ObjCMethodDecl::Optional) {
1093 ClassMethodNames.push_back(
1094 MakeConstantString((*iter)->getSelector().getAsString()));
1095 ClassMethodTypes.push_back(MakeConstantString(TypeStr));
1096 } else {
1097 OptionalClassMethodNames.push_back(
1098 MakeConstantString((*iter)->getSelector().getAsString()));
1099 OptionalClassMethodTypes.push_back(MakeConstantString(TypeStr));
1100 }
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001101 }
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001102
1103 llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
1104 llvm::Constant *InstanceMethodList =
1105 GenerateProtocolMethodList(InstanceMethodNames, InstanceMethodTypes);
1106 llvm::Constant *ClassMethodList =
1107 GenerateProtocolMethodList(ClassMethodNames, ClassMethodTypes);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001108 llvm::Constant *OptionalInstanceMethodList =
1109 GenerateProtocolMethodList(OptionalInstanceMethodNames,
1110 OptionalInstanceMethodTypes);
1111 llvm::Constant *OptionalClassMethodList =
1112 GenerateProtocolMethodList(OptionalClassMethodNames,
1113 OptionalClassMethodTypes);
1114
1115 // Property metadata: name, attributes, isSynthesized, setter name, setter
1116 // types, getter name, getter types.
1117 // The isSynthesized value is always set to 0 in a protocol. It exists to
1118 // simplify the runtime library by allowing it to use the same data
1119 // structures for protocol metadata everywhere.
1120 llvm::StructType *PropertyMetadataTy = llvm::StructType::get(VMContext,
1121 PtrToInt8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty,
1122 PtrToInt8Ty, NULL);
1123 std::vector<llvm::Constant*> Properties;
1124 std::vector<llvm::Constant*> OptionalProperties;
1125
1126 // Add all of the property methods need adding to the method list and to the
1127 // property metadata list.
1128 for (ObjCContainerDecl::prop_iterator
1129 iter = PD->prop_begin(), endIter = PD->prop_end();
1130 iter != endIter ; iter++) {
1131 std::vector<llvm::Constant*> Fields;
1132 ObjCPropertyDecl *property = (*iter);
1133
1134 Fields.push_back(MakeConstantString(property->getNameAsString()));
1135 Fields.push_back(llvm::ConstantInt::get(Int8Ty,
1136 property->getPropertyAttributes()));
1137 Fields.push_back(llvm::ConstantInt::get(Int8Ty, 0));
1138 if (ObjCMethodDecl *getter = property->getGetterMethodDecl()) {
1139 std::string TypeStr;
1140 Context.getObjCEncodingForMethodDecl(getter,TypeStr);
1141 llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1142 InstanceMethodTypes.push_back(TypeEncoding);
1143 Fields.push_back(MakeConstantString(getter->getSelector().getAsString()));
1144 Fields.push_back(TypeEncoding);
1145 } else {
1146 Fields.push_back(NULLPtr);
1147 Fields.push_back(NULLPtr);
1148 }
1149 if (ObjCMethodDecl *setter = property->getSetterMethodDecl()) {
1150 std::string TypeStr;
1151 Context.getObjCEncodingForMethodDecl(setter,TypeStr);
1152 llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1153 InstanceMethodTypes.push_back(TypeEncoding);
1154 Fields.push_back(MakeConstantString(setter->getSelector().getAsString()));
1155 Fields.push_back(TypeEncoding);
1156 } else {
1157 Fields.push_back(NULLPtr);
1158 Fields.push_back(NULLPtr);
1159 }
1160 if (property->getPropertyImplementation() == ObjCPropertyDecl::Optional) {
1161 OptionalProperties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1162 } else {
1163 Properties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1164 }
1165 }
1166 llvm::Constant *PropertyArray = llvm::ConstantArray::get(
1167 llvm::ArrayType::get(PropertyMetadataTy, Properties.size()), Properties);
1168 llvm::Constant* PropertyListInitFields[] =
1169 {llvm::ConstantInt::get(IntTy, Properties.size()), NULLPtr, PropertyArray};
1170
1171 llvm::Constant *PropertyListInit =
Nick Lewycky0d36dd22009-09-19 20:00:52 +00001172 llvm::ConstantStruct::get(VMContext, PropertyListInitFields, 3, false);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001173 llvm::Constant *PropertyList = new llvm::GlobalVariable(TheModule,
1174 PropertyListInit->getType(), false, llvm::GlobalValue::InternalLinkage,
1175 PropertyListInit, ".objc_property_list");
1176
1177 llvm::Constant *OptionalPropertyArray =
1178 llvm::ConstantArray::get(llvm::ArrayType::get(PropertyMetadataTy,
1179 OptionalProperties.size()) , OptionalProperties);
1180 llvm::Constant* OptionalPropertyListInitFields[] = {
1181 llvm::ConstantInt::get(IntTy, OptionalProperties.size()), NULLPtr,
1182 OptionalPropertyArray };
1183
1184 llvm::Constant *OptionalPropertyListInit =
Nick Lewycky0d36dd22009-09-19 20:00:52 +00001185 llvm::ConstantStruct::get(VMContext, OptionalPropertyListInitFields, 3, false);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001186 llvm::Constant *OptionalPropertyList = new llvm::GlobalVariable(TheModule,
1187 OptionalPropertyListInit->getType(), false,
1188 llvm::GlobalValue::InternalLinkage, OptionalPropertyListInit,
1189 ".objc_property_list");
1190
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001191 // Protocols are objects containing lists of the methods implemented and
1192 // protocols adopted.
Owen Anderson47a434f2009-08-05 23:18:46 +00001193 llvm::StructType *ProtocolTy = llvm::StructType::get(VMContext, IdTy,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001194 PtrToInt8Ty,
1195 ProtocolList->getType(),
1196 InstanceMethodList->getType(),
1197 ClassMethodList->getType(),
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001198 OptionalInstanceMethodList->getType(),
1199 OptionalClassMethodList->getType(),
1200 PropertyList->getType(),
1201 OptionalPropertyList->getType(),
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001202 NULL);
Mike Stump1eb44332009-09-09 15:08:12 +00001203 std::vector<llvm::Constant*> Elements;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001204 // The isa pointer must be set to a magic number so the runtime knows it's
1205 // the correct layout.
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001206 int Version = CGM.getContext().getLangOptions().ObjCNonFragileABI ?
1207 NonFragileProtocolVersion : ProtocolVersion;
Owen Anderson3c4972d2009-07-29 18:54:39 +00001208 Elements.push_back(llvm::ConstantExpr::getIntToPtr(
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001209 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Version), IdTy));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001210 Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
1211 Elements.push_back(ProtocolList);
1212 Elements.push_back(InstanceMethodList);
1213 Elements.push_back(ClassMethodList);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001214 Elements.push_back(OptionalInstanceMethodList);
1215 Elements.push_back(OptionalClassMethodList);
1216 Elements.push_back(PropertyList);
1217 Elements.push_back(OptionalPropertyList);
Mike Stump1eb44332009-09-09 15:08:12 +00001218 ExistingProtocols[ProtocolName] =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001219 llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolTy, Elements,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001220 ".objc_protocol"), IdTy);
1221}
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001222void CGObjCGNU::GenerateProtocolHolderCategory(void) {
1223 // Collect information about instance methods
1224 llvm::SmallVector<Selector, 1> MethodSels;
1225 llvm::SmallVector<llvm::Constant*, 1> MethodTypes;
1226
1227 std::vector<llvm::Constant*> Elements;
1228 const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack";
1229 const std::string CategoryName = "AnotherHack";
1230 Elements.push_back(MakeConstantString(CategoryName));
1231 Elements.push_back(MakeConstantString(ClassName));
1232 // Instance method list
1233 Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1234 ClassName, CategoryName, MethodSels, MethodTypes, false), PtrTy));
1235 // Class method list
1236 Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1237 ClassName, CategoryName, MethodSels, MethodTypes, true), PtrTy));
1238 // Protocol list
1239 llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrTy,
1240 ExistingProtocols.size());
1241 llvm::StructType *ProtocolListTy = llvm::StructType::get(VMContext,
1242 PtrTy, //Should be a recurisve pointer, but it's always NULL here.
1243 LongTy,//FIXME: Should be size_t
1244 ProtocolArrayTy,
1245 NULL);
1246 std::vector<llvm::Constant*> ProtocolElements;
1247 for (llvm::StringMapIterator<llvm::Constant*> iter =
1248 ExistingProtocols.begin(), endIter = ExistingProtocols.end();
1249 iter != endIter ; iter++) {
1250 llvm::Constant *Ptr = llvm::ConstantExpr::getBitCast(iter->getValue(),
1251 PtrTy);
1252 ProtocolElements.push_back(Ptr);
1253 }
1254 llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1255 ProtocolElements);
1256 ProtocolElements.clear();
1257 ProtocolElements.push_back(NULLPtr);
1258 ProtocolElements.push_back(llvm::ConstantInt::get(LongTy,
1259 ExistingProtocols.size()));
1260 ProtocolElements.push_back(ProtocolArray);
1261 Elements.push_back(llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolListTy,
1262 ProtocolElements, ".objc_protocol_list"), PtrTy));
1263 Categories.push_back(llvm::ConstantExpr::getBitCast(
1264 MakeGlobal(llvm::StructType::get(VMContext, PtrToInt8Ty, PtrToInt8Ty,
1265 PtrTy, PtrTy, PtrTy, NULL), Elements), PtrTy));
1266}
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001267
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001268void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
Chris Lattner8ec03f52008-11-24 03:54:41 +00001269 std::string ClassName = OCD->getClassInterface()->getNameAsString();
1270 std::string CategoryName = OCD->getNameAsString();
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001271 // Collect information about instance methods
1272 llvm::SmallVector<Selector, 16> InstanceMethodSels;
1273 llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
Douglas Gregor653f1b12009-04-23 01:02:12 +00001274 for (ObjCCategoryImplDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001275 iter = OCD->instmeth_begin(), endIter = OCD->instmeth_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00001276 iter != endIter ; iter++) {
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001277 InstanceMethodSels.push_back((*iter)->getSelector());
1278 std::string TypeStr;
1279 CGM.getContext().getObjCEncodingForMethodDecl(*iter,TypeStr);
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001280 InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001281 }
1282
1283 // Collect information about class methods
1284 llvm::SmallVector<Selector, 16> ClassMethodSels;
1285 llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
Mike Stump1eb44332009-09-09 15:08:12 +00001286 for (ObjCCategoryImplDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001287 iter = OCD->classmeth_begin(), endIter = OCD->classmeth_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00001288 iter != endIter ; iter++) {
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001289 ClassMethodSels.push_back((*iter)->getSelector());
1290 std::string TypeStr;
1291 CGM.getContext().getObjCEncodingForMethodDecl(*iter,TypeStr);
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001292 ClassMethodTypes.push_back(MakeConstantString(TypeStr));
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001293 }
1294
1295 // Collect the names of referenced protocols
1296 llvm::SmallVector<std::string, 16> Protocols;
David Chisnallad9e06d2010-03-13 22:20:45 +00001297 const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl();
1298 const ObjCList<ObjCProtocolDecl> &Protos = CatDecl->getReferencedProtocols();
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001299 for (ObjCList<ObjCProtocolDecl>::iterator I = Protos.begin(),
1300 E = Protos.end(); I != E; ++I)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001301 Protocols.push_back((*I)->getNameAsString());
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001302
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001303 std::vector<llvm::Constant*> Elements;
1304 Elements.push_back(MakeConstantString(CategoryName));
1305 Elements.push_back(MakeConstantString(ClassName));
Mike Stump1eb44332009-09-09 15:08:12 +00001306 // Instance method list
Owen Anderson3c4972d2009-07-29 18:54:39 +00001307 Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
Chris Lattnera4210072008-06-26 05:08:00 +00001308 ClassName, CategoryName, InstanceMethodSels, InstanceMethodTypes,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001309 false), PtrTy));
1310 // Class method list
Owen Anderson3c4972d2009-07-29 18:54:39 +00001311 Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
Chris Lattnera4210072008-06-26 05:08:00 +00001312 ClassName, CategoryName, ClassMethodSels, ClassMethodTypes, true),
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001313 PtrTy));
1314 // Protocol list
Owen Anderson3c4972d2009-07-29 18:54:39 +00001315 Elements.push_back(llvm::ConstantExpr::getBitCast(
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001316 GenerateProtocolList(Protocols), PtrTy));
Owen Anderson3c4972d2009-07-29 18:54:39 +00001317 Categories.push_back(llvm::ConstantExpr::getBitCast(
Mike Stump1eb44332009-09-09 15:08:12 +00001318 MakeGlobal(llvm::StructType::get(VMContext, PtrToInt8Ty, PtrToInt8Ty,
Owen Anderson47a434f2009-08-05 23:18:46 +00001319 PtrTy, PtrTy, PtrTy, NULL), Elements), PtrTy));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001320}
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001321
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001322llvm::Constant *CGObjCGNU::GeneratePropertyList(const ObjCImplementationDecl *OID,
1323 llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
1324 llvm::SmallVectorImpl<llvm::Constant*> &InstanceMethodTypes) {
1325 ASTContext &Context = CGM.getContext();
1326 //
1327 // Property metadata: name, attributes, isSynthesized, setter name, setter
1328 // types, getter name, getter types.
1329 llvm::StructType *PropertyMetadataTy = llvm::StructType::get(VMContext,
1330 PtrToInt8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty,
1331 PtrToInt8Ty, NULL);
1332 std::vector<llvm::Constant*> Properties;
1333
1334
1335 // Add all of the property methods need adding to the method list and to the
1336 // property metadata list.
1337 for (ObjCImplDecl::propimpl_iterator
1338 iter = OID->propimpl_begin(), endIter = OID->propimpl_end();
1339 iter != endIter ; iter++) {
1340 std::vector<llvm::Constant*> Fields;
1341 ObjCPropertyDecl *property = (*iter)->getPropertyDecl();
David Chisnall42ba04a2010-02-26 01:11:38 +00001342 ObjCPropertyImplDecl *propertyImpl = *iter;
1343 bool isSynthesized = (propertyImpl->getPropertyImplementation() ==
1344 ObjCPropertyImplDecl::Synthesize);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001345
1346 Fields.push_back(MakeConstantString(property->getNameAsString()));
1347 Fields.push_back(llvm::ConstantInt::get(Int8Ty,
1348 property->getPropertyAttributes()));
David Chisnall42ba04a2010-02-26 01:11:38 +00001349 Fields.push_back(llvm::ConstantInt::get(Int8Ty, isSynthesized));
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001350 if (ObjCMethodDecl *getter = property->getGetterMethodDecl()) {
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001351 std::string TypeStr;
1352 Context.getObjCEncodingForMethodDecl(getter,TypeStr);
1353 llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
David Chisnall42ba04a2010-02-26 01:11:38 +00001354 if (isSynthesized) {
1355 InstanceMethodTypes.push_back(TypeEncoding);
1356 InstanceMethodSels.push_back(getter->getSelector());
1357 }
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001358 Fields.push_back(MakeConstantString(getter->getSelector().getAsString()));
1359 Fields.push_back(TypeEncoding);
1360 } else {
1361 Fields.push_back(NULLPtr);
1362 Fields.push_back(NULLPtr);
1363 }
1364 if (ObjCMethodDecl *setter = property->getSetterMethodDecl()) {
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001365 std::string TypeStr;
1366 Context.getObjCEncodingForMethodDecl(setter,TypeStr);
1367 llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
David Chisnall42ba04a2010-02-26 01:11:38 +00001368 if (isSynthesized) {
1369 InstanceMethodTypes.push_back(TypeEncoding);
1370 InstanceMethodSels.push_back(setter->getSelector());
1371 }
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001372 Fields.push_back(MakeConstantString(setter->getSelector().getAsString()));
1373 Fields.push_back(TypeEncoding);
1374 } else {
1375 Fields.push_back(NULLPtr);
1376 Fields.push_back(NULLPtr);
1377 }
1378 Properties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1379 }
1380 llvm::ArrayType *PropertyArrayTy =
1381 llvm::ArrayType::get(PropertyMetadataTy, Properties.size());
1382 llvm::Constant *PropertyArray = llvm::ConstantArray::get(PropertyArrayTy,
1383 Properties);
1384 llvm::Constant* PropertyListInitFields[] =
1385 {llvm::ConstantInt::get(IntTy, Properties.size()), NULLPtr, PropertyArray};
1386
1387 llvm::Constant *PropertyListInit =
Nick Lewycky0d36dd22009-09-19 20:00:52 +00001388 llvm::ConstantStruct::get(VMContext, PropertyListInitFields, 3, false);
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001389 return new llvm::GlobalVariable(TheModule, PropertyListInit->getType(), false,
1390 llvm::GlobalValue::InternalLinkage, PropertyListInit,
1391 ".objc_property_list");
1392}
1393
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001394void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
1395 ASTContext &Context = CGM.getContext();
1396
1397 // Get the superclass name.
Mike Stump1eb44332009-09-09 15:08:12 +00001398 const ObjCInterfaceDecl * SuperClassDecl =
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001399 OID->getClassInterface()->getSuperClass();
Chris Lattner8ec03f52008-11-24 03:54:41 +00001400 std::string SuperClassName;
Chris Lattner2a8e4e12009-06-15 01:09:11 +00001401 if (SuperClassDecl) {
Chris Lattner8ec03f52008-11-24 03:54:41 +00001402 SuperClassName = SuperClassDecl->getNameAsString();
Chris Lattner2a8e4e12009-06-15 01:09:11 +00001403 EmitClassRef(SuperClassName);
1404 }
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001405
1406 // Get the class name
Chris Lattner09dc6662009-04-01 02:00:48 +00001407 ObjCInterfaceDecl *ClassDecl =
1408 const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
Chris Lattner8ec03f52008-11-24 03:54:41 +00001409 std::string ClassName = ClassDecl->getNameAsString();
Chris Lattner2a8e4e12009-06-15 01:09:11 +00001410 // Emit the symbol that is used to generate linker errors if this class is
1411 // referenced in other modules but not declared.
Fariborz Jahanianc51db232009-07-03 15:10:14 +00001412 std::string classSymbolName = "__objc_class_name_" + ClassName;
Mike Stump1eb44332009-09-09 15:08:12 +00001413 if (llvm::GlobalVariable *symbol =
Fariborz Jahanianc51db232009-07-03 15:10:14 +00001414 TheModule.getGlobalVariable(classSymbolName)) {
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001415 symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
Fariborz Jahanianc51db232009-07-03 15:10:14 +00001416 } else {
Owen Anderson1c431b32009-07-08 19:05:04 +00001417 new llvm::GlobalVariable(TheModule, LongTy, false,
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001418 llvm::GlobalValue::ExternalLinkage, llvm::ConstantInt::get(LongTy, 0),
Owen Anderson1c431b32009-07-08 19:05:04 +00001419 classSymbolName);
Fariborz Jahanianc51db232009-07-03 15:10:14 +00001420 }
Mike Stump1eb44332009-09-09 15:08:12 +00001421
Daniel Dunbar2bebbf02009-05-03 10:46:44 +00001422 // Get the size of instances.
1423 int instanceSize = Context.getASTObjCImplementationLayout(OID).getSize() / 8;
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001424
1425 // Collect information about instance variables.
1426 llvm::SmallVector<llvm::Constant*, 16> IvarNames;
1427 llvm::SmallVector<llvm::Constant*, 16> IvarTypes;
1428 llvm::SmallVector<llvm::Constant*, 16> IvarOffsets;
Mike Stump1eb44332009-09-09 15:08:12 +00001429
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001430 std::vector<llvm::Constant*> IvarOffsetValues;
1431
Mike Stump1eb44332009-09-09 15:08:12 +00001432 int superInstanceSize = !SuperClassDecl ? 0 :
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00001433 Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize() / 8;
1434 // For non-fragile ivars, set the instance size to 0 - {the size of just this
1435 // class}. The runtime will then set this to the correct value on load.
1436 if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
1437 instanceSize = 0 - (instanceSize - superInstanceSize);
1438 }
David Chisnall7f63cb02010-04-19 00:45:34 +00001439
1440 // Collect declared and synthesized ivars.
1441 llvm::SmallVector<ObjCIvarDecl*, 16> OIvars;
1442 CGM.getContext().ShallowCollectObjCIvars(ClassDecl, OIvars);
1443
1444 for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
1445 ObjCIvarDecl *IVD = OIvars[i];
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001446 // Store the name
David Chisnall7f63cb02010-04-19 00:45:34 +00001447 IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001448 // Get the type encoding for this ivar
1449 std::string TypeStr;
David Chisnall7f63cb02010-04-19 00:45:34 +00001450 Context.getObjCEncodingForType(IVD->getType(), TypeStr);
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001451 IvarTypes.push_back(MakeConstantString(TypeStr));
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001452 // Get the offset
David Chisnalld901da52010-04-19 01:37:25 +00001453 uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
David Chisnallaecbf242009-11-17 19:32:15 +00001454 uint64_t Offset = BaseOffset;
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00001455 if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001456 Offset = BaseOffset - superInstanceSize;
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00001457 }
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001458 IvarOffsets.push_back(
Owen Anderson0032b272009-08-13 21:57:51 +00001459 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Offset));
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001460 IvarOffsetValues.push_back(new llvm::GlobalVariable(TheModule, IntTy,
1461 false, llvm::GlobalValue::ExternalLinkage,
1462 llvm::ConstantInt::get(IntTy, BaseOffset),
1463 "__objc_ivar_offset_value_" + ClassName +"." +
David Chisnall7f63cb02010-04-19 00:45:34 +00001464 IVD->getNameAsString()));
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001465 }
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001466 llvm::Constant *IvarOffsetArrayInit =
1467 llvm::ConstantArray::get(llvm::ArrayType::get(PtrToIntTy,
1468 IvarOffsetValues.size()), IvarOffsetValues);
1469 llvm::GlobalVariable *IvarOffsetArray = new llvm::GlobalVariable(TheModule,
1470 IvarOffsetArrayInit->getType(), false,
1471 llvm::GlobalValue::InternalLinkage, IvarOffsetArrayInit,
1472 ".ivar.offsets");
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001473
1474 // Collect information about instance methods
1475 llvm::SmallVector<Selector, 16> InstanceMethodSels;
1476 llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
Mike Stump1eb44332009-09-09 15:08:12 +00001477 for (ObjCImplementationDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001478 iter = OID->instmeth_begin(), endIter = OID->instmeth_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00001479 iter != endIter ; iter++) {
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001480 InstanceMethodSels.push_back((*iter)->getSelector());
1481 std::string TypeStr;
1482 Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001483 InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001484 }
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001485
1486 llvm::Constant *Properties = GeneratePropertyList(OID, InstanceMethodSels,
1487 InstanceMethodTypes);
1488
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001489
1490 // Collect information about class methods
1491 llvm::SmallVector<Selector, 16> ClassMethodSels;
1492 llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
Douglas Gregor653f1b12009-04-23 01:02:12 +00001493 for (ObjCImplementationDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001494 iter = OID->classmeth_begin(), endIter = OID->classmeth_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00001495 iter != endIter ; iter++) {
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001496 ClassMethodSels.push_back((*iter)->getSelector());
1497 std::string TypeStr;
1498 Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001499 ClassMethodTypes.push_back(MakeConstantString(TypeStr));
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001500 }
1501 // Collect the names of referenced protocols
1502 llvm::SmallVector<std::string, 16> Protocols;
1503 const ObjCList<ObjCProtocolDecl> &Protos =ClassDecl->getReferencedProtocols();
1504 for (ObjCList<ObjCProtocolDecl>::iterator I = Protos.begin(),
1505 E = Protos.end(); I != E; ++I)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001506 Protocols.push_back((*I)->getNameAsString());
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001507
1508
1509
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001510 // Get the superclass pointer.
1511 llvm::Constant *SuperClass;
Chris Lattner8ec03f52008-11-24 03:54:41 +00001512 if (!SuperClassName.empty()) {
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001513 SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
1514 } else {
Owen Anderson03e20502009-07-30 23:11:26 +00001515 SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001516 }
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001517 // Empty vector used to construct empty method lists
1518 llvm::SmallVector<llvm::Constant*, 1> empty;
1519 // Generate the method and instance variable lists
1520 llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
Chris Lattnera4210072008-06-26 05:08:00 +00001521 InstanceMethodSels, InstanceMethodTypes, false);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001522 llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
Chris Lattnera4210072008-06-26 05:08:00 +00001523 ClassMethodSels, ClassMethodTypes, true);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001524 llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
1525 IvarOffsets);
Mike Stump1eb44332009-09-09 15:08:12 +00001526 // Irrespective of whether we are compiling for a fragile or non-fragile ABI,
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001527 // we emit a symbol containing the offset for each ivar in the class. This
1528 // allows code compiled for the non-Fragile ABI to inherit from code compiled
1529 // for the legacy ABI, without causing problems. The converse is also
1530 // possible, but causes all ivar accesses to be fragile.
1531 int i = 0;
1532 // Offset pointer for getting at the correct field in the ivar list when
1533 // setting up the alias. These are: The base address for the global, the
1534 // ivar array (second field), the ivar in this list (set for each ivar), and
1535 // the offset (third field in ivar structure)
1536 const llvm::Type *IndexTy = llvm::Type::getInt32Ty(VMContext);
1537 llvm::Constant *offsetPointerIndexes[] = {Zeros[0],
Mike Stump1eb44332009-09-09 15:08:12 +00001538 llvm::ConstantInt::get(IndexTy, 1), 0,
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001539 llvm::ConstantInt::get(IndexTy, 2) };
1540
1541 for (ObjCInterfaceDecl::ivar_iterator iter = ClassDecl->ivar_begin(),
1542 endIter = ClassDecl->ivar_end() ; iter != endIter ; iter++) {
1543 const std::string Name = "__objc_ivar_offset_" + ClassName + '.'
1544 +(*iter)->getNameAsString();
1545 offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, i++);
1546 // Get the correct ivar field
1547 llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(
1548 IvarList, offsetPointerIndexes, 4);
1549 // Get the existing alias, if one exists.
1550 llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);
1551 if (offset) {
1552 offset->setInitializer(offsetValue);
1553 // If this is the real definition, change its linkage type so that
1554 // different modules will use this one, rather than their private
1555 // copy.
1556 offset->setLinkage(llvm::GlobalValue::ExternalLinkage);
1557 } else {
1558 // Add a new alias if there isn't one already.
1559 offset = new llvm::GlobalVariable(TheModule, offsetValue->getType(),
1560 false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);
1561 }
1562 }
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001563 //Generate metaclass for class methods
1564 llvm::Constant *MetaClassStruct = GenerateClassStructure(NULLPtr,
David Chisnall18044632009-11-16 19:05:54 +00001565 NULLPtr, 0x12L, ClassName.c_str(), 0, Zeros[0], GenerateIvarList(
David Chisnall8c757f92010-04-28 14:29:56 +00001566 empty, empty, empty), ClassMethodList, NULLPtr, NULLPtr, NULLPtr, true);
Daniel Dunbar5efccb12009-05-04 15:31:17 +00001567
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001568 // Generate the class structure
Chris Lattner8ec03f52008-11-24 03:54:41 +00001569 llvm::Constant *ClassStruct =
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001570 GenerateClassStructure(MetaClassStruct, SuperClass, 0x11L,
Chris Lattner8ec03f52008-11-24 03:54:41 +00001571 ClassName.c_str(), 0,
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001572 llvm::ConstantInt::get(LongTy, instanceSize), IvarList,
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001573 MethodList, GenerateProtocolList(Protocols), IvarOffsetArray,
1574 Properties);
Daniel Dunbar5efccb12009-05-04 15:31:17 +00001575
1576 // Resolve the class aliases, if they exist.
1577 if (ClassPtrAlias) {
1578 ClassPtrAlias->setAliasee(
Owen Anderson3c4972d2009-07-29 18:54:39 +00001579 llvm::ConstantExpr::getBitCast(ClassStruct, IdTy));
Daniel Dunbar5efccb12009-05-04 15:31:17 +00001580 ClassPtrAlias = 0;
1581 }
1582 if (MetaClassPtrAlias) {
1583 MetaClassPtrAlias->setAliasee(
Owen Anderson3c4972d2009-07-29 18:54:39 +00001584 llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy));
Daniel Dunbar5efccb12009-05-04 15:31:17 +00001585 MetaClassPtrAlias = 0;
1586 }
1587
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001588 // Add class structure to list to be added to the symtab later
Owen Anderson3c4972d2009-07-29 18:54:39 +00001589 ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001590 Classes.push_back(ClassStruct);
1591}
1592
Fariborz Jahanianc38e9af2009-06-23 21:47:46 +00001593
Mike Stump1eb44332009-09-09 15:08:12 +00001594llvm::Function *CGObjCGNU::ModuleInitFunction() {
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001595 // Only emit an ObjC load function if no Objective-C stuff has been called
1596 if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
1597 ExistingProtocols.empty() && TypedSelectors.empty() &&
Anton Korobeynikov5f58b912008-06-01 15:14:46 +00001598 UntypedSelectors.empty())
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001599 return NULL;
Eli Friedman1b8956e2008-06-01 16:00:02 +00001600
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001601 // Add all referenced protocols to a category.
1602 GenerateProtocolHolderCategory();
1603
Chris Lattnere160c9b2009-01-27 05:06:01 +00001604 const llvm::StructType *SelStructTy = dyn_cast<llvm::StructType>(
1605 SelectorTy->getElementType());
1606 const llvm::Type *SelStructPtrTy = SelectorTy;
1607 bool isSelOpaque = false;
1608 if (SelStructTy == 0) {
Owen Anderson47a434f2009-08-05 23:18:46 +00001609 SelStructTy = llvm::StructType::get(VMContext, PtrToInt8Ty,
1610 PtrToInt8Ty, NULL);
Owen Anderson96e0fc72009-07-29 22:16:19 +00001611 SelStructPtrTy = llvm::PointerType::getUnqual(SelStructTy);
Chris Lattnere160c9b2009-01-27 05:06:01 +00001612 isSelOpaque = true;
1613 }
1614
Eli Friedman1b8956e2008-06-01 16:00:02 +00001615 // Name the ObjC types to make the IR a bit easier to read
Chris Lattnere160c9b2009-01-27 05:06:01 +00001616 TheModule.addTypeName(".objc_selector", SelStructPtrTy);
Eli Friedman1b8956e2008-06-01 16:00:02 +00001617 TheModule.addTypeName(".objc_id", IdTy);
1618 TheModule.addTypeName(".objc_imp", IMPTy);
1619
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001620 std::vector<llvm::Constant*> Elements;
Chris Lattner71238f62009-04-25 23:19:45 +00001621 llvm::Constant *Statics = NULLPtr;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001622 // Generate statics list:
Chris Lattner71238f62009-04-25 23:19:45 +00001623 if (ConstantStrings.size()) {
Owen Anderson96e0fc72009-07-29 22:16:19 +00001624 llvm::ArrayType *StaticsArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
Chris Lattner71238f62009-04-25 23:19:45 +00001625 ConstantStrings.size() + 1);
1626 ConstantStrings.push_back(NULLPtr);
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001627
Daniel Dunbar1b096952009-11-29 02:38:47 +00001628 llvm::StringRef StringClass = CGM.getLangOptions().ObjCConstantStringClass;
1629 if (StringClass.empty()) StringClass = "NXConstantString";
David Chisnall8a5a9aa2009-08-31 16:41:57 +00001630 Elements.push_back(MakeConstantString(StringClass,
1631 ".objc_static_class_name"));
Owen Anderson7db6d832009-07-28 18:33:04 +00001632 Elements.push_back(llvm::ConstantArray::get(StaticsArrayTy,
Chris Lattner71238f62009-04-25 23:19:45 +00001633 ConstantStrings));
Mike Stump1eb44332009-09-09 15:08:12 +00001634 llvm::StructType *StaticsListTy =
Owen Anderson47a434f2009-08-05 23:18:46 +00001635 llvm::StructType::get(VMContext, PtrToInt8Ty, StaticsArrayTy, NULL);
Owen Andersona1cf15f2009-07-14 23:10:40 +00001636 llvm::Type *StaticsListPtrTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +00001637 llvm::PointerType::getUnqual(StaticsListTy);
Chris Lattner71238f62009-04-25 23:19:45 +00001638 Statics = MakeGlobal(StaticsListTy, Elements, ".objc_statics");
Mike Stump1eb44332009-09-09 15:08:12 +00001639 llvm::ArrayType *StaticsListArrayTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +00001640 llvm::ArrayType::get(StaticsListPtrTy, 2);
Chris Lattner71238f62009-04-25 23:19:45 +00001641 Elements.clear();
1642 Elements.push_back(Statics);
Owen Andersonc9c88b42009-07-31 20:28:54 +00001643 Elements.push_back(llvm::Constant::getNullValue(StaticsListPtrTy));
Chris Lattner71238f62009-04-25 23:19:45 +00001644 Statics = MakeGlobal(StaticsListArrayTy, Elements, ".objc_statics_ptr");
Owen Anderson3c4972d2009-07-29 18:54:39 +00001645 Statics = llvm::ConstantExpr::getBitCast(Statics, PtrTy);
Chris Lattner71238f62009-04-25 23:19:45 +00001646 }
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001647 // Array of classes, categories, and constant objects
Owen Anderson96e0fc72009-07-29 22:16:19 +00001648 llvm::ArrayType *ClassListTy = llvm::ArrayType::get(PtrToInt8Ty,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001649 Classes.size() + Categories.size() + 2);
Mike Stump1eb44332009-09-09 15:08:12 +00001650 llvm::StructType *SymTabTy = llvm::StructType::get(VMContext,
Owen Anderson47a434f2009-08-05 23:18:46 +00001651 LongTy, SelStructPtrTy,
Owen Anderson0032b272009-08-13 21:57:51 +00001652 llvm::Type::getInt16Ty(VMContext),
1653 llvm::Type::getInt16Ty(VMContext),
Chris Lattner630404b2008-06-26 04:10:42 +00001654 ClassListTy, NULL);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001655
1656 Elements.clear();
1657 // Pointer to an array of selectors used in this module.
1658 std::vector<llvm::Constant*> Selectors;
1659 for (std::map<TypedSelector, llvm::GlobalAlias*>::iterator
1660 iter = TypedSelectors.begin(), iterEnd = TypedSelectors.end();
1661 iter != iterEnd ; ++iter) {
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001662 Elements.push_back(ExportUniqueString(iter->first.first, ".objc_sel_name"));
David Chisnalla7c5b082009-09-14 19:04:10 +00001663 Elements.push_back(MakeConstantString(iter->first.second,
Chris Lattner630404b2008-06-26 04:10:42 +00001664 ".objc_sel_types"));
Owen Anderson08e25242009-07-27 22:29:56 +00001665 Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001666 Elements.clear();
1667 }
1668 for (llvm::StringMap<llvm::GlobalAlias*>::iterator
1669 iter = UntypedSelectors.begin(), iterEnd = UntypedSelectors.end();
Chris Lattner630404b2008-06-26 04:10:42 +00001670 iter != iterEnd; ++iter) {
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001671 Elements.push_back(
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001672 ExportUniqueString(iter->getKeyData(), ".objc_sel_name"));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001673 Elements.push_back(NULLPtr);
Owen Anderson08e25242009-07-27 22:29:56 +00001674 Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001675 Elements.clear();
1676 }
1677 Elements.push_back(NULLPtr);
1678 Elements.push_back(NULLPtr);
Owen Anderson08e25242009-07-27 22:29:56 +00001679 Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001680 Elements.clear();
1681 // Number of static selectors
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001682 Elements.push_back(llvm::ConstantInt::get(LongTy, Selectors.size() ));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001683 llvm::Constant *SelectorList = MakeGlobal(
Owen Anderson96e0fc72009-07-29 22:16:19 +00001684 llvm::ArrayType::get(SelStructTy, Selectors.size()), Selectors,
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001685 ".objc_selector_list");
Mike Stump1eb44332009-09-09 15:08:12 +00001686 Elements.push_back(llvm::ConstantExpr::getBitCast(SelectorList,
Chris Lattnere160c9b2009-01-27 05:06:01 +00001687 SelStructPtrTy));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001688
1689 // Now that all of the static selectors exist, create pointers to them.
1690 int index = 0;
1691 for (std::map<TypedSelector, llvm::GlobalAlias*>::iterator
1692 iter=TypedSelectors.begin(), iterEnd =TypedSelectors.end();
1693 iter != iterEnd; ++iter) {
1694 llvm::Constant *Idxs[] = {Zeros[0],
Owen Anderson0032b272009-08-13 21:57:51 +00001695 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), index++), Zeros[0]};
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +00001696 llvm::Constant *SelPtr = new llvm::GlobalVariable(TheModule, SelStructPtrTy,
David Chisnall22b88272010-05-09 01:01:43 +00001697 true, llvm::GlobalValue::LinkOnceODRLinkage,
1698 llvm::ConstantExpr::getGetElementPtr(SelectorList, Idxs, 2),
1699 MangleSelectorTypes(".objc_sel_ptr"+iter->first.first+"."+
1700 iter->first.second));
Chris Lattnere160c9b2009-01-27 05:06:01 +00001701 // If selectors are defined as an opaque type, cast the pointer to this
1702 // type.
1703 if (isSelOpaque) {
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +00001704 SelPtr = llvm::ConstantExpr::getBitCast(SelPtr,
1705 llvm::PointerType::getUnqual(SelectorTy));
Chris Lattnere160c9b2009-01-27 05:06:01 +00001706 }
David Chisnall87935a82010-05-08 20:58:05 +00001707 (*iter).second->replaceAllUsesWith(SelPtr);
1708 (*iter).second->eraseFromParent();
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001709 }
1710 for (llvm::StringMap<llvm::GlobalAlias*>::iterator
1711 iter=UntypedSelectors.begin(), iterEnd = UntypedSelectors.end();
1712 iter != iterEnd; iter++) {
1713 llvm::Constant *Idxs[] = {Zeros[0],
Owen Anderson0032b272009-08-13 21:57:51 +00001714 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), index++), Zeros[0]};
David Chisnall87935a82010-05-08 20:58:05 +00001715 llvm::Constant *SelPtr = new llvm::GlobalVariable(TheModule, SelStructPtrTy,
David Chisnall22b88272010-05-09 01:01:43 +00001716 true, llvm::GlobalValue::LinkOnceODRLinkage,
1717 llvm::ConstantExpr::getGetElementPtr(SelectorList, Idxs, 2),
1718 MangleSelectorTypes(std::string(".objc_sel_ptr")+iter->getKey().str()));
Chris Lattnere160c9b2009-01-27 05:06:01 +00001719 // If selectors are defined as an opaque type, cast the pointer to this
1720 // type.
1721 if (isSelOpaque) {
Daniel Dunbar6d5a1c22010-02-03 20:11:42 +00001722 SelPtr = llvm::ConstantExpr::getBitCast(SelPtr,
1723 llvm::PointerType::getUnqual(SelectorTy));
Chris Lattnere160c9b2009-01-27 05:06:01 +00001724 }
David Chisnall87935a82010-05-08 20:58:05 +00001725 (*iter).second->replaceAllUsesWith(SelPtr);
1726 (*iter).second->eraseFromParent();
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001727 }
1728 // Number of classes defined.
Mike Stump1eb44332009-09-09 15:08:12 +00001729 Elements.push_back(llvm::ConstantInt::get(llvm::Type::getInt16Ty(VMContext),
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001730 Classes.size()));
1731 // Number of categories defined
Mike Stump1eb44332009-09-09 15:08:12 +00001732 Elements.push_back(llvm::ConstantInt::get(llvm::Type::getInt16Ty(VMContext),
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001733 Categories.size()));
1734 // Create an array of classes, then categories, then static object instances
1735 Classes.insert(Classes.end(), Categories.begin(), Categories.end());
1736 // NULL-terminated list of static object instances (mainly constant strings)
1737 Classes.push_back(Statics);
1738 Classes.push_back(NULLPtr);
Owen Anderson7db6d832009-07-28 18:33:04 +00001739 llvm::Constant *ClassList = llvm::ConstantArray::get(ClassListTy, Classes);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001740 Elements.push_back(ClassList);
Mike Stump1eb44332009-09-09 15:08:12 +00001741 // Construct the symbol table
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001742 llvm::Constant *SymTab= MakeGlobal(SymTabTy, Elements);
1743
1744 // The symbol table is contained in a module which has some version-checking
1745 // constants
Owen Anderson47a434f2009-08-05 23:18:46 +00001746 llvm::StructType * ModuleTy = llvm::StructType::get(VMContext, LongTy, LongTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00001747 PtrToInt8Ty, llvm::PointerType::getUnqual(SymTabTy), NULL);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001748 Elements.clear();
1749 // Runtime version used for compatibility checking.
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00001750 if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
Mike Stump1eb44332009-09-09 15:08:12 +00001751 Elements.push_back(llvm::ConstantInt::get(LongTy,
Fariborz Jahaniand9a1db32009-09-10 21:48:21 +00001752 NonFragileRuntimeVersion));
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00001753 } else {
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001754 Elements.push_back(llvm::ConstantInt::get(LongTy, RuntimeVersion));
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00001755 }
Fariborz Jahanian91a0b512009-04-01 19:49:42 +00001756 // sizeof(ModuleTy)
Benjamin Kramer74a8bbf2010-02-09 19:31:24 +00001757 llvm::TargetData td(&TheModule);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001758 Elements.push_back(llvm::ConstantInt::get(LongTy,
Owen Andersona1cf15f2009-07-14 23:10:40 +00001759 td.getTypeSizeInBits(ModuleTy)/8));
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001760 //FIXME: Should be the path to the file where this module was declared
1761 Elements.push_back(NULLPtr);
1762 Elements.push_back(SymTab);
1763 llvm::Value *Module = MakeGlobal(ModuleTy, Elements);
1764
1765 // Create the load function calling the runtime entry point with the module
1766 // structure
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001767 llvm::Function * LoadFunction = llvm::Function::Create(
Owen Anderson0032b272009-08-13 21:57:51 +00001768 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001769 llvm::GlobalValue::InternalLinkage, ".objc_load_function",
1770 &TheModule);
Owen Anderson0032b272009-08-13 21:57:51 +00001771 llvm::BasicBlock *EntryBB =
1772 llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
Owen Andersona1cf15f2009-07-14 23:10:40 +00001773 CGBuilderTy Builder(VMContext);
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001774 Builder.SetInsertPoint(EntryBB);
Fariborz Jahanian26c82942009-03-30 18:02:14 +00001775
1776 std::vector<const llvm::Type*> Params(1,
Owen Anderson96e0fc72009-07-29 22:16:19 +00001777 llvm::PointerType::getUnqual(ModuleTy));
1778 llvm::Value *Register = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
Owen Anderson0032b272009-08-13 21:57:51 +00001779 llvm::Type::getVoidTy(VMContext), Params, true), "__objc_exec_class");
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001780 Builder.CreateCall(Register, Module);
1781 Builder.CreateRetVoid();
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00001782
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001783 return LoadFunction;
1784}
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001785
Fariborz Jahanian679a5022009-01-10 21:06:09 +00001786llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
Mike Stump1eb44332009-09-09 15:08:12 +00001787 const ObjCContainerDecl *CD) {
1788 const ObjCCategoryImplDecl *OCD =
Steve Naroff3e0a5402009-01-08 19:41:02 +00001789 dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext());
Chris Lattner077bf5e2008-11-24 03:33:13 +00001790 std::string CategoryName = OCD ? OCD->getNameAsString() : "";
David Chisnall4c8c8e92010-03-20 19:53:29 +00001791 std::string ClassName = CD->getName();
Chris Lattner077bf5e2008-11-24 03:33:13 +00001792 std::string MethodName = OMD->getSelector().getAsString();
Douglas Gregorf8d49f62009-01-09 17:18:27 +00001793 bool isClassMethod = !OMD->isInstanceMethod();
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001794
Daniel Dunbar541b63b2009-02-02 23:23:47 +00001795 CodeGenTypes &Types = CGM.getTypes();
Mike Stump1eb44332009-09-09 15:08:12 +00001796 const llvm::FunctionType *MethodTy =
Daniel Dunbar541b63b2009-02-02 23:23:47 +00001797 Types.GetFunctionType(Types.getFunctionInfo(OMD), OMD->isVariadic());
Anton Korobeynikov20ff3102008-06-01 14:13:53 +00001798 std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
1799 MethodName, isClassMethod);
1800
Daniel Dunbard6c93d72009-09-17 04:01:22 +00001801 llvm::Function *Method
Mike Stump1eb44332009-09-09 15:08:12 +00001802 = llvm::Function::Create(MethodTy,
1803 llvm::GlobalValue::InternalLinkage,
1804 FunctionName,
1805 &TheModule);
Chris Lattner391d77a2008-03-30 23:03:07 +00001806 return Method;
1807}
1808
Daniel Dunbar49f66022008-09-24 03:38:44 +00001809llvm::Function *CGObjCGNU::GetPropertyGetFunction() {
Mike Stump1eb44332009-09-09 15:08:12 +00001810 std::vector<const llvm::Type*> Params;
1811 const llvm::Type *BoolTy =
1812 CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
1813 Params.push_back(IdTy);
1814 Params.push_back(SelectorTy);
David Chisnall7f63cb02010-04-19 00:45:34 +00001815 Params.push_back(IntTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001816 Params.push_back(BoolTy);
David Chisnall7f63cb02010-04-19 00:45:34 +00001817 // void objc_getProperty (id, SEL, int, bool)
Mike Stump1eb44332009-09-09 15:08:12 +00001818 const llvm::FunctionType *FTy =
1819 llvm::FunctionType::get(IdTy, Params, false);
1820 return cast<llvm::Function>(CGM.CreateRuntimeFunction(FTy,
1821 "objc_getProperty"));
Daniel Dunbar49f66022008-09-24 03:38:44 +00001822}
1823
1824llvm::Function *CGObjCGNU::GetPropertySetFunction() {
Mike Stump1eb44332009-09-09 15:08:12 +00001825 std::vector<const llvm::Type*> Params;
1826 const llvm::Type *BoolTy =
1827 CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
1828 Params.push_back(IdTy);
1829 Params.push_back(SelectorTy);
David Chisnall7f63cb02010-04-19 00:45:34 +00001830 Params.push_back(IntTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001831 Params.push_back(IdTy);
1832 Params.push_back(BoolTy);
1833 Params.push_back(BoolTy);
David Chisnall7f63cb02010-04-19 00:45:34 +00001834 // void objc_setProperty (id, SEL, int, id, bool, bool)
Mike Stump1eb44332009-09-09 15:08:12 +00001835 const llvm::FunctionType *FTy =
1836 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Params, false);
1837 return cast<llvm::Function>(CGM.CreateRuntimeFunction(FTy,
1838 "objc_setProperty"));
Daniel Dunbar49f66022008-09-24 03:38:44 +00001839}
1840
Fariborz Jahanian6cc59062010-04-12 18:18:10 +00001841// FIXME. Implement this.
1842llvm::Function *CGObjCGNU::GetCopyStructFunction() {
1843 return 0;
1844}
1845
Daniel Dunbar309a4362009-07-24 07:40:24 +00001846llvm::Constant *CGObjCGNU::EnumerationMutationFunction() {
1847 CodeGen::CodeGenTypes &Types = CGM.getTypes();
1848 ASTContext &Ctx = CGM.getContext();
1849 // void objc_enumerationMutation (id)
John McCallead608a2010-02-26 00:48:12 +00001850 llvm::SmallVector<CanQualType,1> Params;
David Chisnall0f436562009-08-17 16:35:33 +00001851 Params.push_back(ASTIdTy);
Daniel Dunbar309a4362009-07-24 07:40:24 +00001852 const llvm::FunctionType *FTy =
John McCall04a67a62010-02-05 21:31:56 +00001853 Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params,
Rafael Espindola264ba482010-03-30 20:24:48 +00001854 FunctionType::ExtInfo()), false);
Daniel Dunbar309a4362009-07-24 07:40:24 +00001855 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
Anders Carlsson2abd89c2008-08-31 04:05:03 +00001856}
1857
John McCall740e8072010-07-21 00:41:47 +00001858namespace {
John McCall1f0fca52010-07-21 07:22:38 +00001859 struct CallSyncExit : EHScopeStack::Cleanup {
John McCall740e8072010-07-21 00:41:47 +00001860 llvm::Value *SyncExitFn;
1861 llvm::Value *SyncArg;
1862 CallSyncExit(llvm::Value *SyncExitFn, llvm::Value *SyncArg)
1863 : SyncExitFn(SyncExitFn), SyncArg(SyncArg) {}
1864
1865 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
1866 CGF.Builder.CreateCall(SyncExitFn, SyncArg)->setDoesNotThrow();
1867 }
1868 };
1869}
1870
John McCallf1549f62010-07-06 01:34:17 +00001871void CGObjCGNU::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1872 const ObjCAtSynchronizedStmt &S) {
1873 std::vector<const llvm::Type*> Args(1, IdTy);
1874 llvm::FunctionType *FTy =
1875 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
Chris Lattner5dc08672009-05-08 00:11:50 +00001876
John McCallf1549f62010-07-06 01:34:17 +00001877 // Evaluate the lock operand. This should dominate the cleanup.
1878 llvm::Value *SyncArg =
1879 CGF.EmitScalarExpr(S.getSynchExpr());
Chris Lattner5dc08672009-05-08 00:11:50 +00001880
John McCallf1549f62010-07-06 01:34:17 +00001881 // Acquire the lock.
1882 llvm::Value *SyncEnter = CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
1883 SyncArg = CGF.Builder.CreateBitCast(SyncArg, IdTy);
1884 CGF.Builder.CreateCall(SyncEnter, SyncArg);
Chris Lattner5dc08672009-05-08 00:11:50 +00001885
John McCallf1549f62010-07-06 01:34:17 +00001886 // Register an all-paths cleanup to release the lock.
John McCall740e8072010-07-21 00:41:47 +00001887 llvm::Value *SyncExit = CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
John McCall1f0fca52010-07-21 07:22:38 +00001888 CGF.EHStack.pushCleanup<CallSyncExit>(NormalAndEHCleanup, SyncExit, SyncArg);
Chris Lattner5dc08672009-05-08 00:11:50 +00001889
John McCallf1549f62010-07-06 01:34:17 +00001890 // Emit the body of the statement.
1891 CGF.EmitStmt(S.getSynchBody());
Chris Lattner5dc08672009-05-08 00:11:50 +00001892
John McCallf1549f62010-07-06 01:34:17 +00001893 // Pop the lock-release cleanup.
1894 CGF.PopCleanupBlock();
1895}
Chris Lattner5dc08672009-05-08 00:11:50 +00001896
John McCallf1549f62010-07-06 01:34:17 +00001897namespace {
1898 struct CatchHandler {
1899 const VarDecl *Variable;
1900 const Stmt *Body;
1901 llvm::BasicBlock *Block;
1902 llvm::Value *TypeInfo;
1903 };
1904}
David Chisnall0faa5162009-12-24 02:26:34 +00001905
John McCallf1549f62010-07-06 01:34:17 +00001906void CGObjCGNU::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1907 const ObjCAtTryStmt &S) {
1908 // Unlike the Apple non-fragile runtimes, which also uses
1909 // unwind-based zero cost exceptions, the GNU Objective C runtime's
1910 // EH support isn't a veneer over C++ EH. Instead, exception
1911 // objects are created by __objc_exception_throw and destroyed by
1912 // the personality function; this avoids the need for bracketing
1913 // catch handlers with calls to __blah_begin_catch/__blah_end_catch
1914 // (or even _Unwind_DeleteException), but probably doesn't
1915 // interoperate very well with foreign exceptions.
1916
1917 // Jump destination for falling out of catch bodies.
1918 CodeGenFunction::JumpDest Cont;
1919 if (S.getNumCatchStmts())
1920 Cont = CGF.getJumpDestInCurrentScope("eh.cont");
1921
1922 // We handle @finally statements by pushing them as a cleanup
1923 // before entering the catch.
1924 CodeGenFunction::FinallyInfo FinallyInfo;
1925 if (const ObjCAtFinallyStmt *Finally = S.getFinallyStmt()) {
1926 std::vector<const llvm::Type*> Args(1, IdTy);
1927 llvm::FunctionType *FTy =
1928 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
1929 llvm::Constant *Rethrow =
1930 CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
1931
1932 FinallyInfo = CGF.EnterFinallyBlock(Finally->getFinallyBody(), 0, 0,
1933 Rethrow);
David Chisnall0faa5162009-12-24 02:26:34 +00001934 }
Mike Stump1eb44332009-09-09 15:08:12 +00001935
John McCallf1549f62010-07-06 01:34:17 +00001936 llvm::SmallVector<CatchHandler, 8> Handlers;
1937
1938 // Enter the catch, if there is one.
1939 if (S.getNumCatchStmts()) {
1940 for (unsigned I = 0, N = S.getNumCatchStmts(); I != N; ++I) {
1941 const ObjCAtCatchStmt *CatchStmt = S.getCatchStmt(I);
1942 const VarDecl *CatchDecl = CatchStmt->getCatchParamDecl();
1943
1944 Handlers.push_back(CatchHandler());
1945 CatchHandler &Handler = Handlers.back();
1946 Handler.Variable = CatchDecl;
1947 Handler.Body = CatchStmt->getCatchBody();
1948 Handler.Block = CGF.createBasicBlock("catch");
1949
1950 // @catch() and @catch(id) both catch any ObjC exception.
1951 // Treat them as catch-alls.
1952 // FIXME: this is what this code was doing before, but should 'id'
1953 // really be catching foreign exceptions?
1954 if (!CatchDecl
1955 || CatchDecl->getType()->isObjCIdType()
1956 || CatchDecl->getType()->isObjCQualifiedIdType()) {
1957
1958 Handler.TypeInfo = 0; // catch-all
1959
1960 // Don't consider any other catches.
1961 break;
1962 }
1963
1964 // All other types should be Objective-C interface pointer types.
1965 const ObjCObjectPointerType *OPT =
1966 CatchDecl->getType()->getAs<ObjCObjectPointerType>();
1967 assert(OPT && "Invalid @catch type.");
1968 const ObjCInterfaceDecl *IDecl =
1969 OPT->getObjectType()->getInterface();
1970 assert(IDecl && "Invalid @catch type.");
1971 Handler.TypeInfo = MakeConstantString(IDecl->getNameAsString());
1972 }
1973
1974 EHCatchScope *Catch = CGF.EHStack.pushCatch(Handlers.size());
1975 for (unsigned I = 0, E = Handlers.size(); I != E; ++I)
1976 Catch->setHandler(I, Handlers[I].TypeInfo, Handlers[I].Block);
1977 }
1978
1979 // Emit the try body.
1980 CGF.EmitStmt(S.getTryBody());
1981
1982 // Leave the try.
1983 if (S.getNumCatchStmts())
1984 CGF.EHStack.popCatch();
1985
1986 // Remember where we were.
1987 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
1988
1989 // Emit the handlers.
1990 for (unsigned I = 0, E = Handlers.size(); I != E; ++I) {
1991 CatchHandler &Handler = Handlers[I];
1992 CGF.EmitBlock(Handler.Block);
1993
1994 llvm::Value *Exn = CGF.Builder.CreateLoad(CGF.getExceptionSlot());
1995
1996 // Bind the catch parameter if it exists.
1997 if (const VarDecl *CatchParam = Handler.Variable) {
1998 const llvm::Type *CatchType = CGF.ConvertType(CatchParam->getType());
1999 Exn = CGF.Builder.CreateBitCast(Exn, CatchType);
2000
2001 CGF.EmitLocalBlockVarDecl(*CatchParam);
2002 CGF.Builder.CreateStore(Exn, CGF.GetAddrOfLocalVar(CatchParam));
2003 }
2004
2005 CGF.ObjCEHValueStack.push_back(Exn);
2006 CGF.EmitStmt(Handler.Body);
2007 CGF.ObjCEHValueStack.pop_back();
2008
2009 CGF.EmitBranchThroughCleanup(Cont);
2010 }
2011
2012 // Go back to the try-statement fallthrough.
2013 CGF.Builder.restoreIP(SavedIP);
2014
2015 // Pop out of the finally.
2016 if (S.getFinallyStmt())
2017 CGF.ExitFinallyBlock(FinallyInfo);
2018
2019 if (Cont.Block) {
2020 if (Cont.Block->use_empty())
2021 delete Cont.Block;
2022 else {
2023 CGF.EmitBranch(Cont.Block);
2024 CGF.EmitBlock(Cont.Block);
2025 }
2026 }
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00002027}
2028
2029void CGObjCGNU::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar49f66022008-09-24 03:38:44 +00002030 const ObjCAtThrowStmt &S) {
Chris Lattner5dc08672009-05-08 00:11:50 +00002031 llvm::Value *ExceptionAsObject;
2032
2033 std::vector<const llvm::Type*> Args(1, IdTy);
2034 llvm::FunctionType *FTy =
Owen Anderson0032b272009-08-13 21:57:51 +00002035 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
Mike Stump1eb44332009-09-09 15:08:12 +00002036 llvm::Value *ThrowFn =
Chris Lattner5dc08672009-05-08 00:11:50 +00002037 CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
Mike Stump1eb44332009-09-09 15:08:12 +00002038
Chris Lattner5dc08672009-05-08 00:11:50 +00002039 if (const Expr *ThrowExpr = S.getThrowExpr()) {
2040 llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr);
Fariborz Jahanian1e64a952009-05-17 16:49:27 +00002041 ExceptionAsObject = Exception;
Chris Lattner5dc08672009-05-08 00:11:50 +00002042 } else {
Mike Stump1eb44332009-09-09 15:08:12 +00002043 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
Chris Lattner5dc08672009-05-08 00:11:50 +00002044 "Unexpected rethrow outside @catch block.");
2045 ExceptionAsObject = CGF.ObjCEHValueStack.back();
2046 }
Fariborz Jahanian1e64a952009-05-17 16:49:27 +00002047 ExceptionAsObject =
2048 CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy, "tmp");
Mike Stump1eb44332009-09-09 15:08:12 +00002049
Chris Lattner5dc08672009-05-08 00:11:50 +00002050 // Note: This may have to be an invoke, if we want to support constructs like:
2051 // @try {
2052 // @throw(obj);
2053 // }
2054 // @catch(id) ...
2055 //
2056 // This is effectively turning @throw into an incredibly-expensive goto, but
2057 // it may happen as a result of inlining followed by missed optimizations, or
2058 // as a result of stupidity.
2059 llvm::BasicBlock *UnwindBB = CGF.getInvokeDest();
2060 if (!UnwindBB) {
2061 CGF.Builder.CreateCall(ThrowFn, ExceptionAsObject);
2062 CGF.Builder.CreateUnreachable();
2063 } else {
2064 CGF.Builder.CreateInvoke(ThrowFn, UnwindBB, UnwindBB, &ExceptionAsObject,
2065 &ExceptionAsObject+1);
2066 }
2067 // Clear the insertion point to indicate we are in unreachable code.
2068 CGF.Builder.ClearInsertionPoint();
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00002069}
2070
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00002071llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00002072 llvm::Value *AddrWeakObj) {
David Chisnallef6e0f32010-02-03 15:59:02 +00002073 CGBuilderTy B = CGF.Builder;
2074 AddrWeakObj = EnforceType(B, AddrWeakObj, IdTy);
2075 return B.CreateCall(WeakReadFn, AddrWeakObj);
Fariborz Jahanian6dc23172008-11-18 21:45:40 +00002076}
2077
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00002078void CGObjCGNU::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00002079 llvm::Value *src, llvm::Value *dst) {
David Chisnallef6e0f32010-02-03 15:59:02 +00002080 CGBuilderTy B = CGF.Builder;
2081 src = EnforceType(B, src, IdTy);
2082 dst = EnforceType(B, dst, PtrToIdTy);
2083 B.CreateCall2(WeakAssignFn, src, dst);
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00002084}
2085
Fariborz Jahanian58626502008-11-19 00:59:10 +00002086void CGObjCGNU::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00002087 llvm::Value *src, llvm::Value *dst,
2088 bool threadlocal) {
David Chisnallef6e0f32010-02-03 15:59:02 +00002089 CGBuilderTy B = CGF.Builder;
2090 src = EnforceType(B, src, IdTy);
2091 dst = EnforceType(B, dst, PtrToIdTy);
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00002092 if (!threadlocal)
2093 B.CreateCall2(GlobalAssignFn, src, dst);
2094 else
2095 // FIXME. Add threadloca assign API
2096 assert(false && "EmitObjCGlobalAssign - Threal Local API NYI");
Fariborz Jahanian58626502008-11-19 00:59:10 +00002097}
2098
Fariborz Jahanian7eda8362008-11-20 19:23:36 +00002099void CGObjCGNU::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00002100 llvm::Value *src, llvm::Value *dst,
2101 llvm::Value *ivarOffset) {
David Chisnallef6e0f32010-02-03 15:59:02 +00002102 CGBuilderTy B = CGF.Builder;
2103 src = EnforceType(B, src, IdTy);
2104 dst = EnforceType(B, dst, PtrToIdTy);
2105 B.CreateCall3(IvarAssignFn, src, dst, ivarOffset);
Fariborz Jahanian7eda8362008-11-20 19:23:36 +00002106}
2107
Fariborz Jahanian58626502008-11-19 00:59:10 +00002108void CGObjCGNU::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00002109 llvm::Value *src, llvm::Value *dst) {
David Chisnallef6e0f32010-02-03 15:59:02 +00002110 CGBuilderTy B = CGF.Builder;
2111 src = EnforceType(B, src, IdTy);
2112 dst = EnforceType(B, dst, PtrToIdTy);
2113 B.CreateCall2(StrongCastAssignFn, src, dst);
Fariborz Jahanian58626502008-11-19 00:59:10 +00002114}
2115
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00002116void CGObjCGNU::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00002117 llvm::Value *DestPtr,
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00002118 llvm::Value *SrcPtr,
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00002119 llvm::Value *Size) {
David Chisnallef6e0f32010-02-03 15:59:02 +00002120 CGBuilderTy B = CGF.Builder;
2121 DestPtr = EnforceType(B, DestPtr, IdTy);
2122 SrcPtr = EnforceType(B, SrcPtr, PtrToIdTy);
2123
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00002124 B.CreateCall3(MemMoveFn, DestPtr, SrcPtr, Size);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00002125}
2126
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002127llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(
2128 const ObjCInterfaceDecl *ID,
2129 const ObjCIvarDecl *Ivar) {
2130 const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
2131 + '.' + Ivar->getNameAsString();
2132 // Emit the variable and initialize it with what we think the correct value
2133 // is. This allows code compiled with non-fragile ivars to work correctly
2134 // when linked against code which isn't (most of the time).
David Chisnall8a5a9aa2009-08-31 16:41:57 +00002135 llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
2136 if (!IvarOffsetPointer) {
David Chisnalld901da52010-04-19 01:37:25 +00002137 uint64_t Offset;
2138 if (ObjCImplementationDecl *OID =
Dan Gohmancb421fa2010-04-19 16:39:44 +00002139 CGM.getContext().getObjCImplementation(
2140 const_cast<ObjCInterfaceDecl *>(ID)))
David Chisnalld901da52010-04-19 01:37:25 +00002141 Offset = ComputeIvarBaseOffset(CGM, OID, Ivar);
2142 else
2143 Offset = ComputeIvarBaseOffset(CGM, ID, Ivar);
2144
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002145 llvm::ConstantInt *OffsetGuess =
David Chisnallf9508372010-01-11 19:02:35 +00002146 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Offset, "ivar");
David Chisnall8a5a9aa2009-08-31 16:41:57 +00002147 // Don't emit the guess in non-PIC code because the linker will not be able
2148 // to replace it with the real version for a library. In non-PIC code you
2149 // must compile with the fragile ABI if you want to use ivars from a
Mike Stump1eb44332009-09-09 15:08:12 +00002150 // GCC-compiled class.
David Chisnall8a5a9aa2009-08-31 16:41:57 +00002151 if (CGM.getLangOptions().PICLevel) {
2152 llvm::GlobalVariable *IvarOffsetGV = new llvm::GlobalVariable(TheModule,
2153 llvm::Type::getInt32Ty(VMContext), false,
2154 llvm::GlobalValue::PrivateLinkage, OffsetGuess, Name+".guess");
2155 IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
2156 IvarOffsetGV->getType(), false, llvm::GlobalValue::LinkOnceAnyLinkage,
2157 IvarOffsetGV, Name);
2158 } else {
2159 IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +00002160 llvm::Type::getInt32PtrTy(VMContext), false,
2161 llvm::GlobalValue::ExternalLinkage, 0, Name);
David Chisnall8a5a9aa2009-08-31 16:41:57 +00002162 }
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002163 }
David Chisnall8a5a9aa2009-08-31 16:41:57 +00002164 return IvarOffsetPointer;
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002165}
2166
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00002167LValue CGObjCGNU::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
2168 QualType ObjectTy,
2169 llvm::Value *BaseValue,
2170 const ObjCIvarDecl *Ivar,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00002171 unsigned CVRQualifiers) {
John McCallc12c5bb2010-05-15 11:32:37 +00002172 const ObjCInterfaceDecl *ID =
2173 ObjectTy->getAs<ObjCObjectType>()->getInterface();
Daniel Dunbar97776872009-04-22 07:32:20 +00002174 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
2175 EmitIvarOffset(CGF, ID, Ivar));
Fariborz Jahanian0bb20362009-02-02 20:02:29 +00002176}
Mike Stumpbb1c8602009-07-31 21:31:32 +00002177
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002178static const ObjCInterfaceDecl *FindIvarInterface(ASTContext &Context,
2179 const ObjCInterfaceDecl *OID,
2180 const ObjCIvarDecl *OIVD) {
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002181 llvm::SmallVector<ObjCIvarDecl*, 16> Ivars;
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +00002182 Context.ShallowCollectObjCIvars(OID, Ivars);
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002183 for (unsigned k = 0, e = Ivars.size(); k != e; ++k) {
2184 if (OIVD == Ivars[k])
2185 return OID;
2186 }
Mike Stump1eb44332009-09-09 15:08:12 +00002187
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002188 // Otherwise check in the super class.
2189 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
2190 return FindIvarInterface(Context, Super, OIVD);
Mike Stump1eb44332009-09-09 15:08:12 +00002191
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002192 return 0;
2193}
Fariborz Jahanian0bb20362009-02-02 20:02:29 +00002194
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00002195llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar2a031922009-04-22 05:08:15 +00002196 const ObjCInterfaceDecl *Interface,
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00002197 const ObjCIvarDecl *Ivar) {
David Chisnall8a5a9aa2009-08-31 16:41:57 +00002198 if (CGM.getLangOptions().ObjCNonFragileABI) {
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002199 Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar);
David Chisnall8a5a9aa2009-08-31 16:41:57 +00002200 return CGF.Builder.CreateLoad(CGF.Builder.CreateLoad(
2201 ObjCIvarOffsetVariable(Interface, Ivar), false, "ivar"));
Fariborz Jahanian9cd96ff2009-05-20 18:41:51 +00002202 }
Daniel Dunbar97776872009-04-22 07:32:20 +00002203 uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002204 return llvm::ConstantInt::get(LongTy, Offset, "ivar");
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00002205}
2206
Mike Stumpbb1c8602009-07-31 21:31:32 +00002207CodeGen::CGObjCRuntime *
2208CodeGen::CreateGNUObjCRuntime(CodeGen::CodeGenModule &CGM) {
Chris Lattnerdce14062008-06-26 04:19:03 +00002209 return new CGObjCGNU(CGM);
Chris Lattner0f984262008-03-01 08:50:34 +00002210}