blob: 28cdb785557e47a4f990ad59133df884c7585527 [file] [log] [blame]
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001//===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This provides Objective-C code generation targetting the Apple runtime.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CGObjCRuntime.h"
Daniel Dunbar3ad53482008-08-11 21:35:06 +000015
Daniel Dunbar034299e2010-03-31 01:09:11 +000016#include "CGRecordLayout.h"
Daniel Dunbar3ad53482008-08-11 21:35:06 +000017#include "CodeGenModule.h"
Daniel Dunbara94ecd22008-08-16 03:19:19 +000018#include "CodeGenFunction.h"
John McCallbd309292010-07-06 01:34:17 +000019#include "CGException.h"
Daniel Dunbar8b8683f2008-08-12 00:12:39 +000020#include "clang/AST/ASTContext.h"
Daniel Dunbar221fa942008-08-11 04:54:23 +000021#include "clang/AST/Decl.h"
Daniel Dunbarb036db82008-08-13 03:21:16 +000022#include "clang/AST/DeclObjC.h"
Anders Carlsson15b73de2009-07-18 19:43:29 +000023#include "clang/AST/RecordLayout.h"
Chris Lattnerf0b64d72009-04-26 01:32:48 +000024#include "clang/AST/StmtObjC.h"
Daniel Dunbar3ad53482008-08-11 21:35:06 +000025#include "clang/Basic/LangOptions.h"
Chandler Carruth85098242010-06-15 23:19:56 +000026#include "clang/Frontend/CodeGenOptions.h"
Daniel Dunbar3ad53482008-08-11 21:35:06 +000027
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +000028#include "llvm/Intrinsics.h"
Owen Andersonae86c192009-07-13 04:10:07 +000029#include "llvm/LLVMContext.h"
Daniel Dunbar8b8683f2008-08-12 00:12:39 +000030#include "llvm/Module.h"
Daniel Dunbarc475d422008-10-29 22:36:39 +000031#include "llvm/ADT/DenseSet.h"
Daniel Dunbard027a922009-09-07 00:20:42 +000032#include "llvm/ADT/SetVector.h"
33#include "llvm/ADT/SmallString.h"
Fariborz Jahanian751c1e72009-12-12 21:26:21 +000034#include "llvm/ADT/SmallPtrSet.h"
John McCall5c08ab92010-07-13 22:12:14 +000035#include "llvm/Support/CallSite.h"
Daniel Dunbard027a922009-09-07 00:20:42 +000036#include "llvm/Support/raw_ostream.h"
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +000037#include "llvm/Target/TargetData.h"
Torok Edwindb714922009-08-24 13:25:12 +000038#include <cstdio>
Daniel Dunbar303e2c22008-08-11 02:45:11 +000039
40using namespace clang;
Daniel Dunbar41cf9de2008-09-09 01:06:48 +000041using namespace CodeGen;
Daniel Dunbar303e2c22008-08-11 02:45:11 +000042
Daniel Dunbar9fd114d2009-04-22 07:32:20 +000043// Common CGObjCRuntime functions, these don't belong here, but they
44// don't belong in CGObjCRuntime either so we will live with it for
45// now.
46
Daniel Dunbar0cec95f2009-05-03 08:55:17 +000047static uint64_t LookupFieldBitOffset(CodeGen::CodeGenModule &CGM,
48 const ObjCInterfaceDecl *OID,
Daniel Dunbar961202372009-05-03 12:57:56 +000049 const ObjCImplementationDecl *ID,
Daniel Dunbar0cec95f2009-05-03 08:55:17 +000050 const ObjCIvarDecl *Ivar) {
Daniel Dunbar8c7f9812010-04-02 21:14:02 +000051 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
Daniel Dunbar80b4eef2009-05-03 13:15:50 +000052
Daniel Dunbar7e5aba42010-04-02 22:29:40 +000053 // FIXME: We should eliminate the need to have ObjCImplementationDecl passed
54 // in here; it should never be necessary because that should be the lexical
55 // decl context for the ivar.
Daniel Dunbar031d4d42010-04-02 15:43:29 +000056
Daniel Dunbar80b4eef2009-05-03 13:15:50 +000057 // If we know have an implementation (and the ivar is in it) then
58 // look up in the implementation layout.
Daniel Dunbar59e476b2009-08-03 17:06:42 +000059 const ASTRecordLayout *RL;
Daniel Dunbar80b4eef2009-05-03 13:15:50 +000060 if (ID && ID->getClassInterface() == Container)
61 RL = &CGM.getContext().getASTObjCImplementationLayout(ID);
62 else
63 RL = &CGM.getContext().getASTObjCInterfaceLayout(Container);
Daniel Dunbar8c7f9812010-04-02 21:14:02 +000064
65 // Compute field index.
66 //
67 // FIXME: The index here is closely tied to how ASTContext::getObjCLayout is
68 // implemented. This should be fixed to get the information from the layout
69 // directly.
70 unsigned Index = 0;
71 llvm::SmallVector<ObjCIvarDecl*, 16> Ivars;
72 CGM.getContext().ShallowCollectObjCIvars(Container, Ivars);
73 for (unsigned k = 0, e = Ivars.size(); k != e; ++k) {
74 if (Ivar == Ivars[k])
75 break;
76 ++Index;
77 }
78 assert(Index != Ivars.size() && "Ivar is not inside container!");
79
Daniel Dunbar80b4eef2009-05-03 13:15:50 +000080 return RL->getFieldOffset(Index);
Daniel Dunbar0cec95f2009-05-03 08:55:17 +000081}
82
83uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM,
84 const ObjCInterfaceDecl *OID,
85 const ObjCIvarDecl *Ivar) {
Daniel Dunbar961202372009-05-03 12:57:56 +000086 return LookupFieldBitOffset(CGM, OID, 0, Ivar) / 8;
87}
88
89uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM,
90 const ObjCImplementationDecl *OID,
91 const ObjCIvarDecl *Ivar) {
92 return LookupFieldBitOffset(CGM, OID->getClassInterface(), OID, Ivar) / 8;
Daniel Dunbar9fd114d2009-04-22 07:32:20 +000093}
94
95LValue CGObjCRuntime::EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF,
96 const ObjCInterfaceDecl *OID,
97 llvm::Value *BaseValue,
98 const ObjCIvarDecl *Ivar,
99 unsigned CVRQualifiers,
100 llvm::Value *Offset) {
Daniel Dunbar0cec95f2009-05-03 08:55:17 +0000101 // Compute (type*) ( (char *) BaseValue + Offset)
Benjamin Kramerabd5b902009-10-13 10:07:13 +0000102 const llvm::Type *I8Ptr = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
Daniel Dunbar0cec95f2009-05-03 08:55:17 +0000103 QualType IvarTy = Ivar->getType();
104 const llvm::Type *LTy = CGF.CGM.getTypes().ConvertTypeForMem(IvarTy);
Daniel Dunbar9fd114d2009-04-22 07:32:20 +0000105 llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, I8Ptr);
Daniel Dunbar9fd114d2009-04-22 07:32:20 +0000106 V = CGF.Builder.CreateGEP(V, Offset, "add.ptr");
Owen Anderson9793f0e2009-07-29 22:16:19 +0000107 V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy));
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000108
John McCall8ccfcb52009-09-24 19:53:00 +0000109 Qualifiers Quals = CGF.MakeQualifiers(IvarTy);
110 Quals.addCVRQualifiers(CVRQualifiers);
111
Daniel Dunbarb76c4cd2010-04-05 16:20:33 +0000112 if (!Ivar->isBitField())
113 return LValue::MakeAddr(V, Quals);
Daniel Dunbar961202372009-05-03 12:57:56 +0000114
Daniel Dunbarb76c4cd2010-04-05 16:20:33 +0000115 // We need to compute the bit offset for the bit-field, the offset is to the
116 // byte. Note, there is a subtle invariant here: we can only call this routine
117 // on non-synthesized ivars but we may be called for synthesized ivars.
118 // However, a synthesized ivar can never be a bit-field, so this is safe.
119 uint64_t BitOffset = LookupFieldBitOffset(CGF.CGM, OID, 0, Ivar) % 8;
120 uint64_t BitFieldSize =
121 Ivar->getBitWidth()->EvaluateAsInt(CGF.getContext()).getZExtValue();
Daniel Dunbar9fd114d2009-04-22 07:32:20 +0000122
Daniel Dunbardc406b82010-04-05 21:36:35 +0000123 // Allocate a new CGBitFieldInfo object to describe this access.
124 //
125 // FIXME: This is incredibly wasteful, these should be uniqued or part of some
126 // layout object. However, this is blocked on other cleanups to the
127 // Objective-C code, so for now we just live with allocating a bunch of these
128 // objects.
Daniel Dunbardc406b82010-04-05 21:36:35 +0000129
Daniel Dunbarb935b932010-04-13 20:58:55 +0000130 // We always construct a single, possibly unaligned, access for this case.
Daniel Dunbar9c78d632010-04-15 05:09:32 +0000131 CGBitFieldInfo::AccessInfo AI;
Daniel Dunbarb935b932010-04-13 20:58:55 +0000132 AI.FieldIndex = 0;
133 AI.FieldByteOffset = 0;
134 AI.FieldBitStart = BitOffset;
135 AI.AccessWidth = CGF.CGM.getContext().getTypeSize(IvarTy);
136 AI.AccessAlignment = 0;
137 AI.TargetBitOffset = 0;
138 AI.TargetBitWidth = BitFieldSize;
139
Daniel Dunbar9c78d632010-04-15 05:09:32 +0000140 CGBitFieldInfo *Info =
141 new (CGF.CGM.getContext()) CGBitFieldInfo(BitFieldSize, 1, &AI,
142 IvarTy->isSignedIntegerType());
143
Daniel Dunbarb76c4cd2010-04-05 16:20:33 +0000144 // FIXME: We need to set a very conservative alignment on this, or make sure
145 // that the runtime is doing the right thing.
Daniel Dunbar196ea442010-04-06 01:07:44 +0000146 return LValue::MakeBitfield(V, *Info, Quals.getCVRQualifiers());
Daniel Dunbar9fd114d2009-04-22 07:32:20 +0000147}
148
149///
150
Daniel Dunbar303e2c22008-08-11 02:45:11 +0000151namespace {
Daniel Dunbar8b8683f2008-08-12 00:12:39 +0000152
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000153typedef std::vector<llvm::Constant*> ConstantVector;
Daniel Dunbareb1f9a22008-08-27 02:31:56 +0000154
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000155// FIXME: We should find a nicer way to make the labels for metadata, string
156// concatenation is lame.
Daniel Dunbarb036db82008-08-13 03:21:16 +0000157
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000158class ObjCCommonTypesHelper {
Owen Anderson170229f2009-07-14 23:10:40 +0000159protected:
160 llvm::LLVMContext &VMContext;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000161
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000162private:
163 llvm::Constant *getMessageSendFn() const {
164 // id objc_msgSend (id, SEL, ...)
165 std::vector<const llvm::Type*> Params;
166 Params.push_back(ObjectPtrTy);
167 Params.push_back(SelectorPtrTy);
168 return
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000169 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
170 Params, true),
171 "objc_msgSend");
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000172 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000173
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000174 llvm::Constant *getMessageSendStretFn() const {
175 // id objc_msgSend_stret (id, SEL, ...)
176 std::vector<const llvm::Type*> Params;
177 Params.push_back(ObjectPtrTy);
178 Params.push_back(SelectorPtrTy);
179 return
Owen Anderson41a75022009-08-13 21:57:51 +0000180 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000181 Params, true),
182 "objc_msgSend_stret");
183
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000184 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000185
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000186 llvm::Constant *getMessageSendFpretFn() const {
187 // FIXME: This should be long double on x86_64?
188 // [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
189 std::vector<const llvm::Type*> Params;
190 Params.push_back(ObjectPtrTy);
191 Params.push_back(SelectorPtrTy);
192 return
Owen Anderson41a75022009-08-13 21:57:51 +0000193 CGM.CreateRuntimeFunction(llvm::FunctionType::get(
194 llvm::Type::getDoubleTy(VMContext),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000195 Params,
196 true),
197 "objc_msgSend_fpret");
198
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000199 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000200
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000201 llvm::Constant *getMessageSendSuperFn() const {
202 // id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
203 const char *SuperName = "objc_msgSendSuper";
204 std::vector<const llvm::Type*> Params;
205 Params.push_back(SuperPtrTy);
206 Params.push_back(SelectorPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000207 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000208 Params, true),
209 SuperName);
210 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000211
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000212 llvm::Constant *getMessageSendSuperFn2() const {
213 // id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
214 const char *SuperName = "objc_msgSendSuper2";
215 std::vector<const llvm::Type*> Params;
216 Params.push_back(SuperPtrTy);
217 Params.push_back(SelectorPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000218 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000219 Params, true),
220 SuperName);
221 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000222
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000223 llvm::Constant *getMessageSendSuperStretFn() const {
224 // void objc_msgSendSuper_stret(void * stretAddr, struct objc_super *super,
225 // SEL op, ...)
226 std::vector<const llvm::Type*> Params;
227 Params.push_back(Int8PtrTy);
228 Params.push_back(SuperPtrTy);
229 Params.push_back(SelectorPtrTy);
Owen Anderson170229f2009-07-14 23:10:40 +0000230 return CGM.CreateRuntimeFunction(
Owen Anderson41a75022009-08-13 21:57:51 +0000231 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000232 Params, true),
233 "objc_msgSendSuper_stret");
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000234 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000235
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000236 llvm::Constant *getMessageSendSuperStretFn2() const {
237 // void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
238 // SEL op, ...)
239 std::vector<const llvm::Type*> Params;
240 Params.push_back(Int8PtrTy);
241 Params.push_back(SuperPtrTy);
242 Params.push_back(SelectorPtrTy);
Owen Anderson170229f2009-07-14 23:10:40 +0000243 return CGM.CreateRuntimeFunction(
Owen Anderson41a75022009-08-13 21:57:51 +0000244 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000245 Params, true),
246 "objc_msgSendSuper2_stret");
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000247 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000248
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000249 llvm::Constant *getMessageSendSuperFpretFn() const {
250 // There is no objc_msgSendSuper_fpret? How can that work?
251 return getMessageSendSuperFn();
252 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000253
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000254 llvm::Constant *getMessageSendSuperFpretFn2() const {
255 // There is no objc_msgSendSuper_fpret? How can that work?
256 return getMessageSendSuperFn2();
257 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000258
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000259protected:
260 CodeGen::CodeGenModule &CGM;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000261
Daniel Dunbar8b8683f2008-08-12 00:12:39 +0000262public:
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +0000263 const llvm::Type *ShortTy, *IntTy, *LongTy, *LongLongTy;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +0000264 const llvm::Type *Int8PtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000265
Daniel Dunbar5d715592008-08-12 05:28:47 +0000266 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
267 const llvm::Type *ObjectPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000268
Fariborz Jahanian406b1172008-11-18 20:18:11 +0000269 /// PtrObjectPtrTy - LLVM type for id *
270 const llvm::Type *PtrObjectPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000271
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +0000272 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
Daniel Dunbar5d715592008-08-12 05:28:47 +0000273 const llvm::Type *SelectorPtrTy;
Daniel Dunbarb036db82008-08-13 03:21:16 +0000274 /// ProtocolPtrTy - LLVM type for external protocol handles
275 /// (typeof(Protocol))
276 const llvm::Type *ExternalProtocolPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000277
Daniel Dunbarc722b852008-08-30 03:02:31 +0000278 // SuperCTy - clang type for struct objc_super.
279 QualType SuperCTy;
280 // SuperPtrCTy - clang type for struct objc_super *.
281 QualType SuperPtrCTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000282
Daniel Dunbarf6397fe2008-08-23 04:28:29 +0000283 /// SuperTy - LLVM type for struct objc_super.
284 const llvm::StructType *SuperTy;
Daniel Dunbar97ff50d2008-08-23 09:25:55 +0000285 /// SuperPtrTy - LLVM type for struct objc_super *.
286 const llvm::Type *SuperPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000287
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +0000288 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
289 /// in GCC parlance).
290 const llvm::StructType *PropertyTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000291
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +0000292 /// PropertyListTy - LLVM type for struct objc_property_list
293 /// (_prop_list_t in GCC parlance).
294 const llvm::StructType *PropertyListTy;
295 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
296 const llvm::Type *PropertyListPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000297
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +0000298 // MethodTy - LLVM type for struct objc_method.
299 const llvm::StructType *MethodTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000300
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000301 /// CacheTy - LLVM type for struct objc_cache.
302 const llvm::Type *CacheTy;
303 /// CachePtrTy - LLVM type for struct objc_cache *.
304 const llvm::Type *CachePtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000305
Chris Lattnerce8754e2009-04-22 02:44:54 +0000306 llvm::Constant *getGetPropertyFn() {
307 CodeGen::CodeGenTypes &Types = CGM.getTypes();
308 ASTContext &Ctx = CGM.getContext();
309 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
John McCall2da83a32010-02-26 00:48:12 +0000310 llvm::SmallVector<CanQualType,4> Params;
311 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
312 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
Chris Lattnerce8754e2009-04-22 02:44:54 +0000313 Params.push_back(IdType);
314 Params.push_back(SelType);
315 Params.push_back(Ctx.LongTy);
316 Params.push_back(Ctx.BoolTy);
317 const llvm::FunctionType *FTy =
John McCallab26cfa2010-02-05 21:31:56 +0000318 Types.GetFunctionType(Types.getFunctionInfo(IdType, Params,
Rafael Espindolac50c27c2010-03-30 20:24:48 +0000319 FunctionType::ExtInfo()),
320 false);
Chris Lattnerce8754e2009-04-22 02:44:54 +0000321 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
322 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000323
Chris Lattnerce8754e2009-04-22 02:44:54 +0000324 llvm::Constant *getSetPropertyFn() {
325 CodeGen::CodeGenTypes &Types = CGM.getTypes();
326 ASTContext &Ctx = CGM.getContext();
327 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
John McCall2da83a32010-02-26 00:48:12 +0000328 llvm::SmallVector<CanQualType,6> Params;
329 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
330 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
Chris Lattnerce8754e2009-04-22 02:44:54 +0000331 Params.push_back(IdType);
332 Params.push_back(SelType);
333 Params.push_back(Ctx.LongTy);
334 Params.push_back(IdType);
335 Params.push_back(Ctx.BoolTy);
336 Params.push_back(Ctx.BoolTy);
337 const llvm::FunctionType *FTy =
John McCallab26cfa2010-02-05 21:31:56 +0000338 Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params,
Rafael Espindolac50c27c2010-03-30 20:24:48 +0000339 FunctionType::ExtInfo()),
340 false);
Chris Lattnerce8754e2009-04-22 02:44:54 +0000341 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
342 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000343
Fariborz Jahanian5a8c2032010-04-12 18:18:10 +0000344
345 llvm::Constant *getCopyStructFn() {
346 CodeGen::CodeGenTypes &Types = CGM.getTypes();
347 ASTContext &Ctx = CGM.getContext();
348 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
349 llvm::SmallVector<CanQualType,5> Params;
350 Params.push_back(Ctx.VoidPtrTy);
351 Params.push_back(Ctx.VoidPtrTy);
352 Params.push_back(Ctx.LongTy);
353 Params.push_back(Ctx.BoolTy);
354 Params.push_back(Ctx.BoolTy);
355 const llvm::FunctionType *FTy =
356 Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params,
357 FunctionType::ExtInfo()),
358 false);
359 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
360 }
361
Chris Lattnerce8754e2009-04-22 02:44:54 +0000362 llvm::Constant *getEnumerationMutationFn() {
Daniel Dunbar9d82da42009-07-11 20:32:50 +0000363 CodeGen::CodeGenTypes &Types = CGM.getTypes();
364 ASTContext &Ctx = CGM.getContext();
Chris Lattnerce8754e2009-04-22 02:44:54 +0000365 // void objc_enumerationMutation (id)
John McCall2da83a32010-02-26 00:48:12 +0000366 llvm::SmallVector<CanQualType,1> Params;
367 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
Daniel Dunbar9d82da42009-07-11 20:32:50 +0000368 const llvm::FunctionType *FTy =
John McCallab26cfa2010-02-05 21:31:56 +0000369 Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params,
Rafael Espindolac50c27c2010-03-30 20:24:48 +0000370 FunctionType::ExtInfo()),
371 false);
Chris Lattnerce8754e2009-04-22 02:44:54 +0000372 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
373 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000374
Fariborz Jahanianeee54df2009-01-22 00:37:21 +0000375 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
Chris Lattnerce8754e2009-04-22 02:44:54 +0000376 llvm::Constant *getGcReadWeakFn() {
377 // id objc_read_weak (id *)
378 std::vector<const llvm::Type*> Args;
379 Args.push_back(ObjectPtrTy->getPointerTo());
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000380 llvm::FunctionType *FTy =
Owen Anderson9793f0e2009-07-29 22:16:19 +0000381 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattnerce8754e2009-04-22 02:44:54 +0000382 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000383 }
384
Fariborz Jahanianeee54df2009-01-22 00:37:21 +0000385 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
Chris Lattner6fdd57c2009-04-17 22:12:36 +0000386 llvm::Constant *getGcAssignWeakFn() {
387 // id objc_assign_weak (id, id *)
388 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
389 Args.push_back(ObjectPtrTy->getPointerTo());
390 llvm::FunctionType *FTy =
Owen Anderson9793f0e2009-07-29 22:16:19 +0000391 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattner6fdd57c2009-04-17 22:12:36 +0000392 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
393 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000394
Fariborz Jahanianeee54df2009-01-22 00:37:21 +0000395 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
Chris Lattner0a696a422009-04-22 02:38:11 +0000396 llvm::Constant *getGcAssignGlobalFn() {
397 // id objc_assign_global(id, id *)
398 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
399 Args.push_back(ObjectPtrTy->getPointerTo());
Owen Anderson170229f2009-07-14 23:10:40 +0000400 llvm::FunctionType *FTy =
Owen Anderson9793f0e2009-07-29 22:16:19 +0000401 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattner0a696a422009-04-22 02:38:11 +0000402 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
403 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000404
Fariborz Jahanianeee54df2009-01-22 00:37:21 +0000405 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
Chris Lattner0a696a422009-04-22 02:38:11 +0000406 llvm::Constant *getGcAssignIvarFn() {
Fariborz Jahanian7a95d722009-09-24 22:25:38 +0000407 // id objc_assign_ivar(id, id *, ptrdiff_t)
Chris Lattner0a696a422009-04-22 02:38:11 +0000408 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
409 Args.push_back(ObjectPtrTy->getPointerTo());
Fariborz Jahanian7a95d722009-09-24 22:25:38 +0000410 Args.push_back(LongTy);
Owen Anderson170229f2009-07-14 23:10:40 +0000411 llvm::FunctionType *FTy =
Owen Anderson9793f0e2009-07-29 22:16:19 +0000412 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattner0a696a422009-04-22 02:38:11 +0000413 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
414 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000415
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +0000416 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
417 llvm::Constant *GcMemmoveCollectableFn() {
418 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
419 std::vector<const llvm::Type*> Args(1, Int8PtrTy);
420 Args.push_back(Int8PtrTy);
421 Args.push_back(LongTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000422 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +0000423 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
424 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000425
Fariborz Jahanianeee54df2009-01-22 00:37:21 +0000426 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
Chris Lattner0a696a422009-04-22 02:38:11 +0000427 llvm::Constant *getGcAssignStrongCastFn() {
428 // id objc_assign_global(id, id *)
429 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
430 Args.push_back(ObjectPtrTy->getPointerTo());
Owen Anderson170229f2009-07-14 23:10:40 +0000431 llvm::FunctionType *FTy =
Owen Anderson9793f0e2009-07-29 22:16:19 +0000432 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattner0a696a422009-04-22 02:38:11 +0000433 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
434 }
Anders Carlsson9ab53d12009-02-16 22:59:18 +0000435
436 /// ExceptionThrowFn - LLVM objc_exception_throw function.
Chris Lattner0a696a422009-04-22 02:38:11 +0000437 llvm::Constant *getExceptionThrowFn() {
438 // void objc_exception_throw(id)
439 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
440 llvm::FunctionType *FTy =
Owen Anderson41a75022009-08-13 21:57:51 +0000441 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
Chris Lattner0a696a422009-04-22 02:38:11 +0000442 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
443 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000444
Fariborz Jahanian3336de12010-05-28 17:34:43 +0000445 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
446 llvm::Constant *getExceptionRethrowFn() {
447 // void objc_exception_rethrow(void)
448 std::vector<const llvm::Type*> Args;
449 llvm::FunctionType *FTy =
450 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, true);
451 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
452 }
453
Daniel Dunbar94ceb612009-02-24 01:43:46 +0000454 /// SyncEnterFn - LLVM object_sync_enter function.
Chris Lattnerdcceee72009-04-06 16:53:45 +0000455 llvm::Constant *getSyncEnterFn() {
456 // void objc_sync_enter (id)
457 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
458 llvm::FunctionType *FTy =
Owen Anderson41a75022009-08-13 21:57:51 +0000459 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
Chris Lattnerdcceee72009-04-06 16:53:45 +0000460 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
461 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000462
Daniel Dunbar94ceb612009-02-24 01:43:46 +0000463 /// SyncExitFn - LLVM object_sync_exit function.
Chris Lattner0a696a422009-04-22 02:38:11 +0000464 llvm::Constant *getSyncExitFn() {
465 // void objc_sync_exit (id)
466 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
467 llvm::FunctionType *FTy =
Owen Anderson41a75022009-08-13 21:57:51 +0000468 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
Chris Lattner0a696a422009-04-22 02:38:11 +0000469 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
470 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000471
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000472 llvm::Constant *getSendFn(bool IsSuper) const {
473 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
474 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000475
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000476 llvm::Constant *getSendFn2(bool IsSuper) const {
477 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
478 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000479
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000480 llvm::Constant *getSendStretFn(bool IsSuper) const {
481 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
482 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000483
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000484 llvm::Constant *getSendStretFn2(bool IsSuper) const {
485 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
486 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000487
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000488 llvm::Constant *getSendFpretFn(bool IsSuper) const {
489 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
490 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000491
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000492 llvm::Constant *getSendFpretFn2(bool IsSuper) const {
493 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
494 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000495
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000496 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
497 ~ObjCCommonTypesHelper(){}
498};
Daniel Dunbarf6397fe2008-08-23 04:28:29 +0000499
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000500/// ObjCTypesHelper - Helper class that encapsulates lazy
501/// construction of varies types used during ObjC generation.
502class ObjCTypesHelper : public ObjCCommonTypesHelper {
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000503public:
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +0000504 /// SymtabTy - LLVM type for struct objc_symtab.
505 const llvm::StructType *SymtabTy;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +0000506 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
507 const llvm::Type *SymtabPtrTy;
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +0000508 /// ModuleTy - LLVM type for struct objc_module.
509 const llvm::StructType *ModuleTy;
Daniel Dunbarcb515c82008-08-12 03:39:23 +0000510
Daniel Dunbarb036db82008-08-13 03:21:16 +0000511 /// ProtocolTy - LLVM type for struct objc_protocol.
512 const llvm::StructType *ProtocolTy;
513 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
514 const llvm::Type *ProtocolPtrTy;
515 /// ProtocolExtensionTy - LLVM type for struct
516 /// objc_protocol_extension.
517 const llvm::StructType *ProtocolExtensionTy;
518 /// ProtocolExtensionTy - LLVM type for struct
519 /// objc_protocol_extension *.
520 const llvm::Type *ProtocolExtensionPtrTy;
521 /// MethodDescriptionTy - LLVM type for struct
522 /// objc_method_description.
523 const llvm::StructType *MethodDescriptionTy;
524 /// MethodDescriptionListTy - LLVM type for struct
525 /// objc_method_description_list.
526 const llvm::StructType *MethodDescriptionListTy;
527 /// MethodDescriptionListPtrTy - LLVM type for struct
528 /// objc_method_description_list *.
529 const llvm::Type *MethodDescriptionListPtrTy;
Daniel Dunbarb036db82008-08-13 03:21:16 +0000530 /// ProtocolListTy - LLVM type for struct objc_property_list.
531 const llvm::Type *ProtocolListTy;
532 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
533 const llvm::Type *ProtocolListPtrTy;
Daniel Dunbar938a77f2008-08-22 20:34:54 +0000534 /// CategoryTy - LLVM type for struct objc_category.
535 const llvm::StructType *CategoryTy;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +0000536 /// ClassTy - LLVM type for struct objc_class.
537 const llvm::StructType *ClassTy;
538 /// ClassPtrTy - LLVM type for struct objc_class *.
539 const llvm::Type *ClassPtrTy;
540 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
541 const llvm::StructType *ClassExtensionTy;
542 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
543 const llvm::Type *ClassExtensionPtrTy;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +0000544 // IvarTy - LLVM type for struct objc_ivar.
545 const llvm::StructType *IvarTy;
546 /// IvarListTy - LLVM type for struct objc_ivar_list.
547 const llvm::Type *IvarListTy;
548 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
549 const llvm::Type *IvarListPtrTy;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +0000550 /// MethodListTy - LLVM type for struct objc_method_list.
551 const llvm::Type *MethodListTy;
552 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
553 const llvm::Type *MethodListPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000554
Anders Carlsson9ff22482008-09-09 10:10:21 +0000555 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
556 const llvm::Type *ExceptionDataTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000557
Anders Carlsson9ff22482008-09-09 10:10:21 +0000558 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
Chris Lattnerc6406db2009-04-22 02:26:14 +0000559 llvm::Constant *getExceptionTryEnterFn() {
560 std::vector<const llvm::Type*> Params;
Owen Anderson9793f0e2009-07-29 22:16:19 +0000561 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
Owen Anderson170229f2009-07-14 23:10:40 +0000562 return CGM.CreateRuntimeFunction(
Owen Anderson41a75022009-08-13 21:57:51 +0000563 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000564 Params, false),
565 "objc_exception_try_enter");
Chris Lattnerc6406db2009-04-22 02:26:14 +0000566 }
Anders Carlsson9ff22482008-09-09 10:10:21 +0000567
568 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
Chris Lattnerc6406db2009-04-22 02:26:14 +0000569 llvm::Constant *getExceptionTryExitFn() {
570 std::vector<const llvm::Type*> Params;
Owen Anderson9793f0e2009-07-29 22:16:19 +0000571 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
Owen Anderson170229f2009-07-14 23:10:40 +0000572 return CGM.CreateRuntimeFunction(
Owen Anderson41a75022009-08-13 21:57:51 +0000573 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000574 Params, false),
575 "objc_exception_try_exit");
Chris Lattnerc6406db2009-04-22 02:26:14 +0000576 }
Anders Carlsson9ff22482008-09-09 10:10:21 +0000577
578 /// ExceptionExtractFn - LLVM objc_exception_extract function.
Chris Lattnerc6406db2009-04-22 02:26:14 +0000579 llvm::Constant *getExceptionExtractFn() {
580 std::vector<const llvm::Type*> Params;
Owen Anderson9793f0e2009-07-29 22:16:19 +0000581 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
582 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattnerc6406db2009-04-22 02:26:14 +0000583 Params, false),
584 "objc_exception_extract");
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000585
Chris Lattnerc6406db2009-04-22 02:26:14 +0000586 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000587
Anders Carlsson9ff22482008-09-09 10:10:21 +0000588 /// ExceptionMatchFn - LLVM objc_exception_match function.
Chris Lattnerc6406db2009-04-22 02:26:14 +0000589 llvm::Constant *getExceptionMatchFn() {
590 std::vector<const llvm::Type*> Params;
591 Params.push_back(ClassPtrTy);
592 Params.push_back(ObjectPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000593 return CGM.CreateRuntimeFunction(
Owen Anderson41a75022009-08-13 21:57:51 +0000594 llvm::FunctionType::get(llvm::Type::getInt32Ty(VMContext),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000595 Params, false),
596 "objc_exception_match");
597
Chris Lattnerc6406db2009-04-22 02:26:14 +0000598 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000599
Anders Carlsson9ff22482008-09-09 10:10:21 +0000600 /// SetJmpFn - LLVM _setjmp function.
Chris Lattnerc6406db2009-04-22 02:26:14 +0000601 llvm::Constant *getSetJmpFn() {
602 std::vector<const llvm::Type*> Params;
Benjamin Kramerabd5b902009-10-13 10:07:13 +0000603 Params.push_back(llvm::Type::getInt32PtrTy(VMContext));
Chris Lattnerc6406db2009-04-22 02:26:14 +0000604 return
Owen Anderson41a75022009-08-13 21:57:51 +0000605 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getInt32Ty(VMContext),
Chris Lattnerc6406db2009-04-22 02:26:14 +0000606 Params, false),
607 "_setjmp");
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000608
Chris Lattnerc6406db2009-04-22 02:26:14 +0000609 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000610
Daniel Dunbar8b8683f2008-08-12 00:12:39 +0000611public:
612 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000613 ~ObjCTypesHelper() {}
Daniel Dunbar8b8683f2008-08-12 00:12:39 +0000614};
615
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +0000616/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000617/// modern abi
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +0000618class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +0000619public:
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000620
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000621 // MethodListnfABITy - LLVM for struct _method_list_t
622 const llvm::StructType *MethodListnfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000623
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000624 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
625 const llvm::Type *MethodListnfABIPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000626
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000627 // ProtocolnfABITy = LLVM for struct _protocol_t
628 const llvm::StructType *ProtocolnfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000629
Daniel Dunbar8de90f02009-02-15 07:36:20 +0000630 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
631 const llvm::Type *ProtocolnfABIPtrTy;
632
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000633 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
634 const llvm::StructType *ProtocolListnfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000635
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000636 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
637 const llvm::Type *ProtocolListnfABIPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000638
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000639 // ClassnfABITy - LLVM for struct _class_t
640 const llvm::StructType *ClassnfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000641
Fariborz Jahanian71394042009-01-23 23:53:38 +0000642 // ClassnfABIPtrTy - LLVM for struct _class_t*
643 const llvm::Type *ClassnfABIPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000644
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000645 // IvarnfABITy - LLVM for struct _ivar_t
646 const llvm::StructType *IvarnfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000647
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000648 // IvarListnfABITy - LLVM for struct _ivar_list_t
649 const llvm::StructType *IvarListnfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000650
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000651 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
652 const llvm::Type *IvarListnfABIPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000653
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000654 // ClassRonfABITy - LLVM for struct _class_ro_t
655 const llvm::StructType *ClassRonfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000656
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000657 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
658 const llvm::Type *ImpnfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000659
Fariborz Jahanian0232c052009-01-23 01:46:23 +0000660 // CategorynfABITy - LLVM for struct _category_t
661 const llvm::StructType *CategorynfABITy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000662
Fariborz Jahanian82c72e12009-02-03 23:49:23 +0000663 // New types for nonfragile abi messaging.
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000664
Fariborz Jahanian82c72e12009-02-03 23:49:23 +0000665 // MessageRefTy - LLVM for:
666 // struct _message_ref_t {
667 // IMP messenger;
668 // SEL name;
669 // };
670 const llvm::StructType *MessageRefTy;
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +0000671 // MessageRefCTy - clang type for struct _message_ref_t
672 QualType MessageRefCTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000673
Fariborz Jahanian82c72e12009-02-03 23:49:23 +0000674 // MessageRefPtrTy - LLVM for struct _message_ref_t*
675 const llvm::Type *MessageRefPtrTy;
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +0000676 // MessageRefCPtrTy - clang type for struct _message_ref_t*
677 QualType MessageRefCPtrTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000678
Fariborz Jahanian4e87c832009-02-05 01:13:09 +0000679 // MessengerTy - Type of the messenger (shown as IMP above)
680 const llvm::FunctionType *MessengerTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000681
Fariborz Jahanian82c72e12009-02-03 23:49:23 +0000682 // SuperMessageRefTy - LLVM for:
683 // struct _super_message_ref_t {
684 // SUPER_IMP messenger;
685 // SEL name;
686 // };
687 const llvm::StructType *SuperMessageRefTy;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000688
Fariborz Jahanian82c72e12009-02-03 23:49:23 +0000689 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
690 const llvm::Type *SuperMessageRefPtrTy;
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +0000691
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000692 llvm::Constant *getMessageSendFixupFn() {
693 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
694 std::vector<const llvm::Type*> Params;
695 Params.push_back(ObjectPtrTy);
696 Params.push_back(MessageRefPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000697 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000698 Params, true),
699 "objc_msgSend_fixup");
700 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000701
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000702 llvm::Constant *getMessageSendFpretFixupFn() {
703 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
704 std::vector<const llvm::Type*> Params;
705 Params.push_back(ObjectPtrTy);
706 Params.push_back(MessageRefPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000707 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000708 Params, true),
709 "objc_msgSend_fpret_fixup");
710 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000711
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000712 llvm::Constant *getMessageSendStretFixupFn() {
713 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
714 std::vector<const llvm::Type*> Params;
715 Params.push_back(ObjectPtrTy);
716 Params.push_back(MessageRefPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000717 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000718 Params, true),
719 "objc_msgSend_stret_fixup");
720 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000721
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000722 llvm::Constant *getMessageSendIdFixupFn() {
723 // id objc_msgSendId_fixup(id, struct message_ref_t*, ...)
724 std::vector<const llvm::Type*> Params;
725 Params.push_back(ObjectPtrTy);
726 Params.push_back(MessageRefPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000727 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000728 Params, true),
729 "objc_msgSendId_fixup");
730 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000731
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000732 llvm::Constant *getMessageSendIdStretFixupFn() {
733 // id objc_msgSendId_stret_fixup(id, struct message_ref_t*, ...)
734 std::vector<const llvm::Type*> Params;
735 Params.push_back(ObjectPtrTy);
736 Params.push_back(MessageRefPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000737 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000738 Params, true),
739 "objc_msgSendId_stret_fixup");
740 }
741 llvm::Constant *getMessageSendSuper2FixupFn() {
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000742 // id objc_msgSendSuper2_fixup (struct objc_super *,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000743 // struct _super_message_ref_t*, ...)
744 std::vector<const llvm::Type*> Params;
745 Params.push_back(SuperPtrTy);
746 Params.push_back(SuperMessageRefPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000747 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000748 Params, true),
749 "objc_msgSendSuper2_fixup");
750 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000751
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000752 llvm::Constant *getMessageSendSuper2StretFixupFn() {
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000753 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000754 // struct _super_message_ref_t*, ...)
755 std::vector<const llvm::Type*> Params;
756 Params.push_back(SuperPtrTy);
757 Params.push_back(SuperMessageRefPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000758 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner2dfdb3e2009-04-22 02:53:24 +0000759 Params, true),
760 "objc_msgSendSuper2_stret_fixup");
761 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000762
763
764
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +0000765 /// EHPersonalityPtr - LLVM value for an i8* to the Objective-C
766 /// exception personality function.
Chris Lattnerdcceee72009-04-06 16:53:45 +0000767 llvm::Value *getEHPersonalityPtr() {
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000768 llvm::Constant *Personality =
Owen Anderson41a75022009-08-13 21:57:51 +0000769 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getInt32Ty(VMContext),
Chris Lattnerdcceee72009-04-06 16:53:45 +0000770 true),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000771 "__objc_personality_v0");
Owen Andersonade90fd2009-07-29 18:54:39 +0000772 return llvm::ConstantExpr::getBitCast(Personality, Int8PtrTy);
Chris Lattnerdcceee72009-04-06 16:53:45 +0000773 }
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +0000774
Chris Lattnera7c00b42009-04-22 02:15:23 +0000775 llvm::Constant *getUnwindResumeOrRethrowFn() {
776 std::vector<const llvm::Type*> Params;
777 Params.push_back(Int8PtrTy);
Owen Anderson170229f2009-07-14 23:10:40 +0000778 return CGM.CreateRuntimeFunction(
Owen Anderson41a75022009-08-13 21:57:51 +0000779 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000780 Params, false),
Daniel Dunbar3241d402010-02-10 18:49:11 +0000781 (CGM.getLangOptions().SjLjExceptions ? "_Unwind_SjLj_Resume" :
782 "_Unwind_Resume_or_Rethrow"));
Chris Lattnera7c00b42009-04-22 02:15:23 +0000783 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000784
Chris Lattnera7c00b42009-04-22 02:15:23 +0000785 llvm::Constant *getObjCEndCatchFn() {
Owen Anderson41a75022009-08-13 21:57:51 +0000786 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Chris Lattner3dd1b4b2009-07-01 04:13:52 +0000787 false),
Chris Lattnera7c00b42009-04-22 02:15:23 +0000788 "objc_end_catch");
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000789
Chris Lattnera7c00b42009-04-22 02:15:23 +0000790 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000791
Chris Lattnera7c00b42009-04-22 02:15:23 +0000792 llvm::Constant *getObjCBeginCatchFn() {
793 std::vector<const llvm::Type*> Params;
794 Params.push_back(Int8PtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000795 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
Chris Lattnera7c00b42009-04-22 02:15:23 +0000796 Params, false),
797 "objc_begin_catch");
798 }
Daniel Dunbarb1559a42009-03-01 04:46:24 +0000799
800 const llvm::StructType *EHTypeTy;
801 const llvm::Type *EHTypePtrTy;
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +0000802
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +0000803 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
804 ~ObjCNonFragileABITypesHelper(){}
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000805};
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000806
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000807class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +0000808public:
809 // FIXME - accessibility
Fariborz Jahanian524bb202009-03-10 16:22:08 +0000810 class GC_IVAR {
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +0000811 public:
Daniel Dunbar7b89ace2009-05-03 13:44:42 +0000812 unsigned ivar_bytepos;
813 unsigned ivar_size;
814 GC_IVAR(unsigned bytepos = 0, unsigned size = 0)
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000815 : ivar_bytepos(bytepos), ivar_size(size) {}
Daniel Dunbar22b0ada2009-04-23 01:29:05 +0000816
817 // Allow sorting based on byte pos.
818 bool operator<(const GC_IVAR &b) const {
819 return ivar_bytepos < b.ivar_bytepos;
820 }
Fariborz Jahanian524bb202009-03-10 16:22:08 +0000821 };
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000822
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +0000823 class SKIP_SCAN {
Daniel Dunbar7b89ace2009-05-03 13:44:42 +0000824 public:
825 unsigned skip;
826 unsigned scan;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000827 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
Daniel Dunbar7b89ace2009-05-03 13:44:42 +0000828 : skip(_skip), scan(_scan) {}
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +0000829 };
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000830
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000831protected:
832 CodeGen::CodeGenModule &CGM;
Owen Andersonae86c192009-07-13 04:10:07 +0000833 llvm::LLVMContext &VMContext;
Fariborz Jahanian279eda62009-01-21 22:04:16 +0000834 // FIXME! May not be needing this after all.
Daniel Dunbar8b8683f2008-08-12 00:12:39 +0000835 unsigned ObjCABI;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000836
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +0000837 // gc ivar layout bitmap calculation helper caches.
838 llvm::SmallVector<GC_IVAR, 16> SkipIvars;
839 llvm::SmallVector<GC_IVAR, 16> IvarsInfo;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000840
Daniel Dunbarc61d0e92008-08-25 06:02:07 +0000841 /// LazySymbols - Symbols to generate a lazy reference for. See
842 /// DefinedSymbols and FinishModule().
Daniel Dunbard027a922009-09-07 00:20:42 +0000843 llvm::SetVector<IdentifierInfo*> LazySymbols;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000844
Daniel Dunbarc61d0e92008-08-25 06:02:07 +0000845 /// DefinedSymbols - External symbols which are defined by this
846 /// module. The symbols in this list and LazySymbols are used to add
847 /// special linker symbols which ensure that Objective-C modules are
848 /// linked properly.
Daniel Dunbard027a922009-09-07 00:20:42 +0000849 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000850
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +0000851 /// ClassNames - uniqued class names.
Daniel Dunbarb036db82008-08-13 03:21:16 +0000852 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassNames;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000853
Daniel Dunbarcb515c82008-08-12 03:39:23 +0000854 /// MethodVarNames - uniqued method variable names.
855 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000856
Fariborz Jahanian9adb2e62010-06-21 22:05:18 +0000857 /// DefinedCategoryNames - list of category names in form Class_Category.
858 llvm::SetVector<std::string> DefinedCategoryNames;
859
Daniel Dunbarb036db82008-08-13 03:21:16 +0000860 /// MethodVarTypes - uniqued method type signatures. We have to use
861 /// a StringMap here because have no other unique reference.
862 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000863
Daniel Dunbar3c76cb52008-08-26 21:51:14 +0000864 /// MethodDefinitions - map of methods which have been defined in
865 /// this translation unit.
866 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000867
Daniel Dunbar80a840b2008-08-23 00:19:03 +0000868 /// PropertyNames - uniqued method variable names.
869 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000870
Daniel Dunbar22d82ed2008-08-21 04:36:09 +0000871 /// ClassReferences - uniqued class references.
872 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000873
Daniel Dunbarcb515c82008-08-12 03:39:23 +0000874 /// SelectorReferences - uniqued selector references.
875 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000876
Daniel Dunbarb036db82008-08-13 03:21:16 +0000877 /// Protocols - Protocols for which an objc_protocol structure has
878 /// been emitted. Forward declarations are handled by creating an
879 /// empty structure whose initializer is filled in when/if defined.
880 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000881
Daniel Dunbarc475d422008-10-29 22:36:39 +0000882 /// DefinedProtocols - Protocols which have actually been
883 /// defined. We should not need this, see FIXME in GenerateProtocol.
884 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000885
Daniel Dunbar22d82ed2008-08-21 04:36:09 +0000886 /// DefinedClasses - List of defined classes.
887 std::vector<llvm::GlobalValue*> DefinedClasses;
Daniel Dunbar9a017d72009-05-15 22:33:15 +0000888
889 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
890 std::vector<llvm::GlobalValue*> DefinedNonLazyClasses;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000891
Daniel Dunbar22d82ed2008-08-21 04:36:09 +0000892 /// DefinedCategories - List of defined categories.
893 std::vector<llvm::GlobalValue*> DefinedCategories;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000894
Daniel Dunbar9a017d72009-05-15 22:33:15 +0000895 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
896 std::vector<llvm::GlobalValue*> DefinedNonLazyCategories;
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000897
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +0000898 /// GetNameForMethod - Return a name for the given method.
899 /// \param[out] NameOut - The return value.
900 void GetNameForMethod(const ObjCMethodDecl *OMD,
901 const ObjCContainerDecl *CD,
Daniel Dunbard2386812009-10-19 01:21:19 +0000902 llvm::SmallVectorImpl<char> &NameOut);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000903
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +0000904 /// GetMethodVarName - Return a unique constant for the given
905 /// selector's name. The return value has type char *.
906 llvm::Constant *GetMethodVarName(Selector Sel);
907 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
908 llvm::Constant *GetMethodVarName(const std::string &Name);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000909
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +0000910 /// GetMethodVarType - Return a unique constant for the given
911 /// selector's name. The return value has type char *.
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000912
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +0000913 // FIXME: This is a horrible name.
914 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D);
Daniel Dunbarf5c18462009-04-20 06:54:31 +0000915 llvm::Constant *GetMethodVarType(const FieldDecl *D);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000916
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +0000917 /// GetPropertyName - Return a unique constant for the given
918 /// name. The return value has type char *.
919 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000920
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +0000921 // FIXME: This can be dropped once string functions are unified.
922 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
923 const Decl *Container);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000924
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +0000925 /// GetClassName - Return a unique constant for the given selector's
926 /// name. The return value has type char *.
927 llvm::Constant *GetClassName(IdentifierInfo *Ident);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000928
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +0000929 /// BuildIvarLayout - Builds ivar layout bitmap for the class
930 /// implementation for the __strong or __weak case.
931 ///
Fariborz Jahanian1bf72882009-03-12 22:50:49 +0000932 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
933 bool ForStrongLayout);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000934
Daniel Dunbar15bd8882009-05-03 14:10:34 +0000935 void BuildAggrIvarRecordLayout(const RecordType *RT,
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000936 unsigned int BytePos, bool ForStrongLayout,
937 bool &HasUnion);
Daniel Dunbar36e2a1e2009-05-03 21:05:10 +0000938 void BuildAggrIvarLayout(const ObjCImplementationDecl *OI,
Fariborz Jahanian1bf72882009-03-12 22:50:49 +0000939 const llvm::StructLayout *Layout,
Fariborz Jahanian524bb202009-03-10 16:22:08 +0000940 const RecordDecl *RD,
Chris Lattner5b36ddb2009-03-31 08:48:01 +0000941 const llvm::SmallVectorImpl<FieldDecl*> &RecFields,
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +0000942 unsigned int BytePos, bool ForStrongLayout,
Fariborz Jahaniana123b642009-04-24 16:17:09 +0000943 bool &HasUnion);
Fariborz Jahanian1bf72882009-03-12 22:50:49 +0000944
Fariborz Jahanian01dff422009-03-05 19:17:31 +0000945 /// GetIvarLayoutName - Returns a unique constant for the given
946 /// ivar layout bitmap.
947 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
948 const ObjCCommonTypesHelper &ObjCTypes);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000949
Fariborz Jahanian066347e2009-01-28 22:18:42 +0000950 /// EmitPropertyList - Emit the given property list. The return
951 /// value has type PropertyListPtrTy.
Daniel Dunbar349e6fb2009-10-18 20:48:59 +0000952 llvm::Constant *EmitPropertyList(llvm::Twine Name,
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000953 const Decl *Container,
Fariborz Jahanian066347e2009-01-28 22:18:42 +0000954 const ObjCContainerDecl *OCD,
955 const ObjCCommonTypesHelper &ObjCTypes);
Daniel Dunbar59e476b2009-08-03 17:06:42 +0000956
Fariborz Jahanian751c1e72009-12-12 21:26:21 +0000957 /// PushProtocolProperties - Push protocol's property on the input stack.
958 void PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*, 16> &PropertySet,
959 std::vector<llvm::Constant*> &Properties,
960 const Decl *Container,
961 const ObjCProtocolDecl *PROTO,
962 const ObjCCommonTypesHelper &ObjCTypes);
963
Fariborz Jahanian56b3b772009-01-29 19:24:30 +0000964 /// GetProtocolRef - Return a reference to the internal protocol
965 /// description, creating an empty one if it has not been
966 /// defined. The return value has type ProtocolPtrTy.
967 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
Fariborz Jahanian67726212009-03-08 20:18:37 +0000968
Daniel Dunbar30c65362009-03-09 20:09:19 +0000969 /// CreateMetadataVar - Create a global variable with internal
970 /// linkage for use by the Objective-C runtime.
971 ///
972 /// This is a convenience wrapper which not only creates the
973 /// variable, but also sets the section and alignment and adds the
Chris Lattnerf56501c2009-07-17 23:57:13 +0000974 /// global to the "llvm.used" list.
Daniel Dunbar463cc8a2009-03-09 20:50:13 +0000975 ///
976 /// \param Name - The variable name.
977 /// \param Init - The variable initializer; this is also used to
978 /// define the type of the variable.
979 /// \param Section - The section the variable should go into, or 0.
980 /// \param Align - The alignment for the variable, or 0.
981 /// \param AddToUsed - Whether the variable should be added to
Daniel Dunbar4527d302009-04-14 17:42:51 +0000982 /// "llvm.used".
Daniel Dunbar349e6fb2009-10-18 20:48:59 +0000983 llvm::GlobalVariable *CreateMetadataVar(llvm::Twine Name,
Daniel Dunbar30c65362009-03-09 20:09:19 +0000984 llvm::Constant *Init,
985 const char *Section,
Daniel Dunbar463cc8a2009-03-09 20:50:13 +0000986 unsigned Align,
987 bool AddToUsed);
Daniel Dunbar30c65362009-03-09 20:09:19 +0000988
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000989 CodeGen::RValue EmitLegacyMessageSend(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +0000990 ReturnValueSlot Return,
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000991 QualType ResultType,
992 llvm::Value *Sel,
993 llvm::Value *Arg0,
994 QualType Arg0Ty,
995 bool IsSuper,
996 const CallArgList &CallArgs,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +0000997 const ObjCMethodDecl *OMD,
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +0000998 const ObjCCommonTypesHelper &ObjCTypes);
Daniel Dunbarf5c18462009-04-20 06:54:31 +0000999
Daniel Dunbar5e639272010-04-25 20:39:01 +00001000 /// EmitImageInfo - Emit the image info marker used to encode some module
1001 /// level information.
1002 void EmitImageInfo();
1003
Fariborz Jahanian279eda62009-01-21 22:04:16 +00001004public:
Owen Andersonae86c192009-07-13 04:10:07 +00001005 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
Mike Stump11289f42009-09-09 15:08:12 +00001006 CGM(cgm), VMContext(cgm.getLLVMContext()) { }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001007
David Chisnall481e3a82010-01-23 02:40:42 +00001008 virtual llvm::Constant *GenerateConstantString(const StringLiteral *SL);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001009
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00001010 virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1011 const ObjCContainerDecl *CD=0);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001012
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001013 virtual void GenerateProtocol(const ObjCProtocolDecl *PD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001014
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001015 /// GetOrEmitProtocol - Get the protocol object for the given
1016 /// declaration, emitting it if necessary. The return value has type
1017 /// ProtocolPtrTy.
1018 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001019
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001020 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1021 /// object for the given declaration, emitting it if needed. These
1022 /// forward references will be filled in with empty bodies if no
1023 /// definition is seen. The return value has type ProtocolPtrTy.
1024 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
Fariborz Jahanian279eda62009-01-21 22:04:16 +00001025};
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001026
Fariborz Jahanian279eda62009-01-21 22:04:16 +00001027class CGObjCMac : public CGObjCCommonMac {
1028private:
1029 ObjCTypesHelper ObjCTypes;
Daniel Dunbar3ad53482008-08-11 21:35:06 +00001030
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00001031 /// EmitModuleInfo - Another marker encoding module level
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001032 /// information.
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00001033 void EmitModuleInfo();
1034
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001035 /// EmitModuleSymols - Emit module symbols, the list of defined
1036 /// classes and categories. The result has type SymtabPtrTy.
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00001037 llvm::Constant *EmitModuleSymbols();
1038
Daniel Dunbar3ad53482008-08-11 21:35:06 +00001039 /// FinishModule - Write out global data structures at the end of
1040 /// processing a translation unit.
1041 void FinishModule();
Daniel Dunbarb036db82008-08-13 03:21:16 +00001042
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001043 /// EmitClassExtension - Generate the class extension structure used
1044 /// to store the weak ivar layout and properties. The return value
1045 /// has type ClassExtensionPtrTy.
1046 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID);
1047
1048 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1049 /// for the given class.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001050 llvm::Value *EmitClassRef(CGBuilderTy &Builder,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001051 const ObjCInterfaceDecl *ID);
Fariborz Jahanianeb80c982009-11-12 20:14:24 +00001052
1053 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1054 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001055
Daniel Dunbar97ff50d2008-08-23 09:25:55 +00001056 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001057 ReturnValueSlot Return,
Daniel Dunbar4b8c6db2008-08-30 05:35:15 +00001058 QualType ResultType,
1059 Selector Sel,
Daniel Dunbar97ff50d2008-08-23 09:25:55 +00001060 llvm::Value *Arg0,
Daniel Dunbarc722b852008-08-30 03:02:31 +00001061 QualType Arg0Ty,
1062 bool IsSuper,
1063 const CallArgList &CallArgs);
Daniel Dunbar97ff50d2008-08-23 09:25:55 +00001064
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001065 /// EmitIvarList - Emit the ivar list for the given
1066 /// implementation. If ForClass is true the list of class ivars
1067 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1068 /// interface ivars will be emitted. The return value has type
1069 /// IvarListPtrTy.
1070 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
Fariborz Jahanianb042a592009-01-28 19:12:34 +00001071 bool ForClass);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001072
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001073 /// EmitMetaClass - Emit a forward reference to the class structure
1074 /// for the metaclass of the given interface. The return value has
1075 /// type ClassPtrTy.
1076 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1077
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001078 /// EmitMetaClass - Emit a class structure for the metaclass of the
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001079 /// given implementation. The return value has type ClassPtrTy.
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001080 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1081 llvm::Constant *Protocols,
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001082 const ConstantVector &Methods);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001083
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001084 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001085
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001086 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001087
1088 /// EmitMethodList - Emit the method list for the given
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001089 /// implementation. The return value has type MethodListPtrTy.
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001090 llvm::Constant *EmitMethodList(llvm::Twine Name,
Daniel Dunbar938a77f2008-08-22 20:34:54 +00001091 const char *Section,
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001092 const ConstantVector &Methods);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001093
1094 /// EmitMethodDescList - Emit a method description list for a list of
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001095 /// method declarations.
Daniel Dunbarb036db82008-08-13 03:21:16 +00001096 /// - TypeName: The name for the type containing the methods.
1097 /// - IsProtocol: True iff these methods are for a protocol.
1098 /// - ClassMethds: True iff these are class methods.
1099 /// - Required: When true, only "required" methods are
1100 /// listed. Similarly, when false only "optional" methods are
1101 /// listed. For classes this should always be true.
1102 /// - begin, end: The method list to output.
1103 ///
1104 /// The return value has type MethodDescriptionListPtrTy.
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001105 llvm::Constant *EmitMethodDescList(llvm::Twine Name,
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001106 const char *Section,
1107 const ConstantVector &Methods);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001108
Daniel Dunbarc475d422008-10-29 22:36:39 +00001109 /// GetOrEmitProtocol - Get the protocol object for the given
1110 /// declaration, emitting it if necessary. The return value has type
1111 /// ProtocolPtrTy.
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001112 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
Daniel Dunbarc475d422008-10-29 22:36:39 +00001113
1114 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1115 /// object for the given declaration, emitting it if needed. These
1116 /// forward references will be filled in with empty bodies if no
1117 /// definition is seen. The return value has type ProtocolPtrTy.
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001118 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD);
Daniel Dunbarc475d422008-10-29 22:36:39 +00001119
Daniel Dunbarb036db82008-08-13 03:21:16 +00001120 /// EmitProtocolExtension - Generate the protocol extension
1121 /// structure used to store optional instance and class methods, and
1122 /// protocol properties. The return value has type
1123 /// ProtocolExtensionPtrTy.
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001124 llvm::Constant *
1125 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1126 const ConstantVector &OptInstanceMethods,
1127 const ConstantVector &OptClassMethods);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001128
1129 /// EmitProtocolList - Generate the list of referenced
1130 /// protocols. The return value has type ProtocolListPtrTy.
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001131 llvm::Constant *EmitProtocolList(llvm::Twine Name,
Daniel Dunbardec75f82008-08-21 21:57:41 +00001132 ObjCProtocolDecl::protocol_iterator begin,
1133 ObjCProtocolDecl::protocol_iterator end);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001134
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001135 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1136 /// for the given selector.
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00001137 llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel,
1138 bool lval=false);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001139
1140public:
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001141 CGObjCMac(CodeGen::CodeGenModule &cgm);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001142
Fariborz Jahanian71394042009-01-23 23:53:38 +00001143 virtual llvm::Function *ModuleInitFunction();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001144
Daniel Dunbar97db84c2008-08-23 03:46:30 +00001145 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001146 ReturnValueSlot Return,
Daniel Dunbar4b8c6db2008-08-30 05:35:15 +00001147 QualType ResultType,
1148 Selector Sel,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001149 llvm::Value *Receiver,
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001150 const CallArgList &CallArgs,
David Chisnall01aa4672010-04-28 19:33:36 +00001151 const ObjCInterfaceDecl *Class,
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001152 const ObjCMethodDecl *Method);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001153
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001154 virtual CodeGen::RValue
Daniel Dunbar97db84c2008-08-23 03:46:30 +00001155 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001156 ReturnValueSlot Return,
Daniel Dunbar4b8c6db2008-08-30 05:35:15 +00001157 QualType ResultType,
1158 Selector Sel,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001159 const ObjCInterfaceDecl *Class,
Fariborz Jahanianbac73ac2009-02-28 20:07:56 +00001160 bool isCategoryImpl,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001161 llvm::Value *Receiver,
Daniel Dunbarc722b852008-08-30 03:02:31 +00001162 bool IsClassMessage,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00001163 const CallArgList &CallArgs,
1164 const ObjCMethodDecl *Method);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001165
Daniel Dunbarcb463852008-11-01 01:53:16 +00001166 virtual llvm::Value *GetClass(CGBuilderTy &Builder,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001167 const ObjCInterfaceDecl *ID);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001168
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00001169 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
1170 bool lval = false);
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001171
1172 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1173 /// untyped one.
1174 virtual llvm::Value *GetSelector(CGBuilderTy &Builder,
1175 const ObjCMethodDecl *Method);
1176
Daniel Dunbar92992502008-08-15 22:20:32 +00001177 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001178
Daniel Dunbar92992502008-08-15 22:20:32 +00001179 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001180
Daniel Dunbarcb463852008-11-01 01:53:16 +00001181 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
Daniel Dunbar89da6ad2008-08-13 00:59:25 +00001182 const ObjCProtocolDecl *PD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001183
Chris Lattnerd4808922009-03-22 21:03:39 +00001184 virtual llvm::Constant *GetPropertyGetFunction();
1185 virtual llvm::Constant *GetPropertySetFunction();
Fariborz Jahanian5a8c2032010-04-12 18:18:10 +00001186 virtual llvm::Constant *GetCopyStructFunction();
Chris Lattnerd4808922009-03-22 21:03:39 +00001187 virtual llvm::Constant *EnumerationMutationFunction();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001188
John McCallbd309292010-07-06 01:34:17 +00001189 virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1190 const ObjCAtTryStmt &S);
1191 virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1192 const ObjCAtSynchronizedStmt &S);
1193 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
Anders Carlsson1963b0c2008-09-09 10:04:29 +00001194 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
1195 const ObjCAtThrowStmt &S);
Fariborz Jahanian83f45b552008-11-18 22:37:34 +00001196 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001197 llvm::Value *AddrWeakObj);
Fariborz Jahanian83f45b552008-11-18 22:37:34 +00001198 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001199 llvm::Value *src, llvm::Value *dst);
Fariborz Jahaniand7db9642008-11-19 00:59:10 +00001200 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1201 llvm::Value *src, llvm::Value *dest);
Fariborz Jahaniane881b532008-11-20 19:23:36 +00001202 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001203 llvm::Value *src, llvm::Value *dest,
1204 llvm::Value *ivarOffset);
Fariborz Jahaniand7db9642008-11-19 00:59:10 +00001205 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1206 llvm::Value *src, llvm::Value *dest);
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00001207 virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1208 llvm::Value *dest, llvm::Value *src,
Fariborz Jahanian021510e2010-06-15 22:44:06 +00001209 llvm::Value *size);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001210
Fariborz Jahanian712bfa62009-02-03 19:03:09 +00001211 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
1212 QualType ObjectTy,
1213 llvm::Value *BaseValue,
1214 const ObjCIvarDecl *Ivar,
Fariborz Jahanian712bfa62009-02-03 19:03:09 +00001215 unsigned CVRQualifiers);
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00001216 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar722f4242009-04-22 05:08:15 +00001217 const ObjCInterfaceDecl *Interface,
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00001218 const ObjCIvarDecl *Ivar);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001219};
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001220
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00001221class CGObjCNonFragileABIMac : public CGObjCCommonMac {
Fariborz Jahanian279eda62009-01-21 22:04:16 +00001222private:
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00001223 ObjCNonFragileABITypesHelper ObjCTypes;
Fariborz Jahanian71394042009-01-23 23:53:38 +00001224 llvm::GlobalVariable* ObjCEmptyCacheVar;
1225 llvm::GlobalVariable* ObjCEmptyVtableVar;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001226
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00001227 /// SuperClassReferences - uniqued super class references.
1228 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001229
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00001230 /// MetaClassReferences - uniqued meta class references.
1231 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
Daniel Dunbarb1559a42009-03-01 04:46:24 +00001232
1233 /// EHTypeReferences - uniqued class ehtype references.
1234 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001235
Fariborz Jahaniane4128642009-05-12 20:06:41 +00001236 /// NonLegacyDispatchMethods - List of methods for which we do *not* generate
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001237 /// legacy messaging dispatch.
Fariborz Jahaniane4128642009-05-12 20:06:41 +00001238 llvm::DenseSet<Selector> NonLegacyDispatchMethods;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001239
Fariborz Jahanian67260552009-11-17 21:37:35 +00001240 /// DefinedMetaClasses - List of defined meta-classes.
1241 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1242
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001243 /// LegacyDispatchedSelector - Returns true if SEL is not in the list of
Fariborz Jahaniane4128642009-05-12 20:06:41 +00001244 /// NonLegacyDispatchMethods; false otherwise.
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001245 bool LegacyDispatchedSelector(Selector Sel);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001246
Fariborz Jahanian71394042009-01-23 23:53:38 +00001247 /// FinishNonFragileABIModule - Write out global data structures at the end of
1248 /// processing a translation unit.
1249 void FinishNonFragileABIModule();
Daniel Dunbar8f28d012009-04-08 04:21:03 +00001250
Daniel Dunbar19573e72009-05-15 21:48:48 +00001251 /// AddModuleClassList - Add the given list of class pointers to the
1252 /// module with the provided symbol and section names.
1253 void AddModuleClassList(const std::vector<llvm::GlobalValue*> &Container,
1254 const char *SymbolName,
1255 const char *SectionName);
1256
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001257 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1258 unsigned InstanceStart,
1259 unsigned InstanceSize,
1260 const ObjCImplementationDecl *ID);
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00001261 llvm::GlobalVariable * BuildClassMetaData(std::string &ClassName,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001262 llvm::Constant *IsAGV,
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00001263 llvm::Constant *SuperClassGV,
Fariborz Jahanian82208252009-01-31 00:59:10 +00001264 llvm::Constant *ClassRoGV,
1265 bool HiddenVisibility);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001266
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00001267 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001268
Fariborz Jahaniand9c28b82009-01-30 00:46:37 +00001269 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001270
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00001271 /// EmitMethodList - Emit the method list for the given
1272 /// implementation. The return value has type MethodListnfABITy.
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001273 llvm::Constant *EmitMethodList(llvm::Twine Name,
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00001274 const char *Section,
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00001275 const ConstantVector &Methods);
1276 /// EmitIvarList - Emit the ivar list for the given
1277 /// implementation. If ForClass is true the list of class ivars
1278 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1279 /// interface ivars will be emitted. The return value has type
1280 /// IvarListnfABIPtrTy.
1281 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001282
Fariborz Jahanian4e7ae062009-02-10 20:21:06 +00001283 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
Fariborz Jahanian3d3426f2009-01-28 01:36:42 +00001284 const ObjCIvarDecl *Ivar,
Fariborz Jahanian40a4bcd2009-01-28 01:05:23 +00001285 unsigned long int offset);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001286
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001287 /// GetOrEmitProtocol - Get the protocol object for the given
1288 /// declaration, emitting it if necessary. The return value has type
1289 /// ProtocolPtrTy.
1290 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001291
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001292 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1293 /// object for the given declaration, emitting it if needed. These
1294 /// forward references will be filled in with empty bodies if no
1295 /// definition is seen. The return value has type ProtocolPtrTy.
1296 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001297
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001298 /// EmitProtocolList - Generate the list of referenced
1299 /// protocols. The return value has type ProtocolListPtrTy.
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001300 llvm::Constant *EmitProtocolList(llvm::Twine Name,
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001301 ObjCProtocolDecl::protocol_iterator begin,
Fariborz Jahanian3d9296e2009-02-04 00:22:57 +00001302 ObjCProtocolDecl::protocol_iterator end);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001303
Fariborz Jahanian3d9296e2009-02-04 00:22:57 +00001304 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001305 ReturnValueSlot Return,
Fariborz Jahanian3d9296e2009-02-04 00:22:57 +00001306 QualType ResultType,
1307 Selector Sel,
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00001308 llvm::Value *Receiver,
Fariborz Jahanian3d9296e2009-02-04 00:22:57 +00001309 QualType Arg0Ty,
1310 bool IsSuper,
1311 const CallArgList &CallArgs);
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00001312
1313 /// GetClassGlobal - Return the global variable for the Objective-C
1314 /// class of the given name.
Fariborz Jahanian899e7eb2009-04-14 18:41:56 +00001315 llvm::GlobalVariable *GetClassGlobal(const std::string &Name);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001316
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00001317 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00001318 /// for the given class reference.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001319 llvm::Value *EmitClassRef(CGBuilderTy &Builder,
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00001320 const ObjCInterfaceDecl *ID);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001321
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00001322 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1323 /// for the given super class reference.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001324 llvm::Value *EmitSuperClassRef(CGBuilderTy &Builder,
1325 const ObjCInterfaceDecl *ID);
1326
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00001327 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1328 /// meta-data
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001329 llvm::Value *EmitMetaClassRef(CGBuilderTy &Builder,
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00001330 const ObjCInterfaceDecl *ID);
1331
Fariborz Jahanian4e7ae062009-02-10 20:21:06 +00001332 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1333 /// the given ivar.
1334 ///
Daniel Dunbara1060522009-04-19 00:31:15 +00001335 llvm::GlobalVariable * ObjCIvarOffsetVariable(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001336 const ObjCInterfaceDecl *ID,
1337 const ObjCIvarDecl *Ivar);
1338
Fariborz Jahanian74b77222009-02-11 20:51:17 +00001339 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1340 /// for the given selector.
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00001341 llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel,
1342 bool lval=false);
Daniel Dunbarb1559a42009-03-01 04:46:24 +00001343
Daniel Dunbar8f28d012009-04-08 04:21:03 +00001344 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
Daniel Dunbarb1559a42009-03-01 04:46:24 +00001345 /// interface. The return value has type EHTypePtrTy.
Daniel Dunbar8f28d012009-04-08 04:21:03 +00001346 llvm::Value *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1347 bool ForDefinition);
Daniel Dunbar15894b72009-04-07 05:48:37 +00001348
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001349 const char *getMetaclassSymbolPrefix() const {
Daniel Dunbar15894b72009-04-07 05:48:37 +00001350 return "OBJC_METACLASS_$_";
1351 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001352
Daniel Dunbar15894b72009-04-07 05:48:37 +00001353 const char *getClassSymbolPrefix() const {
1354 return "OBJC_CLASS_$_";
1355 }
1356
Daniel Dunbar961202372009-05-03 12:57:56 +00001357 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
Daniel Dunbar554fd792009-04-19 23:41:48 +00001358 uint32_t &InstanceStart,
1359 uint32_t &InstanceSize);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001360
Fariborz Jahaniane4128642009-05-12 20:06:41 +00001361 // Shamelessly stolen from Analysis/CFRefCount.cpp
Daniel Dunbar9a017d72009-05-15 22:33:15 +00001362 Selector GetNullarySelector(const char* name) const {
Fariborz Jahaniane4128642009-05-12 20:06:41 +00001363 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1364 return CGM.getContext().Selectors.getSelector(0, &II);
1365 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001366
Daniel Dunbar9a017d72009-05-15 22:33:15 +00001367 Selector GetUnarySelector(const char* name) const {
Fariborz Jahaniane4128642009-05-12 20:06:41 +00001368 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1369 return CGM.getContext().Selectors.getSelector(1, &II);
1370 }
Daniel Dunbar554fd792009-04-19 23:41:48 +00001371
Daniel Dunbar9a017d72009-05-15 22:33:15 +00001372 /// ImplementationIsNonLazy - Check whether the given category or
1373 /// class implementation is "non-lazy".
Fariborz Jahaniana6bed832009-05-21 01:03:45 +00001374 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
Daniel Dunbar9a017d72009-05-15 22:33:15 +00001375
Fariborz Jahanian279eda62009-01-21 22:04:16 +00001376public:
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00001377 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
Fariborz Jahanian71394042009-01-23 23:53:38 +00001378 // FIXME. All stubs for now!
1379 virtual llvm::Function *ModuleInitFunction();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001380
Fariborz Jahanian71394042009-01-23 23:53:38 +00001381 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001382 ReturnValueSlot Return,
Fariborz Jahanian71394042009-01-23 23:53:38 +00001383 QualType ResultType,
1384 Selector Sel,
1385 llvm::Value *Receiver,
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001386 const CallArgList &CallArgs,
David Chisnall01aa4672010-04-28 19:33:36 +00001387 const ObjCInterfaceDecl *Class,
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001388 const ObjCMethodDecl *Method);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001389
1390 virtual CodeGen::RValue
Fariborz Jahanian71394042009-01-23 23:53:38 +00001391 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001392 ReturnValueSlot Return,
Fariborz Jahanian71394042009-01-23 23:53:38 +00001393 QualType ResultType,
1394 Selector Sel,
1395 const ObjCInterfaceDecl *Class,
Fariborz Jahanianbac73ac2009-02-28 20:07:56 +00001396 bool isCategoryImpl,
Fariborz Jahanian71394042009-01-23 23:53:38 +00001397 llvm::Value *Receiver,
1398 bool IsClassMessage,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00001399 const CallArgList &CallArgs,
1400 const ObjCMethodDecl *Method);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001401
Fariborz Jahanian71394042009-01-23 23:53:38 +00001402 virtual llvm::Value *GetClass(CGBuilderTy &Builder,
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00001403 const ObjCInterfaceDecl *ID);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001404
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00001405 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
1406 bool lvalue = false)
1407 { return EmitSelector(Builder, Sel, lvalue); }
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001408
1409 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1410 /// untyped one.
1411 virtual llvm::Value *GetSelector(CGBuilderTy &Builder,
1412 const ObjCMethodDecl *Method)
1413 { return EmitSelector(Builder, Method->getSelector()); }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001414
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00001415 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001416
Fariborz Jahanian71394042009-01-23 23:53:38 +00001417 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
Fariborz Jahanian71394042009-01-23 23:53:38 +00001418 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
Fariborz Jahanian097feda2009-01-30 18:58:59 +00001419 const ObjCProtocolDecl *PD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001420
1421 virtual llvm::Constant *GetPropertyGetFunction() {
Chris Lattnerce8754e2009-04-22 02:44:54 +00001422 return ObjCTypes.getGetPropertyFn();
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00001423 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001424 virtual llvm::Constant *GetPropertySetFunction() {
1425 return ObjCTypes.getSetPropertyFn();
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00001426 }
Fariborz Jahanian5a8c2032010-04-12 18:18:10 +00001427
1428 virtual llvm::Constant *GetCopyStructFunction() {
1429 return ObjCTypes.getCopyStructFn();
1430 }
1431
Chris Lattnerd4808922009-03-22 21:03:39 +00001432 virtual llvm::Constant *EnumerationMutationFunction() {
Chris Lattnerce8754e2009-04-22 02:44:54 +00001433 return ObjCTypes.getEnumerationMutationFn();
Daniel Dunbard73ea8162009-02-16 18:48:45 +00001434 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001435
John McCallbd309292010-07-06 01:34:17 +00001436 virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1437 const ObjCAtTryStmt &S);
1438 virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1439 const ObjCAtSynchronizedStmt &S);
Fariborz Jahanian71394042009-01-23 23:53:38 +00001440 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
Anders Carlsson9ab53d12009-02-16 22:59:18 +00001441 const ObjCAtThrowStmt &S);
Fariborz Jahanian71394042009-01-23 23:53:38 +00001442 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian06292952009-02-16 22:52:32 +00001443 llvm::Value *AddrWeakObj);
Fariborz Jahanian71394042009-01-23 23:53:38 +00001444 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian06292952009-02-16 22:52:32 +00001445 llvm::Value *src, llvm::Value *dst);
Fariborz Jahanian71394042009-01-23 23:53:38 +00001446 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian06292952009-02-16 22:52:32 +00001447 llvm::Value *src, llvm::Value *dest);
Fariborz Jahanian71394042009-01-23 23:53:38 +00001448 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001449 llvm::Value *src, llvm::Value *dest,
1450 llvm::Value *ivarOffset);
Fariborz Jahanian71394042009-01-23 23:53:38 +00001451 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian06292952009-02-16 22:52:32 +00001452 llvm::Value *src, llvm::Value *dest);
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00001453 virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1454 llvm::Value *dest, llvm::Value *src,
Fariborz Jahanian021510e2010-06-15 22:44:06 +00001455 llvm::Value *size);
Fariborz Jahanian712bfa62009-02-03 19:03:09 +00001456 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
1457 QualType ObjectTy,
1458 llvm::Value *BaseValue,
1459 const ObjCIvarDecl *Ivar,
Fariborz Jahanian712bfa62009-02-03 19:03:09 +00001460 unsigned CVRQualifiers);
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00001461 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar722f4242009-04-22 05:08:15 +00001462 const ObjCInterfaceDecl *Interface,
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00001463 const ObjCIvarDecl *Ivar);
Fariborz Jahanian279eda62009-01-21 22:04:16 +00001464};
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001465
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001466} // end anonymous namespace
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00001467
1468/* *** Helper Functions *** */
1469
1470/// getConstantGEP() - Help routine to construct simple GEPs.
Owen Anderson170229f2009-07-14 23:10:40 +00001471static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001472 llvm::Constant *C,
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00001473 unsigned idx0,
1474 unsigned idx1) {
1475 llvm::Value *Idxs[] = {
Owen Anderson41a75022009-08-13 21:57:51 +00001476 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1477 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00001478 };
Owen Andersonade90fd2009-07-29 18:54:39 +00001479 return llvm::ConstantExpr::getGetElementPtr(C, Idxs, 2);
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00001480}
1481
Daniel Dunbar8f28d012009-04-08 04:21:03 +00001482/// hasObjCExceptionAttribute - Return true if this class or any super
1483/// class has the __objc_exception__ attribute.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001484static bool hasObjCExceptionAttribute(ASTContext &Context,
Douglas Gregor78bd61f2009-06-18 16:11:24 +00001485 const ObjCInterfaceDecl *OID) {
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001486 if (OID->hasAttr<ObjCExceptionAttr>())
Daniel Dunbar8f28d012009-04-08 04:21:03 +00001487 return true;
1488 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
Douglas Gregor78bd61f2009-06-18 16:11:24 +00001489 return hasObjCExceptionAttribute(Context, Super);
Daniel Dunbar8f28d012009-04-08 04:21:03 +00001490 return false;
1491}
1492
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00001493/* *** CGObjCMac Public Interface *** */
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001494
Fariborz Jahanian279eda62009-01-21 22:04:16 +00001495CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
Mike Stump11289f42009-09-09 15:08:12 +00001496 ObjCTypes(cgm) {
Fariborz Jahanian279eda62009-01-21 22:04:16 +00001497 ObjCABI = 1;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001498 EmitImageInfo();
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001499}
1500
Daniel Dunbar7c6d3a72008-08-16 00:25:02 +00001501/// GetClass - Return a reference to the class for the given interface
1502/// decl.
Daniel Dunbarcb463852008-11-01 01:53:16 +00001503llvm::Value *CGObjCMac::GetClass(CGBuilderTy &Builder,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001504 const ObjCInterfaceDecl *ID) {
1505 return EmitClassRef(Builder, ID);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001506}
1507
1508/// GetSelector - Return the pointer to the unique'd string for this selector.
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00001509llvm::Value *CGObjCMac::GetSelector(CGBuilderTy &Builder, Selector Sel,
1510 bool lval) {
1511 return EmitSelector(Builder, Sel, lval);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001512}
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001513llvm::Value *CGObjCMac::GetSelector(CGBuilderTy &Builder, const ObjCMethodDecl
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001514 *Method) {
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001515 return EmitSelector(Builder, Method->getSelector());
1516}
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001517
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00001518/// Generate a constant CFString object.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001519/*
1520 struct __builtin_CFString {
1521 const int *isa; // point to __CFConstantStringClassReference
1522 int flags;
1523 const char *str;
1524 long length;
1525 };
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00001526*/
1527
Fariborz Jahanian63408e82010-04-22 20:26:39 +00001528/// or Generate a constant NSString object.
1529/*
1530 struct __builtin_NSString {
1531 const int *isa; // point to __NSConstantStringClassReference
1532 const char *str;
1533 unsigned int length;
1534 };
1535*/
1536
Fariborz Jahanian71394042009-01-23 23:53:38 +00001537llvm::Constant *CGObjCCommonMac::GenerateConstantString(
David Chisnall481e3a82010-01-23 02:40:42 +00001538 const StringLiteral *SL) {
Fariborz Jahanian63408e82010-04-22 20:26:39 +00001539 return (CGM.getLangOptions().NoConstantCFStrings == 0 ?
1540 CGM.GetAddrOfConstantCFString(SL) :
1541 CGM.GetAddrOfConstantNSString(SL));
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001542}
1543
1544/// Generates a message send where the super is the receiver. This is
1545/// a message send to self with special delivery semantics indicating
1546/// which class's method should be called.
Daniel Dunbar97db84c2008-08-23 03:46:30 +00001547CodeGen::RValue
1548CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001549 ReturnValueSlot Return,
Daniel Dunbar4b8c6db2008-08-30 05:35:15 +00001550 QualType ResultType,
1551 Selector Sel,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001552 const ObjCInterfaceDecl *Class,
Fariborz Jahanianbac73ac2009-02-28 20:07:56 +00001553 bool isCategoryImpl,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001554 llvm::Value *Receiver,
Daniel Dunbarc722b852008-08-30 03:02:31 +00001555 bool IsClassMessage,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00001556 const CodeGen::CallArgList &CallArgs,
1557 const ObjCMethodDecl *Method) {
Daniel Dunbarf6397fe2008-08-23 04:28:29 +00001558 // Create and init a super structure; this is a (receiver, class)
1559 // pair we will pass to objc_msgSendSuper.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001560 llvm::Value *ObjCSuper =
Daniel Dunbarf6397fe2008-08-23 04:28:29 +00001561 CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001562 llvm::Value *ReceiverAsObject =
Daniel Dunbarf6397fe2008-08-23 04:28:29 +00001563 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001564 CGF.Builder.CreateStore(ReceiverAsObject,
Daniel Dunbarf6397fe2008-08-23 04:28:29 +00001565 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
Daniel Dunbarf6397fe2008-08-23 04:28:29 +00001566
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001567 // If this is a class message the metaclass is passed as the target.
1568 llvm::Value *Target;
1569 if (IsClassMessage) {
Fariborz Jahanianbac73ac2009-02-28 20:07:56 +00001570 if (isCategoryImpl) {
1571 // Message sent to 'super' in a class method defined in a category
1572 // implementation requires an odd treatment.
1573 // If we are in a class method, we must retrieve the
1574 // _metaclass_ for the current class, pointed at by
1575 // the class's "isa" pointer. The following assumes that
1576 // isa" is the first ivar in a class (which it must be).
1577 Target = EmitClassRef(CGF.Builder, Class->getSuperClass());
1578 Target = CGF.Builder.CreateStructGEP(Target, 0);
1579 Target = CGF.Builder.CreateLoad(Target);
Mike Stump658fe022009-07-30 22:28:39 +00001580 } else {
Fariborz Jahanianbac73ac2009-02-28 20:07:56 +00001581 llvm::Value *MetaClassPtr = EmitMetaClassRef(Class);
1582 llvm::Value *SuperPtr = CGF.Builder.CreateStructGEP(MetaClassPtr, 1);
1583 llvm::Value *Super = CGF.Builder.CreateLoad(SuperPtr);
1584 Target = Super;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001585 }
Fariborz Jahanianda2efb02009-11-14 02:18:31 +00001586 }
1587 else if (isCategoryImpl)
1588 Target = EmitClassRef(CGF.Builder, Class->getSuperClass());
1589 else {
Fariborz Jahanianeb80c982009-11-12 20:14:24 +00001590 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
1591 ClassPtr = CGF.Builder.CreateStructGEP(ClassPtr, 1);
1592 Target = CGF.Builder.CreateLoad(ClassPtr);
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001593 }
Mike Stump18bb9282009-05-16 07:57:57 +00001594 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
1595 // ObjCTypes types.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001596 const llvm::Type *ClassTy =
Daniel Dunbarc722b852008-08-30 03:02:31 +00001597 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
Daniel Dunbarc475d422008-10-29 22:36:39 +00001598 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001599 CGF.Builder.CreateStore(Target,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001600 CGF.Builder.CreateStructGEP(ObjCSuper, 1));
John McCall78a15112010-05-22 01:48:05 +00001601 return EmitLegacyMessageSend(CGF, Return, ResultType,
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001602 EmitSelector(CGF.Builder, Sel),
1603 ObjCSuper, ObjCTypes.SuperPtrCTy,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00001604 true, CallArgs, Method, ObjCTypes);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001605}
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001606
1607/// Generate code for a message send expression.
Daniel Dunbar97db84c2008-08-23 03:46:30 +00001608CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001609 ReturnValueSlot Return,
Daniel Dunbar4b8c6db2008-08-30 05:35:15 +00001610 QualType ResultType,
1611 Selector Sel,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00001612 llvm::Value *Receiver,
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001613 const CallArgList &CallArgs,
David Chisnall01aa4672010-04-28 19:33:36 +00001614 const ObjCInterfaceDecl *Class,
Fariborz Jahanianf3648b82009-05-05 21:36:57 +00001615 const ObjCMethodDecl *Method) {
John McCall78a15112010-05-22 01:48:05 +00001616 return EmitLegacyMessageSend(CGF, Return, ResultType,
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001617 EmitSelector(CGF.Builder, Sel),
1618 Receiver, CGF.getContext().getObjCIdType(),
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00001619 false, CallArgs, Method, ObjCTypes);
Daniel Dunbar97ff50d2008-08-23 09:25:55 +00001620}
1621
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00001622CodeGen::RValue
1623CGObjCCommonMac::EmitLegacyMessageSend(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00001624 ReturnValueSlot Return,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00001625 QualType ResultType,
1626 llvm::Value *Sel,
1627 llvm::Value *Arg0,
1628 QualType Arg0Ty,
1629 bool IsSuper,
1630 const CallArgList &CallArgs,
1631 const ObjCMethodDecl *Method,
1632 const ObjCCommonTypesHelper &ObjCTypes) {
Daniel Dunbarc722b852008-08-30 03:02:31 +00001633 CallArgList ActualArgs;
Fariborz Jahanian969bc682009-04-24 21:07:43 +00001634 if (!IsSuper)
1635 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy, "tmp");
Daniel Dunbar41cf9de2008-09-09 01:06:48 +00001636 ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty));
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001637 ActualArgs.push_back(std::make_pair(RValue::get(Sel),
Daniel Dunbarc722b852008-08-30 03:02:31 +00001638 CGF.getContext().getObjCSelType()));
1639 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001640
Daniel Dunbarbf8c24a2009-02-02 23:23:47 +00001641 CodeGenTypes &Types = CGM.getTypes();
John McCallab26cfa2010-02-05 21:31:56 +00001642 const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs,
Rafael Espindolac50c27c2010-03-30 20:24:48 +00001643 FunctionType::ExtInfo());
Daniel Dunbardf0e62d2009-09-17 04:01:40 +00001644 const llvm::FunctionType *FTy =
1645 Types.GetFunctionType(FnInfo, Method ? Method->isVariadic() : false);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001646
Anders Carlsson280e61f12010-06-21 20:59:55 +00001647 if (Method)
1648 assert(CGM.getContext().getCanonicalType(Method->getResultType()) ==
1649 CGM.getContext().getCanonicalType(ResultType) &&
1650 "Result type mismatch!");
1651
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001652 llvm::Constant *Fn = NULL;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001653 if (CGM.ReturnTypeUsesSRet(FnInfo)) {
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001654 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001655 : ObjCTypes.getSendStretFn(IsSuper);
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001656 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
1657 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
1658 : ObjCTypes.getSendFpretFn(IsSuper);
Daniel Dunbar3c683f5b2008-10-17 03:24:53 +00001659 } else {
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00001660 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001661 : ObjCTypes.getSendFn(IsSuper);
Daniel Dunbar3c683f5b2008-10-17 03:24:53 +00001662 }
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001663 Fn = llvm::ConstantExpr::getBitCast(Fn, llvm::PointerType::getUnqual(FTy));
John McCall78a15112010-05-22 01:48:05 +00001664 return CGF.EmitCall(FnInfo, Fn, Return, ActualArgs);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001665}
1666
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001667llvm::Value *CGObjCMac::GenerateProtocolRef(CGBuilderTy &Builder,
Daniel Dunbar89da6ad2008-08-13 00:59:25 +00001668 const ObjCProtocolDecl *PD) {
Daniel Dunbar7050c552008-09-04 04:33:15 +00001669 // FIXME: I don't understand why gcc generates this, or where it is
Mike Stump18bb9282009-05-16 07:57:57 +00001670 // resolved. Investigate. Its also wasteful to look this up over and over.
Daniel Dunbar7050c552008-09-04 04:33:15 +00001671 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
1672
Owen Andersonade90fd2009-07-29 18:54:39 +00001673 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
Daniel Dunbarb036db82008-08-13 03:21:16 +00001674 ObjCTypes.ExternalProtocolPtrTy);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001675}
1676
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001677void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
Mike Stump18bb9282009-05-16 07:57:57 +00001678 // FIXME: We shouldn't need this, the protocol decl should contain enough
1679 // information to tell us whether this was a declaration or a definition.
Daniel Dunbarc475d422008-10-29 22:36:39 +00001680 DefinedProtocols.insert(PD->getIdentifier());
1681
1682 // If we have generated a forward reference to this protocol, emit
1683 // it now. Otherwise do nothing, the protocol objects are lazily
1684 // emitted.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001685 if (Protocols.count(PD->getIdentifier()))
Daniel Dunbarc475d422008-10-29 22:36:39 +00001686 GetOrEmitProtocol(PD);
1687}
1688
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00001689llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
Daniel Dunbarc475d422008-10-29 22:36:39 +00001690 if (DefinedProtocols.count(PD->getIdentifier()))
1691 return GetOrEmitProtocol(PD);
1692 return GetOrEmitProtocolRef(PD);
1693}
1694
Daniel Dunbarb036db82008-08-13 03:21:16 +00001695/*
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001696// APPLE LOCAL radar 4585769 - Objective-C 1.0 extensions
1697struct _objc_protocol {
1698struct _objc_protocol_extension *isa;
1699char *protocol_name;
1700struct _objc_protocol_list *protocol_list;
1701struct _objc__method_prototype_list *instance_methods;
1702struct _objc__method_prototype_list *class_methods
1703};
Daniel Dunbarb036db82008-08-13 03:21:16 +00001704
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001705See EmitProtocolExtension().
Daniel Dunbarb036db82008-08-13 03:21:16 +00001706*/
Daniel Dunbarc475d422008-10-29 22:36:39 +00001707llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
1708 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
1709
1710 // Early exit if a defining object has already been generated.
1711 if (Entry && Entry->hasInitializer())
1712 return Entry;
1713
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00001714 // FIXME: I don't understand why gcc generates this, or where it is
Mike Stump18bb9282009-05-16 07:57:57 +00001715 // resolved. Investigate. Its also wasteful to look this up over and over.
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00001716 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
1717
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001718 // Construct method lists.
1719 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
1720 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001721 for (ObjCProtocolDecl::instmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001722 i = PD->instmeth_begin(), e = PD->instmeth_end(); i != e; ++i) {
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001723 ObjCMethodDecl *MD = *i;
1724 llvm::Constant *C = GetMethodDescriptionConstant(MD);
1725 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
1726 OptInstanceMethods.push_back(C);
1727 } else {
1728 InstanceMethods.push_back(C);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001729 }
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001730 }
1731
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001732 for (ObjCProtocolDecl::classmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001733 i = PD->classmeth_begin(), e = PD->classmeth_end(); i != e; ++i) {
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001734 ObjCMethodDecl *MD = *i;
1735 llvm::Constant *C = GetMethodDescriptionConstant(MD);
1736 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
1737 OptClassMethods.push_back(C);
1738 } else {
1739 ClassMethods.push_back(C);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001740 }
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001741 }
1742
Daniel Dunbarb036db82008-08-13 03:21:16 +00001743 std::vector<llvm::Constant*> Values(5);
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001744 Values[0] = EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001745 Values[1] = GetClassName(PD->getIdentifier());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001746 Values[2] =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001747 EmitProtocolList("\01L_OBJC_PROTOCOL_REFS_" + PD->getName(),
Daniel Dunbardec75f82008-08-21 21:57:41 +00001748 PD->protocol_begin(),
1749 PD->protocol_end());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001750 Values[3] =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001751 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_" + PD->getName(),
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001752 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
1753 InstanceMethods);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001754 Values[4] =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001755 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_" + PD->getName(),
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001756 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
1757 ClassMethods);
Owen Anderson0e0189d2009-07-27 22:29:56 +00001758 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
Daniel Dunbarb036db82008-08-13 03:21:16 +00001759 Values);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001760
Daniel Dunbarb036db82008-08-13 03:21:16 +00001761 if (Entry) {
Daniel Dunbarc475d422008-10-29 22:36:39 +00001762 // Already created, fix the linkage and update the initializer.
1763 Entry->setLinkage(llvm::GlobalValue::InternalLinkage);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001764 Entry->setInitializer(Init);
1765 } else {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001766 Entry =
Owen Andersonc10c8d32009-07-08 19:05:04 +00001767 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, false,
Daniel Dunbarb036db82008-08-13 03:21:16 +00001768 llvm::GlobalValue::InternalLinkage,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001769 Init,
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001770 "\01L_OBJC_PROTOCOL_" + PD->getName());
Daniel Dunbarb036db82008-08-13 03:21:16 +00001771 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
Daniel Dunbarb036db82008-08-13 03:21:16 +00001772 // FIXME: Is this necessary? Why only for protocol?
1773 Entry->setAlignment(4);
1774 }
Chris Lattnerf56501c2009-07-17 23:57:13 +00001775 CGM.AddUsedGlobal(Entry);
Daniel Dunbarc475d422008-10-29 22:36:39 +00001776
1777 return Entry;
Daniel Dunbarb036db82008-08-13 03:21:16 +00001778}
1779
Daniel Dunbarc475d422008-10-29 22:36:39 +00001780llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
Daniel Dunbarb036db82008-08-13 03:21:16 +00001781 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
1782
1783 if (!Entry) {
Daniel Dunbarc475d422008-10-29 22:36:39 +00001784 // We use the initializer as a marker of whether this is a forward
1785 // reference or not. At module finalization we add the empty
1786 // contents for protocols which were referenced but never defined.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001787 Entry =
Owen Andersonc10c8d32009-07-08 19:05:04 +00001788 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, false,
Daniel Dunbarc475d422008-10-29 22:36:39 +00001789 llvm::GlobalValue::ExternalLinkage,
1790 0,
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001791 "\01L_OBJC_PROTOCOL_" + PD->getName());
Daniel Dunbarb036db82008-08-13 03:21:16 +00001792 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
Daniel Dunbarb036db82008-08-13 03:21:16 +00001793 // FIXME: Is this necessary? Why only for protocol?
1794 Entry->setAlignment(4);
1795 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001796
Daniel Dunbarb036db82008-08-13 03:21:16 +00001797 return Entry;
1798}
1799
1800/*
1801 struct _objc_protocol_extension {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001802 uint32_t size;
1803 struct objc_method_description_list *optional_instance_methods;
1804 struct objc_method_description_list *optional_class_methods;
1805 struct objc_property_list *instance_properties;
Daniel Dunbarb036db82008-08-13 03:21:16 +00001806 };
1807*/
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001808llvm::Constant *
1809CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
1810 const ConstantVector &OptInstanceMethods,
1811 const ConstantVector &OptClassMethods) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001812 uint64_t Size =
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00001813 CGM.getTargetData().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001814 std::vector<llvm::Constant*> Values(4);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00001815 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001816 Values[1] =
1817 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_OPT_"
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001818 + PD->getName(),
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001819 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
1820 OptInstanceMethods);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001821 Values[2] =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001822 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_OPT_" + PD->getName(),
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001823 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
1824 OptClassMethods);
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001825 Values[3] = EmitPropertyList("\01L_OBJC_$_PROP_PROTO_LIST_" + PD->getName(),
Fariborz Jahanian066347e2009-01-28 22:18:42 +00001826 0, PD, ObjCTypes);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001827
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001828 // Return null if no extension bits are used.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001829 if (Values[1]->isNullValue() && Values[2]->isNullValue() &&
Daniel Dunbarb036db82008-08-13 03:21:16 +00001830 Values[3]->isNullValue())
Owen Anderson0b75f232009-07-31 20:28:54 +00001831 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001832
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001833 llvm::Constant *Init =
Owen Anderson0e0189d2009-07-27 22:29:56 +00001834 llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001835
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00001836 // No special section, but goes in llvm.used
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001837 return CreateMetadataVar("\01L_OBJC_PROTOCOLEXT_" + PD->getName(),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001838 Init,
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00001839 0, 0, true);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001840}
1841
1842/*
1843 struct objc_protocol_list {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001844 struct objc_protocol_list *next;
1845 long count;
1846 Protocol *list[];
Daniel Dunbarb036db82008-08-13 03:21:16 +00001847 };
1848*/
Daniel Dunbardec75f82008-08-21 21:57:41 +00001849llvm::Constant *
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001850CGObjCMac::EmitProtocolList(llvm::Twine Name,
Daniel Dunbardec75f82008-08-21 21:57:41 +00001851 ObjCProtocolDecl::protocol_iterator begin,
1852 ObjCProtocolDecl::protocol_iterator end) {
Daniel Dunbarb036db82008-08-13 03:21:16 +00001853 std::vector<llvm::Constant*> ProtocolRefs;
1854
Daniel Dunbardec75f82008-08-21 21:57:41 +00001855 for (; begin != end; ++begin)
1856 ProtocolRefs.push_back(GetProtocolRef(*begin));
Daniel Dunbarb036db82008-08-13 03:21:16 +00001857
1858 // Just return null for empty protocol lists
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001859 if (ProtocolRefs.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00001860 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001861
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001862 // This list is null terminated.
Owen Anderson0b75f232009-07-31 20:28:54 +00001863 ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy));
Daniel Dunbarb036db82008-08-13 03:21:16 +00001864
1865 std::vector<llvm::Constant*> Values(3);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00001866 // This field is only used by the runtime.
Owen Anderson0b75f232009-07-31 20:28:54 +00001867 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00001868 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001869 ProtocolRefs.size() - 1);
1870 Values[2] =
1871 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy,
1872 ProtocolRefs.size()),
Daniel Dunbarb036db82008-08-13 03:21:16 +00001873 ProtocolRefs);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001874
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00001875 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001876 llvm::GlobalVariable *GV =
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00001877 CreateMetadataVar(Name, Init, "__OBJC,__cat_cls_meth,regular,no_dead_strip",
Daniel Dunbarae333842009-03-09 22:18:41 +00001878 4, false);
Owen Andersonade90fd2009-07-29 18:54:39 +00001879 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001880}
1881
Fariborz Jahanian751c1e72009-12-12 21:26:21 +00001882void CGObjCCommonMac::PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*, 16> &PropertySet,
1883 std::vector<llvm::Constant*> &Properties,
1884 const Decl *Container,
1885 const ObjCProtocolDecl *PROTO,
1886 const ObjCCommonTypesHelper &ObjCTypes) {
1887 std::vector<llvm::Constant*> Prop(2);
1888 for (ObjCProtocolDecl::protocol_iterator P = PROTO->protocol_begin(),
1889 E = PROTO->protocol_end(); P != E; ++P)
1890 PushProtocolProperties(PropertySet, Properties, Container, (*P), ObjCTypes);
1891 for (ObjCContainerDecl::prop_iterator I = PROTO->prop_begin(),
1892 E = PROTO->prop_end(); I != E; ++I) {
1893 const ObjCPropertyDecl *PD = *I;
1894 if (!PropertySet.insert(PD->getIdentifier()))
1895 continue;
1896 Prop[0] = GetPropertyName(PD->getIdentifier());
1897 Prop[1] = GetPropertyTypeString(PD, Container);
1898 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy, Prop));
1899 }
1900}
1901
Daniel Dunbarb036db82008-08-13 03:21:16 +00001902/*
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001903 struct _objc_property {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001904 const char * const name;
1905 const char * const attributes;
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001906 };
1907
1908 struct _objc_property_list {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001909 uint32_t entsize; // sizeof (struct _objc_property)
1910 uint32_t prop_count;
1911 struct _objc_property[prop_count];
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001912 };
1913*/
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001914llvm::Constant *CGObjCCommonMac::EmitPropertyList(llvm::Twine Name,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001915 const Decl *Container,
1916 const ObjCContainerDecl *OCD,
1917 const ObjCCommonTypesHelper &ObjCTypes) {
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001918 std::vector<llvm::Constant*> Properties, Prop(2);
Fariborz Jahanian751c1e72009-12-12 21:26:21 +00001919 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001920 for (ObjCContainerDecl::prop_iterator I = OCD->prop_begin(),
1921 E = OCD->prop_end(); I != E; ++I) {
Steve Naroffba3dc382009-01-11 12:47:58 +00001922 const ObjCPropertyDecl *PD = *I;
Fariborz Jahanian751c1e72009-12-12 21:26:21 +00001923 PropertySet.insert(PD->getIdentifier());
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001924 Prop[0] = GetPropertyName(PD->getIdentifier());
Daniel Dunbar4932b362008-08-28 04:38:10 +00001925 Prop[1] = GetPropertyTypeString(PD, Container);
Owen Anderson0e0189d2009-07-27 22:29:56 +00001926 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy,
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001927 Prop));
1928 }
Fariborz Jahanian7966aff2010-06-22 16:33:55 +00001929 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
Fariborz Jahanian751c1e72009-12-12 21:26:21 +00001930 for (ObjCInterfaceDecl::protocol_iterator P = OID->protocol_begin(),
1931 E = OID->protocol_end(); P != E; ++P)
Fariborz Jahanian7966aff2010-06-22 16:33:55 +00001932 PushProtocolProperties(PropertySet, Properties, Container, (*P),
1933 ObjCTypes);
1934 }
1935 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
1936 for (ObjCCategoryDecl::protocol_iterator P = CD->protocol_begin(),
1937 E = CD->protocol_end(); P != E; ++P)
1938 PushProtocolProperties(PropertySet, Properties, Container, (*P),
1939 ObjCTypes);
1940 }
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001941
1942 // Return null for empty list.
1943 if (Properties.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00001944 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001945
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001946 unsigned PropertySize =
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00001947 CGM.getTargetData().getTypeAllocSize(ObjCTypes.PropertyTy);
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001948 std::vector<llvm::Constant*> Values(3);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00001949 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize);
1950 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001951 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy,
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001952 Properties.size());
Owen Anderson47034e12009-07-28 18:33:04 +00001953 Values[2] = llvm::ConstantArray::get(AT, Properties);
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00001954 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001955
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001956 llvm::GlobalVariable *GV =
1957 CreateMetadataVar(Name, Init,
1958 (ObjCABI == 2) ? "__DATA, __objc_const" :
Daniel Dunbarb25452a2009-04-15 02:56:18 +00001959 "__OBJC,__property,regular,no_dead_strip",
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001960 (ObjCABI == 2) ? 8 : 4,
Daniel Dunbarb25452a2009-04-15 02:56:18 +00001961 true);
Owen Andersonade90fd2009-07-29 18:54:39 +00001962 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
Daniel Dunbar80a840b2008-08-23 00:19:03 +00001963}
1964
1965/*
Daniel Dunbarb036db82008-08-13 03:21:16 +00001966 struct objc_method_description_list {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001967 int count;
1968 struct objc_method_description list[];
Daniel Dunbarb036db82008-08-13 03:21:16 +00001969 };
1970*/
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001971llvm::Constant *
1972CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
1973 std::vector<llvm::Constant*> Desc(2);
Owen Anderson170229f2009-07-14 23:10:40 +00001974 Desc[0] =
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001975 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
1976 ObjCTypes.SelectorPtrTy);
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001977 Desc[1] = GetMethodVarType(MD);
Owen Anderson0e0189d2009-07-27 22:29:56 +00001978 return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy,
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001979 Desc);
1980}
Daniel Dunbarb036db82008-08-13 03:21:16 +00001981
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00001982llvm::Constant *CGObjCMac::EmitMethodDescList(llvm::Twine Name,
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00001983 const char *Section,
1984 const ConstantVector &Methods) {
Daniel Dunbarb036db82008-08-13 03:21:16 +00001985 // Return null for empty list.
1986 if (Methods.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00001987 return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001988
1989 std::vector<llvm::Constant*> Values(2);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00001990 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001991 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy,
Daniel Dunbarb036db82008-08-13 03:21:16 +00001992 Methods.size());
Owen Anderson47034e12009-07-28 18:33:04 +00001993 Values[1] = llvm::ConstantArray::get(AT, Methods);
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00001994 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbarb036db82008-08-13 03:21:16 +00001995
Daniel Dunbarb25452a2009-04-15 02:56:18 +00001996 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00001997 return llvm::ConstantExpr::getBitCast(GV,
Daniel Dunbarb036db82008-08-13 03:21:16 +00001998 ObjCTypes.MethodDescriptionListPtrTy);
Daniel Dunbar303e2c22008-08-11 02:45:11 +00001999}
2000
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002001/*
2002 struct _objc_category {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002003 char *category_name;
2004 char *class_name;
2005 struct _objc_method_list *instance_methods;
2006 struct _objc_method_list *class_methods;
2007 struct _objc_protocol_list *protocols;
2008 uint32_t size; // <rdar://4585769>
2009 struct _objc_property_list *instance_properties;
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002010 };
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002011*/
Daniel Dunbar92992502008-08-15 22:20:32 +00002012void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00002013 unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.CategoryTy);
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002014
Mike Stump18bb9282009-05-16 07:57:57 +00002015 // FIXME: This is poor design, the OCD should have a pointer to the category
2016 // decl. Additionally, note that Category can be null for the @implementation
2017 // w/o an @interface case. Sema should just create one for us as it does for
2018 // @implementation so everyone else can live life under a clear blue sky.
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002019 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002020 const ObjCCategoryDecl *Category =
Daniel Dunbar28e76ca2008-08-26 23:03:11 +00002021 Interface->FindCategoryDeclaration(OCD->getIdentifier());
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002022
2023 llvm::SmallString<256> ExtName;
2024 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
2025 << OCD->getName();
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002026
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002027 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002028 for (ObjCCategoryImplDecl::instmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002029 i = OCD->instmeth_begin(), e = OCD->instmeth_end(); i != e; ++i) {
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002030 // Instance methods should always be defined.
2031 InstanceMethods.push_back(GetMethodConstant(*i));
2032 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002033 for (ObjCCategoryImplDecl::classmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002034 i = OCD->classmeth_begin(), e = OCD->classmeth_end(); i != e; ++i) {
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002035 // Class methods should always be defined.
2036 ClassMethods.push_back(GetMethodConstant(*i));
2037 }
2038
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002039 std::vector<llvm::Constant*> Values(7);
2040 Values[0] = GetClassName(OCD->getIdentifier());
2041 Values[1] = GetClassName(Interface->getIdentifier());
Fariborz Jahaniane55f8662009-04-29 20:40:05 +00002042 LazySymbols.insert(Interface->getIdentifier());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002043 Values[2] =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002044 EmitMethodList("\01L_OBJC_CATEGORY_INSTANCE_METHODS_" + ExtName.str(),
Daniel Dunbar80a840b2008-08-23 00:19:03 +00002045 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002046 InstanceMethods);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002047 Values[3] =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002048 EmitMethodList("\01L_OBJC_CATEGORY_CLASS_METHODS_" + ExtName.str(),
Daniel Dunbarb25452a2009-04-15 02:56:18 +00002049 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002050 ClassMethods);
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00002051 if (Category) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002052 Values[4] =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002053 EmitProtocolList("\01L_OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00002054 Category->protocol_begin(),
2055 Category->protocol_end());
2056 } else {
Owen Anderson0b75f232009-07-31 20:28:54 +00002057 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00002058 }
Owen Andersonb7a2fe62009-07-24 23:12:58 +00002059 Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Daniel Dunbar28e76ca2008-08-26 23:03:11 +00002060
2061 // If there is no category @interface then there can be no properties.
2062 if (Category) {
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002063 Values[6] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
Fariborz Jahanian066347e2009-01-28 22:18:42 +00002064 OCD, Category, ObjCTypes);
Daniel Dunbar28e76ca2008-08-26 23:03:11 +00002065 } else {
Owen Anderson0b75f232009-07-31 20:28:54 +00002066 Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
Daniel Dunbar28e76ca2008-08-26 23:03:11 +00002067 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002068
Owen Anderson0e0189d2009-07-27 22:29:56 +00002069 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy,
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002070 Values);
2071
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002072 llvm::GlobalVariable *GV =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002073 CreateMetadataVar("\01L_OBJC_CATEGORY_" + ExtName.str(), Init,
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00002074 "__OBJC,__category,regular,no_dead_strip",
Daniel Dunbarae333842009-03-09 22:18:41 +00002075 4, true);
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002076 DefinedCategories.push_back(GV);
Fariborz Jahanian9adb2e62010-06-21 22:05:18 +00002077 DefinedCategoryNames.insert(ExtName.str());
Daniel Dunbar303e2c22008-08-11 02:45:11 +00002078}
2079
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002080// FIXME: Get from somewhere?
2081enum ClassFlags {
2082 eClassFlags_Factory = 0x00001,
2083 eClassFlags_Meta = 0x00002,
2084 // <rdr://5142207>
2085 eClassFlags_HasCXXStructors = 0x02000,
2086 eClassFlags_Hidden = 0x20000,
2087 eClassFlags_ABI2_Hidden = 0x00010,
2088 eClassFlags_ABI2_HasCXXStructors = 0x00004 // <rdr://4923634>
2089};
2090
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002091/*
2092 struct _objc_class {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002093 Class isa;
2094 Class super_class;
2095 const char *name;
2096 long version;
2097 long info;
2098 long instance_size;
2099 struct _objc_ivar_list *ivars;
2100 struct _objc_method_list *methods;
2101 struct _objc_cache *cache;
2102 struct _objc_protocol_list *protocols;
2103 // Objective-C 1.0 extensions (<rdr://4585769>)
2104 const char *ivar_layout;
2105 struct _objc_class_ext *ext;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002106 };
2107
2108 See EmitClassExtension();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002109*/
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002110void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00002111 DefinedSymbols.insert(ID->getIdentifier());
2112
Chris Lattner86d7d912008-11-24 03:54:41 +00002113 std::string ClassName = ID->getNameAsString();
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002114 // FIXME: Gross
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002115 ObjCInterfaceDecl *Interface =
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002116 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002117 llvm::Constant *Protocols =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002118 EmitProtocolList("\01L_OBJC_CLASS_PROTOCOLS_" + ID->getName(),
Daniel Dunbardec75f82008-08-21 21:57:41 +00002119 Interface->protocol_begin(),
2120 Interface->protocol_end());
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002121 unsigned Flags = eClassFlags_Factory;
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002122 if (ID->getNumIvarInitializers())
2123 Flags |= eClassFlags_HasCXXStructors;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002124 unsigned Size =
Daniel Dunbar12119b92009-05-03 10:46:44 +00002125 CGM.getContext().getASTObjCImplementationLayout(ID).getSize() / 8;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002126
2127 // FIXME: Set CXX-structors flag.
Daniel Dunbarf5f359f2009-04-14 06:00:08 +00002128 if (CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden)
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002129 Flags |= eClassFlags_Hidden;
2130
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002131 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002132 for (ObjCImplementationDecl::instmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002133 i = ID->instmeth_begin(), e = ID->instmeth_end(); i != e; ++i) {
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002134 // Instance methods should always be defined.
2135 InstanceMethods.push_back(GetMethodConstant(*i));
2136 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002137 for (ObjCImplementationDecl::classmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002138 i = ID->classmeth_begin(), e = ID->classmeth_end(); i != e; ++i) {
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002139 // Class methods should always be defined.
2140 ClassMethods.push_back(GetMethodConstant(*i));
2141 }
2142
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002143 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002144 i = ID->propimpl_begin(), e = ID->propimpl_end(); i != e; ++i) {
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002145 ObjCPropertyImplDecl *PID = *i;
2146
2147 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2148 ObjCPropertyDecl *PD = PID->getPropertyDecl();
2149
2150 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
2151 if (llvm::Constant *C = GetMethodConstant(MD))
2152 InstanceMethods.push_back(C);
2153 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
2154 if (llvm::Constant *C = GetMethodConstant(MD))
2155 InstanceMethods.push_back(C);
2156 }
2157 }
2158
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002159 std::vector<llvm::Constant*> Values(12);
Daniel Dunbarccf61832009-05-03 08:56:52 +00002160 Values[ 0] = EmitMetaClass(ID, Protocols, ClassMethods);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002161 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00002162 // Record a reference to the super class.
2163 LazySymbols.insert(Super->getIdentifier());
2164
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002165 Values[ 1] =
Owen Andersonade90fd2009-07-29 18:54:39 +00002166 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002167 ObjCTypes.ClassPtrTy);
2168 } else {
Owen Anderson0b75f232009-07-31 20:28:54 +00002169 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002170 }
2171 Values[ 2] = GetClassName(ID->getIdentifier());
2172 // Version is always 0.
Owen Andersonb7a2fe62009-07-24 23:12:58 +00002173 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
2174 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
2175 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
Fariborz Jahanianb042a592009-01-28 19:12:34 +00002176 Values[ 6] = EmitIvarList(ID, false);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002177 Values[ 7] =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002178 EmitMethodList("\01L_OBJC_INSTANCE_METHODS_" + ID->getName(),
Daniel Dunbar80a840b2008-08-23 00:19:03 +00002179 "__OBJC,__inst_meth,regular,no_dead_strip",
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002180 InstanceMethods);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002181 // cache is always NULL.
Owen Anderson0b75f232009-07-31 20:28:54 +00002182 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002183 Values[ 9] = Protocols;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002184 Values[10] = BuildIvarLayout(ID, true);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002185 Values[11] = EmitClassExtension(ID);
Owen Anderson0e0189d2009-07-27 22:29:56 +00002186 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002187 Values);
Fariborz Jahanianeb80c982009-11-12 20:14:24 +00002188 std::string Name("\01L_OBJC_CLASS_");
2189 Name += ClassName;
2190 const char *Section = "__OBJC,__class,regular,no_dead_strip";
2191 // Check for a forward reference.
2192 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
2193 if (GV) {
2194 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
2195 "Forward metaclass reference has incorrect type.");
2196 GV->setLinkage(llvm::GlobalValue::InternalLinkage);
2197 GV->setInitializer(Init);
2198 GV->setSection(Section);
2199 GV->setAlignment(4);
2200 CGM.AddUsedGlobal(GV);
2201 }
2202 else
2203 GV = CreateMetadataVar(Name, Init, Section, 4, true);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002204 DefinedClasses.push_back(GV);
2205}
2206
2207llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
2208 llvm::Constant *Protocols,
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00002209 const ConstantVector &Methods) {
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002210 unsigned Flags = eClassFlags_Meta;
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00002211 unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.ClassTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002212
Daniel Dunbarf5f359f2009-04-14 06:00:08 +00002213 if (CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden)
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002214 Flags |= eClassFlags_Hidden;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002215
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002216 std::vector<llvm::Constant*> Values(12);
2217 // The isa for the metaclass is the root of the hierarchy.
2218 const ObjCInterfaceDecl *Root = ID->getClassInterface();
2219 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
2220 Root = Super;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002221 Values[ 0] =
Owen Andersonade90fd2009-07-29 18:54:39 +00002222 llvm::ConstantExpr::getBitCast(GetClassName(Root->getIdentifier()),
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002223 ObjCTypes.ClassPtrTy);
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002224 // The super class for the metaclass is emitted as the name of the
2225 // super class. The runtime fixes this up to point to the
2226 // *metaclass* for the super class.
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002227 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002228 Values[ 1] =
Owen Andersonade90fd2009-07-29 18:54:39 +00002229 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002230 ObjCTypes.ClassPtrTy);
2231 } else {
Owen Anderson0b75f232009-07-31 20:28:54 +00002232 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002233 }
2234 Values[ 2] = GetClassName(ID->getIdentifier());
2235 // Version is always 0.
Owen Andersonb7a2fe62009-07-24 23:12:58 +00002236 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
2237 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
2238 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
Fariborz Jahanianb042a592009-01-28 19:12:34 +00002239 Values[ 6] = EmitIvarList(ID, true);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002240 Values[ 7] =
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00002241 EmitMethodList("\01L_OBJC_CLASS_METHODS_" + ID->getNameAsString(),
Daniel Dunbarb25452a2009-04-15 02:56:18 +00002242 "__OBJC,__cls_meth,regular,no_dead_strip",
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002243 Methods);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002244 // cache is always NULL.
Owen Anderson0b75f232009-07-31 20:28:54 +00002245 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002246 Values[ 9] = Protocols;
2247 // ivar_layout for metaclass is always NULL.
Owen Anderson0b75f232009-07-31 20:28:54 +00002248 Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002249 // The class extension is always unused for metaclasses.
Owen Anderson0b75f232009-07-31 20:28:54 +00002250 Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
Owen Anderson0e0189d2009-07-27 22:29:56 +00002251 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002252 Values);
2253
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002254 std::string Name("\01L_OBJC_METACLASS_");
Chris Lattner86d7d912008-11-24 03:54:41 +00002255 Name += ID->getNameAsCString();
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002256
2257 // Check for a forward reference.
2258 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
2259 if (GV) {
2260 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
2261 "Forward metaclass reference has incorrect type.");
2262 GV->setLinkage(llvm::GlobalValue::InternalLinkage);
2263 GV->setInitializer(Init);
2264 } else {
Owen Andersonc10c8d32009-07-08 19:05:04 +00002265 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002266 llvm::GlobalValue::InternalLinkage,
Owen Andersonc10c8d32009-07-08 19:05:04 +00002267 Init, Name);
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002268 }
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002269 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
Daniel Dunbarae333842009-03-09 22:18:41 +00002270 GV->setAlignment(4);
Chris Lattnerf56501c2009-07-17 23:57:13 +00002271 CGM.AddUsedGlobal(GV);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002272
2273 return GV;
2274}
2275
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002276llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
Chris Lattnerf3d3fae2008-11-24 05:29:24 +00002277 std::string Name = "\01L_OBJC_METACLASS_" + ID->getNameAsString();
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002278
Mike Stump18bb9282009-05-16 07:57:57 +00002279 // FIXME: Should we look these up somewhere other than the module. Its a bit
2280 // silly since we only generate these while processing an implementation, so
2281 // exactly one pointer would work if know when we entered/exitted an
2282 // implementation block.
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002283
2284 // Check for an existing forward reference.
Fariborz Jahanian475831b2009-01-07 20:11:22 +00002285 // Previously, metaclass with internal linkage may have been defined.
2286 // pass 'true' as 2nd argument so it is returned.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002287 if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name,
2288 true)) {
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002289 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
2290 "Forward metaclass reference has incorrect type.");
2291 return GV;
2292 } else {
2293 // Generate as an external reference to keep a consistent
2294 // module. This will be patched up when we emit the metaclass.
Owen Andersonc10c8d32009-07-08 19:05:04 +00002295 return new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002296 llvm::GlobalValue::ExternalLinkage,
2297 0,
Owen Andersonc10c8d32009-07-08 19:05:04 +00002298 Name);
Daniel Dunbarca8531a2008-08-25 08:19:24 +00002299 }
2300}
2301
Fariborz Jahanianeb80c982009-11-12 20:14:24 +00002302llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
2303 std::string Name = "\01L_OBJC_CLASS_" + ID->getNameAsString();
2304
2305 if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name,
2306 true)) {
2307 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
2308 "Forward class metadata reference has incorrect type.");
2309 return GV;
2310 } else {
2311 return new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
2312 llvm::GlobalValue::ExternalLinkage,
2313 0,
2314 Name);
2315 }
2316}
2317
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002318/*
2319 struct objc_class_ext {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002320 uint32_t size;
2321 const char *weak_ivar_layout;
2322 struct _objc_property_list *properties;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002323 };
2324*/
2325llvm::Constant *
2326CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002327 uint64_t Size =
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00002328 CGM.getTargetData().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002329
2330 std::vector<llvm::Constant*> Values(3);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00002331 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Fariborz Jahanian6df69862009-04-22 23:00:43 +00002332 Values[1] = BuildIvarLayout(ID, false);
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002333 Values[2] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getName(),
Fariborz Jahanian066347e2009-01-28 22:18:42 +00002334 ID, ID->getClassInterface(), ObjCTypes);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002335
2336 // Return null if no extension bits are used.
2337 if (Values[1]->isNullValue() && Values[2]->isNullValue())
Owen Anderson0b75f232009-07-31 20:28:54 +00002338 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002339
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002340 llvm::Constant *Init =
Owen Anderson0e0189d2009-07-27 22:29:56 +00002341 llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values);
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002342 return CreateMetadataVar("\01L_OBJC_CLASSEXT_" + ID->getName(),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002343 Init, "__OBJC,__class_ext,regular,no_dead_strip",
Daniel Dunbarb25452a2009-04-15 02:56:18 +00002344 4, true);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002345}
2346
2347/*
2348 struct objc_ivar {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002349 char *ivar_name;
2350 char *ivar_type;
2351 int ivar_offset;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002352 };
2353
2354 struct objc_ivar_list {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002355 int ivar_count;
2356 struct objc_ivar list[count];
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002357 };
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002358*/
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002359llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
Fariborz Jahanianb042a592009-01-28 19:12:34 +00002360 bool ForClass) {
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002361 std::vector<llvm::Constant*> Ivars, Ivar(3);
2362
2363 // When emitting the root class GCC emits ivar entries for the
2364 // actual class structure. It is not clear if we need to follow this
2365 // behavior; for now lets try and get away with not doing it. If so,
2366 // the cleanest solution would be to make up an ObjCInterfaceDecl
2367 // for the class.
2368 if (ForClass)
Owen Anderson0b75f232009-07-31 20:28:54 +00002369 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002370
2371 ObjCInterfaceDecl *OID =
Fariborz Jahanianb042a592009-01-28 19:12:34 +00002372 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002373
Daniel Dunbarf5c18462009-04-20 06:54:31 +00002374 llvm::SmallVector<ObjCIvarDecl*, 16> OIvars;
Fariborz Jahanian7c809592009-06-04 01:19:09 +00002375 CGM.getContext().ShallowCollectObjCIvars(OID, OIvars);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002376
Daniel Dunbarf5c18462009-04-20 06:54:31 +00002377 for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
2378 ObjCIvarDecl *IVD = OIvars[i];
Fariborz Jahanian7c809592009-06-04 01:19:09 +00002379 // Ignore unnamed bit-fields.
2380 if (!IVD->getDeclName())
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002381 continue;
Daniel Dunbar725dc2c2009-04-22 08:22:17 +00002382 Ivar[0] = GetMethodVarName(IVD->getIdentifier());
2383 Ivar[1] = GetMethodVarType(IVD);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002384 Ivar[2] = llvm::ConstantInt::get(ObjCTypes.IntTy,
Daniel Dunbar9fd114d2009-04-22 07:32:20 +00002385 ComputeIvarBaseOffset(CGM, OID, IVD));
Owen Anderson0e0189d2009-07-27 22:29:56 +00002386 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy, Ivar));
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002387 }
2388
2389 // Return null for empty list.
2390 if (Ivars.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00002391 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002392
2393 std::vector<llvm::Constant*> Values(2);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00002394 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
Owen Anderson9793f0e2009-07-29 22:16:19 +00002395 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002396 Ivars.size());
Owen Anderson47034e12009-07-28 18:33:04 +00002397 Values[1] = llvm::ConstantArray::get(AT, Ivars);
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00002398 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002399
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00002400 llvm::GlobalVariable *GV;
2401 if (ForClass)
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002402 GV = CreateMetadataVar("\01L_OBJC_CLASS_VARIABLES_" + ID->getName(),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002403 Init, "__OBJC,__class_vars,regular,no_dead_strip",
Daniel Dunbarae333842009-03-09 22:18:41 +00002404 4, true);
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00002405 else
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002406 GV = CreateMetadataVar("\01L_OBJC_INSTANCE_VARIABLES_" + ID->getName(),
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00002407 Init, "__OBJC,__instance_vars,regular,no_dead_strip",
Daniel Dunbarb25452a2009-04-15 02:56:18 +00002408 4, true);
Owen Andersonade90fd2009-07-29 18:54:39 +00002409 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002410}
2411
2412/*
2413 struct objc_method {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002414 SEL method_name;
2415 char *method_types;
2416 void *method;
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002417 };
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002418
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002419 struct objc_method_list {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002420 struct objc_method_list *obsolete;
2421 int count;
2422 struct objc_method methods_list[count];
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002423 };
2424*/
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002425
2426/// GetMethodConstant - Return a struct objc_method constant for the
2427/// given method if it has been defined. The result is null if the
2428/// method has not been defined. The return value has type MethodPtrTy.
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00002429llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) {
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002430 // FIXME: Use DenseMap::lookup
2431 llvm::Function *Fn = MethodDefinitions[MD];
2432 if (!Fn)
2433 return 0;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002434
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002435 std::vector<llvm::Constant*> Method(3);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002436 Method[0] =
Owen Andersonade90fd2009-07-29 18:54:39 +00002437 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002438 ObjCTypes.SelectorPtrTy);
2439 Method[1] = GetMethodVarType(MD);
Owen Andersonade90fd2009-07-29 18:54:39 +00002440 Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy);
Owen Anderson0e0189d2009-07-27 22:29:56 +00002441 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002442}
2443
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002444llvm::Constant *CGObjCMac::EmitMethodList(llvm::Twine Name,
Daniel Dunbar938a77f2008-08-22 20:34:54 +00002445 const char *Section,
Daniel Dunbareb1f9a22008-08-27 02:31:56 +00002446 const ConstantVector &Methods) {
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002447 // Return null for empty list.
2448 if (Methods.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00002449 return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002450
2451 std::vector<llvm::Constant*> Values(3);
Owen Anderson0b75f232009-07-31 20:28:54 +00002452 Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00002453 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
Owen Anderson9793f0e2009-07-29 22:16:19 +00002454 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002455 Methods.size());
Owen Anderson47034e12009-07-28 18:33:04 +00002456 Values[2] = llvm::ConstantArray::get(AT, Methods);
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00002457 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002458
Daniel Dunbarb25452a2009-04-15 02:56:18 +00002459 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true);
Owen Andersonade90fd2009-07-29 18:54:39 +00002460 return llvm::ConstantExpr::getBitCast(GV,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00002461 ObjCTypes.MethodListPtrTy);
Daniel Dunbara94ecd22008-08-16 03:19:19 +00002462}
2463
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00002464llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002465 const ObjCContainerDecl *CD) {
Daniel Dunbard2386812009-10-19 01:21:19 +00002466 llvm::SmallString<256> Name;
Fariborz Jahanian0196a1c2009-01-10 21:06:09 +00002467 GetNameForMethod(OMD, CD, Name);
Daniel Dunbara94ecd22008-08-16 03:19:19 +00002468
Daniel Dunbarbf8c24a2009-02-02 23:23:47 +00002469 CodeGenTypes &Types = CGM.getTypes();
Daniel Dunbar7a95ca32008-09-10 04:01:49 +00002470 const llvm::FunctionType *MethodTy =
Daniel Dunbarbf8c24a2009-02-02 23:23:47 +00002471 Types.GetFunctionType(Types.getFunctionInfo(OMD), OMD->isVariadic());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002472 llvm::Function *Method =
Daniel Dunbar7a95ca32008-09-10 04:01:49 +00002473 llvm::Function::Create(MethodTy,
Daniel Dunbara94ecd22008-08-16 03:19:19 +00002474 llvm::GlobalValue::InternalLinkage,
Daniel Dunbard2386812009-10-19 01:21:19 +00002475 Name.str(),
Daniel Dunbara94ecd22008-08-16 03:19:19 +00002476 &CGM.getModule());
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00002477 MethodDefinitions.insert(std::make_pair(OMD, Method));
Daniel Dunbara94ecd22008-08-16 03:19:19 +00002478
Daniel Dunbara94ecd22008-08-16 03:19:19 +00002479 return Method;
Daniel Dunbar303e2c22008-08-11 02:45:11 +00002480}
2481
Daniel Dunbar30c65362009-03-09 20:09:19 +00002482llvm::GlobalVariable *
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00002483CGObjCCommonMac::CreateMetadataVar(llvm::Twine Name,
Daniel Dunbar30c65362009-03-09 20:09:19 +00002484 llvm::Constant *Init,
2485 const char *Section,
Daniel Dunbar463cc8a2009-03-09 20:50:13 +00002486 unsigned Align,
2487 bool AddToUsed) {
Daniel Dunbar30c65362009-03-09 20:09:19 +00002488 const llvm::Type *Ty = Init->getType();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002489 llvm::GlobalVariable *GV =
Owen Andersonc10c8d32009-07-08 19:05:04 +00002490 new llvm::GlobalVariable(CGM.getModule(), Ty, false,
Chris Lattnerf56501c2009-07-17 23:57:13 +00002491 llvm::GlobalValue::InternalLinkage, Init, Name);
Daniel Dunbar30c65362009-03-09 20:09:19 +00002492 if (Section)
2493 GV->setSection(Section);
Daniel Dunbar463cc8a2009-03-09 20:50:13 +00002494 if (Align)
2495 GV->setAlignment(Align);
2496 if (AddToUsed)
Chris Lattnerf56501c2009-07-17 23:57:13 +00002497 CGM.AddUsedGlobal(GV);
Daniel Dunbar30c65362009-03-09 20:09:19 +00002498 return GV;
2499}
2500
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002501llvm::Function *CGObjCMac::ModuleInitFunction() {
Daniel Dunbar3ad53482008-08-11 21:35:06 +00002502 // Abuse this interface function as a place to finalize.
2503 FinishModule();
Daniel Dunbar303e2c22008-08-11 02:45:11 +00002504 return NULL;
2505}
2506
Chris Lattnerd4808922009-03-22 21:03:39 +00002507llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
Chris Lattnerce8754e2009-04-22 02:44:54 +00002508 return ObjCTypes.getGetPropertyFn();
Daniel Dunbara91c3e02008-09-24 03:38:44 +00002509}
2510
Chris Lattnerd4808922009-03-22 21:03:39 +00002511llvm::Constant *CGObjCMac::GetPropertySetFunction() {
Chris Lattnerce8754e2009-04-22 02:44:54 +00002512 return ObjCTypes.getSetPropertyFn();
Daniel Dunbara91c3e02008-09-24 03:38:44 +00002513}
2514
Fariborz Jahanian5a8c2032010-04-12 18:18:10 +00002515llvm::Constant *CGObjCMac::GetCopyStructFunction() {
2516 return ObjCTypes.getCopyStructFn();
2517}
2518
Chris Lattnerd4808922009-03-22 21:03:39 +00002519llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
Chris Lattnerce8754e2009-04-22 02:44:54 +00002520 return ObjCTypes.getEnumerationMutationFn();
Anders Carlsson3f35a262008-08-31 04:05:03 +00002521}
2522
John McCallbd309292010-07-06 01:34:17 +00002523void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
2524 return EmitTryOrSynchronizedStmt(CGF, S);
2525}
2526
2527void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
2528 const ObjCAtSynchronizedStmt &S) {
2529 return EmitTryOrSynchronizedStmt(CGF, S);
2530}
2531
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002532/*
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002533
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002534 Objective-C setjmp-longjmp (sjlj) Exception Handling
2535 --
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002536
John McCallbd309292010-07-06 01:34:17 +00002537 A catch buffer is a setjmp buffer plus:
2538 - a pointer to the exception that was caught
2539 - a pointer to the previous exception data buffer
2540 - two pointers of reserved storage
2541 Therefore catch buffers form a stack, with a pointer to the top
2542 of the stack kept in thread-local storage.
2543
2544 objc_exception_try_enter pushes a catch buffer onto the EH stack.
2545 objc_exception_try_exit pops the given catch buffer, which is
2546 required to be the top of the EH stack.
2547 objc_exception_throw pops the top of the EH stack, writes the
2548 thrown exception into the appropriate field, and longjmps
2549 to the setjmp buffer. It crashes the process (with a printf
2550 and an abort()) if there are no catch buffers on the stack.
2551 objc_exception_extract just reads the exception pointer out of the
2552 catch buffer.
2553
2554 There's no reason an implementation couldn't use a light-weight
2555 setjmp here --- something like __builtin_setjmp, but API-compatible
2556 with the heavyweight setjmp. This will be more important if we ever
2557 want to implement correct ObjC/C++ exception interactions for the
2558 fragile ABI.
2559
2560 Note that for this use of setjmp/longjmp to be correct, we may need
2561 to mark some local variables volatile: if a non-volatile local
2562 variable is modified between the setjmp and the longjmp, it has
2563 indeterminate value. For the purposes of LLVM IR, it may be
2564 sufficient to make loads and stores within the @try (to variables
2565 declared outside the @try) volatile. This is necessary for
2566 optimized correctness, but is not currently being done; this is
2567 being tracked as rdar://problem/8160285
2568
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002569 The basic framework for a @try-catch-finally is as follows:
2570 {
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002571 objc_exception_data d;
2572 id _rethrow = null;
Anders Carlssonda0e4562009-02-07 21:26:04 +00002573 bool _call_try_exit = true;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002574
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002575 objc_exception_try_enter(&d);
2576 if (!setjmp(d.jmp_buf)) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002577 ... try body ...
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002578 } else {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002579 // exception path
2580 id _caught = objc_exception_extract(&d);
2581
2582 // enter new try scope for handlers
2583 if (!setjmp(d.jmp_buf)) {
2584 ... match exception and execute catch blocks ...
2585
2586 // fell off end, rethrow.
2587 _rethrow = _caught;
2588 ... jump-through-finally to finally_rethrow ...
2589 } else {
2590 // exception in catch block
2591 _rethrow = objc_exception_extract(&d);
2592 _call_try_exit = false;
2593 ... jump-through-finally to finally_rethrow ...
2594 }
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002595 }
Daniel Dunbar2efd5382008-09-30 01:06:03 +00002596 ... jump-through-finally to finally_end ...
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002597
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002598 finally:
Anders Carlssonda0e4562009-02-07 21:26:04 +00002599 if (_call_try_exit)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002600 objc_exception_try_exit(&d);
Anders Carlssonda0e4562009-02-07 21:26:04 +00002601
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002602 ... finally block ....
Daniel Dunbar2efd5382008-09-30 01:06:03 +00002603 ... dispatch to finally destination ...
2604
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002605 finally_rethrow:
Daniel Dunbar2efd5382008-09-30 01:06:03 +00002606 objc_exception_throw(_rethrow);
2607
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002608 finally_end:
2609 }
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002610
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002611 This framework differs slightly from the one gcc uses, in that gcc
2612 uses _rethrow to determine if objc_exception_try_exit should be called
2613 and if the object should be rethrown. This breaks in the face of
2614 throwing nil and introduces unnecessary branches.
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002615
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002616 We specialize this framework for a few particular circumstances:
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002617
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002618 - If there are no catch blocks, then we avoid emitting the second
2619 exception handling context.
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002620
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002621 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
2622 e)) we avoid emitting the code to rethrow an uncaught exception.
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002623
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002624 - FIXME: If there is no @finally block we can do a few more
2625 simplifications.
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002626
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002627 Rethrows and Jumps-Through-Finally
2628 --
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002629
John McCallbd309292010-07-06 01:34:17 +00002630 '@throw;' is supported by pushing the currently-caught exception
2631 onto ObjCEHStack while the @catch blocks are emitted.
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002632
John McCallbd309292010-07-06 01:34:17 +00002633 Branches through the @finally block are handled with an ordinary
2634 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
2635 exceptions are not compatible with C++ exceptions, and this is
2636 hardly the only place where this will go wrong.
Daniel Dunbar2efd5382008-09-30 01:06:03 +00002637
John McCallbd309292010-07-06 01:34:17 +00002638 @synchronized(expr) { stmt; } is emitted as if it were:
2639 id synch_value = expr;
2640 objc_sync_enter(synch_value);
2641 @try { stmt; } @finally { objc_sync_exit(synch_value); }
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002642*/
2643
Fariborz Jahanianc2ad6dc2008-11-21 00:49:24 +00002644void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
2645 const Stmt &S) {
2646 bool isTry = isa<ObjCAtTryStmt>(S);
John McCallbd309292010-07-06 01:34:17 +00002647
2648 // A destination for the fall-through edges of the catch handlers to
2649 // jump to.
2650 CodeGenFunction::JumpDest FinallyEnd =
2651 CGF.getJumpDestInCurrentScope("finally.end");
2652
2653 // A destination for the rethrow edge of the catch handlers to jump
2654 // to.
2655 CodeGenFunction::JumpDest FinallyRethrow =
2656 CGF.getJumpDestInCurrentScope("finally.rethrow");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002657
Daniel Dunbar94ceb612009-02-24 01:43:46 +00002658 // For @synchronized, call objc_sync_enter(sync.expr). The
2659 // evaluation of the expression must occur before we enter the
2660 // @synchronized. We can safely avoid a temp here because jumps into
2661 // @synchronized are illegal & this will dominate uses.
2662 llvm::Value *SyncArg = 0;
2663 if (!isTry) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002664 SyncArg =
Daniel Dunbar94ceb612009-02-24 01:43:46 +00002665 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
2666 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
John McCallbd309292010-07-06 01:34:17 +00002667 CGF.Builder.CreateCall(ObjCTypes.getSyncEnterFn(), SyncArg)
2668 ->setDoesNotThrow();
Daniel Dunbar94ceb612009-02-24 01:43:46 +00002669 }
Daniel Dunbar2efd5382008-09-30 01:06:03 +00002670
Daniel Dunbar2efd5382008-09-30 01:06:03 +00002671 // Allocate memory for the exception data and rethrow pointer.
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002672 llvm::Value *ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
2673 "exceptiondata.ptr");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002674 llvm::Value *RethrowPtr = CGF.CreateTempAlloca(ObjCTypes.ObjectPtrTy,
Daniel Dunbarc475d422008-10-29 22:36:39 +00002675 "_rethrow");
John McCallbd309292010-07-06 01:34:17 +00002676
2677 // Create a flag indicating whether the cleanup needs to call
2678 // objc_exception_try_exit. This is true except when
2679 // - no catches match and we're branching through the cleanup
2680 // just to rethrow the exception, or
2681 // - a catch matched and we're falling out of the catch handler.
2682 llvm::Value *CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
Anders Carlssonda0e4562009-02-07 21:26:04 +00002683 "_call_try_exit");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002684 CGF.Builder.CreateStore(llvm::ConstantInt::getTrue(VMContext),
John McCallbd309292010-07-06 01:34:17 +00002685 CallTryExitVar);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002686
John McCallbd309292010-07-06 01:34:17 +00002687 // Push a normal cleanup to leave the try scope.
2688 {
John McCall2b7fc382010-07-13 20:32:21 +00002689 CodeGenFunction::CleanupBlock FinallyScope(CGF, NormalCleanup);
Daniel Dunbar2efd5382008-09-30 01:06:03 +00002690
John McCallbd309292010-07-06 01:34:17 +00002691 // Check whether we need to call objc_exception_try_exit.
2692 // In optimized code, this branch will always be folded.
2693 llvm::BasicBlock *FinallyCallExit =
2694 CGF.createBasicBlock("finally.call_exit");
2695 llvm::BasicBlock *FinallyNoCallExit =
2696 CGF.createBasicBlock("finally.no_call_exit");
2697 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
2698 FinallyCallExit, FinallyNoCallExit);
2699
2700 CGF.EmitBlock(FinallyCallExit);
2701 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryExitFn(), ExceptionData)
2702 ->setDoesNotThrow();
2703
2704 CGF.EmitBlock(FinallyNoCallExit);
2705
2706 if (isTry) {
2707 if (const ObjCAtFinallyStmt* FinallyStmt =
2708 cast<ObjCAtTryStmt>(S).getFinallyStmt())
2709 CGF.EmitStmt(FinallyStmt->getFinallyBody());
2710
2711 // ~CleanupBlock requires there to be an exit block.
2712 CGF.EnsureInsertPoint();
2713 } else {
2714 // Emit objc_sync_exit(expr); as finally's sole statement for
2715 // @synchronized.
2716 CGF.Builder.CreateCall(ObjCTypes.getSyncExitFn(), SyncArg)
2717 ->setDoesNotThrow();
2718 }
2719 }
2720
2721 // Enter a try block:
2722 // - Call objc_exception_try_enter to push ExceptionData on top of
2723 // the EH stack.
2724 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryEnterFn(), ExceptionData)
2725 ->setDoesNotThrow();
2726
2727 // - Call setjmp on the exception data buffer.
2728 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
2729 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
2730 llvm::Value *SetJmpBuffer =
2731 CGF.Builder.CreateGEP(ExceptionData, GEPIndexes, GEPIndexes+3, "setjmp_buffer");
2732 llvm::CallInst *SetJmpResult =
2733 CGF.Builder.CreateCall(ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
2734 SetJmpResult->setDoesNotThrow();
2735
2736 // If setjmp returned 0, enter the protected block; otherwise,
2737 // branch to the handler.
Daniel Dunbar75283ff2008-11-11 02:29:29 +00002738 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
2739 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
John McCallbd309292010-07-06 01:34:17 +00002740 llvm::Value *DidCatch =
2741 CGF.Builder.CreateIsNull(SetJmpResult, "did_catch_exception");
2742 CGF.Builder.CreateCondBr(DidCatch, TryBlock, TryHandler);
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002743
John McCallbd309292010-07-06 01:34:17 +00002744 // Emit the protected block.
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002745 CGF.EmitBlock(TryBlock);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002746 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
John McCallbd309292010-07-06 01:34:17 +00002747 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
Anders Carlssonbfee7e92009-02-09 20:38:58 +00002748 CGF.EmitBranchThroughCleanup(FinallyEnd);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002749
John McCallbd309292010-07-06 01:34:17 +00002750 // Emit the exception handler block.
Daniel Dunbar7f086782008-09-27 23:30:04 +00002751 CGF.EmitBlock(TryHandler);
Daniel Dunbarb22ff592008-09-27 07:03:52 +00002752
2753 // Retrieve the exception object. We may emit multiple blocks but
2754 // nothing can cross this so the value is already in SSA form.
John McCallbd309292010-07-06 01:34:17 +00002755 llvm::CallInst *Caught =
Chris Lattnerc6406db2009-04-22 02:26:14 +00002756 CGF.Builder.CreateCall(ObjCTypes.getExceptionExtractFn(),
2757 ExceptionData, "caught");
John McCallbd309292010-07-06 01:34:17 +00002758 Caught->setDoesNotThrow();
2759
2760 // Remember the exception to rethrow.
2761 CGF.Builder.CreateStore(Caught, RethrowPtr);
2762
2763 // Note: at this point, objc_exception_throw already popped the
2764 // catch handler, so anything that branches to the cleanup needs
2765 // to set CallTryExitVar to false.
2766
2767 // For a @synchronized (or a @try with no catches), just branch
2768 // through the cleanup to the rethrow block.
2769 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
2770 // Tell the cleanup not to re-pop the exit.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002771 CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(VMContext),
John McCallbd309292010-07-06 01:34:17 +00002772 CallTryExitVar);
2773
Anders Carlssonbfee7e92009-02-09 20:38:58 +00002774 CGF.EmitBranchThroughCleanup(FinallyRethrow);
John McCallbd309292010-07-06 01:34:17 +00002775
2776 // Otherwise, we have to match against the caught exceptions.
2777 } else {
2778 // Push the exception to rethrow onto the EH value stack for the
2779 // benefit of any @throws in the handlers.
2780 CGF.ObjCEHValueStack.push_back(Caught);
2781
Douglas Gregor96c79492010-04-23 22:50:49 +00002782 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
2783
Daniel Dunbarb22ff592008-09-27 07:03:52 +00002784 // Enter a new exception try block (in case a @catch block throws
John McCallbd309292010-07-06 01:34:17 +00002785 // an exception). Now CallTryExitVar (currently true) is back in
2786 // synch with reality.
2787 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryEnterFn(), ExceptionData)
2788 ->setDoesNotThrow();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002789
John McCallbd309292010-07-06 01:34:17 +00002790 llvm::CallInst *SetJmpResult =
2791 CGF.Builder.CreateCall(ObjCTypes.getSetJmpFn(), SetJmpBuffer,
2792 "setjmp.result");
2793 SetJmpResult->setDoesNotThrow();
2794
2795 llvm::Value *Threw =
2796 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002797
Daniel Dunbar75283ff2008-11-11 02:29:29 +00002798 llvm::BasicBlock *CatchBlock = CGF.createBasicBlock("catch");
John McCallbd309292010-07-06 01:34:17 +00002799 llvm::BasicBlock *CatchHandler = CGF.createBasicBlock("catch_for_catch");
Daniel Dunbar7f086782008-09-27 23:30:04 +00002800 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002801
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002802 CGF.EmitBlock(CatchBlock);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002803
Daniel Dunbarb22ff592008-09-27 07:03:52 +00002804 // Handle catch list. As a special case we check if everything is
2805 // matched and avoid generating code for falling off the end if
2806 // so.
2807 bool AllMatched = false;
Douglas Gregor96c79492010-04-23 22:50:49 +00002808 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
2809 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002810
Douglas Gregor46a572b2010-04-26 16:46:50 +00002811 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
Steve Naroff7cae42b2009-07-10 23:34:53 +00002812 const ObjCObjectPointerType *OPT = 0;
Daniel Dunbar523208f2008-09-27 07:36:24 +00002813
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002814 // catch(...) always matches.
Daniel Dunbarb22ff592008-09-27 07:03:52 +00002815 if (!CatchParam) {
2816 AllMatched = true;
2817 } else {
John McCall9dd450b2009-09-21 23:43:11 +00002818 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002819
John McCallbd309292010-07-06 01:34:17 +00002820 // catch(id e) always matches under this ABI, since only
2821 // ObjC exceptions end up here in the first place.
Daniel Dunbar86919f42008-09-27 22:21:14 +00002822 // FIXME: For the time being we also match id<X>; this should
2823 // be rejected by Sema instead.
Eli Friedman55179ca2009-07-11 00:57:02 +00002824 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
Daniel Dunbarb22ff592008-09-27 07:03:52 +00002825 AllMatched = true;
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002826 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002827
John McCallbd309292010-07-06 01:34:17 +00002828 // If this is a catch-all, we don't need to test anything.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002829 if (AllMatched) {
John McCallbd309292010-07-06 01:34:17 +00002830 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
2831
Anders Carlsson9396a892008-09-11 09:15:33 +00002832 if (CatchParam) {
Steve Naroff371b8fb2009-03-03 19:52:17 +00002833 CGF.EmitLocalBlockVarDecl(*CatchParam);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00002834 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
John McCallbd309292010-07-06 01:34:17 +00002835
2836 // These types work out because ConvertType(id) == i8*.
Steve Naroff371b8fb2009-03-03 19:52:17 +00002837 CGF.Builder.CreateStore(Caught, CGF.GetAddrOfLocalVar(CatchParam));
Anders Carlsson9396a892008-09-11 09:15:33 +00002838 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002839
Anders Carlsson9396a892008-09-11 09:15:33 +00002840 CGF.EmitStmt(CatchStmt->getCatchBody());
John McCallbd309292010-07-06 01:34:17 +00002841
2842 // The scope of the catch variable ends right here.
2843 CatchVarCleanups.ForceCleanup();
2844
Anders Carlssonbfee7e92009-02-09 20:38:58 +00002845 CGF.EmitBranchThroughCleanup(FinallyEnd);
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002846 break;
2847 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002848
Steve Naroff7cae42b2009-07-10 23:34:53 +00002849 assert(OPT && "Unexpected non-object pointer type in @catch");
John McCall96fa4842010-05-17 21:00:27 +00002850 const ObjCObjectType *ObjTy = OPT->getObjectType();
John McCallbd309292010-07-06 01:34:17 +00002851
2852 // FIXME: @catch (Class c) ?
John McCall96fa4842010-05-17 21:00:27 +00002853 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
2854 assert(IDecl && "Catch parameter must have Objective-C type!");
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002855
2856 // Check if the @catch block matches the exception object.
John McCall96fa4842010-05-17 21:00:27 +00002857 llvm::Value *Class = EmitClassRef(CGF.Builder, IDecl);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002858
John McCallbd309292010-07-06 01:34:17 +00002859 llvm::CallInst *Match =
Chris Lattnerc6406db2009-04-22 02:26:14 +00002860 CGF.Builder.CreateCall2(ObjCTypes.getExceptionMatchFn(),
2861 Class, Caught, "match");
John McCallbd309292010-07-06 01:34:17 +00002862 Match->setDoesNotThrow();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002863
John McCallbd309292010-07-06 01:34:17 +00002864 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
2865 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002866
2867 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
Daniel Dunbar7f086782008-09-27 23:30:04 +00002868 MatchedBlock, NextCatchBlock);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002869
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002870 // Emit the @catch block.
2871 CGF.EmitBlock(MatchedBlock);
John McCallbd309292010-07-06 01:34:17 +00002872
2873 // Collect any cleanups for the catch variable. The scope lasts until
2874 // the end of the catch body.
2875 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
2876
Steve Naroff371b8fb2009-03-03 19:52:17 +00002877 CGF.EmitLocalBlockVarDecl(*CatchParam);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00002878 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002879
John McCallbd309292010-07-06 01:34:17 +00002880 // Initialize the catch variable.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002881 llvm::Value *Tmp =
2882 CGF.Builder.CreateBitCast(Caught,
2883 CGF.ConvertType(CatchParam->getType()),
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002884 "tmp");
Steve Naroff371b8fb2009-03-03 19:52:17 +00002885 CGF.Builder.CreateStore(Tmp, CGF.GetAddrOfLocalVar(CatchParam));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002886
Anders Carlsson9396a892008-09-11 09:15:33 +00002887 CGF.EmitStmt(CatchStmt->getCatchBody());
John McCallbd309292010-07-06 01:34:17 +00002888
2889 // We're done with the catch variable.
2890 CatchVarCleanups.ForceCleanup();
2891
Anders Carlssonbfee7e92009-02-09 20:38:58 +00002892 CGF.EmitBranchThroughCleanup(FinallyEnd);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002893
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002894 CGF.EmitBlock(NextCatchBlock);
2895 }
2896
John McCallbd309292010-07-06 01:34:17 +00002897 CGF.ObjCEHValueStack.pop_back();
2898
Daniel Dunbarb22ff592008-09-27 07:03:52 +00002899 if (!AllMatched) {
2900 // None of the handlers caught the exception, so store it to be
2901 // rethrown at the end of the @finally block.
2902 CGF.Builder.CreateStore(Caught, RethrowPtr);
Anders Carlssonbfee7e92009-02-09 20:38:58 +00002903 CGF.EmitBranchThroughCleanup(FinallyRethrow);
Daniel Dunbarb22ff592008-09-27 07:03:52 +00002904 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002905
Daniel Dunbarb22ff592008-09-27 07:03:52 +00002906 // Emit the exception handler for the @catch blocks.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002907 CGF.EmitBlock(CatchHandler);
John McCallbd309292010-07-06 01:34:17 +00002908
2909 // Rethrow the new exception, not the old one.
2910 Caught = CGF.Builder.CreateCall(ObjCTypes.getExceptionExtractFn(),
2911 ExceptionData);
2912 Caught->setDoesNotThrow();
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002913 CGF.Builder.CreateStore(Caught, RethrowPtr);
John McCallbd309292010-07-06 01:34:17 +00002914
2915 // Don't pop the catch handler; the throw already did.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002916 CGF.Builder.CreateStore(llvm::ConstantInt::getFalse(VMContext),
John McCallbd309292010-07-06 01:34:17 +00002917 CallTryExitVar);
Anders Carlssonbfee7e92009-02-09 20:38:58 +00002918 CGF.EmitBranchThroughCleanup(FinallyRethrow);
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002919 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002920
John McCallbd309292010-07-06 01:34:17 +00002921 // Pop the cleanup.
2922 CGF.PopCleanupBlock();
2923 CGF.EmitBlock(FinallyEnd.Block);
Anders Carlssonbfee7e92009-02-09 20:38:58 +00002924
John McCallbd309292010-07-06 01:34:17 +00002925 // Emit the rethrow block.
2926 CGF.Builder.ClearInsertionPoint();
2927 CGF.EmitBlock(FinallyRethrow.Block, true);
2928 if (CGF.HaveInsertPoint()) {
2929 CGF.Builder.CreateCall(ObjCTypes.getExceptionThrowFn(),
2930 CGF.Builder.CreateLoad(RethrowPtr))
2931 ->setDoesNotThrow();
2932 CGF.Builder.CreateUnreachable();
Fariborz Jahaniane2caaaa2008-11-21 19:21:53 +00002933 }
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002934
John McCallbd309292010-07-06 01:34:17 +00002935 CGF.Builder.SetInsertPoint(FinallyEnd.Block);
Anders Carlsson1963b0c2008-09-09 10:04:29 +00002936}
2937
2938void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar2efd5382008-09-30 01:06:03 +00002939 const ObjCAtThrowStmt &S) {
Anders Carlssone005aa12008-09-09 16:16:55 +00002940 llvm::Value *ExceptionAsObject;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002941
Anders Carlssone005aa12008-09-09 16:16:55 +00002942 if (const Expr *ThrowExpr = S.getThrowExpr()) {
2943 llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002944 ExceptionAsObject =
Anders Carlssone005aa12008-09-09 16:16:55 +00002945 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp");
2946 } else {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002947 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00002948 "Unexpected rethrow outside @catch block.");
Anders Carlssonbf8a1be2009-02-07 21:37:21 +00002949 ExceptionAsObject = CGF.ObjCEHValueStack.back();
Anders Carlssone005aa12008-09-09 16:16:55 +00002950 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002951
John McCallbd309292010-07-06 01:34:17 +00002952 CGF.Builder.CreateCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
2953 ->setDoesNotReturn();
Anders Carlsson4f1c7c32008-09-09 17:59:25 +00002954 CGF.Builder.CreateUnreachable();
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00002955
2956 // Clear the insertion point to indicate we are in unreachable code.
2957 CGF.Builder.ClearInsertionPoint();
Anders Carlsson1963b0c2008-09-09 10:04:29 +00002958}
2959
Fariborz Jahanian83f45b552008-11-18 22:37:34 +00002960/// EmitObjCWeakRead - Code gen for loading value of a __weak
Fariborz Jahanianf5125d12008-11-18 21:45:40 +00002961/// object: objc_read_weak (id *src)
2962///
Fariborz Jahanian83f45b552008-11-18 22:37:34 +00002963llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00002964 llvm::Value *AddrWeakObj) {
Eli Friedmana374b682009-03-07 03:57:15 +00002965 const llvm::Type* DestTy =
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002966 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
2967 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
2968 ObjCTypes.PtrObjectPtrTy);
Chris Lattnerce8754e2009-04-22 02:44:54 +00002969 llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.getGcReadWeakFn(),
Fariborz Jahanian83f45b552008-11-18 22:37:34 +00002970 AddrWeakObj, "weakread");
Eli Friedmana374b682009-03-07 03:57:15 +00002971 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
Fariborz Jahanianf5125d12008-11-18 21:45:40 +00002972 return read_weak;
2973}
2974
Fariborz Jahanian83f45b552008-11-18 22:37:34 +00002975/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
2976/// objc_assign_weak (id src, id *dst)
2977///
2978void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00002979 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00002980 const llvm::Type * SrcTy = src->getType();
2981 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00002982 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00002983 assert(Size <= 8 && "does not support size > 8");
2984 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00002985 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
Fariborz Jahanian1b074a32009-03-13 00:42:52 +00002986 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
2987 }
Fariborz Jahanian50a12702008-11-19 17:34:06 +00002988 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
2989 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattner6fdd57c2009-04-17 22:12:36 +00002990 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignWeakFn(),
Fariborz Jahanian83f45b552008-11-18 22:37:34 +00002991 src, dst, "weakassign");
2992 return;
2993}
2994
Fariborz Jahaniand7db9642008-11-19 00:59:10 +00002995/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
2996/// objc_assign_global (id src, id *dst)
2997///
2998void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00002999 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00003000 const llvm::Type * SrcTy = src->getType();
3001 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00003002 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00003003 assert(Size <= 8 && "does not support size > 8");
3004 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003005 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
Fariborz Jahanian1b074a32009-03-13 00:42:52 +00003006 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
3007 }
Fariborz Jahanian50a12702008-11-19 17:34:06 +00003008 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
3009 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattner0a696a422009-04-22 02:38:11 +00003010 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignGlobalFn(),
Fariborz Jahaniand7db9642008-11-19 00:59:10 +00003011 src, dst, "globalassign");
3012 return;
3013}
3014
Fariborz Jahaniane881b532008-11-20 19:23:36 +00003015/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00003016/// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
Fariborz Jahaniane881b532008-11-20 19:23:36 +00003017///
3018void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00003019 llvm::Value *src, llvm::Value *dst,
3020 llvm::Value *ivarOffset) {
3021 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00003022 const llvm::Type * SrcTy = src->getType();
3023 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00003024 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00003025 assert(Size <= 8 && "does not support size > 8");
3026 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003027 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
Fariborz Jahanian1b074a32009-03-13 00:42:52 +00003028 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
3029 }
Fariborz Jahaniane881b532008-11-20 19:23:36 +00003030 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
3031 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00003032 CGF.Builder.CreateCall3(ObjCTypes.getGcAssignIvarFn(),
3033 src, dst, ivarOffset);
Fariborz Jahaniane881b532008-11-20 19:23:36 +00003034 return;
3035}
3036
Fariborz Jahaniand7db9642008-11-19 00:59:10 +00003037/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
3038/// objc_assign_strongCast (id src, id *dst)
3039///
3040void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00003041 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00003042 const llvm::Type * SrcTy = src->getType();
3043 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00003044 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00003045 assert(Size <= 8 && "does not support size > 8");
3046 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003047 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
Fariborz Jahanian1b074a32009-03-13 00:42:52 +00003048 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
3049 }
Fariborz Jahanian50a12702008-11-19 17:34:06 +00003050 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
3051 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattner0a696a422009-04-22 02:38:11 +00003052 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignStrongCastFn(),
Fariborz Jahaniand7db9642008-11-19 00:59:10 +00003053 src, dst, "weakassign");
3054 return;
3055}
3056
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00003057void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003058 llvm::Value *DestPtr,
3059 llvm::Value *SrcPtr,
Fariborz Jahanian021510e2010-06-15 22:44:06 +00003060 llvm::Value *size) {
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00003061 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
3062 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00003063 CGF.Builder.CreateCall3(ObjCTypes.GcMemmoveCollectableFn(),
Fariborz Jahanian021510e2010-06-15 22:44:06 +00003064 DestPtr, SrcPtr, size);
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00003065 return;
3066}
3067
Fariborz Jahanian9f84b782009-02-02 20:02:29 +00003068/// EmitObjCValueForIvar - Code Gen for ivar reference.
3069///
Fariborz Jahanian712bfa62009-02-03 19:03:09 +00003070LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
3071 QualType ObjectTy,
3072 llvm::Value *BaseValue,
3073 const ObjCIvarDecl *Ivar,
Fariborz Jahanian712bfa62009-02-03 19:03:09 +00003074 unsigned CVRQualifiers) {
John McCall8b07ec22010-05-15 11:32:37 +00003075 const ObjCInterfaceDecl *ID =
3076 ObjectTy->getAs<ObjCObjectType>()->getInterface();
Daniel Dunbar9fd114d2009-04-22 07:32:20 +00003077 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
3078 EmitIvarOffset(CGF, ID, Ivar));
Fariborz Jahanian9f84b782009-02-02 20:02:29 +00003079}
3080
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00003081llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar722f4242009-04-22 05:08:15 +00003082 const ObjCInterfaceDecl *Interface,
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00003083 const ObjCIvarDecl *Ivar) {
Daniel Dunbar9fd114d2009-04-22 07:32:20 +00003084 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00003085 return llvm::ConstantInt::get(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003086 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
3087 Offset);
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00003088}
3089
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003090/* *** Private Interface *** */
3091
3092/// EmitImageInfo - Emit the image info marker used to encode some module
3093/// level information.
3094///
3095/// See: <rdr://4810609&4810587&4810587>
3096/// struct IMAGE_INFO {
3097/// unsigned version;
3098/// unsigned flags;
3099/// };
3100enum ImageInfoFlags {
Daniel Dunbar5e639272010-04-25 20:39:01 +00003101 eImageInfo_FixAndContinue = (1 << 0),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003102 eImageInfo_GarbageCollected = (1 << 1),
3103 eImageInfo_GCOnly = (1 << 2),
Daniel Dunbar75e909f2009-04-20 07:11:47 +00003104 eImageInfo_OptimizedByDyld = (1 << 3), // FIXME: When is this set.
3105
Daniel Dunbar5e639272010-04-25 20:39:01 +00003106 // A flag indicating that the module has no instances of a @synthesize of a
3107 // superclass variable. <rdar://problem/6803242>
Daniel Dunbar75e909f2009-04-20 07:11:47 +00003108 eImageInfo_CorrectedSynthesize = (1 << 4)
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003109};
3110
Daniel Dunbar5e639272010-04-25 20:39:01 +00003111void CGObjCCommonMac::EmitImageInfo() {
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003112 unsigned version = 0; // Version is unused?
3113 unsigned flags = 0;
3114
3115 // FIXME: Fix and continue?
3116 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC)
3117 flags |= eImageInfo_GarbageCollected;
3118 if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly)
3119 flags |= eImageInfo_GCOnly;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003120
Daniel Dunbar75e909f2009-04-20 07:11:47 +00003121 // We never allow @synthesize of a superclass property.
3122 flags |= eImageInfo_CorrectedSynthesize;
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003123
Chris Lattner5e016ae2010-06-27 07:15:29 +00003124 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
3125
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003126 // Emitted as int[2];
3127 llvm::Constant *values[2] = {
Chris Lattner5e016ae2010-06-27 07:15:29 +00003128 llvm::ConstantInt::get(Int32Ty, version),
3129 llvm::ConstantInt::get(Int32Ty, flags)
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003130 };
Chris Lattner5e016ae2010-06-27 07:15:29 +00003131 llvm::ArrayType *AT = llvm::ArrayType::get(Int32Ty, 2);
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003132
3133 const char *Section;
3134 if (ObjCABI == 1)
3135 Section = "__OBJC, __image_info,regular";
3136 else
3137 Section = "__DATA, __objc_imageinfo, regular, no_dead_strip";
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003138 llvm::GlobalVariable *GV =
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003139 CreateMetadataVar("\01L_OBJC_IMAGE_INFO",
Owen Anderson47034e12009-07-28 18:33:04 +00003140 llvm::ConstantArray::get(AT, values, 2),
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003141 Section,
3142 0,
3143 true);
3144 GV->setConstant(true);
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003145}
3146
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003147
3148// struct objc_module {
3149// unsigned long version;
3150// unsigned long size;
3151// const char *name;
3152// Symtab symtab;
3153// };
3154
3155// FIXME: Get from somewhere
3156static const int ModuleVersion = 7;
3157
3158void CGObjCMac::EmitModuleInfo() {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00003159 uint64_t Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.ModuleTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003160
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003161 std::vector<llvm::Constant*> Values(4);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00003162 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion);
3163 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
Daniel Dunbar92992502008-08-15 22:20:32 +00003164 // This used to be the filename, now it is unused. <rdr://4327263>
Daniel Dunbarb036db82008-08-13 03:21:16 +00003165 Values[2] = GetClassName(&CGM.getContext().Idents.get(""));
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003166 Values[3] = EmitModuleSymbols();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003167 CreateMetadataVar("\01L_OBJC_MODULES",
Owen Anderson0e0189d2009-07-27 22:29:56 +00003168 llvm::ConstantStruct::get(ObjCTypes.ModuleTy, Values),
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003169 "__OBJC,__module_info,regular,no_dead_strip",
Daniel Dunbarae333842009-03-09 22:18:41 +00003170 4, true);
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003171}
3172
3173llvm::Constant *CGObjCMac::EmitModuleSymbols() {
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003174 unsigned NumClasses = DefinedClasses.size();
3175 unsigned NumCategories = DefinedCategories.size();
3176
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00003177 // Return null if no symbols were defined.
3178 if (!NumClasses && !NumCategories)
Owen Anderson0b75f232009-07-31 20:28:54 +00003179 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00003180
3181 std::vector<llvm::Constant*> Values(5);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00003182 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
Owen Anderson0b75f232009-07-31 20:28:54 +00003183 Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00003184 Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
3185 Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003186
Daniel Dunbar938a77f2008-08-22 20:34:54 +00003187 // The runtime expects exactly the list of defined classes followed
3188 // by the list of defined categories, in a single array.
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003189 std::vector<llvm::Constant*> Symbols(NumClasses + NumCategories);
Daniel Dunbar938a77f2008-08-22 20:34:54 +00003190 for (unsigned i=0; i<NumClasses; i++)
Owen Andersonade90fd2009-07-29 18:54:39 +00003191 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
Daniel Dunbar938a77f2008-08-22 20:34:54 +00003192 ObjCTypes.Int8PtrTy);
3193 for (unsigned i=0; i<NumCategories; i++)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003194 Symbols[NumClasses + i] =
Owen Andersonade90fd2009-07-29 18:54:39 +00003195 llvm::ConstantExpr::getBitCast(DefinedCategories[i],
Daniel Dunbar938a77f2008-08-22 20:34:54 +00003196 ObjCTypes.Int8PtrTy);
3197
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003198 Values[4] =
Owen Anderson9793f0e2009-07-29 22:16:19 +00003199 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003200 NumClasses + NumCategories),
3201 Symbols);
3202
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00003203 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003204
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003205 llvm::GlobalVariable *GV =
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003206 CreateMetadataVar("\01L_OBJC_SYMBOLS", Init,
3207 "__OBJC,__symbols,regular,no_dead_strip",
Daniel Dunbarb25452a2009-04-15 02:56:18 +00003208 4, true);
Owen Andersonade90fd2009-07-29 18:54:39 +00003209 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003210}
3211
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003212llvm::Value *CGObjCMac::EmitClassRef(CGBuilderTy &Builder,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003213 const ObjCInterfaceDecl *ID) {
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00003214 LazySymbols.insert(ID->getIdentifier());
3215
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003216 llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()];
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003217
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003218 if (!Entry) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003219 llvm::Constant *Casted =
Owen Andersonade90fd2009-07-29 18:54:39 +00003220 llvm::ConstantExpr::getBitCast(GetClassName(ID->getIdentifier()),
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003221 ObjCTypes.ClassPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003222 Entry =
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003223 CreateMetadataVar("\01L_OBJC_CLASS_REFERENCES_", Casted,
3224 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
Daniel Dunbarb25452a2009-04-15 02:56:18 +00003225 4, true);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003226 }
3227
Daniel Dunbarc76493a2009-11-29 21:23:36 +00003228 return Builder.CreateLoad(Entry, "tmp");
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003229}
3230
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00003231llvm::Value *CGObjCMac::EmitSelector(CGBuilderTy &Builder, Selector Sel,
3232 bool lvalue) {
Daniel Dunbarcb515c82008-08-12 03:39:23 +00003233 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003234
Daniel Dunbarcb515c82008-08-12 03:39:23 +00003235 if (!Entry) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003236 llvm::Constant *Casted =
Owen Andersonade90fd2009-07-29 18:54:39 +00003237 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
Daniel Dunbarcb515c82008-08-12 03:39:23 +00003238 ObjCTypes.SelectorPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003239 Entry =
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003240 CreateMetadataVar("\01L_OBJC_SELECTOR_REFERENCES_", Casted,
3241 "__OBJC,__message_refs,literal_pointers,no_dead_strip",
Daniel Dunbarb25452a2009-04-15 02:56:18 +00003242 4, true);
Daniel Dunbarcb515c82008-08-12 03:39:23 +00003243 }
3244
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00003245 if (lvalue)
3246 return Entry;
Daniel Dunbarc76493a2009-11-29 21:23:36 +00003247 return Builder.CreateLoad(Entry, "tmp");
Daniel Dunbarcb515c82008-08-12 03:39:23 +00003248}
3249
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00003250llvm::Constant *CGObjCCommonMac::GetClassName(IdentifierInfo *Ident) {
Daniel Dunbarb036db82008-08-13 03:21:16 +00003251 llvm::GlobalVariable *&Entry = ClassNames[Ident];
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003252
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003253 if (!Entry)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003254 Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00003255 llvm::ConstantArray::get(VMContext,
3256 Ident->getNameStart()),
Jim Grosbach71d963e2010-07-20 16:20:26 +00003257 ((ObjCABI == 2) ?
3258 "__TEXT,__objc_classname,cstring_literals" :
3259 "__TEXT,__cstring,cstring_literals"),
Daniel Dunbar3241fae2009-04-14 23:14:47 +00003260 1, true);
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003261
Owen Anderson170229f2009-07-14 23:10:40 +00003262 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003263}
3264
Fariborz Jahanian01dff422009-03-05 19:17:31 +00003265/// GetIvarLayoutName - Returns a unique constant for the given
3266/// ivar layout bitmap.
3267llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003268 const ObjCCommonTypesHelper &ObjCTypes) {
Owen Anderson0b75f232009-07-31 20:28:54 +00003269 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
Fariborz Jahanian01dff422009-03-05 19:17:31 +00003270}
3271
John McCall8ccfcb52009-09-24 19:53:00 +00003272static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT) {
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003273 if (FQT.isObjCGCStrong())
John McCall8ccfcb52009-09-24 19:53:00 +00003274 return Qualifiers::Strong;
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003275
3276 if (FQT.isObjCGCWeak())
John McCall8ccfcb52009-09-24 19:53:00 +00003277 return Qualifiers::Weak;
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003278
Fariborz Jahanian10e9bff2009-09-11 17:39:05 +00003279 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
John McCall8ccfcb52009-09-24 19:53:00 +00003280 return Qualifiers::Strong;
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003281
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003282 if (const PointerType *PT = FQT->getAs<PointerType>())
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003283 return GetGCAttrTypeForType(Ctx, PT->getPointeeType());
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003284
John McCall8ccfcb52009-09-24 19:53:00 +00003285 return Qualifiers::GCNone;
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003286}
3287
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003288void CGObjCCommonMac::BuildAggrIvarRecordLayout(const RecordType *RT,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003289 unsigned int BytePos,
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003290 bool ForStrongLayout,
3291 bool &HasUnion) {
3292 const RecordDecl *RD = RT->getDecl();
3293 // FIXME - Use iterator.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00003294 llvm::SmallVector<FieldDecl*, 16> Fields(RD->field_begin(), RD->field_end());
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003295 const llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003296 const llvm::StructLayout *RecLayout =
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003297 CGM.getTargetData().getStructLayout(cast<llvm::StructType>(Ty));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003298
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003299 BuildAggrIvarLayout(0, RecLayout, RD, Fields, BytePos,
3300 ForStrongLayout, HasUnion);
3301}
3302
Daniel Dunbar36e2a1e2009-05-03 21:05:10 +00003303void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCImplementationDecl *OI,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003304 const llvm::StructLayout *Layout,
3305 const RecordDecl *RD,
Chris Lattner5b36ddb2009-03-31 08:48:01 +00003306 const llvm::SmallVectorImpl<FieldDecl*> &RecFields,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003307 unsigned int BytePos, bool ForStrongLayout,
3308 bool &HasUnion) {
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003309 bool IsUnion = (RD && RD->isUnion());
3310 uint64_t MaxUnionIvarSize = 0;
3311 uint64_t MaxSkippedUnionIvarSize = 0;
3312 FieldDecl *MaxField = 0;
3313 FieldDecl *MaxSkippedField = 0;
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003314 FieldDecl *LastFieldBitfield = 0;
Daniel Dunbar5b743912009-05-03 23:31:46 +00003315 uint64_t MaxFieldOffset = 0;
3316 uint64_t MaxSkippedFieldOffset = 0;
3317 uint64_t LastBitfieldOffset = 0;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003318
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003319 if (RecFields.empty())
3320 return;
Chris Lattner5b36ddb2009-03-31 08:48:01 +00003321 unsigned WordSizeInBits = CGM.getContext().Target.getPointerWidth(0);
3322 unsigned ByteSizeInBits = CGM.getContext().Target.getCharWidth();
3323
Chris Lattner5b36ddb2009-03-31 08:48:01 +00003324 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003325 FieldDecl *Field = RecFields[i];
Daniel Dunbar62b10702009-05-03 23:35:23 +00003326 uint64_t FieldOffset;
Anders Carlssone2c6baf2009-07-24 17:23:54 +00003327 if (RD) {
Daniel Dunbard51c1a62010-04-14 17:02:21 +00003328 // Note that 'i' here is actually the field index inside RD of Field,
3329 // although this dependency is hidden.
3330 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
3331 FieldOffset = RL.getFieldOffset(i) / 8;
Anders Carlssone2c6baf2009-07-24 17:23:54 +00003332 } else
Daniel Dunbar62b10702009-05-03 23:35:23 +00003333 FieldOffset = ComputeIvarBaseOffset(CGM, OI, cast<ObjCIvarDecl>(Field));
Daniel Dunbar94f46dc2009-05-03 14:17:18 +00003334
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003335 // Skip over unnamed or bitfields
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003336 if (!Field->getIdentifier() || Field->isBitField()) {
3337 LastFieldBitfield = Field;
Daniel Dunbar5b743912009-05-03 23:31:46 +00003338 LastBitfieldOffset = FieldOffset;
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003339 continue;
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003340 }
Daniel Dunbar94f46dc2009-05-03 14:17:18 +00003341
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003342 LastFieldBitfield = 0;
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003343 QualType FQT = Field->getType();
Fariborz Jahanianf909f922009-03-25 22:36:49 +00003344 if (FQT->isRecordType() || FQT->isUnionType()) {
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003345 if (FQT->isUnionType())
3346 HasUnion = true;
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003347
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003348 BuildAggrIvarRecordLayout(FQT->getAs<RecordType>(),
Daniel Dunbar94f46dc2009-05-03 14:17:18 +00003349 BytePos + FieldOffset,
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003350 ForStrongLayout, HasUnion);
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003351 continue;
3352 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003353
Chris Lattner5b36ddb2009-03-31 08:48:01 +00003354 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003355 const ConstantArrayType *CArray =
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003356 dyn_cast_or_null<ConstantArrayType>(Array);
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003357 uint64_t ElCount = CArray->getSize().getZExtValue();
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003358 assert(CArray && "only array with known element size is supported");
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003359 FQT = CArray->getElementType();
Fariborz Jahanianf909f922009-03-25 22:36:49 +00003360 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
3361 const ConstantArrayType *CArray =
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003362 dyn_cast_or_null<ConstantArrayType>(Array);
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003363 ElCount *= CArray->getSize().getZExtValue();
Fariborz Jahanianf909f922009-03-25 22:36:49 +00003364 FQT = CArray->getElementType();
3365 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003366
3367 assert(!FQT->isUnionType() &&
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003368 "layout for array of unions not supported");
3369 if (FQT->isRecordType()) {
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003370 int OldIndex = IvarsInfo.size() - 1;
3371 int OldSkIndex = SkipIvars.size() -1;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003372
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003373 const RecordType *RT = FQT->getAs<RecordType>();
Daniel Dunbar94f46dc2009-05-03 14:17:18 +00003374 BuildAggrIvarRecordLayout(RT, BytePos + FieldOffset,
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003375 ForStrongLayout, HasUnion);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003376
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003377 // Replicate layout information for each array element. Note that
3378 // one element is already done.
3379 uint64_t ElIx = 1;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003380 for (int FirstIndex = IvarsInfo.size() - 1,
3381 FirstSkIndex = SkipIvars.size() - 1 ;ElIx < ElCount; ElIx++) {
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003382 uint64_t Size = CGM.getContext().getTypeSize(RT)/ByteSizeInBits;
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003383 for (int i = OldIndex+1; i <= FirstIndex; ++i)
3384 IvarsInfo.push_back(GC_IVAR(IvarsInfo[i].ivar_bytepos + Size*ElIx,
3385 IvarsInfo[i].ivar_size));
3386 for (int i = OldSkIndex+1; i <= FirstSkIndex; ++i)
3387 SkipIvars.push_back(GC_IVAR(SkipIvars[i].ivar_bytepos + Size*ElIx,
3388 SkipIvars[i].ivar_size));
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003389 }
3390 continue;
3391 }
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003392 }
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003393 // At this point, we are done with Record/Union and array there of.
3394 // For other arrays we are down to its element type.
John McCall8ccfcb52009-09-24 19:53:00 +00003395 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), FQT);
Daniel Dunbar7abf83c2009-05-03 13:55:09 +00003396
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003397 unsigned FieldSize = CGM.getContext().getTypeSize(Field->getType());
John McCall8ccfcb52009-09-24 19:53:00 +00003398 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
3399 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
Daniel Dunbar22007d32009-05-03 13:32:01 +00003400 if (IsUnion) {
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003401 uint64_t UnionIvarSize = FieldSize / WordSizeInBits;
Daniel Dunbar22007d32009-05-03 13:32:01 +00003402 if (UnionIvarSize > MaxUnionIvarSize) {
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003403 MaxUnionIvarSize = UnionIvarSize;
3404 MaxField = Field;
Daniel Dunbar5b743912009-05-03 23:31:46 +00003405 MaxFieldOffset = FieldOffset;
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003406 }
Daniel Dunbar22007d32009-05-03 13:32:01 +00003407 } else {
Daniel Dunbar94f46dc2009-05-03 14:17:18 +00003408 IvarsInfo.push_back(GC_IVAR(BytePos + FieldOffset,
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003409 FieldSize / WordSizeInBits));
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003410 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003411 } else if ((ForStrongLayout &&
John McCall8ccfcb52009-09-24 19:53:00 +00003412 (GCAttr == Qualifiers::GCNone || GCAttr == Qualifiers::Weak))
3413 || (!ForStrongLayout && GCAttr != Qualifiers::Weak)) {
Daniel Dunbar22007d32009-05-03 13:32:01 +00003414 if (IsUnion) {
Mike Stump18bb9282009-05-16 07:57:57 +00003415 // FIXME: Why the asymmetry? We divide by word size in bits on other
3416 // side.
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003417 uint64_t UnionIvarSize = FieldSize;
Daniel Dunbar22007d32009-05-03 13:32:01 +00003418 if (UnionIvarSize > MaxSkippedUnionIvarSize) {
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003419 MaxSkippedUnionIvarSize = UnionIvarSize;
3420 MaxSkippedField = Field;
Daniel Dunbar5b743912009-05-03 23:31:46 +00003421 MaxSkippedFieldOffset = FieldOffset;
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003422 }
Daniel Dunbar22007d32009-05-03 13:32:01 +00003423 } else {
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003424 // FIXME: Why the asymmetry, we divide by byte size in bits here?
Daniel Dunbar94f46dc2009-05-03 14:17:18 +00003425 SkipIvars.push_back(GC_IVAR(BytePos + FieldOffset,
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003426 FieldSize / ByteSizeInBits));
Fariborz Jahanian3b0f8862009-03-11 00:07:04 +00003427 }
3428 }
3429 }
Daniel Dunbar15bd8882009-05-03 14:10:34 +00003430
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003431 if (LastFieldBitfield) {
3432 // Last field was a bitfield. Must update skip info.
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003433 Expr *BitWidth = LastFieldBitfield->getBitWidth();
3434 uint64_t BitFieldSize =
Eli Friedman1c4a1752009-04-26 19:19:15 +00003435 BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue();
Daniel Dunbar22007d32009-05-03 13:32:01 +00003436 GC_IVAR skivar;
Daniel Dunbar5b743912009-05-03 23:31:46 +00003437 skivar.ivar_bytepos = BytePos + LastBitfieldOffset;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003438 skivar.ivar_size = (BitFieldSize / ByteSizeInBits)
3439 + ((BitFieldSize % ByteSizeInBits) != 0);
3440 SkipIvars.push_back(skivar);
Fariborz Jahanianf5fec022009-04-21 18:33:06 +00003441 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003442
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003443 if (MaxField)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003444 IvarsInfo.push_back(GC_IVAR(BytePos + MaxFieldOffset,
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003445 MaxUnionIvarSize));
3446 if (MaxSkippedField)
Daniel Dunbar5b743912009-05-03 23:31:46 +00003447 SkipIvars.push_back(GC_IVAR(BytePos + MaxSkippedFieldOffset,
Daniel Dunbar7b89ace2009-05-03 13:44:42 +00003448 MaxSkippedUnionIvarSize));
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +00003449}
3450
3451/// BuildIvarLayout - Builds ivar layout bitmap for the class
3452/// implementation for the __strong or __weak case.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003453/// The layout map displays which words in ivar list must be skipped
3454/// and which must be scanned by GC (see below). String is built of bytes.
3455/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +00003456/// of words to skip and right nibble is count of words to scan. So, each
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003457/// nibble represents up to 15 workds to skip or scan. Skipping the rest is
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +00003458/// represented by a 0x00 byte which also ends the string.
3459/// 1. when ForStrongLayout is true, following ivars are scanned:
3460/// - id, Class
3461/// - object *
3462/// - __strong anything
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003463///
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +00003464/// 2. When ForStrongLayout is false, following ivars are scanned:
3465/// - __weak anything
3466///
Fariborz Jahanian524bb202009-03-10 16:22:08 +00003467llvm::Constant *CGObjCCommonMac::BuildIvarLayout(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003468 const ObjCImplementationDecl *OMD,
3469 bool ForStrongLayout) {
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +00003470 bool hasUnion = false;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003471
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003472 unsigned int WordsToScan, WordsToSkip;
Benjamin Kramerabd5b902009-10-13 10:07:13 +00003473 const llvm::Type *PtrTy = llvm::Type::getInt8PtrTy(VMContext);
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003474 if (CGM.getLangOptions().getGCMode() == LangOptions::NonGC)
Owen Anderson0b75f232009-07-31 20:28:54 +00003475 return llvm::Constant::getNullValue(PtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003476
Chris Lattner5b36ddb2009-03-31 08:48:01 +00003477 llvm::SmallVector<FieldDecl*, 32> RecFields;
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003478 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +00003479 CGM.getContext().CollectObjCIvars(OI, RecFields);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003480
Daniel Dunbar98ba9642009-05-04 04:10:48 +00003481 // Add this implementations synthesized ivars.
Fariborz Jahanian0f44d812009-05-12 18:14:29 +00003482 llvm::SmallVector<ObjCIvarDecl*, 16> Ivars;
Fariborz Jahanianaef66222010-02-19 00:31:17 +00003483 CGM.getContext().CollectNonClassIvars(OI, Ivars);
Fariborz Jahanian0f44d812009-05-12 18:14:29 +00003484 for (unsigned k = 0, e = Ivars.size(); k != e; ++k)
3485 RecFields.push_back(cast<FieldDecl>(Ivars[k]));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003486
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +00003487 if (RecFields.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00003488 return llvm::Constant::getNullValue(PtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003489
3490 SkipIvars.clear();
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003491 IvarsInfo.clear();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003492
Daniel Dunbar36e2a1e2009-05-03 21:05:10 +00003493 BuildAggrIvarLayout(OMD, 0, 0, RecFields, 0, ForStrongLayout, hasUnion);
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003494 if (IvarsInfo.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00003495 return llvm::Constant::getNullValue(PtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003496
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003497 // Sort on byte position in case we encounterred a union nested in
3498 // the ivar list.
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003499 if (hasUnion && !IvarsInfo.empty())
Daniel Dunbar22b0ada2009-04-23 01:29:05 +00003500 std::sort(IvarsInfo.begin(), IvarsInfo.end());
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003501 if (hasUnion && !SkipIvars.empty())
Daniel Dunbar22b0ada2009-04-23 01:29:05 +00003502 std::sort(SkipIvars.begin(), SkipIvars.end());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003503
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003504 // Build the string of skip/scan nibbles
Fariborz Jahaniance5676572009-04-24 17:15:27 +00003505 llvm::SmallVector<SKIP_SCAN, 32> SkipScanIvars;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003506 unsigned int WordSize =
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00003507 CGM.getTypes().getTargetData().getTypeAllocSize(PtrTy);
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003508 if (IvarsInfo[0].ivar_bytepos == 0) {
3509 WordsToSkip = 0;
3510 WordsToScan = IvarsInfo[0].ivar_size;
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003511 } else {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003512 WordsToSkip = IvarsInfo[0].ivar_bytepos/WordSize;
3513 WordsToScan = IvarsInfo[0].ivar_size;
3514 }
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003515 for (unsigned int i=1, Last=IvarsInfo.size(); i != Last; i++) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003516 unsigned int TailPrevGCObjC =
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003517 IvarsInfo[i-1].ivar_bytepos + IvarsInfo[i-1].ivar_size * WordSize;
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003518 if (IvarsInfo[i].ivar_bytepos == TailPrevGCObjC) {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003519 // consecutive 'scanned' object pointers.
3520 WordsToScan += IvarsInfo[i].ivar_size;
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003521 } else {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003522 // Skip over 'gc'able object pointer which lay over each other.
3523 if (TailPrevGCObjC > IvarsInfo[i].ivar_bytepos)
3524 continue;
3525 // Must skip over 1 or more words. We save current skip/scan values
3526 // and start a new pair.
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003527 SKIP_SCAN SkScan;
3528 SkScan.skip = WordsToSkip;
3529 SkScan.scan = WordsToScan;
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003530 SkipScanIvars.push_back(SkScan);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003531
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003532 // Skip the hole.
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003533 SkScan.skip = (IvarsInfo[i].ivar_bytepos - TailPrevGCObjC) / WordSize;
3534 SkScan.scan = 0;
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003535 SkipScanIvars.push_back(SkScan);
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003536 WordsToSkip = 0;
3537 WordsToScan = IvarsInfo[i].ivar_size;
3538 }
3539 }
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003540 if (WordsToScan > 0) {
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003541 SKIP_SCAN SkScan;
3542 SkScan.skip = WordsToSkip;
3543 SkScan.scan = WordsToScan;
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003544 SkipScanIvars.push_back(SkScan);
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003545 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003546
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003547 if (!SkipIvars.empty()) {
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003548 unsigned int LastIndex = SkipIvars.size()-1;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003549 int LastByteSkipped =
3550 SkipIvars[LastIndex].ivar_bytepos + SkipIvars[LastIndex].ivar_size;
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003551 LastIndex = IvarsInfo.size()-1;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003552 int LastByteScanned =
3553 IvarsInfo[LastIndex].ivar_bytepos +
3554 IvarsInfo[LastIndex].ivar_size * WordSize;
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003555 // Compute number of bytes to skip at the tail end of the last ivar scanned.
Benjamin Kramerd20ef752009-12-25 15:43:36 +00003556 if (LastByteSkipped > LastByteScanned) {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003557 unsigned int TotalWords = (LastByteSkipped + (WordSize -1)) / WordSize;
Fariborz Jahanian1bf72882009-03-12 22:50:49 +00003558 SKIP_SCAN SkScan;
3559 SkScan.skip = TotalWords - (LastByteScanned/WordSize);
3560 SkScan.scan = 0;
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003561 SkipScanIvars.push_back(SkScan);
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003562 }
3563 }
3564 // Mini optimization of nibbles such that an 0xM0 followed by 0x0N is produced
3565 // as 0xMN.
Fariborz Jahaniana123b642009-04-24 16:17:09 +00003566 int SkipScan = SkipScanIvars.size()-1;
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003567 for (int i = 0; i <= SkipScan; i++) {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003568 if ((i < SkipScan) && SkipScanIvars[i].skip && SkipScanIvars[i].scan == 0
3569 && SkipScanIvars[i+1].skip == 0 && SkipScanIvars[i+1].scan) {
3570 // 0xM0 followed by 0x0N detected.
3571 SkipScanIvars[i].scan = SkipScanIvars[i+1].scan;
3572 for (int j = i+1; j < SkipScan; j++)
3573 SkipScanIvars[j] = SkipScanIvars[j+1];
3574 --SkipScan;
3575 }
3576 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003577
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003578 // Generate the string.
3579 std::string BitMap;
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003580 for (int i = 0; i <= SkipScan; i++) {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003581 unsigned char byte;
3582 unsigned int skip_small = SkipScanIvars[i].skip % 0xf;
3583 unsigned int scan_small = SkipScanIvars[i].scan % 0xf;
3584 unsigned int skip_big = SkipScanIvars[i].skip / 0xf;
3585 unsigned int scan_big = SkipScanIvars[i].scan / 0xf;
3586
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003587 // first skip big.
3588 for (unsigned int ix = 0; ix < skip_big; ix++)
3589 BitMap += (unsigned char)(0xf0);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003590
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003591 // next (skip small, scan)
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003592 if (skip_small) {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003593 byte = skip_small << 4;
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003594 if (scan_big > 0) {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003595 byte |= 0xf;
3596 --scan_big;
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003597 } else if (scan_small) {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003598 byte |= scan_small;
3599 scan_small = 0;
3600 }
3601 BitMap += byte;
3602 }
3603 // next scan big
3604 for (unsigned int ix = 0; ix < scan_big; ix++)
3605 BitMap += (unsigned char)(0x0f);
3606 // last scan small
Daniel Dunbard22aa4a2009-05-03 23:21:22 +00003607 if (scan_small) {
Fariborz Jahaniancbaf73c2009-03-11 20:59:05 +00003608 byte = scan_small;
3609 BitMap += byte;
3610 }
3611 }
3612 // null terminate string.
Fariborz Jahanianf909f922009-03-25 22:36:49 +00003613 unsigned char zero = 0;
3614 BitMap += zero;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003615
Fariborz Jahanian80c9ce22009-04-20 22:03:45 +00003616 if (CGM.getLangOptions().ObjCGCBitmapPrint) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003617 printf("\n%s ivar layout for class '%s': ",
Fariborz Jahanian80c9ce22009-04-20 22:03:45 +00003618 ForStrongLayout ? "strong" : "weak",
3619 OMD->getClassInterface()->getNameAsCString());
3620 const unsigned char *s = (unsigned char*)BitMap.c_str();
3621 for (unsigned i = 0; i < BitMap.size(); i++)
3622 if (!(s[i] & 0xf0))
3623 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
3624 else
3625 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
3626 printf("\n");
3627 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003628 llvm::GlobalVariable * Entry =
3629 CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
Owen Anderson41a75022009-08-13 21:57:51 +00003630 llvm::ConstantArray::get(VMContext, BitMap.c_str()),
Jim Grosbach71d963e2010-07-20 16:20:26 +00003631 ((ObjCABI == 2) ?
3632 "__TEXT,__objc_classname,cstring_literals" :
3633 "__TEXT,__cstring,cstring_literals"),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003634 1, true);
3635 return getConstantGEP(VMContext, Entry, 0, 0);
Fariborz Jahanianc559f3f2009-03-05 22:39:55 +00003636}
3637
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +00003638llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
Daniel Dunbarcb515c82008-08-12 03:39:23 +00003639 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
3640
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003641 // FIXME: Avoid std::string copying.
3642 if (!Entry)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003643 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_NAME_",
Owen Anderson41a75022009-08-13 21:57:51 +00003644 llvm::ConstantArray::get(VMContext, Sel.getAsString()),
Jim Grosbach71d963e2010-07-20 16:20:26 +00003645 ((ObjCABI == 2) ?
3646 "__TEXT,__objc_methname,cstring_literals" :
3647 "__TEXT,__cstring,cstring_literals"),
Daniel Dunbar3241fae2009-04-14 23:14:47 +00003648 1, true);
Daniel Dunbarcb515c82008-08-12 03:39:23 +00003649
Owen Anderson170229f2009-07-14 23:10:40 +00003650 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbarb036db82008-08-13 03:21:16 +00003651}
3652
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003653// FIXME: Merge into a single cstring creation function.
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +00003654llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003655 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
3656}
3657
3658// FIXME: Merge into a single cstring creation function.
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +00003659llvm::Constant *CGObjCCommonMac::GetMethodVarName(const std::string &Name) {
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003660 return GetMethodVarName(&CGM.getContext().Idents.get(Name));
3661}
3662
Daniel Dunbarf5c18462009-04-20 06:54:31 +00003663llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
Devang Patel4b6e4bb2009-03-04 18:21:39 +00003664 std::string TypeStr;
3665 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
3666
3667 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
Daniel Dunbarb036db82008-08-13 03:21:16 +00003668
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003669 if (!Entry)
3670 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
Owen Anderson41a75022009-08-13 21:57:51 +00003671 llvm::ConstantArray::get(VMContext, TypeStr),
Jim Grosbach71d963e2010-07-20 16:20:26 +00003672 ((ObjCABI == 2) ?
3673 "__TEXT,__objc_methtype,cstring_literals" :
3674 "__TEXT,__cstring,cstring_literals"),
Daniel Dunbar3241fae2009-04-14 23:14:47 +00003675 1, true);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003676
Owen Anderson170229f2009-07-14 23:10:40 +00003677 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbarcb515c82008-08-12 03:39:23 +00003678}
3679
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +00003680llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D) {
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003681 std::string TypeStr;
Daniel Dunbar3c76cb52008-08-26 21:51:14 +00003682 CGM.getContext().getObjCEncodingForMethodDecl(const_cast<ObjCMethodDecl*>(D),
3683 TypeStr);
Devang Patel4b6e4bb2009-03-04 18:21:39 +00003684
3685 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
3686
Daniel Dunbar3241fae2009-04-14 23:14:47 +00003687 if (!Entry)
3688 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
Owen Anderson41a75022009-08-13 21:57:51 +00003689 llvm::ConstantArray::get(VMContext, TypeStr),
Jim Grosbach71d963e2010-07-20 16:20:26 +00003690 ((ObjCABI == 2) ?
3691 "__TEXT,__objc_methtype,cstring_literals" :
3692 "__TEXT,__cstring,cstring_literals"),
Daniel Dunbar3241fae2009-04-14 23:14:47 +00003693 1, true);
Devang Patel4b6e4bb2009-03-04 18:21:39 +00003694
Owen Anderson170229f2009-07-14 23:10:40 +00003695 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003696}
3697
Daniel Dunbar80a840b2008-08-23 00:19:03 +00003698// FIXME: Merge into a single cstring creation function.
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +00003699llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
Daniel Dunbar80a840b2008-08-23 00:19:03 +00003700 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003701
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003702 if (!Entry)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003703 Entry = CreateMetadataVar("\01L_OBJC_PROP_NAME_ATTR_",
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00003704 llvm::ConstantArray::get(VMContext,
3705 Ident->getNameStart()),
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003706 "__TEXT,__cstring,cstring_literals",
Daniel Dunbar3241fae2009-04-14 23:14:47 +00003707 1, true);
Daniel Dunbar80a840b2008-08-23 00:19:03 +00003708
Owen Anderson170229f2009-07-14 23:10:40 +00003709 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbar80a840b2008-08-23 00:19:03 +00003710}
3711
3712// FIXME: Merge into a single cstring creation function.
Daniel Dunbar4932b362008-08-28 04:38:10 +00003713// FIXME: This Decl should be more precise.
Daniel Dunbarc2d4b622009-03-09 21:49:58 +00003714llvm::Constant *
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003715CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
3716 const Decl *Container) {
Daniel Dunbar4932b362008-08-28 04:38:10 +00003717 std::string TypeStr;
3718 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
Daniel Dunbar80a840b2008-08-23 00:19:03 +00003719 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
3720}
3721
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003722void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
Fariborz Jahanian0b1ccdc2009-01-21 23:34:32 +00003723 const ObjCContainerDecl *CD,
Daniel Dunbard2386812009-10-19 01:21:19 +00003724 llvm::SmallVectorImpl<char> &Name) {
3725 llvm::raw_svector_ostream OS(Name);
Fariborz Jahanian0196a1c2009-01-10 21:06:09 +00003726 assert (CD && "Missing container decl in GetNameForMethod");
Daniel Dunbard2386812009-10-19 01:21:19 +00003727 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
3728 << '[' << CD->getName();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003729 if (const ObjCCategoryImplDecl *CID =
Daniel Dunbard2386812009-10-19 01:21:19 +00003730 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
Benjamin Kramerb11416d2010-04-17 09:33:03 +00003731 OS << '(' << CID << ')';
Daniel Dunbard2386812009-10-19 01:21:19 +00003732 OS << ' ' << D->getSelector().getAsString() << ']';
Daniel Dunbara94ecd22008-08-16 03:19:19 +00003733}
3734
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003735void CGObjCMac::FinishModule() {
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003736 EmitModuleInfo();
3737
Daniel Dunbarc475d422008-10-29 22:36:39 +00003738 // Emit the dummy bodies for any protocols which were referenced but
3739 // never defined.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003740 for (llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*>::iterator
Chris Lattnerf56501c2009-07-17 23:57:13 +00003741 I = Protocols.begin(), e = Protocols.end(); I != e; ++I) {
3742 if (I->second->hasInitializer())
Daniel Dunbarc475d422008-10-29 22:36:39 +00003743 continue;
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003744
Daniel Dunbarc475d422008-10-29 22:36:39 +00003745 std::vector<llvm::Constant*> Values(5);
Owen Anderson0b75f232009-07-31 20:28:54 +00003746 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
Chris Lattnerf56501c2009-07-17 23:57:13 +00003747 Values[1] = GetClassName(I->first);
Owen Anderson0b75f232009-07-31 20:28:54 +00003748 Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
Daniel Dunbarc475d422008-10-29 22:36:39 +00003749 Values[3] = Values[4] =
Owen Anderson0b75f232009-07-31 20:28:54 +00003750 llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
Chris Lattnerf56501c2009-07-17 23:57:13 +00003751 I->second->setLinkage(llvm::GlobalValue::InternalLinkage);
Owen Anderson0e0189d2009-07-27 22:29:56 +00003752 I->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
Daniel Dunbarc475d422008-10-29 22:36:39 +00003753 Values));
Chris Lattnerf56501c2009-07-17 23:57:13 +00003754 CGM.AddUsedGlobal(I->second);
Daniel Dunbarc475d422008-10-29 22:36:39 +00003755 }
3756
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00003757 // Add assembler directives to add lazy undefined symbol references
3758 // for classes which are referenced but not defined. This is
3759 // important for correct linker interaction.
Daniel Dunbard027a922009-09-07 00:20:42 +00003760 //
3761 // FIXME: It would be nice if we had an LLVM construct for this.
3762 if (!LazySymbols.empty() || !DefinedSymbols.empty()) {
3763 llvm::SmallString<256> Asm;
3764 Asm += CGM.getModule().getModuleInlineAsm();
3765 if (!Asm.empty() && Asm.back() != '\n')
3766 Asm += '\n';
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00003767
Daniel Dunbard027a922009-09-07 00:20:42 +00003768 llvm::raw_svector_ostream OS(Asm);
Daniel Dunbard027a922009-09-07 00:20:42 +00003769 for (llvm::SetVector<IdentifierInfo*>::iterator I = DefinedSymbols.begin(),
3770 e = DefinedSymbols.end(); I != e; ++I)
Daniel Dunbar07d07852009-10-18 21:17:35 +00003771 OS << "\t.objc_class_name_" << (*I)->getName() << "=0\n"
3772 << "\t.globl .objc_class_name_" << (*I)->getName() << "\n";
Chris Lattnera299f2c2010-04-17 18:26:20 +00003773 for (llvm::SetVector<IdentifierInfo*>::iterator I = LazySymbols.begin(),
Fariborz Jahanian9adb2e62010-06-21 22:05:18 +00003774 e = LazySymbols.end(); I != e; ++I) {
Chris Lattnera299f2c2010-04-17 18:26:20 +00003775 OS << "\t.lazy_reference .objc_class_name_" << (*I)->getName() << "\n";
Fariborz Jahanian9adb2e62010-06-21 22:05:18 +00003776 }
3777
3778 for (size_t i = 0; i < DefinedCategoryNames.size(); ++i) {
3779 OS << "\t.objc_category_name_" << DefinedCategoryNames[i] << "=0\n"
3780 << "\t.globl .objc_category_name_" << DefinedCategoryNames[i] << "\n";
3781 }
Chris Lattnera299f2c2010-04-17 18:26:20 +00003782
Daniel Dunbard027a922009-09-07 00:20:42 +00003783 CGM.getModule().setModuleInlineAsm(OS.str());
Daniel Dunbarc61d0e92008-08-25 06:02:07 +00003784 }
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003785}
3786
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003787CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003788 : CGObjCCommonMac(cgm),
Mike Stump11289f42009-09-09 15:08:12 +00003789 ObjCTypes(cgm) {
Fariborz Jahanian71394042009-01-23 23:53:38 +00003790 ObjCEmptyCacheVar = ObjCEmptyVtableVar = NULL;
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003791 ObjCABI = 2;
3792}
3793
Daniel Dunbar3ad53482008-08-11 21:35:06 +00003794/* *** */
3795
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003796ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
Mike Stump11289f42009-09-09 15:08:12 +00003797 : VMContext(cgm.getLLVMContext()), CGM(cgm) {
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003798 CodeGen::CodeGenTypes &Types = CGM.getTypes();
3799 ASTContext &Ctx = CGM.getContext();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003800
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003801 ShortTy = Types.ConvertType(Ctx.ShortTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00003802 IntTy = Types.ConvertType(Ctx.IntTy);
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003803 LongTy = Types.ConvertType(Ctx.LongTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00003804 LongLongTy = Types.ConvertType(Ctx.LongLongTy);
Benjamin Kramerabd5b902009-10-13 10:07:13 +00003805 Int8PtrTy = llvm::Type::getInt8PtrTy(VMContext);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003806
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003807 ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType());
Owen Anderson9793f0e2009-07-29 22:16:19 +00003808 PtrObjectPtrTy = llvm::PointerType::getUnqual(ObjectPtrTy);
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003809 SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003810
Mike Stump18bb9282009-05-16 07:57:57 +00003811 // FIXME: It would be nice to unify this with the opaque type, so that the IR
3812 // comes out a bit cleaner.
Daniel Dunbarb036db82008-08-13 03:21:16 +00003813 const llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
Owen Anderson9793f0e2009-07-29 22:16:19 +00003814 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003815
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003816 // I'm not sure I like this. The implicit coordination is a bit
3817 // gross. We should solve this in a reasonable fashion because this
3818 // is a pretty common task (match some runtime data structure with
3819 // an LLVM data structure).
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003820
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003821 // FIXME: This is leaked.
3822 // FIXME: Merge with rewriter code?
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003823
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003824 // struct _objc_super {
3825 // id self;
3826 // Class cls;
3827 // }
Abramo Bagnara6150c882010-05-11 21:36:43 +00003828 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
Daniel Dunbar0c005372010-04-29 16:29:11 +00003829 Ctx.getTranslationUnitDecl(),
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003830 SourceLocation(),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003831 &Ctx.Idents.get("_objc_super"));
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00003832 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00003833 Ctx.getObjCIdType(), 0, 0, false));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003834 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00003835 Ctx.getObjCClassType(), 0, 0, false));
Douglas Gregord5058122010-02-11 01:19:42 +00003836 RD->completeDefinition();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003837
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003838 SuperCTy = Ctx.getTagDeclType(RD);
3839 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003840
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003841 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003842 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
3843
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003844 // struct _prop_t {
3845 // char *name;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003846 // char *attributes;
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003847 // }
Owen Anderson758428f2009-08-05 23:18:46 +00003848 PropertyTy = llvm::StructType::get(VMContext, Int8PtrTy, Int8PtrTy, NULL);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003849 CGM.getModule().addTypeName("struct._prop_t",
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003850 PropertyTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003851
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003852 // struct _prop_list_t {
Fariborz Jahanian0232c052009-01-23 01:46:23 +00003853 // uint32_t entsize; // sizeof(struct _prop_t)
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003854 // uint32_t count_of_properties;
Fariborz Jahanian0232c052009-01-23 01:46:23 +00003855 // struct _prop_t prop_list[count_of_properties];
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003856 // }
Owen Anderson758428f2009-08-05 23:18:46 +00003857 PropertyListTy = llvm::StructType::get(VMContext, IntTy,
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003858 IntTy,
Owen Anderson9793f0e2009-07-29 22:16:19 +00003859 llvm::ArrayType::get(PropertyTy, 0),
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003860 NULL);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003861 CGM.getModule().addTypeName("struct._prop_list_t",
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003862 PropertyListTy);
3863 // struct _prop_list_t *
Owen Anderson9793f0e2009-07-29 22:16:19 +00003864 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003865
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003866 // struct _objc_method {
3867 // SEL _cmd;
3868 // char *method_type;
3869 // char *_imp;
3870 // }
Owen Anderson758428f2009-08-05 23:18:46 +00003871 MethodTy = llvm::StructType::get(VMContext, SelectorPtrTy,
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00003872 Int8PtrTy,
3873 Int8PtrTy,
3874 NULL);
3875 CGM.getModule().addTypeName("struct._objc_method", MethodTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003876
Fariborz Jahanian0232c052009-01-23 01:46:23 +00003877 // struct _objc_cache *
Owen Andersonc36edfe2009-08-13 23:27:53 +00003878 CacheTy = llvm::OpaqueType::get(VMContext);
Fariborz Jahanian0232c052009-01-23 01:46:23 +00003879 CGM.getModule().addTypeName("struct._objc_cache", CacheTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00003880 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003881}
Daniel Dunbar7bd00bd2008-08-12 06:48:42 +00003882
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003883ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
Mike Stump11289f42009-09-09 15:08:12 +00003884 : ObjCCommonTypesHelper(cgm) {
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003885 // struct _objc_method_description {
3886 // SEL name;
3887 // char *types;
3888 // }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003889 MethodDescriptionTy =
Owen Anderson758428f2009-08-05 23:18:46 +00003890 llvm::StructType::get(VMContext, SelectorPtrTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003891 Int8PtrTy,
Daniel Dunbarb036db82008-08-13 03:21:16 +00003892 NULL);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003893 CGM.getModule().addTypeName("struct._objc_method_description",
Daniel Dunbarb036db82008-08-13 03:21:16 +00003894 MethodDescriptionTy);
3895
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003896 // struct _objc_method_description_list {
3897 // int count;
3898 // struct _objc_method_description[1];
3899 // }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003900 MethodDescriptionListTy =
Owen Anderson758428f2009-08-05 23:18:46 +00003901 llvm::StructType::get(VMContext, IntTy,
Owen Anderson9793f0e2009-07-29 22:16:19 +00003902 llvm::ArrayType::get(MethodDescriptionTy, 0),
Daniel Dunbarb036db82008-08-13 03:21:16 +00003903 NULL);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003904 CGM.getModule().addTypeName("struct._objc_method_description_list",
Daniel Dunbarb036db82008-08-13 03:21:16 +00003905 MethodDescriptionListTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003906
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003907 // struct _objc_method_description_list *
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003908 MethodDescriptionListPtrTy =
Owen Anderson9793f0e2009-07-29 22:16:19 +00003909 llvm::PointerType::getUnqual(MethodDescriptionListTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00003910
Daniel Dunbarb036db82008-08-13 03:21:16 +00003911 // Protocol description structures
3912
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003913 // struct _objc_protocol_extension {
3914 // uint32_t size; // sizeof(struct _objc_protocol_extension)
3915 // struct _objc_method_description_list *optional_instance_methods;
3916 // struct _objc_method_description_list *optional_class_methods;
3917 // struct _objc_property_list *instance_properties;
3918 // }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003919 ProtocolExtensionTy =
Owen Anderson758428f2009-08-05 23:18:46 +00003920 llvm::StructType::get(VMContext, IntTy,
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003921 MethodDescriptionListPtrTy,
3922 MethodDescriptionListPtrTy,
Daniel Dunbarb036db82008-08-13 03:21:16 +00003923 PropertyListPtrTy,
3924 NULL);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003925 CGM.getModule().addTypeName("struct._objc_protocol_extension",
Daniel Dunbarb036db82008-08-13 03:21:16 +00003926 ProtocolExtensionTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003927
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003928 // struct _objc_protocol_extension *
Owen Anderson9793f0e2009-07-29 22:16:19 +00003929 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00003930
Daniel Dunbarc475d422008-10-29 22:36:39 +00003931 // Handle recursive construction of Protocol and ProtocolList types
Daniel Dunbarb036db82008-08-13 03:21:16 +00003932
Owen Andersonc36edfe2009-08-13 23:27:53 +00003933 llvm::PATypeHolder ProtocolTyHolder = llvm::OpaqueType::get(VMContext);
3934 llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get(VMContext);
Daniel Dunbarb036db82008-08-13 03:21:16 +00003935
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003936 const llvm::Type *T =
Mike Stump11289f42009-09-09 15:08:12 +00003937 llvm::StructType::get(VMContext,
Owen Anderson758428f2009-08-05 23:18:46 +00003938 llvm::PointerType::getUnqual(ProtocolListTyHolder),
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003939 LongTy,
Owen Anderson9793f0e2009-07-29 22:16:19 +00003940 llvm::ArrayType::get(ProtocolTyHolder, 0),
Fariborz Jahanian279eda62009-01-21 22:04:16 +00003941 NULL);
Daniel Dunbarb036db82008-08-13 03:21:16 +00003942 cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(T);
3943
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003944 // struct _objc_protocol {
3945 // struct _objc_protocol_extension *isa;
3946 // char *protocol_name;
3947 // struct _objc_protocol **_objc_protocol_list;
3948 // struct _objc_method_description_list *instance_methods;
3949 // struct _objc_method_description_list *class_methods;
3950 // }
Owen Anderson758428f2009-08-05 23:18:46 +00003951 T = llvm::StructType::get(VMContext, ProtocolExtensionPtrTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003952 Int8PtrTy,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003953 llvm::PointerType::getUnqual(ProtocolListTyHolder),
Daniel Dunbarb036db82008-08-13 03:21:16 +00003954 MethodDescriptionListPtrTy,
3955 MethodDescriptionListPtrTy,
3956 NULL);
3957 cast<llvm::OpaqueType>(ProtocolTyHolder.get())->refineAbstractTypeTo(T);
3958
3959 ProtocolListTy = cast<llvm::StructType>(ProtocolListTyHolder.get());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003960 CGM.getModule().addTypeName("struct._objc_protocol_list",
Daniel Dunbarb036db82008-08-13 03:21:16 +00003961 ProtocolListTy);
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003962 // struct _objc_protocol_list *
Owen Anderson9793f0e2009-07-29 22:16:19 +00003963 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
Daniel Dunbarb036db82008-08-13 03:21:16 +00003964
3965 ProtocolTy = cast<llvm::StructType>(ProtocolTyHolder.get());
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003966 CGM.getModule().addTypeName("struct._objc_protocol", ProtocolTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00003967 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003968
3969 // Class description structures
3970
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003971 // struct _objc_ivar {
3972 // char *ivar_name;
3973 // char *ivar_type;
3974 // int ivar_offset;
3975 // }
Owen Anderson758428f2009-08-05 23:18:46 +00003976 IvarTy = llvm::StructType::get(VMContext, Int8PtrTy,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003977 Int8PtrTy,
3978 IntTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003979 NULL);
3980 CGM.getModule().addTypeName("struct._objc_ivar", IvarTy);
3981
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003982 // struct _objc_ivar_list *
Owen Andersonc36edfe2009-08-13 23:27:53 +00003983 IvarListTy = llvm::OpaqueType::get(VMContext);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003984 CGM.getModule().addTypeName("struct._objc_ivar_list", IvarListTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00003985 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003986
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003987 // struct _objc_method_list *
Owen Andersonc36edfe2009-08-13 23:27:53 +00003988 MethodListTy = llvm::OpaqueType::get(VMContext);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003989 CGM.getModule().addTypeName("struct._objc_method_list", MethodListTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00003990 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003991
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00003992 // struct _objc_class_extension *
Daniel Dunbar59e476b2009-08-03 17:06:42 +00003993 ClassExtensionTy =
Owen Anderson758428f2009-08-05 23:18:46 +00003994 llvm::StructType::get(VMContext, IntTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00003995 Int8PtrTy,
3996 PropertyListPtrTy,
3997 NULL);
3998 CGM.getModule().addTypeName("struct._objc_class_extension", ClassExtensionTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00003999 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004000
Owen Andersonc36edfe2009-08-13 23:27:53 +00004001 llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get(VMContext);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004002
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00004003 // struct _objc_class {
4004 // Class isa;
4005 // Class super_class;
4006 // char *name;
4007 // long version;
4008 // long info;
4009 // long instance_size;
4010 // struct _objc_ivar_list *ivars;
4011 // struct _objc_method_list *methods;
4012 // struct _objc_cache *cache;
4013 // struct _objc_protocol_list *protocols;
4014 // char *ivar_layout;
4015 // struct _objc_class_ext *ext;
4016 // };
Owen Anderson758428f2009-08-05 23:18:46 +00004017 T = llvm::StructType::get(VMContext,
4018 llvm::PointerType::getUnqual(ClassTyHolder),
Owen Anderson9793f0e2009-07-29 22:16:19 +00004019 llvm::PointerType::getUnqual(ClassTyHolder),
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004020 Int8PtrTy,
4021 LongTy,
4022 LongTy,
4023 LongTy,
4024 IvarListPtrTy,
4025 MethodListPtrTy,
4026 CachePtrTy,
4027 ProtocolListPtrTy,
4028 Int8PtrTy,
4029 ClassExtensionPtrTy,
4030 NULL);
4031 cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(T);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004032
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004033 ClassTy = cast<llvm::StructType>(ClassTyHolder.get());
4034 CGM.getModule().addTypeName("struct._objc_class", ClassTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00004035 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004036
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00004037 // struct _objc_category {
4038 // char *category_name;
4039 // char *class_name;
4040 // struct _objc_method_list *instance_method;
4041 // struct _objc_method_list *class_method;
4042 // uint32_t size; // sizeof(struct _objc_category)
4043 // struct _objc_property_list *instance_properties;// category's @property
4044 // }
Owen Anderson758428f2009-08-05 23:18:46 +00004045 CategoryTy = llvm::StructType::get(VMContext, Int8PtrTy,
Daniel Dunbar938a77f2008-08-22 20:34:54 +00004046 Int8PtrTy,
4047 MethodListPtrTy,
4048 MethodListPtrTy,
4049 ProtocolListPtrTy,
4050 IntTy,
4051 PropertyListPtrTy,
4052 NULL);
4053 CGM.getModule().addTypeName("struct._objc_category", CategoryTy);
4054
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004055 // Global metadata structures
4056
Fariborz Jahanian4b4c8262009-01-21 00:39:53 +00004057 // struct _objc_symtab {
4058 // long sel_ref_cnt;
4059 // SEL *refs;
4060 // short cls_def_cnt;
4061 // short cat_def_cnt;
4062 // char *defs[cls_def_cnt + cat_def_cnt];
4063 // }
Owen Anderson758428f2009-08-05 23:18:46 +00004064 SymtabTy = llvm::StructType::get(VMContext, LongTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004065 SelectorPtrTy,
4066 ShortTy,
4067 ShortTy,
Owen Anderson9793f0e2009-07-29 22:16:19 +00004068 llvm::ArrayType::get(Int8PtrTy, 0),
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004069 NULL);
4070 CGM.getModule().addTypeName("struct._objc_symtab", SymtabTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00004071 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004072
Fariborz Jahanianeee54df2009-01-22 00:37:21 +00004073 // struct _objc_module {
4074 // long version;
4075 // long size; // sizeof(struct _objc_module)
4076 // char *name;
4077 // struct _objc_symtab* symtab;
4078 // }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004079 ModuleTy =
Owen Anderson758428f2009-08-05 23:18:46 +00004080 llvm::StructType::get(VMContext, LongTy,
Daniel Dunbar22d82ed2008-08-21 04:36:09 +00004081 LongTy,
4082 Int8PtrTy,
4083 SymtabPtrTy,
4084 NULL);
4085 CGM.getModule().addTypeName("struct._objc_module", ModuleTy);
Daniel Dunbar97ff50d2008-08-23 09:25:55 +00004086
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004087
Mike Stump18bb9282009-05-16 07:57:57 +00004088 // FIXME: This is the size of the setjmp buffer and should be target
4089 // specific. 18 is what's used on 32-bit X86.
Anders Carlsson9ff22482008-09-09 10:10:21 +00004090 uint64_t SetJmpBufferSize = 18;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004091
Anders Carlsson9ff22482008-09-09 10:10:21 +00004092 // Exceptions
Owen Anderson9793f0e2009-07-29 22:16:19 +00004093 const llvm::Type *StackPtrTy = llvm::ArrayType::get(
Benjamin Kramerabd5b902009-10-13 10:07:13 +00004094 llvm::Type::getInt8PtrTy(VMContext), 4);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004095
4096 ExceptionDataTy =
Chris Lattner5e016ae2010-06-27 07:15:29 +00004097 llvm::StructType::get(VMContext,
4098 llvm::ArrayType::get(llvm::Type::getInt32Ty(VMContext),
4099 SetJmpBufferSize),
Anders Carlsson9ff22482008-09-09 10:10:21 +00004100 StackPtrTy, NULL);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004101 CGM.getModule().addTypeName("struct._objc_exception_data",
Anders Carlsson9ff22482008-09-09 10:10:21 +00004102 ExceptionDataTy);
4103
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00004104}
4105
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004106ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
Mike Stump11289f42009-09-09 15:08:12 +00004107 : ObjCCommonTypesHelper(cgm) {
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00004108 // struct _method_list_t {
4109 // uint32_t entsize; // sizeof(struct _objc_method)
4110 // uint32_t method_count;
4111 // struct _objc_method method_list[method_count];
4112 // }
Owen Anderson758428f2009-08-05 23:18:46 +00004113 MethodListnfABITy = llvm::StructType::get(VMContext, IntTy,
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004114 IntTy,
Owen Anderson9793f0e2009-07-29 22:16:19 +00004115 llvm::ArrayType::get(MethodTy, 0),
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004116 NULL);
4117 CGM.getModule().addTypeName("struct.__method_list_t",
4118 MethodListnfABITy);
4119 // struct method_list_t *
Owen Anderson9793f0e2009-07-29 22:16:19 +00004120 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004121
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00004122 // struct _protocol_t {
4123 // id isa; // NULL
4124 // const char * const protocol_name;
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004125 // const struct _protocol_list_t * protocol_list; // super protocols
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00004126 // const struct method_list_t * const instance_methods;
4127 // const struct method_list_t * const class_methods;
4128 // const struct method_list_t *optionalInstanceMethods;
4129 // const struct method_list_t *optionalClassMethods;
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004130 // const struct _prop_list_t * properties;
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00004131 // const uint32_t size; // sizeof(struct _protocol_t)
4132 // const uint32_t flags; // = 0
4133 // }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004134
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004135 // Holder for struct _protocol_list_t *
Owen Andersonc36edfe2009-08-13 23:27:53 +00004136 llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get(VMContext);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004137
Owen Anderson758428f2009-08-05 23:18:46 +00004138 ProtocolnfABITy = llvm::StructType::get(VMContext, ObjectPtrTy,
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004139 Int8PtrTy,
Owen Anderson9793f0e2009-07-29 22:16:19 +00004140 llvm::PointerType::getUnqual(
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004141 ProtocolListTyHolder),
4142 MethodListnfABIPtrTy,
4143 MethodListnfABIPtrTy,
4144 MethodListnfABIPtrTy,
4145 MethodListnfABIPtrTy,
4146 PropertyListPtrTy,
4147 IntTy,
4148 IntTy,
4149 NULL);
4150 CGM.getModule().addTypeName("struct._protocol_t",
4151 ProtocolnfABITy);
Daniel Dunbar8de90f02009-02-15 07:36:20 +00004152
4153 // struct _protocol_t*
Owen Anderson9793f0e2009-07-29 22:16:19 +00004154 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004155
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00004156 // struct _protocol_list_t {
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004157 // long protocol_count; // Note, this is 32/64 bit
Daniel Dunbar8de90f02009-02-15 07:36:20 +00004158 // struct _protocol_t *[protocol_count];
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00004159 // }
Owen Anderson758428f2009-08-05 23:18:46 +00004160 ProtocolListnfABITy = llvm::StructType::get(VMContext, LongTy,
Owen Anderson9793f0e2009-07-29 22:16:19 +00004161 llvm::ArrayType::get(
Daniel Dunbar8de90f02009-02-15 07:36:20 +00004162 ProtocolnfABIPtrTy, 0),
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004163 NULL);
4164 CGM.getModule().addTypeName("struct._objc_protocol_list",
4165 ProtocolListnfABITy);
Daniel Dunbar8de90f02009-02-15 07:36:20 +00004166 cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004167 ProtocolListnfABITy);
4168
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004169 // struct _objc_protocol_list*
Owen Anderson9793f0e2009-07-29 22:16:19 +00004170 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004171
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00004172 // struct _ivar_t {
4173 // unsigned long int *offset; // pointer to ivar offset location
4174 // char *name;
4175 // char *type;
4176 // uint32_t alignment;
4177 // uint32_t size;
4178 // }
Mike Stump11289f42009-09-09 15:08:12 +00004179 IvarnfABITy = llvm::StructType::get(VMContext,
Owen Anderson758428f2009-08-05 23:18:46 +00004180 llvm::PointerType::getUnqual(LongTy),
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004181 Int8PtrTy,
4182 Int8PtrTy,
4183 IntTy,
4184 IntTy,
4185 NULL);
4186 CGM.getModule().addTypeName("struct._ivar_t", IvarnfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004187
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00004188 // struct _ivar_list_t {
4189 // uint32 entsize; // sizeof(struct _ivar_t)
4190 // uint32 count;
4191 // struct _iver_t list[count];
4192 // }
Owen Anderson758428f2009-08-05 23:18:46 +00004193 IvarListnfABITy = llvm::StructType::get(VMContext, IntTy,
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004194 IntTy,
Owen Anderson9793f0e2009-07-29 22:16:19 +00004195 llvm::ArrayType::get(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004196 IvarnfABITy, 0),
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004197 NULL);
4198 CGM.getModule().addTypeName("struct._ivar_list_t", IvarListnfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004199
Owen Anderson9793f0e2009-07-29 22:16:19 +00004200 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004201
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004202 // struct _class_ro_t {
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00004203 // uint32_t const flags;
4204 // uint32_t const instanceStart;
4205 // uint32_t const instanceSize;
4206 // uint32_t const reserved; // only when building for 64bit targets
4207 // const uint8_t * const ivarLayout;
4208 // const char *const name;
4209 // const struct _method_list_t * const baseMethods;
4210 // const struct _objc_protocol_list *const baseProtocols;
4211 // const struct _ivar_list_t *const ivars;
4212 // const uint8_t * const weakIvarLayout;
4213 // const struct _prop_list_t * const properties;
4214 // }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004215
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004216 // FIXME. Add 'reserved' field in 64bit abi mode!
Owen Anderson758428f2009-08-05 23:18:46 +00004217 ClassRonfABITy = llvm::StructType::get(VMContext, IntTy,
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004218 IntTy,
4219 IntTy,
4220 Int8PtrTy,
4221 Int8PtrTy,
4222 MethodListnfABIPtrTy,
4223 ProtocolListnfABIPtrTy,
4224 IvarListnfABIPtrTy,
4225 Int8PtrTy,
4226 PropertyListPtrTy,
4227 NULL);
4228 CGM.getModule().addTypeName("struct._class_ro_t",
4229 ClassRonfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004230
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004231 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
4232 std::vector<const llvm::Type*> Params;
4233 Params.push_back(ObjectPtrTy);
4234 Params.push_back(SelectorPtrTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00004235 ImpnfABITy = llvm::PointerType::getUnqual(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004236 llvm::FunctionType::get(ObjectPtrTy, Params, false));
4237
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004238 // struct _class_t {
4239 // struct _class_t *isa;
4240 // struct _class_t * const superclass;
4241 // void *cache;
4242 // IMP *vtable;
4243 // struct class_ro_t *ro;
4244 // }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004245
Owen Andersonc36edfe2009-08-13 23:27:53 +00004246 llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get(VMContext);
Owen Anderson170229f2009-07-14 23:10:40 +00004247 ClassnfABITy =
Owen Anderson758428f2009-08-05 23:18:46 +00004248 llvm::StructType::get(VMContext,
4249 llvm::PointerType::getUnqual(ClassTyHolder),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004250 llvm::PointerType::getUnqual(ClassTyHolder),
4251 CachePtrTy,
4252 llvm::PointerType::getUnqual(ImpnfABITy),
4253 llvm::PointerType::getUnqual(ClassRonfABITy),
4254 NULL);
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004255 CGM.getModule().addTypeName("struct._class_t", ClassnfABITy);
4256
4257 cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004258 ClassnfABITy);
4259
Fariborz Jahanian71394042009-01-23 23:53:38 +00004260 // LLVM for struct _class_t *
Owen Anderson9793f0e2009-07-29 22:16:19 +00004261 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004262
Fariborz Jahanian0232c052009-01-23 01:46:23 +00004263 // struct _category_t {
4264 // const char * const name;
4265 // struct _class_t *const cls;
4266 // const struct _method_list_t * const instance_methods;
4267 // const struct _method_list_t * const class_methods;
4268 // const struct _protocol_list_t * const protocols;
4269 // const struct _prop_list_t * const properties;
Fariborz Jahanian5a63e4c2009-01-23 17:41:22 +00004270 // }
Owen Anderson758428f2009-08-05 23:18:46 +00004271 CategorynfABITy = llvm::StructType::get(VMContext, Int8PtrTy,
Fariborz Jahanian71394042009-01-23 23:53:38 +00004272 ClassnfABIPtrTy,
Fariborz Jahanian5a63e4c2009-01-23 17:41:22 +00004273 MethodListnfABIPtrTy,
4274 MethodListnfABIPtrTy,
4275 ProtocolListnfABIPtrTy,
4276 PropertyListPtrTy,
4277 NULL);
4278 CGM.getModule().addTypeName("struct._category_t", CategorynfABITy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004279
Fariborz Jahanian82c72e12009-02-03 23:49:23 +00004280 // New types for nonfragile abi messaging.
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00004281 CodeGen::CodeGenTypes &Types = CGM.getTypes();
4282 ASTContext &Ctx = CGM.getContext();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004283
Fariborz Jahanian82c72e12009-02-03 23:49:23 +00004284 // MessageRefTy - LLVM for:
4285 // struct _message_ref_t {
4286 // IMP messenger;
4287 // SEL name;
4288 // };
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004289
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00004290 // First the clang type for struct _message_ref_t
Abramo Bagnara6150c882010-05-11 21:36:43 +00004291 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
Daniel Dunbar0c005372010-04-29 16:29:11 +00004292 Ctx.getTranslationUnitDecl(),
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00004293 SourceLocation(),
4294 &Ctx.Idents.get("_message_ref_t"));
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004295 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00004296 Ctx.VoidPtrTy, 0, 0, false));
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004297 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00004298 Ctx.getObjCSelType(), 0, 0, false));
Douglas Gregord5058122010-02-11 01:19:42 +00004299 RD->completeDefinition();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004300
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00004301 MessageRefCTy = Ctx.getTagDeclType(RD);
4302 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
4303 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004304
Fariborz Jahanian82c72e12009-02-03 23:49:23 +00004305 // MessageRefPtrTy - LLVM for struct _message_ref_t*
Owen Anderson9793f0e2009-07-29 22:16:19 +00004306 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004307
Fariborz Jahanian82c72e12009-02-03 23:49:23 +00004308 // SuperMessageRefTy - LLVM for:
4309 // struct _super_message_ref_t {
4310 // SUPER_IMP messenger;
4311 // SEL name;
4312 // };
Owen Anderson758428f2009-08-05 23:18:46 +00004313 SuperMessageRefTy = llvm::StructType::get(VMContext, ImpnfABITy,
Fariborz Jahanian82c72e12009-02-03 23:49:23 +00004314 SelectorPtrTy,
4315 NULL);
4316 CGM.getModule().addTypeName("struct._super_message_ref_t", SuperMessageRefTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004317
Fariborz Jahanian82c72e12009-02-03 23:49:23 +00004318 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004319 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
4320
Daniel Dunbarb1559a42009-03-01 04:46:24 +00004321
4322 // struct objc_typeinfo {
4323 // const void** vtable; // objc_ehtype_vtable + 2
4324 // const char* name; // c++ typeinfo string
4325 // Class cls;
4326 // };
Owen Anderson758428f2009-08-05 23:18:46 +00004327 EHTypeTy = llvm::StructType::get(VMContext,
4328 llvm::PointerType::getUnqual(Int8PtrTy),
Daniel Dunbarb1559a42009-03-01 04:46:24 +00004329 Int8PtrTy,
4330 ClassnfABIPtrTy,
4331 NULL);
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00004332 CGM.getModule().addTypeName("struct._objc_typeinfo", EHTypeTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00004333 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00004334}
4335
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004336llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
Fariborz Jahanian71394042009-01-23 23:53:38 +00004337 FinishNonFragileABIModule();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004338
Fariborz Jahanian71394042009-01-23 23:53:38 +00004339 return NULL;
4340}
4341
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004342void CGObjCNonFragileABIMac::AddModuleClassList(const
4343 std::vector<llvm::GlobalValue*>
4344 &Container,
Daniel Dunbar19573e72009-05-15 21:48:48 +00004345 const char *SymbolName,
4346 const char *SectionName) {
4347 unsigned NumClasses = Container.size();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004348
Daniel Dunbar19573e72009-05-15 21:48:48 +00004349 if (!NumClasses)
4350 return;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004351
Daniel Dunbar19573e72009-05-15 21:48:48 +00004352 std::vector<llvm::Constant*> Symbols(NumClasses);
4353 for (unsigned i=0; i<NumClasses; i++)
Owen Andersonade90fd2009-07-29 18:54:39 +00004354 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
Daniel Dunbar19573e72009-05-15 21:48:48 +00004355 ObjCTypes.Int8PtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004356 llvm::Constant* Init =
Owen Anderson9793f0e2009-07-29 22:16:19 +00004357 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
Daniel Dunbar19573e72009-05-15 21:48:48 +00004358 NumClasses),
4359 Symbols);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004360
Daniel Dunbar19573e72009-05-15 21:48:48 +00004361 llvm::GlobalVariable *GV =
Owen Andersonc10c8d32009-07-08 19:05:04 +00004362 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Daniel Dunbar19573e72009-05-15 21:48:48 +00004363 llvm::GlobalValue::InternalLinkage,
4364 Init,
Owen Andersonc10c8d32009-07-08 19:05:04 +00004365 SymbolName);
Daniel Dunbar710cb202010-04-25 20:39:32 +00004366 GV->setAlignment(CGM.getTargetData().getABITypeAlignment(Init->getType()));
Daniel Dunbar19573e72009-05-15 21:48:48 +00004367 GV->setSection(SectionName);
Chris Lattnerf56501c2009-07-17 23:57:13 +00004368 CGM.AddUsedGlobal(GV);
Daniel Dunbar19573e72009-05-15 21:48:48 +00004369}
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004370
Fariborz Jahanian71394042009-01-23 23:53:38 +00004371void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
4372 // nonfragile abi has no module definition.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004373
Daniel Dunbar19573e72009-05-15 21:48:48 +00004374 // Build list of all implemented class addresses in array
Fariborz Jahanian279abd32009-01-30 20:55:31 +00004375 // L_OBJC_LABEL_CLASS_$.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004376 AddModuleClassList(DefinedClasses,
Daniel Dunbar19573e72009-05-15 21:48:48 +00004377 "\01L_OBJC_LABEL_CLASS_$",
4378 "__DATA, __objc_classlist, regular, no_dead_strip");
Fariborz Jahanian67260552009-11-17 21:37:35 +00004379
Fariborz Jahanian67260552009-11-17 21:37:35 +00004380 for (unsigned i = 0; i < DefinedClasses.size(); i++) {
4381 llvm::GlobalValue *IMPLGV = DefinedClasses[i];
4382 if (IMPLGV->getLinkage() != llvm::GlobalValue::ExternalWeakLinkage)
4383 continue;
4384 IMPLGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
Fariborz Jahanian67260552009-11-17 21:37:35 +00004385 }
4386
Fariborz Jahaniana6227fd2009-12-01 18:25:24 +00004387 for (unsigned i = 0; i < DefinedMetaClasses.size(); i++) {
4388 llvm::GlobalValue *IMPLGV = DefinedMetaClasses[i];
4389 if (IMPLGV->getLinkage() != llvm::GlobalValue::ExternalWeakLinkage)
4390 continue;
4391 IMPLGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
4392 }
Fariborz Jahanian67260552009-11-17 21:37:35 +00004393
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004394 AddModuleClassList(DefinedNonLazyClasses,
Daniel Dunbar9a017d72009-05-15 22:33:15 +00004395 "\01L_OBJC_LABEL_NONLAZY_CLASS_$",
4396 "__DATA, __objc_nlclslist, regular, no_dead_strip");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004397
Fariborz Jahanian279abd32009-01-30 20:55:31 +00004398 // Build list of all implemented category addresses in array
4399 // L_OBJC_LABEL_CATEGORY_$.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004400 AddModuleClassList(DefinedCategories,
Daniel Dunbar19573e72009-05-15 21:48:48 +00004401 "\01L_OBJC_LABEL_CATEGORY_$",
4402 "__DATA, __objc_catlist, regular, no_dead_strip");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004403 AddModuleClassList(DefinedNonLazyCategories,
Daniel Dunbar9a017d72009-05-15 22:33:15 +00004404 "\01L_OBJC_LABEL_NONLAZY_CATEGORY_$",
4405 "__DATA, __objc_nlcatlist, regular, no_dead_strip");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004406
Daniel Dunbar5e639272010-04-25 20:39:01 +00004407 EmitImageInfo();
Fariborz Jahanian71394042009-01-23 23:53:38 +00004408}
4409
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00004410/// LegacyDispatchedSelector - Returns true if SEL is not in the list of
Fariborz Jahaniane4128642009-05-12 20:06:41 +00004411/// NonLegacyDispatchMethods; false otherwise. What this means is that
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004412/// except for the 19 selectors in the list, we generate 32bit-style
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00004413/// message dispatch call for all the rest.
4414///
4415bool CGObjCNonFragileABIMac::LegacyDispatchedSelector(Selector Sel) {
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +00004416 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
4417 default:
4418 assert(0 && "Invalid dispatch method!");
4419 case CodeGenOptions::Legacy:
Daniel Dunbarca5e3eb2010-02-01 21:07:33 +00004420 return true;
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +00004421 case CodeGenOptions::NonLegacy:
Fariborz Jahaniandfb39832010-04-19 17:53:30 +00004422 return false;
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +00004423 case CodeGenOptions::Mixed:
4424 break;
4425 }
4426
4427 // If so, see whether this selector is in the white-list of things which must
4428 // use the new dispatch convention. We lazily build a dense set for this.
Fariborz Jahaniane4128642009-05-12 20:06:41 +00004429 if (NonLegacyDispatchMethods.empty()) {
4430 NonLegacyDispatchMethods.insert(GetNullarySelector("alloc"));
4431 NonLegacyDispatchMethods.insert(GetNullarySelector("class"));
4432 NonLegacyDispatchMethods.insert(GetNullarySelector("self"));
4433 NonLegacyDispatchMethods.insert(GetNullarySelector("isFlipped"));
4434 NonLegacyDispatchMethods.insert(GetNullarySelector("length"));
4435 NonLegacyDispatchMethods.insert(GetNullarySelector("count"));
4436 NonLegacyDispatchMethods.insert(GetNullarySelector("retain"));
4437 NonLegacyDispatchMethods.insert(GetNullarySelector("release"));
4438 NonLegacyDispatchMethods.insert(GetNullarySelector("autorelease"));
4439 NonLegacyDispatchMethods.insert(GetNullarySelector("hash"));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004440
Fariborz Jahaniane4128642009-05-12 20:06:41 +00004441 NonLegacyDispatchMethods.insert(GetUnarySelector("allocWithZone"));
4442 NonLegacyDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
4443 NonLegacyDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
4444 NonLegacyDispatchMethods.insert(GetUnarySelector("objectForKey"));
4445 NonLegacyDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
4446 NonLegacyDispatchMethods.insert(GetUnarySelector("isEqualToString"));
4447 NonLegacyDispatchMethods.insert(GetUnarySelector("isEqual"));
4448 NonLegacyDispatchMethods.insert(GetUnarySelector("addObject"));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004449 // "countByEnumeratingWithState:objects:count"
Fariborz Jahanian18801362009-05-13 16:19:02 +00004450 IdentifierInfo *KeyIdents[] = {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004451 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
4452 &CGM.getContext().Idents.get("objects"),
4453 &CGM.getContext().Idents.get("count")
Fariborz Jahanian18801362009-05-13 16:19:02 +00004454 };
4455 NonLegacyDispatchMethods.insert(
4456 CGM.getContext().Selectors.getSelector(3, KeyIdents));
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00004457 }
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +00004458
Fariborz Jahaniane4128642009-05-12 20:06:41 +00004459 return (NonLegacyDispatchMethods.count(Sel) == 0);
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00004460}
4461
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004462// Metadata flags
4463enum MetaDataDlags {
4464 CLS = 0x0,
4465 CLS_META = 0x1,
4466 CLS_ROOT = 0x2,
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004467 OBJC2_CLS_HIDDEN = 0x10,
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004468 CLS_EXCEPTION = 0x20
4469};
4470/// BuildClassRoTInitializer - generate meta-data for:
4471/// struct _class_ro_t {
4472/// uint32_t const flags;
4473/// uint32_t const instanceStart;
4474/// uint32_t const instanceSize;
4475/// uint32_t const reserved; // only when building for 64bit targets
4476/// const uint8_t * const ivarLayout;
4477/// const char *const name;
4478/// const struct _method_list_t * const baseMethods;
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00004479/// const struct _protocol_list_t *const baseProtocols;
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004480/// const struct _ivar_list_t *const ivars;
4481/// const uint8_t * const weakIvarLayout;
4482/// const struct _prop_list_t * const properties;
4483/// }
4484///
4485llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004486 unsigned flags,
4487 unsigned InstanceStart,
4488 unsigned InstanceSize,
4489 const ObjCImplementationDecl *ID) {
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004490 std::string ClassName = ID->getNameAsString();
4491 std::vector<llvm::Constant*> Values(10); // 11 for 64bit targets!
Owen Andersonb7a2fe62009-07-24 23:12:58 +00004492 Values[ 0] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags);
4493 Values[ 1] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceStart);
4494 Values[ 2] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceSize);
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004495 // FIXME. For 64bit targets add 0 here.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004496 Values[ 3] = (flags & CLS_META) ? GetIvarLayoutName(0, ObjCTypes)
4497 : BuildIvarLayout(ID, true);
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004498 Values[ 4] = GetClassName(ID->getIdentifier());
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004499 // const struct _method_list_t * const baseMethods;
4500 std::vector<llvm::Constant*> Methods;
4501 std::string MethodListName("\01l_OBJC_$_");
4502 if (flags & CLS_META) {
4503 MethodListName += "CLASS_METHODS_" + ID->getNameAsString();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004504 for (ObjCImplementationDecl::classmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004505 i = ID->classmeth_begin(), e = ID->classmeth_end(); i != e; ++i) {
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004506 // Class methods should always be defined.
4507 Methods.push_back(GetMethodConstant(*i));
4508 }
4509 } else {
4510 MethodListName += "INSTANCE_METHODS_" + ID->getNameAsString();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004511 for (ObjCImplementationDecl::instmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004512 i = ID->instmeth_begin(), e = ID->instmeth_end(); i != e; ++i) {
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004513 // Instance methods should always be defined.
4514 Methods.push_back(GetMethodConstant(*i));
4515 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004516 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004517 i = ID->propimpl_begin(), e = ID->propimpl_end(); i != e; ++i) {
Fariborz Jahaniand27a8202009-01-28 22:46:49 +00004518 ObjCPropertyImplDecl *PID = *i;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004519
Fariborz Jahaniand27a8202009-01-28 22:46:49 +00004520 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
4521 ObjCPropertyDecl *PD = PID->getPropertyDecl();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004522
Fariborz Jahaniand27a8202009-01-28 22:46:49 +00004523 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
4524 if (llvm::Constant *C = GetMethodConstant(MD))
4525 Methods.push_back(C);
4526 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
4527 if (llvm::Constant *C = GetMethodConstant(MD))
4528 Methods.push_back(C);
4529 }
4530 }
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004531 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004532 Values[ 5] = EmitMethodList(MethodListName,
4533 "__DATA, __objc_const", Methods);
4534
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00004535 const ObjCInterfaceDecl *OID = ID->getClassInterface();
4536 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004537 Values[ 6] = EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00004538 + OID->getName(),
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00004539 OID->protocol_begin(),
4540 OID->protocol_end());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004541
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00004542 if (flags & CLS_META)
Owen Anderson0b75f232009-07-31 20:28:54 +00004543 Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00004544 else
4545 Values[ 7] = EmitIvarList(ID);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004546 Values[ 8] = (flags & CLS_META) ? GetIvarLayoutName(0, ObjCTypes)
4547 : BuildIvarLayout(ID, false);
Fariborz Jahanian066347e2009-01-28 22:18:42 +00004548 if (flags & CLS_META)
Owen Anderson0b75f232009-07-31 20:28:54 +00004549 Values[ 9] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
Fariborz Jahanian066347e2009-01-28 22:18:42 +00004550 else
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00004551 Values[ 9] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getName(),
4552 ID, ID->getClassInterface(), ObjCTypes);
Owen Anderson0e0189d2009-07-27 22:29:56 +00004553 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassRonfABITy,
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004554 Values);
4555 llvm::GlobalVariable *CLASS_RO_GV =
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004556 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassRonfABITy, false,
4557 llvm::GlobalValue::InternalLinkage,
4558 Init,
4559 (flags & CLS_META) ?
4560 std::string("\01l_OBJC_METACLASS_RO_$_")+ClassName :
4561 std::string("\01l_OBJC_CLASS_RO_$_")+ClassName);
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00004562 CLASS_RO_GV->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00004563 CGM.getTargetData().getABITypeAlignment(ObjCTypes.ClassRonfABITy));
Fariborz Jahanian40a4bcd2009-01-28 01:05:23 +00004564 CLASS_RO_GV->setSection("__DATA, __objc_const");
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004565 return CLASS_RO_GV;
Fariborz Jahanian2612e142009-01-26 22:58:07 +00004566
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004567}
4568
4569/// BuildClassMetaData - This routine defines that to-level meta-data
4570/// for the given ClassName for:
4571/// struct _class_t {
4572/// struct _class_t *isa;
4573/// struct _class_t * const superclass;
4574/// void *cache;
4575/// IMP *vtable;
4576/// struct class_ro_t *ro;
4577/// }
4578///
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004579llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassMetaData(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004580 std::string &ClassName,
4581 llvm::Constant *IsAGV,
4582 llvm::Constant *SuperClassGV,
4583 llvm::Constant *ClassRoGV,
4584 bool HiddenVisibility) {
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004585 std::vector<llvm::Constant*> Values(5);
4586 Values[0] = IsAGV;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004587 Values[1] = SuperClassGV;
4588 if (!Values[1])
4589 Values[1] = llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy);
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004590 Values[2] = ObjCEmptyCacheVar; // &ObjCEmptyCacheVar
4591 Values[3] = ObjCEmptyVtableVar; // &ObjCEmptyVtableVar
4592 Values[4] = ClassRoGV; // &CLASS_RO_GV
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004593 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy,
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004594 Values);
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00004595 llvm::GlobalVariable *GV = GetClassGlobal(ClassName);
4596 GV->setInitializer(Init);
Fariborz Jahanian04087232009-01-31 01:07:39 +00004597 GV->setSection("__DATA, __objc_data");
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00004598 GV->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00004599 CGM.getTargetData().getABITypeAlignment(ObjCTypes.ClassnfABITy));
Fariborz Jahanian82208252009-01-31 00:59:10 +00004600 if (HiddenVisibility)
4601 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004602 return GV;
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004603}
4604
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004605bool
Fariborz Jahaniana6bed832009-05-21 01:03:45 +00004606CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004607 return OD->getClassMethod(GetNullarySelector("load")) != 0;
Daniel Dunbar9a017d72009-05-15 22:33:15 +00004608}
4609
Daniel Dunbar961202372009-05-03 12:57:56 +00004610void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
Daniel Dunbar554fd792009-04-19 23:41:48 +00004611 uint32_t &InstanceStart,
4612 uint32_t &InstanceSize) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004613 const ASTRecordLayout &RL =
Daniel Dunbar9252ee12009-05-04 21:26:30 +00004614 CGM.getContext().getASTObjCImplementationLayout(OID);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004615
Daniel Dunbar9b042e02009-05-04 23:23:09 +00004616 // InstanceSize is really instance end.
Anders Carlsson27b50132009-07-18 21:26:44 +00004617 InstanceSize = llvm::RoundUpToAlignment(RL.getDataSize(), 8) / 8;
Daniel Dunbar9b042e02009-05-04 23:23:09 +00004618
4619 // If there are no fields, the start is the same as the end.
4620 if (!RL.getFieldCount())
4621 InstanceStart = InstanceSize;
4622 else
4623 InstanceStart = RL.getFieldOffset(0) / 8;
Daniel Dunbar554fd792009-04-19 23:41:48 +00004624}
4625
Fariborz Jahanian71394042009-01-23 23:53:38 +00004626void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
4627 std::string ClassName = ID->getNameAsString();
4628 if (!ObjCEmptyCacheVar) {
4629 ObjCEmptyCacheVar = new llvm::GlobalVariable(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004630 CGM.getModule(),
4631 ObjCTypes.CacheTy,
4632 false,
4633 llvm::GlobalValue::ExternalLinkage,
4634 0,
4635 "_objc_empty_cache");
4636
Fariborz Jahanian71394042009-01-23 23:53:38 +00004637 ObjCEmptyVtableVar = new llvm::GlobalVariable(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004638 CGM.getModule(),
4639 ObjCTypes.ImpnfABITy,
4640 false,
4641 llvm::GlobalValue::ExternalLinkage,
4642 0,
4643 "_objc_empty_vtable");
Fariborz Jahanian71394042009-01-23 23:53:38 +00004644 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004645 assert(ID->getClassInterface() &&
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004646 "CGObjCNonFragileABIMac::GenerateClass - class is 0");
Daniel Dunbare3f5cfc2009-04-20 20:18:54 +00004647 // FIXME: Is this correct (that meta class size is never computed)?
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004648 uint32_t InstanceStart =
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00004649 CGM.getTargetData().getTypeAllocSize(ObjCTypes.ClassnfABITy);
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004650 uint32_t InstanceSize = InstanceStart;
4651 uint32_t flags = CLS_META;
Daniel Dunbar15894b72009-04-07 05:48:37 +00004652 std::string ObjCMetaClassName(getMetaclassSymbolPrefix());
4653 std::string ObjCClassName(getClassSymbolPrefix());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004654
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004655 llvm::GlobalVariable *SuperClassGV, *IsAGV;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004656
4657 bool classIsHidden =
Daniel Dunbarf5f359f2009-04-14 06:00:08 +00004658 CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden;
Fariborz Jahanian82208252009-01-31 00:59:10 +00004659 if (classIsHidden)
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004660 flags |= OBJC2_CLS_HIDDEN;
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004661 if (ID->getNumIvarInitializers())
4662 flags |= eClassFlags_ABI2_HasCXXStructors;
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004663 if (!ID->getClassInterface()->getSuperClass()) {
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004664 // class is root
4665 flags |= CLS_ROOT;
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00004666 SuperClassGV = GetClassGlobal(ObjCClassName + ClassName);
Fariborz Jahanian899e7eb2009-04-14 18:41:56 +00004667 IsAGV = GetClassGlobal(ObjCMetaClassName + ClassName);
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004668 } else {
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004669 // Has a root. Current class is not a root.
Fariborz Jahanian03b300b2009-02-26 18:23:47 +00004670 const ObjCInterfaceDecl *Root = ID->getClassInterface();
4671 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
4672 Root = Super;
Fariborz Jahanian899e7eb2009-04-14 18:41:56 +00004673 IsAGV = GetClassGlobal(ObjCMetaClassName + Root->getNameAsString());
Fariborz Jahaniana6227fd2009-12-01 18:25:24 +00004674 if (Root->hasAttr<WeakImportAttr>())
4675 IsAGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Fariborz Jahanian03b300b2009-02-26 18:23:47 +00004676 // work on super class metadata symbol.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004677 std::string SuperClassName =
Fariborz Jahaniana6227fd2009-12-01 18:25:24 +00004678 ObjCMetaClassName +
4679 ID->getClassInterface()->getSuperClass()->getNameAsString();
Fariborz Jahanian899e7eb2009-04-14 18:41:56 +00004680 SuperClassGV = GetClassGlobal(SuperClassName);
Fariborz Jahanian67260552009-11-17 21:37:35 +00004681 if (ID->getClassInterface()->getSuperClass()->hasAttr<WeakImportAttr>())
4682 SuperClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Fariborz Jahanian9e3ad522009-01-24 20:21:50 +00004683 }
4684 llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags,
4685 InstanceStart,
4686 InstanceSize,ID);
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004687 std::string TClassName = ObjCMetaClassName + ClassName;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004688 llvm::GlobalVariable *MetaTClass =
Fariborz Jahanian82208252009-01-31 00:59:10 +00004689 BuildClassMetaData(TClassName, IsAGV, SuperClassGV, CLASS_RO_GV,
4690 classIsHidden);
Fariborz Jahanian67260552009-11-17 21:37:35 +00004691 DefinedMetaClasses.push_back(MetaTClass);
Daniel Dunbar15894b72009-04-07 05:48:37 +00004692
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004693 // Metadata for the class
4694 flags = CLS;
Fariborz Jahanian82208252009-01-31 00:59:10 +00004695 if (classIsHidden)
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004696 flags |= OBJC2_CLS_HIDDEN;
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00004697 if (ID->getNumIvarInitializers())
4698 flags |= eClassFlags_ABI2_HasCXXStructors;
Daniel Dunbar8f28d012009-04-08 04:21:03 +00004699
Douglas Gregor78bd61f2009-06-18 16:11:24 +00004700 if (hasObjCExceptionAttribute(CGM.getContext(), ID->getClassInterface()))
Daniel Dunbar8f28d012009-04-08 04:21:03 +00004701 flags |= CLS_EXCEPTION;
4702
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004703 if (!ID->getClassInterface()->getSuperClass()) {
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004704 flags |= CLS_ROOT;
4705 SuperClassGV = 0;
Chris Lattnerb433b272009-04-19 06:02:28 +00004706 } else {
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004707 // Has a root. Current class is not a root.
Fariborz Jahanian03b300b2009-02-26 18:23:47 +00004708 std::string RootClassName =
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004709 ID->getClassInterface()->getSuperClass()->getNameAsString();
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00004710 SuperClassGV = GetClassGlobal(ObjCClassName + RootClassName);
Fariborz Jahanian67260552009-11-17 21:37:35 +00004711 if (ID->getClassInterface()->getSuperClass()->hasAttr<WeakImportAttr>())
4712 SuperClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004713 }
Daniel Dunbar961202372009-05-03 12:57:56 +00004714 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004715 CLASS_RO_GV = BuildClassRoTInitializer(flags,
Fariborz Jahaniana887e632009-01-24 23:43:01 +00004716 InstanceStart,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004717 InstanceSize,
Fariborz Jahaniana887e632009-01-24 23:43:01 +00004718 ID);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004719
Fariborz Jahanian4723fb72009-01-24 21:21:53 +00004720 TClassName = ObjCClassName + ClassName;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004721 llvm::GlobalVariable *ClassMD =
Fariborz Jahanian82208252009-01-31 00:59:10 +00004722 BuildClassMetaData(TClassName, MetaTClass, SuperClassGV, CLASS_RO_GV,
4723 classIsHidden);
Fariborz Jahanian279abd32009-01-30 20:55:31 +00004724 DefinedClasses.push_back(ClassMD);
Daniel Dunbar8f28d012009-04-08 04:21:03 +00004725
Daniel Dunbar9a017d72009-05-15 22:33:15 +00004726 // Determine if this class is also "non-lazy".
4727 if (ImplementationIsNonLazy(ID))
4728 DefinedNonLazyClasses.push_back(ClassMD);
4729
Daniel Dunbar8f28d012009-04-08 04:21:03 +00004730 // Force the definition of the EHType if necessary.
4731 if (flags & CLS_EXCEPTION)
4732 GetInterfaceEHType(ID->getClassInterface(), true);
Fariborz Jahanian71394042009-01-23 23:53:38 +00004733}
4734
Fariborz Jahanian097feda2009-01-30 18:58:59 +00004735/// GenerateProtocolRef - This routine is called to generate code for
4736/// a protocol reference expression; as in:
4737/// @code
4738/// @protocol(Proto1);
4739/// @endcode
4740/// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
4741/// which will hold address of the protocol meta-data.
4742///
4743llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CGBuilderTy &Builder,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004744 const ObjCProtocolDecl *PD) {
4745
Fariborz Jahanian464423d2009-04-10 18:47:34 +00004746 // This routine is called for @protocol only. So, we must build definition
4747 // of protocol's meta-data (not a reference to it!)
4748 //
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004749 llvm::Constant *Init =
4750 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
4751 ObjCTypes.ExternalProtocolPtrTy);
4752
Fariborz Jahanian097feda2009-01-30 18:58:59 +00004753 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
4754 ProtocolName += PD->getNameAsCString();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004755
Fariborz Jahanian097feda2009-01-30 18:58:59 +00004756 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
4757 if (PTGV)
Daniel Dunbarc76493a2009-11-29 21:23:36 +00004758 return Builder.CreateLoad(PTGV, "tmp");
Fariborz Jahanian097feda2009-01-30 18:58:59 +00004759 PTGV = new llvm::GlobalVariable(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004760 CGM.getModule(),
4761 Init->getType(), false,
4762 llvm::GlobalValue::WeakAnyLinkage,
4763 Init,
4764 ProtocolName);
Fariborz Jahanian097feda2009-01-30 18:58:59 +00004765 PTGV->setSection("__DATA, __objc_protorefs, coalesced, no_dead_strip");
4766 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Chris Lattnerf56501c2009-07-17 23:57:13 +00004767 CGM.AddUsedGlobal(PTGV);
Daniel Dunbarc76493a2009-11-29 21:23:36 +00004768 return Builder.CreateLoad(PTGV, "tmp");
Fariborz Jahanian097feda2009-01-30 18:58:59 +00004769}
4770
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00004771/// GenerateCategory - Build metadata for a category implementation.
4772/// struct _category_t {
4773/// const char * const name;
4774/// struct _class_t *const cls;
4775/// const struct _method_list_t * const instance_methods;
4776/// const struct _method_list_t * const class_methods;
4777/// const struct _protocol_list_t * const protocols;
4778/// const struct _prop_list_t * const properties;
4779/// }
4780///
Daniel Dunbar9a017d72009-05-15 22:33:15 +00004781void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00004782 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
Fariborz Jahanian2612e142009-01-26 22:58:07 +00004783 const char *Prefix = "\01l_OBJC_$_CATEGORY_";
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004784 std::string ExtCatName(Prefix + Interface->getNameAsString()+
4785 "_$_" + OCD->getNameAsString());
4786 std::string ExtClassName(getClassSymbolPrefix() +
Daniel Dunbar15894b72009-04-07 05:48:37 +00004787 Interface->getNameAsString());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004788
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00004789 std::vector<llvm::Constant*> Values(6);
4790 Values[0] = GetClassName(OCD->getIdentifier());
4791 // meta-class entry symbol
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00004792 llvm::GlobalVariable *ClassGV = GetClassGlobal(ExtClassName);
Fariborz Jahanian3ad8dcf2009-11-17 22:02:21 +00004793 if (Interface->hasAttr<WeakImportAttr>())
4794 ClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
4795
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00004796 Values[1] = ClassGV;
Fariborz Jahanian2612e142009-01-26 22:58:07 +00004797 std::vector<llvm::Constant*> Methods;
4798 std::string MethodListName(Prefix);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004799 MethodListName += "INSTANCE_METHODS_" + Interface->getNameAsString() +
Fariborz Jahanian2612e142009-01-26 22:58:07 +00004800 "_$_" + OCD->getNameAsString();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004801
4802 for (ObjCCategoryImplDecl::instmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004803 i = OCD->instmeth_begin(), e = OCD->instmeth_end(); i != e; ++i) {
Fariborz Jahanian2612e142009-01-26 22:58:07 +00004804 // Instance methods should always be defined.
4805 Methods.push_back(GetMethodConstant(*i));
4806 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004807
4808 Values[2] = EmitMethodList(MethodListName,
4809 "__DATA, __objc_const",
Fariborz Jahanian2612e142009-01-26 22:58:07 +00004810 Methods);
4811
4812 MethodListName = Prefix;
4813 MethodListName += "CLASS_METHODS_" + Interface->getNameAsString() + "_$_" +
4814 OCD->getNameAsString();
4815 Methods.clear();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004816 for (ObjCCategoryImplDecl::classmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004817 i = OCD->classmeth_begin(), e = OCD->classmeth_end(); i != e; ++i) {
Fariborz Jahanian2612e142009-01-26 22:58:07 +00004818 // Class methods should always be defined.
4819 Methods.push_back(GetMethodConstant(*i));
4820 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004821
4822 Values[3] = EmitMethodList(MethodListName,
4823 "__DATA, __objc_const",
Fariborz Jahanian2612e142009-01-26 22:58:07 +00004824 Methods);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004825 const ObjCCategoryDecl *Category =
Fariborz Jahanian066347e2009-01-28 22:18:42 +00004826 Interface->FindCategoryDeclaration(OCD->getIdentifier());
Fariborz Jahaniand8fc1052009-02-13 17:52:22 +00004827 if (Category) {
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00004828 llvm::SmallString<256> ExtName;
4829 llvm::raw_svector_ostream(ExtName) << Interface->getName() << "_$_"
4830 << OCD->getName();
Fariborz Jahaniand8fc1052009-02-13 17:52:22 +00004831 Values[4] = EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00004832 + Interface->getName() + "_$_"
4833 + Category->getName(),
Fariborz Jahaniand8fc1052009-02-13 17:52:22 +00004834 Category->protocol_begin(),
4835 Category->protocol_end());
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00004836 Values[5] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
4837 OCD, Category, ObjCTypes);
Mike Stump658fe022009-07-30 22:28:39 +00004838 } else {
Owen Anderson0b75f232009-07-31 20:28:54 +00004839 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
4840 Values[5] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
Fariborz Jahaniand8fc1052009-02-13 17:52:22 +00004841 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004842
4843 llvm::Constant *Init =
4844 llvm::ConstantStruct::get(ObjCTypes.CategorynfABITy,
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00004845 Values);
4846 llvm::GlobalVariable *GCATV
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004847 = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CategorynfABITy,
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00004848 false,
4849 llvm::GlobalValue::InternalLinkage,
4850 Init,
Owen Andersonc10c8d32009-07-08 19:05:04 +00004851 ExtCatName);
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00004852 GCATV->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00004853 CGM.getTargetData().getABITypeAlignment(ObjCTypes.CategorynfABITy));
Fariborz Jahanian40a4bcd2009-01-28 01:05:23 +00004854 GCATV->setSection("__DATA, __objc_const");
Chris Lattnerf56501c2009-07-17 23:57:13 +00004855 CGM.AddUsedGlobal(GCATV);
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00004856 DefinedCategories.push_back(GCATV);
Daniel Dunbar9a017d72009-05-15 22:33:15 +00004857
4858 // Determine if this category is also "non-lazy".
4859 if (ImplementationIsNonLazy(OCD))
4860 DefinedNonLazyCategories.push_back(GCATV);
Fariborz Jahanian0c8d0602009-01-26 18:32:24 +00004861}
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004862
4863/// GetMethodConstant - Return a struct objc_method constant for the
4864/// given method if it has been defined. The result is null if the
4865/// method has not been defined. The return value has type MethodPtrTy.
4866llvm::Constant *CGObjCNonFragileABIMac::GetMethodConstant(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004867 const ObjCMethodDecl *MD) {
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004868 // FIXME: Use DenseMap::lookup
4869 llvm::Function *Fn = MethodDefinitions[MD];
4870 if (!Fn)
4871 return 0;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004872
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004873 std::vector<llvm::Constant*> Method(3);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004874 Method[0] =
Owen Andersonade90fd2009-07-29 18:54:39 +00004875 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004876 ObjCTypes.SelectorPtrTy);
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004877 Method[1] = GetMethodVarType(MD);
Owen Andersonade90fd2009-07-29 18:54:39 +00004878 Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy);
Owen Anderson0e0189d2009-07-27 22:29:56 +00004879 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004880}
4881
4882/// EmitMethodList - Build meta-data for method declarations
4883/// struct _method_list_t {
4884/// uint32_t entsize; // sizeof(struct _objc_method)
4885/// uint32_t method_count;
4886/// struct _objc_method method_list[method_count];
4887/// }
4888///
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00004889llvm::Constant *CGObjCNonFragileABIMac::EmitMethodList(llvm::Twine Name,
4890 const char *Section,
4891 const ConstantVector &Methods) {
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004892 // Return null for empty list.
4893 if (Methods.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00004894 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004895
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004896 std::vector<llvm::Constant*> Values(3);
4897 // sizeof(struct _objc_method)
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00004898 unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.MethodTy);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00004899 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004900 // method_count
Owen Andersonb7a2fe62009-07-24 23:12:58 +00004901 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
Owen Anderson9793f0e2009-07-29 22:16:19 +00004902 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004903 Methods.size());
Owen Anderson47034e12009-07-28 18:33:04 +00004904 Values[2] = llvm::ConstantArray::get(AT, Methods);
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00004905 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004906
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004907 llvm::GlobalVariable *GV =
Owen Andersonc10c8d32009-07-08 19:05:04 +00004908 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004909 llvm::GlobalValue::InternalLinkage,
4910 Init,
Owen Andersonc10c8d32009-07-08 19:05:04 +00004911 Name);
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00004912 GV->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00004913 CGM.getTargetData().getABITypeAlignment(Init->getType()));
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004914 GV->setSection(Section);
Chris Lattnerf56501c2009-07-17 23:57:13 +00004915 CGM.AddUsedGlobal(GV);
Owen Andersonade90fd2009-07-29 18:54:39 +00004916 return llvm::ConstantExpr::getBitCast(GV,
Fariborz Jahanian99113fd2009-01-26 21:38:32 +00004917 ObjCTypes.MethodListnfABIPtrTy);
4918}
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00004919
Fariborz Jahanian4e7ae062009-02-10 20:21:06 +00004920/// ObjCIvarOffsetVariable - Returns the ivar offset variable for
4921/// the given ivar.
Daniel Dunbar8c7f9812010-04-02 21:14:02 +00004922llvm::GlobalVariable *
4923CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
4924 const ObjCIvarDecl *Ivar) {
4925 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
Daniel Dunbar3f86b9c2009-05-05 00:36:57 +00004926 std::string Name = "OBJC_IVAR_$_" + Container->getNameAsString() +
Douglas Gregorbcced4e2009-04-09 21:40:53 +00004927 '.' + Ivar->getNameAsString();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004928 llvm::GlobalVariable *IvarOffsetGV =
Fariborz Jahanian4e7ae062009-02-10 20:21:06 +00004929 CGM.getModule().getGlobalVariable(Name);
4930 if (!IvarOffsetGV)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004931 IvarOffsetGV =
Owen Andersonc10c8d32009-07-08 19:05:04 +00004932 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.LongTy,
Fariborz Jahanian4e7ae062009-02-10 20:21:06 +00004933 false,
4934 llvm::GlobalValue::ExternalLinkage,
4935 0,
Owen Andersonc10c8d32009-07-08 19:05:04 +00004936 Name);
Fariborz Jahanian4e7ae062009-02-10 20:21:06 +00004937 return IvarOffsetGV;
4938}
4939
Daniel Dunbar8c7f9812010-04-02 21:14:02 +00004940llvm::Constant *
4941CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
4942 const ObjCIvarDecl *Ivar,
4943 unsigned long int Offset) {
Daniel Dunbarbf90b332009-04-19 00:44:02 +00004944 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004945 IvarOffsetGV->setInitializer(llvm::ConstantInt::get(ObjCTypes.LongTy,
Daniel Dunbarbf90b332009-04-19 00:44:02 +00004946 Offset));
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00004947 IvarOffsetGV->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00004948 CGM.getTargetData().getABITypeAlignment(ObjCTypes.LongTy));
Daniel Dunbarbf90b332009-04-19 00:44:02 +00004949
Mike Stump18bb9282009-05-16 07:57:57 +00004950 // FIXME: This matches gcc, but shouldn't the visibility be set on the use as
4951 // well (i.e., in ObjCIvarOffsetVariable).
Daniel Dunbarbf90b332009-04-19 00:44:02 +00004952 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
4953 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
4954 CGM.getDeclVisibilityMode(ID) == LangOptions::Hidden)
Fariborz Jahanian3d3426f2009-01-28 01:36:42 +00004955 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Daniel Dunbarf5f359f2009-04-14 06:00:08 +00004956 else
Fariborz Jahanianbc3c77b2009-04-06 18:30:00 +00004957 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Fariborz Jahanian40a4bcd2009-01-28 01:05:23 +00004958 IvarOffsetGV->setSection("__DATA, __objc_const");
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00004959 return IvarOffsetGV;
Fariborz Jahanian40a4bcd2009-01-28 01:05:23 +00004960}
4961
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00004962/// EmitIvarList - Emit the ivar list for the given
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00004963/// implementation. The return value has type
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00004964/// IvarListnfABIPtrTy.
4965/// struct _ivar_t {
4966/// unsigned long int *offset; // pointer to ivar offset location
4967/// char *name;
4968/// char *type;
4969/// uint32_t alignment;
4970/// uint32_t size;
4971/// }
4972/// struct _ivar_list_t {
4973/// uint32 entsize; // sizeof(struct _ivar_t)
4974/// uint32 count;
4975/// struct _iver_t list[count];
4976/// }
4977///
Daniel Dunbarf5c18462009-04-20 06:54:31 +00004978
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00004979llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004980 const ObjCImplementationDecl *ID) {
4981
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00004982 std::vector<llvm::Constant*> Ivars, Ivar(5);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004983
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00004984 const ObjCInterfaceDecl *OID = ID->getClassInterface();
4985 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004986
Fariborz Jahanian40a4bcd2009-01-28 01:05:23 +00004987 // FIXME. Consolidate this with similar code in GenerateClass.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004988
Daniel Dunbarae032262009-04-20 00:33:43 +00004989 // Collect declared and synthesized ivars in a small vector.
Fariborz Jahanian63a224a2009-03-31 18:11:23 +00004990 llvm::SmallVector<ObjCIvarDecl*, 16> OIvars;
Fariborz Jahanian7c809592009-06-04 01:19:09 +00004991 CGM.getContext().ShallowCollectObjCIvars(OID, OIvars);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004992
Daniel Dunbarf5c18462009-04-20 06:54:31 +00004993 for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
4994 ObjCIvarDecl *IVD = OIvars[i];
Fariborz Jahanian7c809592009-06-04 01:19:09 +00004995 // Ignore unnamed bit-fields.
4996 if (!IVD->getDeclName())
4997 continue;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00004998 Ivar[0] = EmitIvarOffsetVar(ID->getClassInterface(), IVD,
Daniel Dunbar961202372009-05-03 12:57:56 +00004999 ComputeIvarBaseOffset(CGM, ID, IVD));
Daniel Dunbar725dc2c2009-04-22 08:22:17 +00005000 Ivar[1] = GetMethodVarName(IVD->getIdentifier());
5001 Ivar[2] = GetMethodVarType(IVD);
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00005002 const llvm::Type *FieldTy =
Daniel Dunbar725dc2c2009-04-22 08:22:17 +00005003 CGM.getTypes().ConvertTypeForMem(IVD->getType());
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00005004 unsigned Size = CGM.getTargetData().getTypeAllocSize(FieldTy);
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00005005 unsigned Align = CGM.getContext().getPreferredTypeAlign(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005006 IVD->getType().getTypePtr()) >> 3;
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00005007 Align = llvm::Log2_32(Align);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00005008 Ivar[3] = llvm::ConstantInt::get(ObjCTypes.IntTy, Align);
Daniel Dunbarae032262009-04-20 00:33:43 +00005009 // NOTE. Size of a bitfield does not match gcc's, because of the
5010 // way bitfields are treated special in each. But I am told that
5011 // 'size' for bitfield ivars is ignored by the runtime so it does
5012 // not matter. If it matters, there is enough info to get the
5013 // bitfield right!
Owen Andersonb7a2fe62009-07-24 23:12:58 +00005014 Ivar[4] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Owen Anderson0e0189d2009-07-27 22:29:56 +00005015 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarnfABITy, Ivar));
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00005016 }
5017 // Return null for empty list.
5018 if (Ivars.empty())
Owen Anderson0b75f232009-07-31 20:28:54 +00005019 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00005020 std::vector<llvm::Constant*> Values(3);
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00005021 unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.IvarnfABITy);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00005022 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
5023 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
Owen Anderson9793f0e2009-07-29 22:16:19 +00005024 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarnfABITy,
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00005025 Ivars.size());
Owen Anderson47034e12009-07-28 18:33:04 +00005026 Values[2] = llvm::ConstantArray::get(AT, Ivars);
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00005027 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00005028 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
5029 llvm::GlobalVariable *GV =
Owen Andersonc10c8d32009-07-08 19:05:04 +00005030 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Fariborz Jahanian7415caa2009-01-27 19:38:51 +00005031 llvm::GlobalValue::InternalLinkage,
5032 Init,
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005033 Prefix + OID->getName());
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00005034 GV->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00005035 CGM.getTargetData().getABITypeAlignment(Init->getType()));
Fariborz Jahanian40a4bcd2009-01-28 01:05:23 +00005036 GV->setSection("__DATA, __objc_const");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005037
Chris Lattnerf56501c2009-07-17 23:57:13 +00005038 CGM.AddUsedGlobal(GV);
Owen Andersonade90fd2009-07-29 18:54:39 +00005039 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005040}
5041
5042llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005043 const ObjCProtocolDecl *PD) {
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005044 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005045
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005046 if (!Entry) {
5047 // We use the initializer as a marker of whether this is a forward
5048 // reference or not. At module finalization we add the empty
5049 // contents for protocols which were referenced but never defined.
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005050 Entry =
5051 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy, false,
5052 llvm::GlobalValue::ExternalLinkage,
5053 0,
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005054 "\01l_OBJC_PROTOCOL_$_" + PD->getName());
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005055 Entry->setSection("__DATA,__datacoal_nt,coalesced");
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005056 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005057
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005058 return Entry;
5059}
5060
5061/// GetOrEmitProtocol - Generate the protocol meta-data:
5062/// @code
5063/// struct _protocol_t {
5064/// id isa; // NULL
5065/// const char * const protocol_name;
5066/// const struct _protocol_list_t * protocol_list; // super protocols
5067/// const struct method_list_t * const instance_methods;
5068/// const struct method_list_t * const class_methods;
5069/// const struct method_list_t *optionalInstanceMethods;
5070/// const struct method_list_t *optionalClassMethods;
5071/// const struct _prop_list_t * properties;
5072/// const uint32_t size; // sizeof(struct _protocol_t)
5073/// const uint32_t flags; // = 0
5074/// }
5075/// @endcode
5076///
5077
5078llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005079 const ObjCProtocolDecl *PD) {
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005080 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005081
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005082 // Early exit if a defining object has already been generated.
5083 if (Entry && Entry->hasInitializer())
5084 return Entry;
5085
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005086 // Construct method lists.
5087 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
5088 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005089 for (ObjCProtocolDecl::instmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00005090 i = PD->instmeth_begin(), e = PD->instmeth_end(); i != e; ++i) {
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005091 ObjCMethodDecl *MD = *i;
Fariborz Jahaniand9c28b82009-01-30 00:46:37 +00005092 llvm::Constant *C = GetMethodDescriptionConstant(MD);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005093 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
5094 OptInstanceMethods.push_back(C);
5095 } else {
5096 InstanceMethods.push_back(C);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005097 }
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005098 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005099
5100 for (ObjCProtocolDecl::classmeth_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00005101 i = PD->classmeth_begin(), e = PD->classmeth_end(); i != e; ++i) {
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005102 ObjCMethodDecl *MD = *i;
Fariborz Jahaniand9c28b82009-01-30 00:46:37 +00005103 llvm::Constant *C = GetMethodDescriptionConstant(MD);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005104 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
5105 OptClassMethods.push_back(C);
5106 } else {
5107 ClassMethods.push_back(C);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005108 }
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005109 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005110
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005111 std::vector<llvm::Constant*> Values(10);
5112 // isa is NULL
Owen Anderson0b75f232009-07-31 20:28:54 +00005113 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005114 Values[1] = GetClassName(PD->getIdentifier());
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005115 Values[2] = EmitProtocolList("\01l_OBJC_$_PROTOCOL_REFS_" + PD->getName(),
5116 PD->protocol_begin(),
5117 PD->protocol_end());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005118
Fariborz Jahaniand9c28b82009-01-30 00:46:37 +00005119 Values[3] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_"
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005120 + PD->getName(),
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005121 "__DATA, __objc_const",
5122 InstanceMethods);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005123 Values[4] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_"
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005124 + PD->getName(),
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005125 "__DATA, __objc_const",
5126 ClassMethods);
Fariborz Jahaniand9c28b82009-01-30 00:46:37 +00005127 Values[5] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_"
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005128 + PD->getName(),
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005129 "__DATA, __objc_const",
5130 OptInstanceMethods);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005131 Values[6] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_"
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005132 + PD->getName(),
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005133 "__DATA, __objc_const",
5134 OptClassMethods);
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005135 Values[7] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + PD->getName(),
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005136 0, PD, ObjCTypes);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005137 uint32_t Size =
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00005138 CGM.getTargetData().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
Owen Andersonb7a2fe62009-07-24 23:12:58 +00005139 Values[8] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Owen Anderson0b75f232009-07-31 20:28:54 +00005140 Values[9] = llvm::Constant::getNullValue(ObjCTypes.IntTy);
Owen Anderson0e0189d2009-07-27 22:29:56 +00005141 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolnfABITy,
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005142 Values);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005143
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005144 if (Entry) {
5145 // Already created, fix the linkage and update the initializer.
Mike Stumpa6ca3342009-03-07 16:33:28 +00005146 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005147 Entry->setInitializer(Init);
5148 } else {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005149 Entry =
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005150 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
5151 false, llvm::GlobalValue::WeakAnyLinkage, Init,
5152 "\01l_OBJC_PROTOCOL_$_" + PD->getName());
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00005153 Entry->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00005154 CGM.getTargetData().getABITypeAlignment(ObjCTypes.ProtocolnfABITy));
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005155 Entry->setSection("__DATA,__datacoal_nt,coalesced");
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005156 }
Fariborz Jahanian61cd4b52009-01-29 20:10:59 +00005157 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
Chris Lattnerf56501c2009-07-17 23:57:13 +00005158 CGM.AddUsedGlobal(Entry);
5159
Fariborz Jahanian61cd4b52009-01-29 20:10:59 +00005160 // Use this protocol meta-data to build protocol list table in section
5161 // __DATA, __objc_protolist
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005162 llvm::GlobalVariable *PTGV =
5163 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
5164 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
5165 "\01l_OBJC_LABEL_PROTOCOL_$_" + PD->getName());
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00005166 PTGV->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00005167 CGM.getTargetData().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
Daniel Dunbarb25452a2009-04-15 02:56:18 +00005168 PTGV->setSection("__DATA, __objc_protolist, coalesced, no_dead_strip");
Fariborz Jahanian61cd4b52009-01-29 20:10:59 +00005169 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Chris Lattnerf56501c2009-07-17 23:57:13 +00005170 CGM.AddUsedGlobal(PTGV);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005171 return Entry;
5172}
5173
5174/// EmitProtocolList - Generate protocol list meta-data:
5175/// @code
5176/// struct _protocol_list_t {
5177/// long protocol_count; // Note, this is 32/64 bit
5178/// struct _protocol_t[protocol_count];
5179/// }
5180/// @endcode
5181///
5182llvm::Constant *
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005183CGObjCNonFragileABIMac::EmitProtocolList(llvm::Twine Name,
5184 ObjCProtocolDecl::protocol_iterator begin,
5185 ObjCProtocolDecl::protocol_iterator end) {
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005186 std::vector<llvm::Constant*> ProtocolRefs;
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005187
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005188 // Just return null for empty protocol lists
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005189 if (begin == end)
Owen Anderson0b75f232009-07-31 20:28:54 +00005190 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005191
Daniel Dunbar8de90f02009-02-15 07:36:20 +00005192 // FIXME: We shouldn't need to do this lookup here, should we?
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005193 llvm::SmallString<256> TmpName;
5194 Name.toVector(TmpName);
5195 llvm::GlobalVariable *GV =
5196 CGM.getModule().getGlobalVariable(TmpName.str(), true);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005197 if (GV)
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005198 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005199
Daniel Dunbar8de90f02009-02-15 07:36:20 +00005200 for (; begin != end; ++begin)
5201 ProtocolRefs.push_back(GetProtocolRef(*begin)); // Implemented???
5202
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005203 // This list is null terminated.
Owen Anderson0b75f232009-07-31 20:28:54 +00005204 ProtocolRefs.push_back(llvm::Constant::getNullValue(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005205 ObjCTypes.ProtocolnfABIPtrTy));
5206
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005207 std::vector<llvm::Constant*> Values(2);
Owen Anderson170229f2009-07-14 23:10:40 +00005208 Values[0] =
Owen Andersonb7a2fe62009-07-24 23:12:58 +00005209 llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005210 Values[1] =
Owen Anderson47034e12009-07-28 18:33:04 +00005211 llvm::ConstantArray::get(
Owen Anderson9793f0e2009-07-29 22:16:19 +00005212 llvm::ArrayType::get(ObjCTypes.ProtocolnfABIPtrTy,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005213 ProtocolRefs.size()),
5214 ProtocolRefs);
5215
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00005216 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Owen Andersonc10c8d32009-07-08 19:05:04 +00005217 GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005218 llvm::GlobalValue::InternalLinkage,
5219 Init,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005220 Name);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005221 GV->setSection("__DATA, __objc_const");
Fariborz Jahanianc22f2362009-01-31 02:43:27 +00005222 GV->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00005223 CGM.getTargetData().getABITypeAlignment(Init->getType()));
Chris Lattnerf56501c2009-07-17 23:57:13 +00005224 CGM.AddUsedGlobal(GV);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005225 return llvm::ConstantExpr::getBitCast(GV,
Daniel Dunbar8de90f02009-02-15 07:36:20 +00005226 ObjCTypes.ProtocolListnfABIPtrTy);
Fariborz Jahanian56b3b772009-01-29 19:24:30 +00005227}
5228
Fariborz Jahaniand9c28b82009-01-30 00:46:37 +00005229/// GetMethodDescriptionConstant - This routine build following meta-data:
5230/// struct _objc_method {
5231/// SEL _cmd;
5232/// char *method_type;
5233/// char *_imp;
5234/// }
5235
5236llvm::Constant *
5237CGObjCNonFragileABIMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
5238 std::vector<llvm::Constant*> Desc(3);
Owen Anderson170229f2009-07-14 23:10:40 +00005239 Desc[0] =
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005240 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
5241 ObjCTypes.SelectorPtrTy);
Fariborz Jahaniand9c28b82009-01-30 00:46:37 +00005242 Desc[1] = GetMethodVarType(MD);
Fariborz Jahanian097feda2009-01-30 18:58:59 +00005243 // Protocol methods have no implementation. So, this entry is always NULL.
Owen Anderson0b75f232009-07-31 20:28:54 +00005244 Desc[2] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
Owen Anderson0e0189d2009-07-27 22:29:56 +00005245 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Desc);
Fariborz Jahaniand9c28b82009-01-30 00:46:37 +00005246}
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00005247
5248/// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
5249/// This code gen. amounts to generating code for:
5250/// @code
5251/// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
5252/// @encode
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005253///
Fariborz Jahanian712bfa62009-02-03 19:03:09 +00005254LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
John McCall96fa4842010-05-17 21:00:27 +00005255 CodeGen::CodeGenFunction &CGF,
5256 QualType ObjectTy,
5257 llvm::Value *BaseValue,
5258 const ObjCIvarDecl *Ivar,
5259 unsigned CVRQualifiers) {
5260 ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
Daniel Dunbar9fd114d2009-04-22 07:32:20 +00005261 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
5262 EmitIvarOffset(CGF, ID, Ivar));
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00005263}
5264
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00005265llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005266 CodeGen::CodeGenFunction &CGF,
5267 const ObjCInterfaceDecl *Interface,
5268 const ObjCIvarDecl *Ivar) {
Daniel Dunbarc76493a2009-11-29 21:23:36 +00005269 return CGF.Builder.CreateLoad(ObjCIvarOffsetVariable(Interface, Ivar),"ivar");
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00005270}
5271
Fariborz Jahanian3d9296e2009-02-04 00:22:57 +00005272CodeGen::RValue CGObjCNonFragileABIMac::EmitMessageSend(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005273 CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00005274 ReturnValueSlot Return,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005275 QualType ResultType,
5276 Selector Sel,
5277 llvm::Value *Receiver,
5278 QualType Arg0Ty,
5279 bool IsSuper,
5280 const CallArgList &CallArgs) {
Mike Stump18bb9282009-05-16 07:57:57 +00005281 // FIXME. Even though IsSuper is passes. This function doese not handle calls
5282 // to 'super' receivers.
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005283 CodeGenTypes &Types = CGM.getTypes();
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005284 llvm::Value *Arg0 = Receiver;
5285 if (!IsSuper)
5286 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy, "tmp");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005287
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005288 // Find the message function name.
Mike Stump18bb9282009-05-16 07:57:57 +00005289 // FIXME. This is too much work to get the ABI-specific result type needed to
5290 // find the message name.
John McCall2da83a32010-02-26 00:48:12 +00005291 const CGFunctionInfo &FnInfo
Rafael Espindolac50c27c2010-03-30 20:24:48 +00005292 = Types.getFunctionInfo(ResultType, CallArgList(),
5293 FunctionType::ExtInfo());
Fariborz Jahaniane29b4f02009-04-30 23:08:58 +00005294 llvm::Constant *Fn = 0;
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005295 std::string Name("\01l_");
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00005296 if (CGM.ReturnTypeUsesSRet(FnInfo)) {
Fariborz Jahanian90655412009-02-05 18:00:27 +00005297#if 0
5298 // unlike what is documented. gcc never generates this API!!
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005299 if (Receiver->getType() == ObjCTypes.ObjectPtrTy) {
Chris Lattner2dfdb3e2009-04-22 02:53:24 +00005300 Fn = ObjCTypes.getMessageSendIdStretFixupFn();
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005301 // FIXME. Is there a better way of getting these names.
5302 // They are available in RuntimeFunctions vector pair.
5303 Name += "objc_msgSendId_stret_fixup";
Mike Stump658fe022009-07-30 22:28:39 +00005304 } else
Fariborz Jahanian90655412009-02-05 18:00:27 +00005305#endif
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005306 if (IsSuper) {
Chris Lattner2dfdb3e2009-04-22 02:53:24 +00005307 Fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005308 Name += "objc_msgSendSuper2_stret_fixup";
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005309 } else {
5310 Fn = ObjCTypes.getMessageSendStretFixupFn();
5311 Name += "objc_msgSend_stret_fixup";
5312 }
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00005313 } else if (!IsSuper && CGM.ReturnTypeUsesFPRet(ResultType)) {
5314 Fn = ObjCTypes.getMessageSendFpretFixupFn();
5315 Name += "objc_msgSend_fpret_fixup";
Mike Stump658fe022009-07-30 22:28:39 +00005316 } else {
Fariborz Jahanian90655412009-02-05 18:00:27 +00005317#if 0
5318// unlike what is documented. gcc never generates this API!!
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005319 if (Receiver->getType() == ObjCTypes.ObjectPtrTy) {
Chris Lattner2dfdb3e2009-04-22 02:53:24 +00005320 Fn = ObjCTypes.getMessageSendIdFixupFn();
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005321 Name += "objc_msgSendId_fixup";
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005322 } else
Fariborz Jahanian90655412009-02-05 18:00:27 +00005323#endif
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005324 if (IsSuper) {
Chris Lattner2dfdb3e2009-04-22 02:53:24 +00005325 Fn = ObjCTypes.getMessageSendSuper2FixupFn();
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005326 Name += "objc_msgSendSuper2_fixup";
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005327 } else {
5328 Fn = ObjCTypes.getMessageSendFixupFn();
5329 Name += "objc_msgSend_fixup";
5330 }
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005331 }
Fariborz Jahaniane29b4f02009-04-30 23:08:58 +00005332 assert(Fn && "CGObjCNonFragileABIMac::EmitMessageSend");
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005333 Name += '_';
5334 std::string SelName(Sel.getAsString());
5335 // Replace all ':' in selector name with '_' ouch!
Mike Stump11289f42009-09-09 15:08:12 +00005336 for (unsigned i = 0; i < SelName.size(); i++)
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005337 if (SelName[i] == ':')
5338 SelName[i] = '_';
5339 Name += SelName;
5340 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
5341 if (!GV) {
Daniel Dunbare60aa052009-04-15 19:03:14 +00005342 // Build message ref table entry.
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005343 std::vector<llvm::Constant*> Values(2);
5344 Values[0] = Fn;
5345 Values[1] = GetMethodVarName(Sel);
Nick Lewycky41eaf0a2009-09-19 20:00:52 +00005346 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Owen Andersonc10c8d32009-07-08 19:05:04 +00005347 GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Mike Stumpa6ca3342009-03-07 16:33:28 +00005348 llvm::GlobalValue::WeakAnyLinkage,
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005349 Init,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005350 Name);
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005351 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Daniel Dunbar24645c92009-04-15 19:04:46 +00005352 GV->setAlignment(16);
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005353 GV->setSection("__DATA, __objc_msgrefs, coalesced");
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005354 }
5355 llvm::Value *Arg1 = CGF.Builder.CreateBitCast(GV, ObjCTypes.MessageRefPtrTy);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005356
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005357 CallArgList ActualArgs;
5358 ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005359 ActualArgs.push_back(std::make_pair(RValue::get(Arg1),
Fariborz Jahaniane4dc35d2009-02-04 20:42:28 +00005360 ObjCTypes.MessageRefCPtrTy));
5361 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
John McCallab26cfa2010-02-05 21:31:56 +00005362 const CGFunctionInfo &FnInfo1 = Types.getFunctionInfo(ResultType, ActualArgs,
Rafael Espindolac50c27c2010-03-30 20:24:48 +00005363 FunctionType::ExtInfo());
Fariborz Jahanian4e87c832009-02-05 01:13:09 +00005364 llvm::Value *Callee = CGF.Builder.CreateStructGEP(Arg1, 0);
5365 Callee = CGF.Builder.CreateLoad(Callee);
Fariborz Jahanian35afdfc2009-02-14 21:25:36 +00005366 const llvm::FunctionType *FTy = Types.GetFunctionType(FnInfo1, true);
Fariborz Jahanian4e87c832009-02-05 01:13:09 +00005367 Callee = CGF.Builder.CreateBitCast(Callee,
Owen Anderson9793f0e2009-07-29 22:16:19 +00005368 llvm::PointerType::getUnqual(FTy));
John McCall78a15112010-05-22 01:48:05 +00005369 return CGF.EmitCall(FnInfo1, Callee, Return, ActualArgs);
Fariborz Jahanian3d9296e2009-02-04 00:22:57 +00005370}
5371
5372/// Generate code for a message send expression in the nonfragile abi.
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00005373CodeGen::RValue
5374CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00005375 ReturnValueSlot Return,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00005376 QualType ResultType,
5377 Selector Sel,
5378 llvm::Value *Receiver,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00005379 const CallArgList &CallArgs,
David Chisnall01aa4672010-04-28 19:33:36 +00005380 const ObjCInterfaceDecl *Class,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00005381 const ObjCMethodDecl *Method) {
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00005382 return LegacyDispatchedSelector(Sel)
John McCall78a15112010-05-22 01:48:05 +00005383 ? EmitLegacyMessageSend(CGF, Return, ResultType,
5384 EmitSelector(CGF.Builder, Sel),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005385 Receiver, CGF.getContext().getObjCIdType(),
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00005386 false, CallArgs, Method, ObjCTypes)
John McCall78a15112010-05-22 01:48:05 +00005387 : EmitMessageSend(CGF, Return, ResultType, Sel,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005388 Receiver, CGF.getContext().getObjCIdType(),
5389 false, CallArgs);
Fariborz Jahanian3d9296e2009-02-04 00:22:57 +00005390}
5391
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00005392llvm::GlobalVariable *
Fariborz Jahanian899e7eb2009-04-14 18:41:56 +00005393CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name) {
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00005394 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
5395
Daniel Dunbara6468342009-03-02 05:18:14 +00005396 if (!GV) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005397 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005398 false, llvm::GlobalValue::ExternalLinkage,
5399 0, Name);
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00005400 }
5401
5402 return GV;
5403}
5404
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005405llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CGBuilderTy &Builder,
5406 const ObjCInterfaceDecl *ID) {
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00005407 llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()];
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005408
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00005409 if (!Entry) {
Daniel Dunbar15894b72009-04-07 05:48:37 +00005410 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
Daniel Dunbarc6928bb2009-03-01 04:40:10 +00005411 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005412 Entry =
5413 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005414 false, llvm::GlobalValue::InternalLinkage,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005415 ClassGV,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005416 "\01L_OBJC_CLASSLIST_REFERENCES_$_");
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00005417 Entry->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00005418 CGM.getTargetData().getABITypeAlignment(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005419 ObjCTypes.ClassnfABIPtrTy));
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005420 Entry->setSection("__DATA, __objc_classrefs, regular, no_dead_strip");
Chris Lattnerf56501c2009-07-17 23:57:13 +00005421 CGM.AddUsedGlobal(Entry);
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005422 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005423
Daniel Dunbarc76493a2009-11-29 21:23:36 +00005424 return Builder.CreateLoad(Entry, "tmp");
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005425}
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00005426
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005427llvm::Value *
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005428CGObjCNonFragileABIMac::EmitSuperClassRef(CGBuilderTy &Builder,
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005429 const ObjCInterfaceDecl *ID) {
5430 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005431
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005432 if (!Entry) {
5433 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
5434 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005435 Entry =
5436 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005437 false, llvm::GlobalValue::InternalLinkage,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005438 ClassGV,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005439 "\01L_OBJC_CLASSLIST_SUP_REFS_$_");
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005440 Entry->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00005441 CGM.getTargetData().getABITypeAlignment(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005442 ObjCTypes.ClassnfABIPtrTy));
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005443 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
Chris Lattnerf56501c2009-07-17 23:57:13 +00005444 CGM.AddUsedGlobal(Entry);
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00005445 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005446
Daniel Dunbarc76493a2009-11-29 21:23:36 +00005447 return Builder.CreateLoad(Entry, "tmp");
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00005448}
5449
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005450/// EmitMetaClassRef - Return a Value * of the address of _class_t
5451/// meta-data
5452///
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005453llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CGBuilderTy &Builder,
5454 const ObjCInterfaceDecl *ID) {
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005455 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
5456 if (Entry)
Daniel Dunbarc76493a2009-11-29 21:23:36 +00005457 return Builder.CreateLoad(Entry, "tmp");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005458
Daniel Dunbar15894b72009-04-07 05:48:37 +00005459 std::string MetaClassName(getMetaclassSymbolPrefix() + ID->getNameAsString());
Fariborz Jahanian899e7eb2009-04-14 18:41:56 +00005460 llvm::GlobalVariable *MetaClassGV = GetClassGlobal(MetaClassName);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005461 Entry =
Owen Andersonc10c8d32009-07-08 19:05:04 +00005462 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy, false,
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005463 llvm::GlobalValue::InternalLinkage,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005464 MetaClassGV,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005465 "\01L_OBJC_CLASSLIST_SUP_REFS_$_");
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005466 Entry->setAlignment(
Daniel Dunbar710cb202010-04-25 20:39:32 +00005467 CGM.getTargetData().getABITypeAlignment(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005468 ObjCTypes.ClassnfABIPtrTy));
5469
Daniel Dunbare60aa052009-04-15 19:03:14 +00005470 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
Chris Lattnerf56501c2009-07-17 23:57:13 +00005471 CGM.AddUsedGlobal(Entry);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005472
Daniel Dunbarc76493a2009-11-29 21:23:36 +00005473 return Builder.CreateLoad(Entry, "tmp");
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005474}
5475
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00005476/// GetClass - Return a reference to the class for the given interface
5477/// decl.
5478llvm::Value *CGObjCNonFragileABIMac::GetClass(CGBuilderTy &Builder,
5479 const ObjCInterfaceDecl *ID) {
Fariborz Jahanian95ace552009-11-17 22:42:00 +00005480 if (ID->hasAttr<WeakImportAttr>()) {
5481 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
5482 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
5483 ClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
5484 }
5485
Fariborz Jahanian33f66e62009-02-05 20:41:40 +00005486 return EmitClassRef(Builder, ID);
5487}
5488
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005489/// Generates a message send where the super is the receiver. This is
5490/// a message send to self with special delivery semantics indicating
5491/// which class's method should be called.
5492CodeGen::RValue
5493CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCall78a15112010-05-22 01:48:05 +00005494 ReturnValueSlot Return,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005495 QualType ResultType,
5496 Selector Sel,
5497 const ObjCInterfaceDecl *Class,
5498 bool isCategoryImpl,
5499 llvm::Value *Receiver,
5500 bool IsClassMessage,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00005501 const CodeGen::CallArgList &CallArgs,
5502 const ObjCMethodDecl *Method) {
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005503 // ...
5504 // Create and init a super structure; this is a (receiver, class)
5505 // pair we will pass to objc_msgSendSuper.
5506 llvm::Value *ObjCSuper =
5507 CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super");
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005508
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005509 llvm::Value *ReceiverAsObject =
5510 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
5511 CGF.Builder.CreateStore(ReceiverAsObject,
5512 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005513
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005514 // If this is a class message the metaclass is passed as the target.
Fariborz Jahanianbac73ac2009-02-28 20:07:56 +00005515 llvm::Value *Target;
5516 if (IsClassMessage) {
5517 if (isCategoryImpl) {
5518 // Message sent to "super' in a class method defined in
5519 // a category implementation.
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005520 Target = EmitClassRef(CGF.Builder, Class);
Fariborz Jahanianbac73ac2009-02-28 20:07:56 +00005521 Target = CGF.Builder.CreateStructGEP(Target, 0);
5522 Target = CGF.Builder.CreateLoad(Target);
Mike Stump658fe022009-07-30 22:28:39 +00005523 } else
Fariborz Jahanianbac73ac2009-02-28 20:07:56 +00005524 Target = EmitMetaClassRef(CGF.Builder, Class);
Mike Stump658fe022009-07-30 22:28:39 +00005525 } else
Daniel Dunbar508a7dd2009-04-18 08:51:00 +00005526 Target = EmitSuperClassRef(CGF.Builder, Class);
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005527
Mike Stump18bb9282009-05-16 07:57:57 +00005528 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
5529 // ObjCTypes types.
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005530 const llvm::Type *ClassTy =
5531 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
5532 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
5533 CGF.Builder.CreateStore(Target,
5534 CGF.Builder.CreateStructGEP(ObjCSuper, 1));
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005535
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00005536 return (LegacyDispatchedSelector(Sel))
John McCall78a15112010-05-22 01:48:05 +00005537 ? EmitLegacyMessageSend(CGF, Return, ResultType,
5538 EmitSelector(CGF.Builder, Sel),
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005539 ObjCSuper, ObjCTypes.SuperPtrCTy,
Daniel Dunbaraff9fca2009-09-17 04:01:22 +00005540 true, CallArgs, Method, ObjCTypes)
John McCall78a15112010-05-22 01:48:05 +00005541 : EmitMessageSend(CGF, Return, ResultType, Sel,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005542 ObjCSuper, ObjCTypes.SuperPtrCTy,
5543 true, CallArgs);
Fariborz Jahanian6b7cd6e2009-02-06 20:09:23 +00005544}
Fariborz Jahanian74b77222009-02-11 20:51:17 +00005545
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005546llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CGBuilderTy &Builder,
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00005547 Selector Sel, bool lval) {
Fariborz Jahanian74b77222009-02-11 20:51:17 +00005548 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005549
Fariborz Jahanian74b77222009-02-11 20:51:17 +00005550 if (!Entry) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005551 llvm::Constant *Casted =
5552 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5553 ObjCTypes.SelectorPtrTy);
5554 Entry =
5555 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
5556 llvm::GlobalValue::InternalLinkage,
5557 Casted, "\01L_OBJC_SELECTOR_REFERENCES_");
Fariborz Jahanian5d5ed2d2009-05-11 19:25:47 +00005558 Entry->setSection("__DATA, __objc_selrefs, literal_pointers, no_dead_strip");
Chris Lattnerf56501c2009-07-17 23:57:13 +00005559 CGM.AddUsedGlobal(Entry);
Fariborz Jahanian74b77222009-02-11 20:51:17 +00005560 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005561
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00005562 if (lval)
5563 return Entry;
Daniel Dunbarc76493a2009-11-29 21:23:36 +00005564 return Builder.CreateLoad(Entry, "tmp");
Fariborz Jahanian74b77222009-02-11 20:51:17 +00005565}
Fariborz Jahanian06292952009-02-16 22:52:32 +00005566/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00005567/// objc_assign_ivar (id src, id *dst, ptrdiff_t)
Fariborz Jahanian06292952009-02-16 22:52:32 +00005568///
5569void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00005570 llvm::Value *src,
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00005571 llvm::Value *dst,
5572 llvm::Value *ivarOffset) {
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00005573 const llvm::Type * SrcTy = src->getType();
5574 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00005575 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00005576 assert(Size <= 8 && "does not support size > 8");
5577 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
5578 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
Fariborz Jahanian1b074a32009-03-13 00:42:52 +00005579 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5580 }
Fariborz Jahanian06292952009-02-16 22:52:32 +00005581 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5582 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00005583 CGF.Builder.CreateCall3(ObjCTypes.getGcAssignIvarFn(),
5584 src, dst, ivarOffset);
Fariborz Jahanian06292952009-02-16 22:52:32 +00005585 return;
5586}
5587
5588/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5589/// objc_assign_strongCast (id src, id *dst)
5590///
5591void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005592 CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00005593 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00005594 const llvm::Type * SrcTy = src->getType();
5595 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00005596 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00005597 assert(Size <= 8 && "does not support size > 8");
5598 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005599 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
Fariborz Jahanian1b074a32009-03-13 00:42:52 +00005600 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5601 }
Fariborz Jahanian06292952009-02-16 22:52:32 +00005602 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5603 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattner0a696a422009-04-22 02:38:11 +00005604 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignStrongCastFn(),
Fariborz Jahanian06292952009-02-16 22:52:32 +00005605 src, dst, "weakassign");
5606 return;
5607}
5608
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00005609void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005610 CodeGen::CodeGenFunction &CGF,
5611 llvm::Value *DestPtr,
5612 llvm::Value *SrcPtr,
Fariborz Jahanian021510e2010-06-15 22:44:06 +00005613 llvm::Value *Size) {
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00005614 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
5615 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00005616 CGF.Builder.CreateCall3(ObjCTypes.GcMemmoveCollectableFn(),
Fariborz Jahanian021510e2010-06-15 22:44:06 +00005617 DestPtr, SrcPtr, Size);
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00005618 return;
5619}
5620
Fariborz Jahanian06292952009-02-16 22:52:32 +00005621/// EmitObjCWeakRead - Code gen for loading value of a __weak
5622/// object: objc_read_weak (id *src)
5623///
5624llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005625 CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00005626 llvm::Value *AddrWeakObj) {
Eli Friedmana374b682009-03-07 03:57:15 +00005627 const llvm::Type* DestTy =
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005628 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
5629 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
Chris Lattnerce8754e2009-04-22 02:44:54 +00005630 llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.getGcReadWeakFn(),
Fariborz Jahanian06292952009-02-16 22:52:32 +00005631 AddrWeakObj, "weakread");
Eli Friedmana374b682009-03-07 03:57:15 +00005632 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
Fariborz Jahanian06292952009-02-16 22:52:32 +00005633 return read_weak;
5634}
5635
5636/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
5637/// objc_assign_weak (id src, id *dst)
5638///
5639void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00005640 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00005641 const llvm::Type * SrcTy = src->getType();
5642 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00005643 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00005644 assert(Size <= 8 && "does not support size > 8");
5645 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
5646 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
Fariborz Jahanian1b074a32009-03-13 00:42:52 +00005647 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5648 }
Fariborz Jahanian06292952009-02-16 22:52:32 +00005649 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5650 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattner6fdd57c2009-04-17 22:12:36 +00005651 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignWeakFn(),
Fariborz Jahanian06292952009-02-16 22:52:32 +00005652 src, dst, "weakassign");
5653 return;
5654}
5655
5656/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
5657/// objc_assign_global (id src, id *dst)
5658///
5659void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump11289f42009-09-09 15:08:12 +00005660 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00005661 const llvm::Type * SrcTy = src->getType();
5662 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sandsc76fe8b2009-05-09 07:08:47 +00005663 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanianaedcfa42009-03-23 19:10:40 +00005664 assert(Size <= 8 && "does not support size > 8");
5665 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
5666 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
Fariborz Jahanian1b074a32009-03-13 00:42:52 +00005667 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5668 }
Fariborz Jahanian06292952009-02-16 22:52:32 +00005669 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5670 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattner0a696a422009-04-22 02:38:11 +00005671 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignGlobalFn(),
Fariborz Jahanian06292952009-02-16 22:52:32 +00005672 src, dst, "globalassign");
5673 return;
5674}
Fariborz Jahanian74b77222009-02-11 20:51:17 +00005675
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005676void
John McCallbd309292010-07-06 01:34:17 +00005677CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
5678 const ObjCAtSynchronizedStmt &S) {
5679 // Evaluate the lock operand. This should dominate the cleanup.
5680 llvm::Value *SyncArg = CGF.EmitScalarExpr(S.getSynchExpr());
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005681
John McCallbd309292010-07-06 01:34:17 +00005682 // Acquire the lock.
5683 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
5684 CGF.Builder.CreateCall(ObjCTypes.getSyncEnterFn(), SyncArg)
5685 ->setDoesNotThrow();
5686
5687 // Register an all-paths cleanup to release the lock.
5688 {
John McCall2b7fc382010-07-13 20:32:21 +00005689 CodeGenFunction::CleanupBlock ReleaseScope(CGF, NormalAndEHCleanup);
John McCallbd309292010-07-06 01:34:17 +00005690
5691 CGF.Builder.CreateCall(ObjCTypes.getSyncExitFn(), SyncArg)
5692 ->setDoesNotThrow();
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005693 }
5694
John McCallbd309292010-07-06 01:34:17 +00005695 // Emit the body of the statement.
5696 CGF.EmitStmt(S.getSynchBody());
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005697
John McCallbd309292010-07-06 01:34:17 +00005698 // Pop the lock-release cleanup.
5699 CGF.PopCleanupBlock();
5700}
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005701
John McCallbd309292010-07-06 01:34:17 +00005702namespace {
5703 struct CatchHandler {
5704 const VarDecl *Variable;
5705 const Stmt *Body;
5706 llvm::BasicBlock *Block;
5707 llvm::Value *TypeInfo;
5708 };
John McCall5c08ab92010-07-13 22:12:14 +00005709
5710 struct CallObjCEndCatch : EHScopeStack::LazyCleanup {
5711 CallObjCEndCatch(bool MightThrow, llvm::Value *Fn) :
5712 MightThrow(MightThrow), Fn(Fn) {}
5713 bool MightThrow;
5714 llvm::Value *Fn;
5715
5716 void Emit(CodeGenFunction &CGF, bool IsForEH) {
5717 if (!MightThrow) {
5718 CGF.Builder.CreateCall(Fn)->setDoesNotThrow();
5719 return;
5720 }
5721
5722 CGF.EmitCallOrInvoke(Fn, 0, 0);
5723 }
5724 };
John McCallbd309292010-07-06 01:34:17 +00005725}
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005726
John McCallbd309292010-07-06 01:34:17 +00005727void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
5728 const ObjCAtTryStmt &S) {
5729 // Jump destination for falling out of catch bodies.
5730 CodeGenFunction::JumpDest Cont;
5731 if (S.getNumCatchStmts())
5732 Cont = CGF.getJumpDestInCurrentScope("eh.cont");
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005733
John McCallbd309292010-07-06 01:34:17 +00005734 CodeGenFunction::FinallyInfo FinallyInfo;
5735 if (const ObjCAtFinallyStmt *Finally = S.getFinallyStmt())
5736 FinallyInfo = CGF.EnterFinallyBlock(Finally->getFinallyBody(),
5737 ObjCTypes.getObjCBeginCatchFn(),
5738 ObjCTypes.getObjCEndCatchFn(),
5739 ObjCTypes.getExceptionRethrowFn());
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005740
John McCallbd309292010-07-06 01:34:17 +00005741 llvm::SmallVector<CatchHandler, 8> Handlers;
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005742
John McCallbd309292010-07-06 01:34:17 +00005743 // Enter the catch, if there is one.
5744 if (S.getNumCatchStmts()) {
5745 for (unsigned I = 0, N = S.getNumCatchStmts(); I != N; ++I) {
5746 const ObjCAtCatchStmt *CatchStmt = S.getCatchStmt(I);
Douglas Gregor46a572b2010-04-26 16:46:50 +00005747 const VarDecl *CatchDecl = CatchStmt->getCatchParamDecl();
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005748
John McCallbd309292010-07-06 01:34:17 +00005749 Handlers.push_back(CatchHandler());
5750 CatchHandler &Handler = Handlers.back();
5751 Handler.Variable = CatchDecl;
5752 Handler.Body = CatchStmt->getCatchBody();
5753 Handler.Block = CGF.createBasicBlock("catch");
5754
5755 // @catch(...) always matches.
Douglas Gregor96c79492010-04-23 22:50:49 +00005756 if (!CatchDecl) {
John McCallbd309292010-07-06 01:34:17 +00005757 Handler.TypeInfo = 0; // catch-all
5758 // Don't consider any other catches.
Douglas Gregor96c79492010-04-23 22:50:49 +00005759 break;
5760 }
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005761
John McCallbd309292010-07-06 01:34:17 +00005762 // There's a particular fixed type info for 'id'.
Douglas Gregor96c79492010-04-23 22:50:49 +00005763 if (CatchDecl->getType()->isObjCIdType() ||
5764 CatchDecl->getType()->isObjCQualifiedIdType()) {
5765 llvm::Value *IDEHType =
5766 CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
5767 if (!IDEHType)
5768 IDEHType =
5769 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
5770 false,
5771 llvm::GlobalValue::ExternalLinkage,
5772 0, "OBJC_EHTYPE_id");
John McCallbd309292010-07-06 01:34:17 +00005773 Handler.TypeInfo = IDEHType;
Douglas Gregor96c79492010-04-23 22:50:49 +00005774 } else {
5775 // All other types should be Objective-C interface pointer types.
5776 const ObjCObjectPointerType *PT =
5777 CatchDecl->getType()->getAs<ObjCObjectPointerType>();
5778 assert(PT && "Invalid @catch type.");
5779 const ObjCInterfaceType *IT = PT->getInterfaceType();
5780 assert(IT && "Invalid @catch type.");
John McCallbd309292010-07-06 01:34:17 +00005781 Handler.TypeInfo = GetInterfaceEHType(IT->getDecl(), false);
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005782 }
5783 }
John McCallbd309292010-07-06 01:34:17 +00005784
5785 EHCatchScope *Catch = CGF.EHStack.pushCatch(Handlers.size());
5786 for (unsigned I = 0, E = Handlers.size(); I != E; ++I)
5787 Catch->setHandler(I, Handlers[I].TypeInfo, Handlers[I].Block);
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005788 }
John McCallbd309292010-07-06 01:34:17 +00005789
5790 // Emit the try body.
5791 CGF.EmitStmt(S.getTryBody());
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005792
John McCallbd309292010-07-06 01:34:17 +00005793 // Leave the try.
5794 if (S.getNumCatchStmts())
5795 CGF.EHStack.popCatch();
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005796
John McCallbd309292010-07-06 01:34:17 +00005797 // Remember where we were.
5798 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005799
John McCallbd309292010-07-06 01:34:17 +00005800 // Emit the handlers.
5801 for (unsigned I = 0, E = Handlers.size(); I != E; ++I) {
5802 CatchHandler &Handler = Handlers[I];
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005803
John McCallbd309292010-07-06 01:34:17 +00005804 CGF.EmitBlock(Handler.Block);
5805 llvm::Value *RawExn = CGF.Builder.CreateLoad(CGF.getExceptionSlot());
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005806
John McCallbd309292010-07-06 01:34:17 +00005807 // Enter the catch.
5808 llvm::CallInst *Exn =
5809 CGF.Builder.CreateCall(ObjCTypes.getObjCBeginCatchFn(), RawExn,
5810 "exn.adjusted");
5811 Exn->setDoesNotThrow();
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005812
John McCallbd309292010-07-06 01:34:17 +00005813 // Add a cleanup to leave the catch.
John McCall5c08ab92010-07-13 22:12:14 +00005814 bool EndCatchMightThrow = (Handler.Variable == 0);
5815 CGF.EHStack.pushLazyCleanup<CallObjCEndCatch>(NormalAndEHCleanup,
5816 EndCatchMightThrow,
5817 ObjCTypes.getObjCEndCatchFn());
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005818
John McCallbd309292010-07-06 01:34:17 +00005819 // Bind the catch parameter if it exists.
5820 if (const VarDecl *CatchParam = Handler.Variable) {
5821 const llvm::Type *CatchType = CGF.ConvertType(CatchParam->getType());
5822 llvm::Value *CastExn = CGF.Builder.CreateBitCast(Exn, CatchType);
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005823
John McCallbd309292010-07-06 01:34:17 +00005824 CGF.EmitLocalBlockVarDecl(*CatchParam);
5825 CGF.Builder.CreateStore(CastExn, CGF.GetAddrOfLocalVar(CatchParam));
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005826 }
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005827
John McCallbd309292010-07-06 01:34:17 +00005828 CGF.ObjCEHValueStack.push_back(Exn);
5829 CGF.EmitStmt(Handler.Body);
5830 CGF.ObjCEHValueStack.pop_back();
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005831
John McCallbd309292010-07-06 01:34:17 +00005832 // Leave the earlier cleanup.
5833 CGF.PopCleanupBlock();
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005834
John McCallbd309292010-07-06 01:34:17 +00005835 CGF.EmitBranchThroughCleanup(Cont);
5836 }
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005837
John McCallbd309292010-07-06 01:34:17 +00005838 // Go back to the try-statement fallthrough.
5839 CGF.Builder.restoreIP(SavedIP);
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005840
John McCallbd309292010-07-06 01:34:17 +00005841 // Pop out of the normal cleanup on the finally.
5842 if (S.getFinallyStmt())
5843 CGF.ExitFinallyBlock(FinallyInfo);
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005844
John McCallbd309292010-07-06 01:34:17 +00005845 if (Cont.Block)
5846 CGF.EmitBlock(Cont.Block);
Daniel Dunbar0b0dcd92009-02-24 07:47:38 +00005847}
5848
Anders Carlsson9ab53d12009-02-16 22:59:18 +00005849/// EmitThrowStmt - Generate code for a throw statement.
5850void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
5851 const ObjCAtThrowStmt &S) {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005852 llvm::Value *Exception;
Fariborz Jahanian3336de12010-05-28 17:34:43 +00005853 llvm::Constant *FunctionThrowOrRethrow;
Anders Carlsson9ab53d12009-02-16 22:59:18 +00005854 if (const Expr *ThrowExpr = S.getThrowExpr()) {
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005855 Exception = CGF.EmitScalarExpr(ThrowExpr);
Fariborz Jahanian3336de12010-05-28 17:34:43 +00005856 FunctionThrowOrRethrow = ObjCTypes.getExceptionThrowFn();
Anders Carlsson9ab53d12009-02-16 22:59:18 +00005857 } else {
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005858 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005859 "Unexpected rethrow outside @catch block.");
5860 Exception = CGF.ObjCEHValueStack.back();
Fariborz Jahanian3336de12010-05-28 17:34:43 +00005861 FunctionThrowOrRethrow = ObjCTypes.getExceptionRethrowFn();
Anders Carlsson9ab53d12009-02-16 22:59:18 +00005862 }
5863
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005864 llvm::Value *ExceptionAsObject =
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005865 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp");
5866 llvm::BasicBlock *InvokeDest = CGF.getInvokeDest();
5867 if (InvokeDest) {
Fariborz Jahanian3336de12010-05-28 17:34:43 +00005868 CGF.Builder.CreateInvoke(FunctionThrowOrRethrow,
John McCallbd309292010-07-06 01:34:17 +00005869 CGF.getUnreachableBlock(), InvokeDest,
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005870 &ExceptionAsObject, &ExceptionAsObject + 1);
John McCallbd309292010-07-06 01:34:17 +00005871 } else {
5872 CGF.Builder.CreateCall(FunctionThrowOrRethrow, ExceptionAsObject)
5873 ->setDoesNotReturn();
5874 CGF.Builder.CreateUnreachable();
5875 }
Daniel Dunbar76b7acc2009-03-02 06:08:11 +00005876
Anders Carlsson9ab53d12009-02-16 22:59:18 +00005877 // Clear the insertion point to indicate we are in unreachable code.
5878 CGF.Builder.ClearInsertionPoint();
5879}
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005880
5881llvm::Value *
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005882CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005883 bool ForDefinition) {
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005884 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005885
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005886 // If we don't need a definition, return the entry if found or check
5887 // if we use an external reference.
5888 if (!ForDefinition) {
5889 if (Entry)
5890 return Entry;
Daniel Dunbard7beeea2009-04-07 06:43:45 +00005891
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005892 // If this type (or a super class) has the __objc_exception__
5893 // attribute, emit an external reference.
Douglas Gregor78bd61f2009-06-18 16:11:24 +00005894 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005895 return Entry =
Owen Andersonc10c8d32009-07-08 19:05:04 +00005896 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005897 llvm::GlobalValue::ExternalLinkage,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005898 0,
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005899 ("OBJC_EHTYPE_$_" +
Daniel Dunbar07d07852009-10-18 21:17:35 +00005900 ID->getIdentifier()->getName()));
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005901 }
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005902
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005903 // Otherwise we need to either make a new entry or fill in the
5904 // initializer.
5905 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
Daniel Dunbar15894b72009-04-07 05:48:37 +00005906 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005907 std::string VTableName = "objc_ehtype_vtable";
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005908 llvm::GlobalVariable *VTableGV =
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005909 CGM.getModule().getGlobalVariable(VTableName);
5910 if (!VTableGV)
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005911 VTableGV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy,
5912 false,
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005913 llvm::GlobalValue::ExternalLinkage,
Owen Andersonc10c8d32009-07-08 19:05:04 +00005914 0, VTableName);
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005915
Chris Lattner5e016ae2010-06-27 07:15:29 +00005916 llvm::Value *VTableIdx =
5917 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 2);
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005918
5919 std::vector<llvm::Constant*> Values(3);
Owen Andersonade90fd2009-07-29 18:54:39 +00005920 Values[0] = llvm::ConstantExpr::getGetElementPtr(VTableGV, &VTableIdx, 1);
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005921 Values[1] = GetClassName(ID->getIdentifier());
Fariborz Jahanian899e7eb2009-04-14 18:41:56 +00005922 Values[2] = GetClassGlobal(ClassName);
Owen Anderson170229f2009-07-14 23:10:40 +00005923 llvm::Constant *Init =
Owen Anderson0e0189d2009-07-27 22:29:56 +00005924 llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values);
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005925
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005926 if (Entry) {
5927 Entry->setInitializer(Init);
5928 } else {
Owen Andersonc10c8d32009-07-08 19:05:04 +00005929 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005930 llvm::GlobalValue::WeakAnyLinkage,
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005931 Init,
Daniel Dunbar349e6fb2009-10-18 20:48:59 +00005932 ("OBJC_EHTYPE_$_" +
Daniel Dunbar07d07852009-10-18 21:17:35 +00005933 ID->getIdentifier()->getName()));
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005934 }
5935
Daniel Dunbarf5f359f2009-04-14 06:00:08 +00005936 if (CGM.getLangOptions().getVisibilityMode() == LangOptions::Hidden)
Daniel Dunbar15894b72009-04-07 05:48:37 +00005937 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
Daniel Dunbar710cb202010-04-25 20:39:32 +00005938 Entry->setAlignment(CGM.getTargetData().getABITypeAlignment(
5939 ObjCTypes.EHTypeTy));
Daniel Dunbar8f28d012009-04-08 04:21:03 +00005940
5941 if (ForDefinition) {
5942 Entry->setSection("__DATA,__objc_const");
5943 Entry->setLinkage(llvm::GlobalValue::ExternalLinkage);
5944 } else {
5945 Entry->setSection("__DATA,__datacoal_nt,coalesced");
5946 }
Daniel Dunbarb1559a42009-03-01 04:46:24 +00005947
5948 return Entry;
5949}
Daniel Dunbar59e476b2009-08-03 17:06:42 +00005950
Daniel Dunbar8b8683f2008-08-12 00:12:39 +00005951/* *** */
5952
Daniel Dunbarb036db82008-08-13 03:21:16 +00005953CodeGen::CGObjCRuntime *
5954CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
Daniel Dunbar303e2c22008-08-11 02:45:11 +00005955 return new CGObjCMac(CGM);
5956}
Fariborz Jahanian279eda62009-01-21 22:04:16 +00005957
5958CodeGen::CGObjCRuntime *
Fariborz Jahanianb15a3d52009-01-22 23:02:58 +00005959CodeGen::CreateMacNonFragileABIObjCRuntime(CodeGen::CodeGenModule &CGM) {
Fariborz Jahanian71394042009-01-23 23:53:38 +00005960 return new CGObjCNonFragileABIMac(CGM);
Fariborz Jahanian279eda62009-01-21 22:04:16 +00005961}