blob: 8b3fd499b66286538dcdef377a288c9dda13ae5e [file] [log] [blame]
Daniel Dunbarc17a4d32008-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 Dunbarf77ac862008-08-11 21:35:06 +000015
Daniel Dunbar198bcb42010-03-31 01:09:11 +000016#include "CGRecordLayout.h"
Daniel Dunbarf77ac862008-08-11 21:35:06 +000017#include "CodeGenModule.h"
Daniel Dunbarb7ec2462008-08-16 03:19:19 +000018#include "CodeGenFunction.h"
John McCallf1549f62010-07-06 01:34:17 +000019#include "CGException.h"
Daniel Dunbarbbce49b2008-08-12 00:12:39 +000020#include "clang/AST/ASTContext.h"
Daniel Dunbare91593e2008-08-11 04:54:23 +000021#include "clang/AST/Decl.h"
Daniel Dunbar6efc0c52008-08-13 03:21:16 +000022#include "clang/AST/DeclObjC.h"
Anders Carlsson19cc4ab2009-07-18 19:43:29 +000023#include "clang/AST/RecordLayout.h"
Chris Lattner16f00492009-04-26 01:32:48 +000024#include "clang/AST/StmtObjC.h"
Daniel Dunbarf77ac862008-08-11 21:35:06 +000025#include "clang/Basic/LangOptions.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000026#include "clang/Frontend/CodeGenOptions.h"
Daniel Dunbarf77ac862008-08-11 21:35:06 +000027
John McCall87bb5822010-07-31 23:20:56 +000028#include "llvm/InlineAsm.h"
29#include "llvm/IntrinsicInst.h"
Owen Anderson69243822009-07-13 04:10:07 +000030#include "llvm/LLVMContext.h"
Daniel Dunbarbbce49b2008-08-12 00:12:39 +000031#include "llvm/Module.h"
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +000032#include "llvm/ADT/DenseSet.h"
Daniel Dunbar33063492009-09-07 00:20:42 +000033#include "llvm/ADT/SetVector.h"
34#include "llvm/ADT/SmallString.h"
Fariborz Jahanian191dcd72009-12-12 21:26:21 +000035#include "llvm/ADT/SmallPtrSet.h"
John McCall8e3f8612010-07-13 22:12:14 +000036#include "llvm/Support/CallSite.h"
Daniel Dunbar33063492009-09-07 00:20:42 +000037#include "llvm/Support/raw_ostream.h"
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +000038#include "llvm/Target/TargetData.h"
Torok Edwinf42e4a62009-08-24 13:25:12 +000039#include <cstdio>
Daniel Dunbarc17a4d32008-08-11 02:45:11 +000040
41using namespace clang;
Daniel Dunbar46f45b92008-09-09 01:06:48 +000042using namespace CodeGen;
Daniel Dunbarc17a4d32008-08-11 02:45:11 +000043
Daniel Dunbar97776872009-04-22 07:32:20 +000044// Common CGObjCRuntime functions, these don't belong here, but they
45// don't belong in CGObjCRuntime either so we will live with it for
46// now.
47
Daniel Dunbar1d7e5392009-05-03 08:55:17 +000048static uint64_t LookupFieldBitOffset(CodeGen::CodeGenModule &CGM,
49 const ObjCInterfaceDecl *OID,
Daniel Dunbar9f89f2b2009-05-03 12:57:56 +000050 const ObjCImplementationDecl *ID,
Daniel Dunbar1d7e5392009-05-03 08:55:17 +000051 const ObjCIvarDecl *Ivar) {
Daniel Dunbare83be122010-04-02 21:14:02 +000052 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
Daniel Dunbar532d4da2009-05-03 13:15:50 +000053
Daniel Dunbar61ac1d22010-04-02 22:29:40 +000054 // FIXME: We should eliminate the need to have ObjCImplementationDecl passed
55 // in here; it should never be necessary because that should be the lexical
56 // decl context for the ivar.
Daniel Dunbar3a2c80f2010-04-02 15:43:29 +000057
Daniel Dunbar532d4da2009-05-03 13:15:50 +000058 // If we know have an implementation (and the ivar is in it) then
59 // look up in the implementation layout.
Daniel Dunbar6bff2512009-08-03 17:06:42 +000060 const ASTRecordLayout *RL;
Daniel Dunbar532d4da2009-05-03 13:15:50 +000061 if (ID && ID->getClassInterface() == Container)
62 RL = &CGM.getContext().getASTObjCImplementationLayout(ID);
63 else
64 RL = &CGM.getContext().getASTObjCInterfaceLayout(Container);
Daniel Dunbare83be122010-04-02 21:14:02 +000065
66 // Compute field index.
67 //
68 // FIXME: The index here is closely tied to how ASTContext::getObjCLayout is
69 // implemented. This should be fixed to get the information from the layout
70 // directly.
71 unsigned Index = 0;
72 llvm::SmallVector<ObjCIvarDecl*, 16> Ivars;
73 CGM.getContext().ShallowCollectObjCIvars(Container, Ivars);
74 for (unsigned k = 0, e = Ivars.size(); k != e; ++k) {
75 if (Ivar == Ivars[k])
76 break;
77 ++Index;
78 }
79 assert(Index != Ivars.size() && "Ivar is not inside container!");
80
Daniel Dunbar532d4da2009-05-03 13:15:50 +000081 return RL->getFieldOffset(Index);
Daniel Dunbar1d7e5392009-05-03 08:55:17 +000082}
83
84uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM,
85 const ObjCInterfaceDecl *OID,
86 const ObjCIvarDecl *Ivar) {
Daniel Dunbar9f89f2b2009-05-03 12:57:56 +000087 return LookupFieldBitOffset(CGM, OID, 0, Ivar) / 8;
88}
89
90uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM,
91 const ObjCImplementationDecl *OID,
92 const ObjCIvarDecl *Ivar) {
93 return LookupFieldBitOffset(CGM, OID->getClassInterface(), OID, Ivar) / 8;
Daniel Dunbar97776872009-04-22 07:32:20 +000094}
95
96LValue CGObjCRuntime::EmitValueForIvarAtOffset(CodeGen::CodeGenFunction &CGF,
97 const ObjCInterfaceDecl *OID,
98 llvm::Value *BaseValue,
99 const ObjCIvarDecl *Ivar,
100 unsigned CVRQualifiers,
101 llvm::Value *Offset) {
Daniel Dunbar1d7e5392009-05-03 08:55:17 +0000102 // Compute (type*) ( (char *) BaseValue + Offset)
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +0000103 const llvm::Type *I8Ptr = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
Daniel Dunbar1d7e5392009-05-03 08:55:17 +0000104 QualType IvarTy = Ivar->getType();
105 const llvm::Type *LTy = CGF.CGM.getTypes().ConvertTypeForMem(IvarTy);
Daniel Dunbar97776872009-04-22 07:32:20 +0000106 llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, I8Ptr);
Daniel Dunbar97776872009-04-22 07:32:20 +0000107 V = CGF.Builder.CreateGEP(V, Offset, "add.ptr");
Owen Anderson96e0fc72009-07-29 22:16:19 +0000108 V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy));
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000109
Daniel Dunbar6d5eb762010-08-21 03:44:13 +0000110 if (!Ivar->isBitField()) {
111 LValue LV = CGF.MakeAddrLValue(V, IvarTy);
112 LV.getQuals().addCVRQualifiers(CVRQualifiers);
113 return LV;
114 }
Daniel Dunbar9f89f2b2009-05-03 12:57:56 +0000115
Daniel Dunbarc5c446c2010-09-02 23:53:31 +0000116 // We need to compute an access strategy for this bit-field. We are given the
117 // offset to the first byte in the bit-field, the sub-byte offset is taken
118 // from the original layout. We reuse the normal bit-field access strategy by
119 // treating this as an access to a struct where the bit-field is in byte 0,
120 // and adjust the containing type size as appropriate.
121 //
122 // FIXME: Note that currently we make a very conservative estimate of the
123 // alignment of the bit-field, because (a) it is not clear what guarantees the
124 // runtime makes us, and (b) we don't have a way to specify that the struct is
125 // at an alignment plus offset.
126 //
127 // Note, there is a subtle invariant here: we can only call this routine on
128 // non-synthesized ivars but we may be called for synthesized ivars. However,
129 // a synthesized ivar can never be a bit-field, so this is safe.
130 const ASTRecordLayout &RL =
131 CGF.CGM.getContext().getASTObjCInterfaceLayout(OID);
132 uint64_t TypeSizeInBits = RL.getSize();
133 uint64_t FieldBitOffset = LookupFieldBitOffset(CGF.CGM, OID, 0, Ivar);
134 uint64_t BitOffset = FieldBitOffset % 8;
135 uint64_t ContainingTypeAlign = 8;
136 uint64_t ContainingTypeSize = TypeSizeInBits - (FieldBitOffset - BitOffset);
Daniel Dunbar56229f52010-04-05 16:20:33 +0000137 uint64_t BitFieldSize =
138 Ivar->getBitWidth()->EvaluateAsInt(CGF.getContext()).getZExtValue();
Daniel Dunbar97776872009-04-22 07:32:20 +0000139
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000140 // Allocate a new CGBitFieldInfo object to describe this access.
141 //
142 // FIXME: This is incredibly wasteful, these should be uniqued or part of some
143 // layout object. However, this is blocked on other cleanups to the
144 // Objective-C code, so for now we just live with allocating a bunch of these
145 // objects.
Daniel Dunbarc5c446c2010-09-02 23:53:31 +0000146 CGBitFieldInfo *Info = new (CGF.CGM.getContext()) CGBitFieldInfo(
147 CGBitFieldInfo::MakeInfo(CGF.CGM.getTypes(), Ivar, BitOffset, BitFieldSize,
148 ContainingTypeSize, ContainingTypeAlign));
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000149
Daniel Dunbar76695ca2010-08-21 04:05:54 +0000150 return LValue::MakeBitfield(V, *Info,
151 IvarTy.getCVRQualifiers() | CVRQualifiers);
Daniel Dunbar97776872009-04-22 07:32:20 +0000152}
153
154///
155
Daniel Dunbarc17a4d32008-08-11 02:45:11 +0000156namespace {
Daniel Dunbarbbce49b2008-08-12 00:12:39 +0000157
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000158typedef std::vector<llvm::Constant*> ConstantVector;
Daniel Dunbarae226fa2008-08-27 02:31:56 +0000159
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000160// FIXME: We should find a nicer way to make the labels for metadata, string
161// concatenation is lame.
Daniel Dunbar6efc0c52008-08-13 03:21:16 +0000162
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000163class ObjCCommonTypesHelper {
Owen Andersona1cf15f2009-07-14 23:10:40 +0000164protected:
165 llvm::LLVMContext &VMContext;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000166
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000167private:
168 llvm::Constant *getMessageSendFn() const {
169 // id objc_msgSend (id, SEL, ...)
170 std::vector<const llvm::Type*> Params;
171 Params.push_back(ObjectPtrTy);
172 Params.push_back(SelectorPtrTy);
173 return
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000174 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
175 Params, true),
176 "objc_msgSend");
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000177 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000178
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000179 llvm::Constant *getMessageSendStretFn() const {
180 // id objc_msgSend_stret (id, SEL, ...)
181 std::vector<const llvm::Type*> Params;
182 Params.push_back(ObjectPtrTy);
183 Params.push_back(SelectorPtrTy);
184 return
Owen Anderson0032b272009-08-13 21:57:51 +0000185 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000186 Params, true),
187 "objc_msgSend_stret");
188
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000189 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000190
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000191 llvm::Constant *getMessageSendFpretFn() const {
192 // FIXME: This should be long double on x86_64?
193 // [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
194 std::vector<const llvm::Type*> Params;
195 Params.push_back(ObjectPtrTy);
196 Params.push_back(SelectorPtrTy);
197 return
Owen Anderson0032b272009-08-13 21:57:51 +0000198 CGM.CreateRuntimeFunction(llvm::FunctionType::get(
199 llvm::Type::getDoubleTy(VMContext),
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000200 Params,
201 true),
202 "objc_msgSend_fpret");
203
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000204 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000205
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000206 llvm::Constant *getMessageSendSuperFn() const {
207 // id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
208 const char *SuperName = "objc_msgSendSuper";
209 std::vector<const llvm::Type*> Params;
210 Params.push_back(SuperPtrTy);
211 Params.push_back(SelectorPtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000212 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000213 Params, true),
214 SuperName);
215 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000216
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000217 llvm::Constant *getMessageSendSuperFn2() const {
218 // id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
219 const char *SuperName = "objc_msgSendSuper2";
220 std::vector<const llvm::Type*> Params;
221 Params.push_back(SuperPtrTy);
222 Params.push_back(SelectorPtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000223 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000224 Params, true),
225 SuperName);
226 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000227
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000228 llvm::Constant *getMessageSendSuperStretFn() const {
229 // void objc_msgSendSuper_stret(void * stretAddr, struct objc_super *super,
230 // SEL op, ...)
231 std::vector<const llvm::Type*> Params;
232 Params.push_back(Int8PtrTy);
233 Params.push_back(SuperPtrTy);
234 Params.push_back(SelectorPtrTy);
Owen Andersona1cf15f2009-07-14 23:10:40 +0000235 return CGM.CreateRuntimeFunction(
Owen Anderson0032b272009-08-13 21:57:51 +0000236 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000237 Params, true),
238 "objc_msgSendSuper_stret");
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000239 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000240
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000241 llvm::Constant *getMessageSendSuperStretFn2() const {
242 // void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
243 // SEL op, ...)
244 std::vector<const llvm::Type*> Params;
245 Params.push_back(Int8PtrTy);
246 Params.push_back(SuperPtrTy);
247 Params.push_back(SelectorPtrTy);
Owen Andersona1cf15f2009-07-14 23:10:40 +0000248 return CGM.CreateRuntimeFunction(
Owen Anderson0032b272009-08-13 21:57:51 +0000249 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000250 Params, true),
251 "objc_msgSendSuper2_stret");
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000252 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000253
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000254 llvm::Constant *getMessageSendSuperFpretFn() const {
255 // There is no objc_msgSendSuper_fpret? How can that work?
256 return getMessageSendSuperFn();
257 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000258
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000259 llvm::Constant *getMessageSendSuperFpretFn2() const {
260 // There is no objc_msgSendSuper_fpret? How can that work?
261 return getMessageSendSuperFn2();
262 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000263
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000264protected:
265 CodeGen::CodeGenModule &CGM;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000266
Daniel Dunbarbbce49b2008-08-12 00:12:39 +0000267public:
Fariborz Jahanian0a855d02009-03-23 19:10:40 +0000268 const llvm::Type *ShortTy, *IntTy, *LongTy, *LongLongTy;
Daniel Dunbar27f9d772008-08-21 04:36:09 +0000269 const llvm::Type *Int8PtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000270
Daniel Dunbar2bedbf82008-08-12 05:28:47 +0000271 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
272 const llvm::Type *ObjectPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000273
Fariborz Jahanian6d657c42008-11-18 20:18:11 +0000274 /// PtrObjectPtrTy - LLVM type for id *
275 const llvm::Type *PtrObjectPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000276
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +0000277 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
Daniel Dunbar2bedbf82008-08-12 05:28:47 +0000278 const llvm::Type *SelectorPtrTy;
Daniel Dunbar6efc0c52008-08-13 03:21:16 +0000279 /// ProtocolPtrTy - LLVM type for external protocol handles
280 /// (typeof(Protocol))
281 const llvm::Type *ExternalProtocolPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000282
Daniel Dunbar19cd87e2008-08-30 03:02:31 +0000283 // SuperCTy - clang type for struct objc_super.
284 QualType SuperCTy;
285 // SuperPtrCTy - clang type for struct objc_super *.
286 QualType SuperPtrCTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000287
Daniel Dunbare8b470d2008-08-23 04:28:29 +0000288 /// SuperTy - LLVM type for struct objc_super.
289 const llvm::StructType *SuperTy;
Daniel Dunbar14c80b72008-08-23 09:25:55 +0000290 /// SuperPtrTy - LLVM type for struct objc_super *.
291 const llvm::Type *SuperPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000292
Fariborz Jahanian30bc5712009-01-22 23:02:58 +0000293 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
294 /// in GCC parlance).
295 const llvm::StructType *PropertyTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000296
Fariborz Jahanian30bc5712009-01-22 23:02:58 +0000297 /// PropertyListTy - LLVM type for struct objc_property_list
298 /// (_prop_list_t in GCC parlance).
299 const llvm::StructType *PropertyListTy;
300 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
301 const llvm::Type *PropertyListPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000302
Fariborz Jahanian30bc5712009-01-22 23:02:58 +0000303 // MethodTy - LLVM type for struct objc_method.
304 const llvm::StructType *MethodTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000305
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000306 /// CacheTy - LLVM type for struct objc_cache.
307 const llvm::Type *CacheTy;
308 /// CachePtrTy - LLVM type for struct objc_cache *.
309 const llvm::Type *CachePtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000310
Chris Lattner72db6c32009-04-22 02:44:54 +0000311 llvm::Constant *getGetPropertyFn() {
312 CodeGen::CodeGenTypes &Types = CGM.getTypes();
313 ASTContext &Ctx = CGM.getContext();
314 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
John McCallead608a2010-02-26 00:48:12 +0000315 llvm::SmallVector<CanQualType,4> Params;
316 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
317 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
Chris Lattner72db6c32009-04-22 02:44:54 +0000318 Params.push_back(IdType);
319 Params.push_back(SelType);
320 Params.push_back(Ctx.LongTy);
321 Params.push_back(Ctx.BoolTy);
322 const llvm::FunctionType *FTy =
John McCall04a67a62010-02-05 21:31:56 +0000323 Types.GetFunctionType(Types.getFunctionInfo(IdType, Params,
Rafael Espindola264ba482010-03-30 20:24:48 +0000324 FunctionType::ExtInfo()),
325 false);
Chris Lattner72db6c32009-04-22 02:44:54 +0000326 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
327 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000328
Chris Lattner72db6c32009-04-22 02:44:54 +0000329 llvm::Constant *getSetPropertyFn() {
330 CodeGen::CodeGenTypes &Types = CGM.getTypes();
331 ASTContext &Ctx = CGM.getContext();
332 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
John McCallead608a2010-02-26 00:48:12 +0000333 llvm::SmallVector<CanQualType,6> Params;
334 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
335 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
Chris Lattner72db6c32009-04-22 02:44:54 +0000336 Params.push_back(IdType);
337 Params.push_back(SelType);
338 Params.push_back(Ctx.LongTy);
339 Params.push_back(IdType);
340 Params.push_back(Ctx.BoolTy);
341 Params.push_back(Ctx.BoolTy);
342 const llvm::FunctionType *FTy =
John McCall04a67a62010-02-05 21:31:56 +0000343 Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params,
Rafael Espindola264ba482010-03-30 20:24:48 +0000344 FunctionType::ExtInfo()),
345 false);
Chris Lattner72db6c32009-04-22 02:44:54 +0000346 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
347 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000348
Fariborz Jahanian6cc59062010-04-12 18:18:10 +0000349
350 llvm::Constant *getCopyStructFn() {
351 CodeGen::CodeGenTypes &Types = CGM.getTypes();
352 ASTContext &Ctx = CGM.getContext();
353 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
354 llvm::SmallVector<CanQualType,5> Params;
355 Params.push_back(Ctx.VoidPtrTy);
356 Params.push_back(Ctx.VoidPtrTy);
357 Params.push_back(Ctx.LongTy);
358 Params.push_back(Ctx.BoolTy);
359 Params.push_back(Ctx.BoolTy);
360 const llvm::FunctionType *FTy =
361 Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params,
362 FunctionType::ExtInfo()),
363 false);
364 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
365 }
366
Chris Lattner72db6c32009-04-22 02:44:54 +0000367 llvm::Constant *getEnumerationMutationFn() {
Daniel Dunbarc1ab9002009-07-11 20:32:50 +0000368 CodeGen::CodeGenTypes &Types = CGM.getTypes();
369 ASTContext &Ctx = CGM.getContext();
Chris Lattner72db6c32009-04-22 02:44:54 +0000370 // void objc_enumerationMutation (id)
John McCallead608a2010-02-26 00:48:12 +0000371 llvm::SmallVector<CanQualType,1> Params;
372 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
Daniel Dunbarc1ab9002009-07-11 20:32:50 +0000373 const llvm::FunctionType *FTy =
John McCall04a67a62010-02-05 21:31:56 +0000374 Types.GetFunctionType(Types.getFunctionInfo(Ctx.VoidTy, Params,
Rafael Espindola264ba482010-03-30 20:24:48 +0000375 FunctionType::ExtInfo()),
376 false);
Chris Lattner72db6c32009-04-22 02:44:54 +0000377 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
378 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000379
Fariborz Jahaniandb286862009-01-22 00:37:21 +0000380 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
Chris Lattner72db6c32009-04-22 02:44:54 +0000381 llvm::Constant *getGcReadWeakFn() {
382 // id objc_read_weak (id *)
383 std::vector<const llvm::Type*> Args;
384 Args.push_back(ObjectPtrTy->getPointerTo());
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000385 llvm::FunctionType *FTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000386 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattner72db6c32009-04-22 02:44:54 +0000387 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000388 }
389
Fariborz Jahaniandb286862009-01-22 00:37:21 +0000390 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
Chris Lattner96508e12009-04-17 22:12:36 +0000391 llvm::Constant *getGcAssignWeakFn() {
392 // id objc_assign_weak (id, id *)
393 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
394 Args.push_back(ObjectPtrTy->getPointerTo());
395 llvm::FunctionType *FTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000396 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattner96508e12009-04-17 22:12:36 +0000397 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
398 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000399
Fariborz Jahaniandb286862009-01-22 00:37:21 +0000400 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
Chris Lattnerbbccd612009-04-22 02:38:11 +0000401 llvm::Constant *getGcAssignGlobalFn() {
402 // id objc_assign_global(id, id *)
403 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
404 Args.push_back(ObjectPtrTy->getPointerTo());
Owen Andersona1cf15f2009-07-14 23:10:40 +0000405 llvm::FunctionType *FTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000406 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattnerbbccd612009-04-22 02:38:11 +0000407 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
408 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000409
Fariborz Jahanian021a7a62010-07-20 20:30:03 +0000410 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
411 llvm::Constant *getGcAssignThreadLocalFn() {
412 // id objc_assign_threadlocal(id src, id * dest)
413 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
414 Args.push_back(ObjectPtrTy->getPointerTo());
415 llvm::FunctionType *FTy =
416 llvm::FunctionType::get(ObjectPtrTy, Args, false);
417 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
418 }
419
Fariborz Jahaniandb286862009-01-22 00:37:21 +0000420 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
Chris Lattnerbbccd612009-04-22 02:38:11 +0000421 llvm::Constant *getGcAssignIvarFn() {
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000422 // id objc_assign_ivar(id, id *, ptrdiff_t)
Chris Lattnerbbccd612009-04-22 02:38:11 +0000423 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
424 Args.push_back(ObjectPtrTy->getPointerTo());
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000425 Args.push_back(LongTy);
Owen Andersona1cf15f2009-07-14 23:10:40 +0000426 llvm::FunctionType *FTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000427 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattnerbbccd612009-04-22 02:38:11 +0000428 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
429 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000430
Fariborz Jahanian082b02e2009-07-08 01:18:33 +0000431 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
432 llvm::Constant *GcMemmoveCollectableFn() {
433 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
434 std::vector<const llvm::Type*> Args(1, Int8PtrTy);
435 Args.push_back(Int8PtrTy);
436 Args.push_back(LongTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000437 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +0000438 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
439 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000440
Fariborz Jahaniandb286862009-01-22 00:37:21 +0000441 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
Chris Lattnerbbccd612009-04-22 02:38:11 +0000442 llvm::Constant *getGcAssignStrongCastFn() {
Fariborz Jahanian021a7a62010-07-20 20:30:03 +0000443 // id objc_assign_strongCast(id, id *)
Chris Lattnerbbccd612009-04-22 02:38:11 +0000444 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
445 Args.push_back(ObjectPtrTy->getPointerTo());
Owen Andersona1cf15f2009-07-14 23:10:40 +0000446 llvm::FunctionType *FTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000447 llvm::FunctionType::get(ObjectPtrTy, Args, false);
Chris Lattnerbbccd612009-04-22 02:38:11 +0000448 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
449 }
Anders Carlssonf57c5b22009-02-16 22:59:18 +0000450
451 /// ExceptionThrowFn - LLVM objc_exception_throw function.
Chris Lattnerbbccd612009-04-22 02:38:11 +0000452 llvm::Constant *getExceptionThrowFn() {
453 // void objc_exception_throw(id)
454 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
455 llvm::FunctionType *FTy =
Owen Anderson0032b272009-08-13 21:57:51 +0000456 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
Chris Lattnerbbccd612009-04-22 02:38:11 +0000457 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
458 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000459
Fariborz Jahanian69677ea2010-05-28 17:34:43 +0000460 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
461 llvm::Constant *getExceptionRethrowFn() {
462 // void objc_exception_rethrow(void)
463 std::vector<const llvm::Type*> Args;
464 llvm::FunctionType *FTy =
465 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, true);
466 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
467 }
468
Daniel Dunbar1c566672009-02-24 01:43:46 +0000469 /// SyncEnterFn - LLVM object_sync_enter function.
Chris Lattnerb02e53b2009-04-06 16:53:45 +0000470 llvm::Constant *getSyncEnterFn() {
471 // void objc_sync_enter (id)
472 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
473 llvm::FunctionType *FTy =
Owen Anderson0032b272009-08-13 21:57:51 +0000474 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
Chris Lattnerb02e53b2009-04-06 16:53:45 +0000475 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
476 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000477
Daniel Dunbar1c566672009-02-24 01:43:46 +0000478 /// SyncExitFn - LLVM object_sync_exit function.
Chris Lattnerbbccd612009-04-22 02:38:11 +0000479 llvm::Constant *getSyncExitFn() {
480 // void objc_sync_exit (id)
481 std::vector<const llvm::Type*> Args(1, ObjectPtrTy);
482 llvm::FunctionType *FTy =
Owen Anderson0032b272009-08-13 21:57:51 +0000483 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Args, false);
Chris Lattnerbbccd612009-04-22 02:38:11 +0000484 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
485 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000486
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000487 llvm::Constant *getSendFn(bool IsSuper) const {
488 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
489 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000490
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000491 llvm::Constant *getSendFn2(bool IsSuper) const {
492 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
493 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000494
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000495 llvm::Constant *getSendStretFn(bool IsSuper) const {
496 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
497 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000498
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000499 llvm::Constant *getSendStretFn2(bool IsSuper) const {
500 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
501 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000502
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000503 llvm::Constant *getSendFpretFn(bool IsSuper) const {
504 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
505 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000506
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000507 llvm::Constant *getSendFpretFn2(bool IsSuper) const {
508 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
509 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000510
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000511 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
512 ~ObjCCommonTypesHelper(){}
513};
Daniel Dunbare8b470d2008-08-23 04:28:29 +0000514
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000515/// ObjCTypesHelper - Helper class that encapsulates lazy
516/// construction of varies types used during ObjC generation.
517class ObjCTypesHelper : public ObjCCommonTypesHelper {
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000518public:
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +0000519 /// SymtabTy - LLVM type for struct objc_symtab.
520 const llvm::StructType *SymtabTy;
Daniel Dunbar27f9d772008-08-21 04:36:09 +0000521 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
522 const llvm::Type *SymtabPtrTy;
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +0000523 /// ModuleTy - LLVM type for struct objc_module.
524 const llvm::StructType *ModuleTy;
Daniel Dunbar259d93d2008-08-12 03:39:23 +0000525
Daniel Dunbar6efc0c52008-08-13 03:21:16 +0000526 /// ProtocolTy - LLVM type for struct objc_protocol.
527 const llvm::StructType *ProtocolTy;
528 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
529 const llvm::Type *ProtocolPtrTy;
530 /// ProtocolExtensionTy - LLVM type for struct
531 /// objc_protocol_extension.
532 const llvm::StructType *ProtocolExtensionTy;
533 /// ProtocolExtensionTy - LLVM type for struct
534 /// objc_protocol_extension *.
535 const llvm::Type *ProtocolExtensionPtrTy;
536 /// MethodDescriptionTy - LLVM type for struct
537 /// objc_method_description.
538 const llvm::StructType *MethodDescriptionTy;
539 /// MethodDescriptionListTy - LLVM type for struct
540 /// objc_method_description_list.
541 const llvm::StructType *MethodDescriptionListTy;
542 /// MethodDescriptionListPtrTy - LLVM type for struct
543 /// objc_method_description_list *.
544 const llvm::Type *MethodDescriptionListPtrTy;
Daniel Dunbar6efc0c52008-08-13 03:21:16 +0000545 /// ProtocolListTy - LLVM type for struct objc_property_list.
546 const llvm::Type *ProtocolListTy;
547 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
548 const llvm::Type *ProtocolListPtrTy;
Daniel Dunbar86e253a2008-08-22 20:34:54 +0000549 /// CategoryTy - LLVM type for struct objc_category.
550 const llvm::StructType *CategoryTy;
Daniel Dunbar27f9d772008-08-21 04:36:09 +0000551 /// ClassTy - LLVM type for struct objc_class.
552 const llvm::StructType *ClassTy;
553 /// ClassPtrTy - LLVM type for struct objc_class *.
554 const llvm::Type *ClassPtrTy;
555 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
556 const llvm::StructType *ClassExtensionTy;
557 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
558 const llvm::Type *ClassExtensionPtrTy;
Daniel Dunbar27f9d772008-08-21 04:36:09 +0000559 // IvarTy - LLVM type for struct objc_ivar.
560 const llvm::StructType *IvarTy;
561 /// IvarListTy - LLVM type for struct objc_ivar_list.
562 const llvm::Type *IvarListTy;
563 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
564 const llvm::Type *IvarListPtrTy;
Daniel Dunbar27f9d772008-08-21 04:36:09 +0000565 /// MethodListTy - LLVM type for struct objc_method_list.
566 const llvm::Type *MethodListTy;
567 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
568 const llvm::Type *MethodListPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000569
Anders Carlsson124526b2008-09-09 10:10:21 +0000570 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
571 const llvm::Type *ExceptionDataTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000572
Anders Carlsson124526b2008-09-09 10:10:21 +0000573 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
Chris Lattner34b02a12009-04-22 02:26:14 +0000574 llvm::Constant *getExceptionTryEnterFn() {
575 std::vector<const llvm::Type*> Params;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000576 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
Owen Andersona1cf15f2009-07-14 23:10:40 +0000577 return CGM.CreateRuntimeFunction(
Owen Anderson0032b272009-08-13 21:57:51 +0000578 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000579 Params, false),
580 "objc_exception_try_enter");
Chris Lattner34b02a12009-04-22 02:26:14 +0000581 }
Anders Carlsson124526b2008-09-09 10:10:21 +0000582
583 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
Chris Lattner34b02a12009-04-22 02:26:14 +0000584 llvm::Constant *getExceptionTryExitFn() {
585 std::vector<const llvm::Type*> Params;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000586 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
Owen Andersona1cf15f2009-07-14 23:10:40 +0000587 return CGM.CreateRuntimeFunction(
Owen Anderson0032b272009-08-13 21:57:51 +0000588 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000589 Params, false),
590 "objc_exception_try_exit");
Chris Lattner34b02a12009-04-22 02:26:14 +0000591 }
Anders Carlsson124526b2008-09-09 10:10:21 +0000592
593 /// ExceptionExtractFn - LLVM objc_exception_extract function.
Chris Lattner34b02a12009-04-22 02:26:14 +0000594 llvm::Constant *getExceptionExtractFn() {
595 std::vector<const llvm::Type*> Params;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000596 Params.push_back(llvm::PointerType::getUnqual(ExceptionDataTy));
597 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner34b02a12009-04-22 02:26:14 +0000598 Params, false),
599 "objc_exception_extract");
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000600
Chris Lattner34b02a12009-04-22 02:26:14 +0000601 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000602
Anders Carlsson124526b2008-09-09 10:10:21 +0000603 /// ExceptionMatchFn - LLVM objc_exception_match function.
Chris Lattner34b02a12009-04-22 02:26:14 +0000604 llvm::Constant *getExceptionMatchFn() {
605 std::vector<const llvm::Type*> Params;
606 Params.push_back(ClassPtrTy);
607 Params.push_back(ObjectPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000608 return CGM.CreateRuntimeFunction(
Owen Anderson0032b272009-08-13 21:57:51 +0000609 llvm::FunctionType::get(llvm::Type::getInt32Ty(VMContext),
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000610 Params, false),
611 "objc_exception_match");
612
Chris Lattner34b02a12009-04-22 02:26:14 +0000613 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000614
Anders Carlsson124526b2008-09-09 10:10:21 +0000615 /// SetJmpFn - LLVM _setjmp function.
Chris Lattner34b02a12009-04-22 02:26:14 +0000616 llvm::Constant *getSetJmpFn() {
617 std::vector<const llvm::Type*> Params;
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +0000618 Params.push_back(llvm::Type::getInt32PtrTy(VMContext));
Chris Lattner34b02a12009-04-22 02:26:14 +0000619 return
Owen Anderson0032b272009-08-13 21:57:51 +0000620 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getInt32Ty(VMContext),
Chris Lattner34b02a12009-04-22 02:26:14 +0000621 Params, false),
622 "_setjmp");
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000623
Chris Lattner34b02a12009-04-22 02:26:14 +0000624 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000625
Daniel Dunbarbbce49b2008-08-12 00:12:39 +0000626public:
627 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000628 ~ObjCTypesHelper() {}
Daniel Dunbarbbce49b2008-08-12 00:12:39 +0000629};
630
Fariborz Jahanian30bc5712009-01-22 23:02:58 +0000631/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000632/// modern abi
Fariborz Jahanian30bc5712009-01-22 23:02:58 +0000633class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
Fariborz Jahanian83a8a752009-02-04 20:42:28 +0000634public:
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000635
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000636 // MethodListnfABITy - LLVM for struct _method_list_t
637 const llvm::StructType *MethodListnfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000638
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000639 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
640 const llvm::Type *MethodListnfABIPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000641
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000642 // ProtocolnfABITy = LLVM for struct _protocol_t
643 const llvm::StructType *ProtocolnfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000644
Daniel Dunbar948e2582009-02-15 07:36:20 +0000645 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
646 const llvm::Type *ProtocolnfABIPtrTy;
647
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000648 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
649 const llvm::StructType *ProtocolListnfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000650
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000651 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
652 const llvm::Type *ProtocolListnfABIPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000653
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000654 // ClassnfABITy - LLVM for struct _class_t
655 const llvm::StructType *ClassnfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000656
Fariborz Jahanianaa23b572009-01-23 23:53:38 +0000657 // ClassnfABIPtrTy - LLVM for struct _class_t*
658 const llvm::Type *ClassnfABIPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000659
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000660 // IvarnfABITy - LLVM for struct _ivar_t
661 const llvm::StructType *IvarnfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000662
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000663 // IvarListnfABITy - LLVM for struct _ivar_list_t
664 const llvm::StructType *IvarListnfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000665
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000666 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
667 const llvm::Type *IvarListnfABIPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000668
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000669 // ClassRonfABITy - LLVM for struct _class_ro_t
670 const llvm::StructType *ClassRonfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000671
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000672 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
673 const llvm::Type *ImpnfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000674
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +0000675 // CategorynfABITy - LLVM for struct _category_t
676 const llvm::StructType *CategorynfABITy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000677
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +0000678 // New types for nonfragile abi messaging.
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000679
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +0000680 // MessageRefTy - LLVM for:
681 // struct _message_ref_t {
682 // IMP messenger;
683 // SEL name;
684 // };
685 const llvm::StructType *MessageRefTy;
Fariborz Jahanian83a8a752009-02-04 20:42:28 +0000686 // MessageRefCTy - clang type for struct _message_ref_t
687 QualType MessageRefCTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000688
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +0000689 // MessageRefPtrTy - LLVM for struct _message_ref_t*
690 const llvm::Type *MessageRefPtrTy;
Fariborz Jahanian83a8a752009-02-04 20:42:28 +0000691 // MessageRefCPtrTy - clang type for struct _message_ref_t*
692 QualType MessageRefCPtrTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000693
Fariborz Jahanianef163782009-02-05 01:13:09 +0000694 // MessengerTy - Type of the messenger (shown as IMP above)
695 const llvm::FunctionType *MessengerTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000696
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +0000697 // SuperMessageRefTy - LLVM for:
698 // struct _super_message_ref_t {
699 // SUPER_IMP messenger;
700 // SEL name;
701 // };
702 const llvm::StructType *SuperMessageRefTy;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000703
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +0000704 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
705 const llvm::Type *SuperMessageRefPtrTy;
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +0000706
Chris Lattner1c02f862009-04-22 02:53:24 +0000707 llvm::Constant *getMessageSendFixupFn() {
708 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
709 std::vector<const llvm::Type*> Params;
710 Params.push_back(ObjectPtrTy);
711 Params.push_back(MessageRefPtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000712 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner1c02f862009-04-22 02:53:24 +0000713 Params, true),
714 "objc_msgSend_fixup");
715 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000716
Chris Lattner1c02f862009-04-22 02:53:24 +0000717 llvm::Constant *getMessageSendFpretFixupFn() {
718 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
719 std::vector<const llvm::Type*> Params;
720 Params.push_back(ObjectPtrTy);
721 Params.push_back(MessageRefPtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000722 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner1c02f862009-04-22 02:53:24 +0000723 Params, true),
724 "objc_msgSend_fpret_fixup");
725 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000726
Chris Lattner1c02f862009-04-22 02:53:24 +0000727 llvm::Constant *getMessageSendStretFixupFn() {
728 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
729 std::vector<const llvm::Type*> Params;
730 Params.push_back(ObjectPtrTy);
731 Params.push_back(MessageRefPtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000732 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner1c02f862009-04-22 02:53:24 +0000733 Params, true),
734 "objc_msgSend_stret_fixup");
735 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000736
Chris Lattner1c02f862009-04-22 02:53:24 +0000737 llvm::Constant *getMessageSendSuper2FixupFn() {
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000738 // id objc_msgSendSuper2_fixup (struct objc_super *,
Chris Lattner1c02f862009-04-22 02:53:24 +0000739 // struct _super_message_ref_t*, ...)
740 std::vector<const llvm::Type*> Params;
741 Params.push_back(SuperPtrTy);
742 Params.push_back(SuperMessageRefPtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000743 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner1c02f862009-04-22 02:53:24 +0000744 Params, true),
745 "objc_msgSendSuper2_fixup");
746 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000747
Chris Lattner1c02f862009-04-22 02:53:24 +0000748 llvm::Constant *getMessageSendSuper2StretFixupFn() {
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000749 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
Chris Lattner1c02f862009-04-22 02:53:24 +0000750 // struct _super_message_ref_t*, ...)
751 std::vector<const llvm::Type*> Params;
752 Params.push_back(SuperPtrTy);
753 Params.push_back(SuperMessageRefPtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000754 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
Chris Lattner1c02f862009-04-22 02:53:24 +0000755 Params, true),
756 "objc_msgSendSuper2_stret_fixup");
757 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000758
Chris Lattner8a569112009-04-22 02:15:23 +0000759 llvm::Constant *getObjCEndCatchFn() {
Owen Anderson0032b272009-08-13 21:57:51 +0000760 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Chris Lattnerb59761b2009-07-01 04:13:52 +0000761 false),
Chris Lattner8a569112009-04-22 02:15:23 +0000762 "objc_end_catch");
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000763
Chris Lattner8a569112009-04-22 02:15:23 +0000764 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000765
Chris Lattner8a569112009-04-22 02:15:23 +0000766 llvm::Constant *getObjCBeginCatchFn() {
767 std::vector<const llvm::Type*> Params;
768 Params.push_back(Int8PtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000769 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
Chris Lattner8a569112009-04-22 02:15:23 +0000770 Params, false),
771 "objc_begin_catch");
772 }
Daniel Dunbare588b992009-03-01 04:46:24 +0000773
774 const llvm::StructType *EHTypeTy;
775 const llvm::Type *EHTypePtrTy;
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +0000776
Fariborz Jahanian30bc5712009-01-22 23:02:58 +0000777 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
778 ~ObjCNonFragileABITypesHelper(){}
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000779};
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000780
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000781class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +0000782public:
783 // FIXME - accessibility
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +0000784 class GC_IVAR {
Fariborz Jahanian820e0202009-03-11 00:07:04 +0000785 public:
Daniel Dunbar8b2926c2009-05-03 13:44:42 +0000786 unsigned ivar_bytepos;
787 unsigned ivar_size;
788 GC_IVAR(unsigned bytepos = 0, unsigned size = 0)
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000789 : ivar_bytepos(bytepos), ivar_size(size) {}
Daniel Dunbar0941b492009-04-23 01:29:05 +0000790
791 // Allow sorting based on byte pos.
792 bool operator<(const GC_IVAR &b) const {
793 return ivar_bytepos < b.ivar_bytepos;
794 }
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +0000795 };
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000796
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +0000797 class SKIP_SCAN {
Daniel Dunbar8b2926c2009-05-03 13:44:42 +0000798 public:
799 unsigned skip;
800 unsigned scan;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000801 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
Daniel Dunbar8b2926c2009-05-03 13:44:42 +0000802 : skip(_skip), scan(_scan) {}
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +0000803 };
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000804
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000805protected:
806 CodeGen::CodeGenModule &CGM;
Owen Anderson69243822009-07-13 04:10:07 +0000807 llvm::LLVMContext &VMContext;
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000808 // FIXME! May not be needing this after all.
Daniel Dunbarbbce49b2008-08-12 00:12:39 +0000809 unsigned ObjCABI;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000810
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +0000811 // gc ivar layout bitmap calculation helper caches.
812 llvm::SmallVector<GC_IVAR, 16> SkipIvars;
813 llvm::SmallVector<GC_IVAR, 16> IvarsInfo;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000814
Daniel Dunbar242d4dc2008-08-25 06:02:07 +0000815 /// LazySymbols - Symbols to generate a lazy reference for. See
816 /// DefinedSymbols and FinishModule().
Daniel Dunbar33063492009-09-07 00:20:42 +0000817 llvm::SetVector<IdentifierInfo*> LazySymbols;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000818
Daniel Dunbar242d4dc2008-08-25 06:02:07 +0000819 /// DefinedSymbols - External symbols which are defined by this
820 /// module. The symbols in this list and LazySymbols are used to add
821 /// special linker symbols which ensure that Objective-C modules are
822 /// linked properly.
Daniel Dunbar33063492009-09-07 00:20:42 +0000823 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000824
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +0000825 /// ClassNames - uniqued class names.
Daniel Dunbar6efc0c52008-08-13 03:21:16 +0000826 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassNames;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000827
Daniel Dunbar259d93d2008-08-12 03:39:23 +0000828 /// MethodVarNames - uniqued method variable names.
829 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000830
Fariborz Jahanianb9c5b3d2010-06-21 22:05:18 +0000831 /// DefinedCategoryNames - list of category names in form Class_Category.
832 llvm::SetVector<std::string> DefinedCategoryNames;
833
Daniel Dunbar6efc0c52008-08-13 03:21:16 +0000834 /// MethodVarTypes - uniqued method type signatures. We have to use
835 /// a StringMap here because have no other unique reference.
836 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000837
Daniel Dunbarc45ef602008-08-26 21:51:14 +0000838 /// MethodDefinitions - map of methods which have been defined in
839 /// this translation unit.
840 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000841
Daniel Dunbarc8ef5512008-08-23 00:19:03 +0000842 /// PropertyNames - uniqued method variable names.
843 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000844
Daniel Dunbar27f9d772008-08-21 04:36:09 +0000845 /// ClassReferences - uniqued class references.
846 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000847
Daniel Dunbar259d93d2008-08-12 03:39:23 +0000848 /// SelectorReferences - uniqued selector references.
849 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000850
Daniel Dunbar6efc0c52008-08-13 03:21:16 +0000851 /// Protocols - Protocols for which an objc_protocol structure has
852 /// been emitted. Forward declarations are handled by creating an
853 /// empty structure whose initializer is filled in when/if defined.
854 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000855
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +0000856 /// DefinedProtocols - Protocols which have actually been
857 /// defined. We should not need this, see FIXME in GenerateProtocol.
858 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000859
Daniel Dunbar27f9d772008-08-21 04:36:09 +0000860 /// DefinedClasses - List of defined classes.
861 std::vector<llvm::GlobalValue*> DefinedClasses;
Daniel Dunbar74d4b122009-05-15 22:33:15 +0000862
863 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
864 std::vector<llvm::GlobalValue*> DefinedNonLazyClasses;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000865
Daniel Dunbar27f9d772008-08-21 04:36:09 +0000866 /// DefinedCategories - List of defined categories.
867 std::vector<llvm::GlobalValue*> DefinedCategories;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000868
Daniel Dunbar74d4b122009-05-15 22:33:15 +0000869 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
870 std::vector<llvm::GlobalValue*> DefinedNonLazyCategories;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000871
Fariborz Jahanian56210f72009-01-21 23:34:32 +0000872 /// GetNameForMethod - Return a name for the given method.
873 /// \param[out] NameOut - The return value.
874 void GetNameForMethod(const ObjCMethodDecl *OMD,
875 const ObjCContainerDecl *CD,
Daniel Dunbarc575ce72009-10-19 01:21:19 +0000876 llvm::SmallVectorImpl<char> &NameOut);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000877
Fariborz Jahanian56210f72009-01-21 23:34:32 +0000878 /// GetMethodVarName - Return a unique constant for the given
879 /// selector's name. The return value has type char *.
880 llvm::Constant *GetMethodVarName(Selector Sel);
881 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000882
Fariborz Jahanian56210f72009-01-21 23:34:32 +0000883 /// GetMethodVarType - Return a unique constant for the given
884 /// selector's name. The return value has type char *.
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000885
Fariborz Jahanian56210f72009-01-21 23:34:32 +0000886 // FIXME: This is a horrible name.
887 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D);
Daniel Dunbar3e5f0d82009-04-20 06:54:31 +0000888 llvm::Constant *GetMethodVarType(const FieldDecl *D);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000889
Fariborz Jahanian56210f72009-01-21 23:34:32 +0000890 /// GetPropertyName - Return a unique constant for the given
891 /// name. The return value has type char *.
892 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000893
Fariborz Jahanian56210f72009-01-21 23:34:32 +0000894 // FIXME: This can be dropped once string functions are unified.
895 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
896 const Decl *Container);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000897
Fariborz Jahanian058a1b72009-01-24 20:21:50 +0000898 /// GetClassName - Return a unique constant for the given selector's
899 /// name. The return value has type char *.
900 llvm::Constant *GetClassName(IdentifierInfo *Ident);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000901
Argyrios Kyrtzidis9d50c062010-08-09 10:54:20 +0000902 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
903
Fariborz Jahaniand61a50a2009-03-05 22:39:55 +0000904 /// BuildIvarLayout - Builds ivar layout bitmap for the class
905 /// implementation for the __strong or __weak case.
906 ///
Fariborz Jahanianc8ce9c82009-03-12 22:50:49 +0000907 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
908 bool ForStrongLayout);
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +0000909
Fariborz Jahanianb8fd2eb2010-08-05 00:19:48 +0000910 llvm::Constant *BuildIvarLayoutBitmap(std::string &BitMap);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000911
Daniel Dunbard58edcb2009-05-03 14:10:34 +0000912 void BuildAggrIvarRecordLayout(const RecordType *RT,
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000913 unsigned int BytePos, bool ForStrongLayout,
914 bool &HasUnion);
Daniel Dunbar5a5a8032009-05-03 21:05:10 +0000915 void BuildAggrIvarLayout(const ObjCImplementationDecl *OI,
Fariborz Jahanianc8ce9c82009-03-12 22:50:49 +0000916 const llvm::StructLayout *Layout,
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +0000917 const RecordDecl *RD,
Chris Lattnerf1690852009-03-31 08:48:01 +0000918 const llvm::SmallVectorImpl<FieldDecl*> &RecFields,
Fariborz Jahaniand61a50a2009-03-05 22:39:55 +0000919 unsigned int BytePos, bool ForStrongLayout,
Fariborz Jahanian81adc052009-04-24 16:17:09 +0000920 bool &HasUnion);
Fariborz Jahanianc8ce9c82009-03-12 22:50:49 +0000921
Fariborz Jahaniand80d81b2009-03-05 19:17:31 +0000922 /// GetIvarLayoutName - Returns a unique constant for the given
923 /// ivar layout bitmap.
924 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
925 const ObjCCommonTypesHelper &ObjCTypes);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000926
Fariborz Jahanian5de14dc2009-01-28 22:18:42 +0000927 /// EmitPropertyList - Emit the given property list. The return
928 /// value has type PropertyListPtrTy.
Daniel Dunbar9c29bf52009-10-18 20:48:59 +0000929 llvm::Constant *EmitPropertyList(llvm::Twine Name,
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000930 const Decl *Container,
Fariborz Jahanian5de14dc2009-01-28 22:18:42 +0000931 const ObjCContainerDecl *OCD,
932 const ObjCCommonTypesHelper &ObjCTypes);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000933
Fariborz Jahanian191dcd72009-12-12 21:26:21 +0000934 /// PushProtocolProperties - Push protocol's property on the input stack.
935 void PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*, 16> &PropertySet,
936 std::vector<llvm::Constant*> &Properties,
937 const Decl *Container,
938 const ObjCProtocolDecl *PROTO,
939 const ObjCCommonTypesHelper &ObjCTypes);
940
Fariborz Jahanianda320092009-01-29 19:24:30 +0000941 /// GetProtocolRef - Return a reference to the internal protocol
942 /// description, creating an empty one if it has not been
943 /// defined. The return value has type ProtocolPtrTy.
944 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
Fariborz Jahanianb21f07e2009-03-08 20:18:37 +0000945
Daniel Dunbarfd65d372009-03-09 20:09:19 +0000946 /// CreateMetadataVar - Create a global variable with internal
947 /// linkage for use by the Objective-C runtime.
948 ///
949 /// This is a convenience wrapper which not only creates the
950 /// variable, but also sets the section and alignment and adds the
Chris Lattnerad64e022009-07-17 23:57:13 +0000951 /// global to the "llvm.used" list.
Daniel Dunbar35bd7632009-03-09 20:50:13 +0000952 ///
953 /// \param Name - The variable name.
954 /// \param Init - The variable initializer; this is also used to
955 /// define the type of the variable.
956 /// \param Section - The section the variable should go into, or 0.
957 /// \param Align - The alignment for the variable, or 0.
958 /// \param AddToUsed - Whether the variable should be added to
Daniel Dunbarc1583062009-04-14 17:42:51 +0000959 /// "llvm.used".
Daniel Dunbar9c29bf52009-10-18 20:48:59 +0000960 llvm::GlobalVariable *CreateMetadataVar(llvm::Twine Name,
Daniel Dunbarfd65d372009-03-09 20:09:19 +0000961 llvm::Constant *Init,
962 const char *Section,
Daniel Dunbar35bd7632009-03-09 20:50:13 +0000963 unsigned Align,
964 bool AddToUsed);
Daniel Dunbarfd65d372009-03-09 20:09:19 +0000965
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000966 CodeGen::RValue EmitLegacyMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +0000967 ReturnValueSlot Return,
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000968 QualType ResultType,
969 llvm::Value *Sel,
970 llvm::Value *Arg0,
971 QualType Arg0Ty,
972 bool IsSuper,
973 const CallArgList &CallArgs,
Daniel Dunbard6c93d72009-09-17 04:01:22 +0000974 const ObjCMethodDecl *OMD,
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +0000975 const ObjCCommonTypesHelper &ObjCTypes);
Daniel Dunbar3e5f0d82009-04-20 06:54:31 +0000976
Daniel Dunbarfce176b2010-04-25 20:39:01 +0000977 /// EmitImageInfo - Emit the image info marker used to encode some module
978 /// level information.
979 void EmitImageInfo();
980
Fariborz Jahanianee0af742009-01-21 22:04:16 +0000981public:
Owen Anderson69243822009-07-13 04:10:07 +0000982 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
Mike Stump1eb44332009-09-09 15:08:12 +0000983 CGM(cgm), VMContext(cgm.getLLVMContext()) { }
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000984
David Chisnall0d13f6f2010-01-23 02:40:42 +0000985 virtual llvm::Constant *GenerateConstantString(const StringLiteral *SL);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000986
Fariborz Jahanian493dab72009-01-26 21:38:32 +0000987 virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
988 const ObjCContainerDecl *CD=0);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000989
Fariborz Jahanianda320092009-01-29 19:24:30 +0000990 virtual void GenerateProtocol(const ObjCProtocolDecl *PD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000991
Fariborz Jahanianda320092009-01-29 19:24:30 +0000992 /// GetOrEmitProtocol - Get the protocol object for the given
993 /// declaration, emitting it if necessary. The return value has type
994 /// ProtocolPtrTy.
995 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
Daniel Dunbar6bff2512009-08-03 17:06:42 +0000996
Fariborz Jahanianda320092009-01-29 19:24:30 +0000997 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
998 /// object for the given declaration, emitting it if needed. These
999 /// forward references will be filled in with empty bodies if no
1000 /// definition is seen. The return value has type ProtocolPtrTy.
1001 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
Fariborz Jahanian89ecd412010-08-04 16:57:49 +00001002 virtual llvm::Constant *GCBlockLayout(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanianc5904b42010-09-11 01:27:29 +00001003 const llvm::SmallVectorImpl<const Expr *> &);
Fariborz Jahanian89ecd412010-08-04 16:57:49 +00001004
Fariborz Jahanianee0af742009-01-21 22:04:16 +00001005};
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001006
Fariborz Jahanianee0af742009-01-21 22:04:16 +00001007class CGObjCMac : public CGObjCCommonMac {
1008private:
1009 ObjCTypesHelper ObjCTypes;
Daniel Dunbarf77ac862008-08-11 21:35:06 +00001010
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00001011 /// EmitModuleInfo - Another marker encoding module level
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001012 /// information.
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00001013 void EmitModuleInfo();
1014
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001015 /// EmitModuleSymols - Emit module symbols, the list of defined
1016 /// classes and categories. The result has type SymtabPtrTy.
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00001017 llvm::Constant *EmitModuleSymbols();
1018
Daniel Dunbarf77ac862008-08-11 21:35:06 +00001019 /// FinishModule - Write out global data structures at the end of
1020 /// processing a translation unit.
1021 void FinishModule();
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001022
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001023 /// EmitClassExtension - Generate the class extension structure used
1024 /// to store the weak ivar layout and properties. The return value
1025 /// has type ClassExtensionPtrTy.
1026 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID);
1027
1028 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1029 /// for the given class.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001030 llvm::Value *EmitClassRef(CGBuilderTy &Builder,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001031 const ObjCInterfaceDecl *ID);
Fariborz Jahanianb0069ee2009-11-12 20:14:24 +00001032
1033 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1034 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001035
1036 /// EmitIvarList - Emit the ivar list for the given
1037 /// implementation. If ForClass is true the list of class ivars
1038 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1039 /// interface ivars will be emitted. The return value has type
1040 /// IvarListPtrTy.
1041 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
Fariborz Jahanian46b86c62009-01-28 19:12:34 +00001042 bool ForClass);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001043
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001044 /// EmitMetaClass - Emit a forward reference to the class structure
1045 /// for the metaclass of the given interface. The return value has
1046 /// type ClassPtrTy.
1047 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1048
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001049 /// EmitMetaClass - Emit a class structure for the metaclass of the
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001050 /// given implementation. The return value has type ClassPtrTy.
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001051 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1052 llvm::Constant *Protocols,
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001053 const ConstantVector &Methods);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001054
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001055 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001056
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001057 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001058
1059 /// EmitMethodList - Emit the method list for the given
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001060 /// implementation. The return value has type MethodListPtrTy.
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001061 llvm::Constant *EmitMethodList(llvm::Twine Name,
Daniel Dunbar86e253a2008-08-22 20:34:54 +00001062 const char *Section,
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001063 const ConstantVector &Methods);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001064
1065 /// EmitMethodDescList - Emit a method description list for a list of
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001066 /// method declarations.
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001067 /// - TypeName: The name for the type containing the methods.
1068 /// - IsProtocol: True iff these methods are for a protocol.
1069 /// - ClassMethds: True iff these are class methods.
1070 /// - Required: When true, only "required" methods are
1071 /// listed. Similarly, when false only "optional" methods are
1072 /// listed. For classes this should always be true.
1073 /// - begin, end: The method list to output.
1074 ///
1075 /// The return value has type MethodDescriptionListPtrTy.
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001076 llvm::Constant *EmitMethodDescList(llvm::Twine Name,
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001077 const char *Section,
1078 const ConstantVector &Methods);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001079
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001080 /// GetOrEmitProtocol - Get the protocol object for the given
1081 /// declaration, emitting it if necessary. The return value has type
1082 /// ProtocolPtrTy.
Fariborz Jahanianda320092009-01-29 19:24:30 +00001083 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001084
1085 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1086 /// object for the given declaration, emitting it if needed. These
1087 /// forward references will be filled in with empty bodies if no
1088 /// definition is seen. The return value has type ProtocolPtrTy.
Fariborz Jahanianda320092009-01-29 19:24:30 +00001089 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD);
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001090
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001091 /// EmitProtocolExtension - Generate the protocol extension
1092 /// structure used to store optional instance and class methods, and
1093 /// protocol properties. The return value has type
1094 /// ProtocolExtensionPtrTy.
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001095 llvm::Constant *
1096 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1097 const ConstantVector &OptInstanceMethods,
1098 const ConstantVector &OptClassMethods);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001099
1100 /// EmitProtocolList - Generate the list of referenced
1101 /// protocols. The return value has type ProtocolListPtrTy.
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001102 llvm::Constant *EmitProtocolList(llvm::Twine Name,
Daniel Dunbardbc933702008-08-21 21:57:41 +00001103 ObjCProtocolDecl::protocol_iterator begin,
1104 ObjCProtocolDecl::protocol_iterator end);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001105
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001106 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1107 /// for the given selector.
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001108 llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel,
1109 bool lval=false);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001110
1111public:
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001112 CGObjCMac(CodeGen::CodeGenModule &cgm);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001113
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001114 virtual llvm::Function *ModuleInitFunction();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001115
Daniel Dunbar8f2926b2008-08-23 03:46:30 +00001116 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00001117 ReturnValueSlot Return,
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +00001118 QualType ResultType,
1119 Selector Sel,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001120 llvm::Value *Receiver,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001121 const CallArgList &CallArgs,
David Chisnallc6cd5fd2010-04-28 19:33:36 +00001122 const ObjCInterfaceDecl *Class,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001123 const ObjCMethodDecl *Method);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001124
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001125 virtual CodeGen::RValue
Daniel Dunbar8f2926b2008-08-23 03:46:30 +00001126 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00001127 ReturnValueSlot Return,
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +00001128 QualType ResultType,
1129 Selector Sel,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001130 const ObjCInterfaceDecl *Class,
Fariborz Jahanian7ce77922009-02-28 20:07:56 +00001131 bool isCategoryImpl,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001132 llvm::Value *Receiver,
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00001133 bool IsClassMessage,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00001134 const CallArgList &CallArgs,
1135 const ObjCMethodDecl *Method);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001136
Daniel Dunbar45d196b2008-11-01 01:53:16 +00001137 virtual llvm::Value *GetClass(CGBuilderTy &Builder,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001138 const ObjCInterfaceDecl *ID);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001139
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001140 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
1141 bool lval = false);
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001142
1143 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1144 /// untyped one.
1145 virtual llvm::Value *GetSelector(CGBuilderTy &Builder,
1146 const ObjCMethodDecl *Method);
1147
John McCall5a180392010-07-24 00:37:23 +00001148 virtual llvm::Constant *GetEHType(QualType T);
1149
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001150 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001151
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00001152 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001153
Daniel Dunbar45d196b2008-11-01 01:53:16 +00001154 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001155 const ObjCProtocolDecl *PD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001156
Chris Lattner74391b42009-03-22 21:03:39 +00001157 virtual llvm::Constant *GetPropertyGetFunction();
1158 virtual llvm::Constant *GetPropertySetFunction();
Fariborz Jahanian6cc59062010-04-12 18:18:10 +00001159 virtual llvm::Constant *GetCopyStructFunction();
Chris Lattner74391b42009-03-22 21:03:39 +00001160 virtual llvm::Constant *EnumerationMutationFunction();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001161
John McCallf1549f62010-07-06 01:34:17 +00001162 virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1163 const ObjCAtTryStmt &S);
1164 virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1165 const ObjCAtSynchronizedStmt &S);
1166 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00001167 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
1168 const ObjCAtThrowStmt &S);
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00001169 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001170 llvm::Value *AddrWeakObj);
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00001171 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001172 llvm::Value *src, llvm::Value *dst);
Fariborz Jahanian58626502008-11-19 00:59:10 +00001173 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00001174 llvm::Value *src, llvm::Value *dest,
1175 bool threadlocal = false);
Fariborz Jahanian7eda8362008-11-20 19:23:36 +00001176 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001177 llvm::Value *src, llvm::Value *dest,
1178 llvm::Value *ivarOffset);
Fariborz Jahanian58626502008-11-19 00:59:10 +00001179 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1180 llvm::Value *src, llvm::Value *dest);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00001181 virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1182 llvm::Value *dest, llvm::Value *src,
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00001183 llvm::Value *size);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001184
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001185 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
1186 QualType ObjectTy,
1187 llvm::Value *BaseValue,
1188 const ObjCIvarDecl *Ivar,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001189 unsigned CVRQualifiers);
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00001190 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar2a031922009-04-22 05:08:15 +00001191 const ObjCInterfaceDecl *Interface,
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00001192 const ObjCIvarDecl *Ivar);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001193};
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001194
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00001195class CGObjCNonFragileABIMac : public CGObjCCommonMac {
Fariborz Jahanianee0af742009-01-21 22:04:16 +00001196private:
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00001197 ObjCNonFragileABITypesHelper ObjCTypes;
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001198 llvm::GlobalVariable* ObjCEmptyCacheVar;
1199 llvm::GlobalVariable* ObjCEmptyVtableVar;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001200
Daniel Dunbar11394522009-04-18 08:51:00 +00001201 /// SuperClassReferences - uniqued super class references.
1202 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001203
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00001204 /// MetaClassReferences - uniqued meta class references.
1205 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
Daniel Dunbare588b992009-03-01 04:46:24 +00001206
1207 /// EHTypeReferences - uniqued class ehtype references.
1208 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001209
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00001210 /// NonLegacyDispatchMethods - List of methods for which we do *not* generate
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001211 /// legacy messaging dispatch.
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00001212 llvm::DenseSet<Selector> NonLegacyDispatchMethods;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001213
Fariborz Jahaniana03d0dd2009-11-17 21:37:35 +00001214 /// DefinedMetaClasses - List of defined meta-classes.
1215 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1216
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001217 /// LegacyDispatchedSelector - Returns true if SEL is not in the list of
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00001218 /// NonLegacyDispatchMethods; false otherwise.
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001219 bool LegacyDispatchedSelector(Selector Sel);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001220
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001221 /// FinishNonFragileABIModule - Write out global data structures at the end of
1222 /// processing a translation unit.
1223 void FinishNonFragileABIModule();
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00001224
Daniel Dunbar463b8762009-05-15 21:48:48 +00001225 /// AddModuleClassList - Add the given list of class pointers to the
1226 /// module with the provided symbol and section names.
1227 void AddModuleClassList(const std::vector<llvm::GlobalValue*> &Container,
1228 const char *SymbolName,
1229 const char *SectionName);
1230
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001231 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1232 unsigned InstanceStart,
1233 unsigned InstanceSize,
1234 const ObjCImplementationDecl *ID);
Fariborz Jahanian84394a52009-01-24 21:21:53 +00001235 llvm::GlobalVariable * BuildClassMetaData(std::string &ClassName,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001236 llvm::Constant *IsAGV,
Fariborz Jahanian84394a52009-01-24 21:21:53 +00001237 llvm::Constant *SuperClassGV,
Fariborz Jahaniancf555162009-01-31 00:59:10 +00001238 llvm::Constant *ClassRoGV,
1239 bool HiddenVisibility);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001240
Fariborz Jahanian493dab72009-01-26 21:38:32 +00001241 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001242
Fariborz Jahanian3819a0b2009-01-30 00:46:37 +00001243 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001244
Fariborz Jahanian493dab72009-01-26 21:38:32 +00001245 /// EmitMethodList - Emit the method list for the given
1246 /// implementation. The return value has type MethodListnfABITy.
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001247 llvm::Constant *EmitMethodList(llvm::Twine Name,
Fariborz Jahanian493dab72009-01-26 21:38:32 +00001248 const char *Section,
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00001249 const ConstantVector &Methods);
1250 /// EmitIvarList - Emit the ivar list for the given
1251 /// implementation. If ForClass is true the list of class ivars
1252 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1253 /// interface ivars will be emitted. The return value has type
1254 /// IvarListnfABIPtrTy.
1255 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001256
Fariborz Jahanianed157d32009-02-10 20:21:06 +00001257 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
Fariborz Jahanian2fa5a272009-01-28 01:36:42 +00001258 const ObjCIvarDecl *Ivar,
Fariborz Jahanian1bf0afb2009-01-28 01:05:23 +00001259 unsigned long int offset);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001260
Fariborz Jahanianda320092009-01-29 19:24:30 +00001261 /// GetOrEmitProtocol - Get the protocol object for the given
1262 /// declaration, emitting it if necessary. The return value has type
1263 /// ProtocolPtrTy.
1264 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001265
Fariborz Jahanianda320092009-01-29 19:24:30 +00001266 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1267 /// object for the given declaration, emitting it if needed. These
1268 /// forward references will be filled in with empty bodies if no
1269 /// definition is seen. The return value has type ProtocolPtrTy.
1270 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001271
Fariborz Jahanianda320092009-01-29 19:24:30 +00001272 /// EmitProtocolList - Generate the list of referenced
1273 /// protocols. The return value has type ProtocolListPtrTy.
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001274 llvm::Constant *EmitProtocolList(llvm::Twine Name,
Fariborz Jahanianda320092009-01-29 19:24:30 +00001275 ObjCProtocolDecl::protocol_iterator begin,
Fariborz Jahanian46551122009-02-04 00:22:57 +00001276 ObjCProtocolDecl::protocol_iterator end);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001277
Fariborz Jahanian46551122009-02-04 00:22:57 +00001278 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00001279 ReturnValueSlot Return,
Fariborz Jahanian46551122009-02-04 00:22:57 +00001280 QualType ResultType,
1281 Selector Sel,
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00001282 llvm::Value *Receiver,
Fariborz Jahanian46551122009-02-04 00:22:57 +00001283 QualType Arg0Ty,
1284 bool IsSuper,
1285 const CallArgList &CallArgs);
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00001286
1287 /// GetClassGlobal - Return the global variable for the Objective-C
1288 /// class of the given name.
Fariborz Jahanian0f902942009-04-14 18:41:56 +00001289 llvm::GlobalVariable *GetClassGlobal(const std::string &Name);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001290
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00001291 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
Daniel Dunbar11394522009-04-18 08:51:00 +00001292 /// for the given class reference.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001293 llvm::Value *EmitClassRef(CGBuilderTy &Builder,
Daniel Dunbar11394522009-04-18 08:51:00 +00001294 const ObjCInterfaceDecl *ID);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001295
Daniel Dunbar11394522009-04-18 08:51:00 +00001296 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1297 /// for the given super class reference.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001298 llvm::Value *EmitSuperClassRef(CGBuilderTy &Builder,
1299 const ObjCInterfaceDecl *ID);
1300
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00001301 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1302 /// meta-data
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001303 llvm::Value *EmitMetaClassRef(CGBuilderTy &Builder,
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00001304 const ObjCInterfaceDecl *ID);
1305
Fariborz Jahanianed157d32009-02-10 20:21:06 +00001306 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1307 /// the given ivar.
1308 ///
Daniel Dunbar5e88bea2009-04-19 00:31:15 +00001309 llvm::GlobalVariable * ObjCIvarOffsetVariable(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001310 const ObjCInterfaceDecl *ID,
1311 const ObjCIvarDecl *Ivar);
1312
Fariborz Jahanian26cc89f2009-02-11 20:51:17 +00001313 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1314 /// for the given selector.
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001315 llvm::Value *EmitSelector(CGBuilderTy &Builder, Selector Sel,
1316 bool lval=false);
Daniel Dunbare588b992009-03-01 04:46:24 +00001317
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00001318 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
Daniel Dunbare588b992009-03-01 04:46:24 +00001319 /// interface. The return value has type EHTypePtrTy.
John McCall5a180392010-07-24 00:37:23 +00001320 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00001321 bool ForDefinition);
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00001322
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001323 const char *getMetaclassSymbolPrefix() const {
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00001324 return "OBJC_METACLASS_$_";
1325 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001326
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00001327 const char *getClassSymbolPrefix() const {
1328 return "OBJC_CLASS_$_";
1329 }
1330
Daniel Dunbar9f89f2b2009-05-03 12:57:56 +00001331 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
Daniel Dunbarb02532a2009-04-19 23:41:48 +00001332 uint32_t &InstanceStart,
1333 uint32_t &InstanceSize);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001334
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00001335 // Shamelessly stolen from Analysis/CFRefCount.cpp
Daniel Dunbar74d4b122009-05-15 22:33:15 +00001336 Selector GetNullarySelector(const char* name) const {
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00001337 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1338 return CGM.getContext().Selectors.getSelector(0, &II);
1339 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001340
Daniel Dunbar74d4b122009-05-15 22:33:15 +00001341 Selector GetUnarySelector(const char* name) const {
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00001342 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1343 return CGM.getContext().Selectors.getSelector(1, &II);
1344 }
Daniel Dunbarb02532a2009-04-19 23:41:48 +00001345
Daniel Dunbar74d4b122009-05-15 22:33:15 +00001346 /// ImplementationIsNonLazy - Check whether the given category or
1347 /// class implementation is "non-lazy".
Fariborz Jahanianecfbdcb2009-05-21 01:03:45 +00001348 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
Daniel Dunbar74d4b122009-05-15 22:33:15 +00001349
Fariborz Jahanianee0af742009-01-21 22:04:16 +00001350public:
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00001351 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001352 // FIXME. All stubs for now!
1353 virtual llvm::Function *ModuleInitFunction();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001354
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001355 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00001356 ReturnValueSlot Return,
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001357 QualType ResultType,
1358 Selector Sel,
1359 llvm::Value *Receiver,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001360 const CallArgList &CallArgs,
David Chisnallc6cd5fd2010-04-28 19:33:36 +00001361 const ObjCInterfaceDecl *Class,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001362 const ObjCMethodDecl *Method);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001363
1364 virtual CodeGen::RValue
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001365 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00001366 ReturnValueSlot Return,
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001367 QualType ResultType,
1368 Selector Sel,
1369 const ObjCInterfaceDecl *Class,
Fariborz Jahanian7ce77922009-02-28 20:07:56 +00001370 bool isCategoryImpl,
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001371 llvm::Value *Receiver,
1372 bool IsClassMessage,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00001373 const CallArgList &CallArgs,
1374 const ObjCMethodDecl *Method);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001375
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001376 virtual llvm::Value *GetClass(CGBuilderTy &Builder,
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00001377 const ObjCInterfaceDecl *ID);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001378
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001379 virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
1380 bool lvalue = false)
1381 { return EmitSelector(Builder, Sel, lvalue); }
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001382
1383 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1384 /// untyped one.
1385 virtual llvm::Value *GetSelector(CGBuilderTy &Builder,
1386 const ObjCMethodDecl *Method)
1387 { return EmitSelector(Builder, Method->getSelector()); }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001388
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00001389 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001390
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001391 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001392 virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
Fariborz Jahanian8cfd3972009-01-30 18:58:59 +00001393 const ObjCProtocolDecl *PD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001394
John McCall5a180392010-07-24 00:37:23 +00001395 virtual llvm::Constant *GetEHType(QualType T);
1396
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001397 virtual llvm::Constant *GetPropertyGetFunction() {
Chris Lattner72db6c32009-04-22 02:44:54 +00001398 return ObjCTypes.getGetPropertyFn();
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00001399 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001400 virtual llvm::Constant *GetPropertySetFunction() {
1401 return ObjCTypes.getSetPropertyFn();
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00001402 }
Fariborz Jahanian6cc59062010-04-12 18:18:10 +00001403
1404 virtual llvm::Constant *GetCopyStructFunction() {
1405 return ObjCTypes.getCopyStructFn();
1406 }
1407
Chris Lattner74391b42009-03-22 21:03:39 +00001408 virtual llvm::Constant *EnumerationMutationFunction() {
Chris Lattner72db6c32009-04-22 02:44:54 +00001409 return ObjCTypes.getEnumerationMutationFn();
Daniel Dunbar28ed0842009-02-16 18:48:45 +00001410 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001411
John McCallf1549f62010-07-06 01:34:17 +00001412 virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1413 const ObjCAtTryStmt &S);
1414 virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1415 const ObjCAtSynchronizedStmt &S);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001416 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
Anders Carlssonf57c5b22009-02-16 22:59:18 +00001417 const ObjCAtThrowStmt &S);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001418 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00001419 llvm::Value *AddrWeakObj);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001420 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00001421 llvm::Value *src, llvm::Value *dst);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001422 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00001423 llvm::Value *src, llvm::Value *dest,
1424 bool threadlocal = false);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001425 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001426 llvm::Value *src, llvm::Value *dest,
1427 llvm::Value *ivarOffset);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001428 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00001429 llvm::Value *src, llvm::Value *dest);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00001430 virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1431 llvm::Value *dest, llvm::Value *src,
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00001432 llvm::Value *size);
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001433 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
1434 QualType ObjectTy,
1435 llvm::Value *BaseValue,
1436 const ObjCIvarDecl *Ivar,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001437 unsigned CVRQualifiers);
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00001438 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar2a031922009-04-22 05:08:15 +00001439 const ObjCInterfaceDecl *Interface,
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00001440 const ObjCIvarDecl *Ivar);
Fariborz Jahanianee0af742009-01-21 22:04:16 +00001441};
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001442
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001443} // end anonymous namespace
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00001444
1445/* *** Helper Functions *** */
1446
1447/// getConstantGEP() - Help routine to construct simple GEPs.
Owen Andersona1cf15f2009-07-14 23:10:40 +00001448static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001449 llvm::Constant *C,
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00001450 unsigned idx0,
1451 unsigned idx1) {
1452 llvm::Value *Idxs[] = {
Owen Anderson0032b272009-08-13 21:57:51 +00001453 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1454 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00001455 };
Owen Anderson3c4972d2009-07-29 18:54:39 +00001456 return llvm::ConstantExpr::getGetElementPtr(C, Idxs, 2);
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00001457}
1458
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00001459/// hasObjCExceptionAttribute - Return true if this class or any super
1460/// class has the __objc_exception__ attribute.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001461static bool hasObjCExceptionAttribute(ASTContext &Context,
Douglas Gregor68584ed2009-06-18 16:11:24 +00001462 const ObjCInterfaceDecl *OID) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001463 if (OID->hasAttr<ObjCExceptionAttr>())
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00001464 return true;
1465 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
Douglas Gregor68584ed2009-06-18 16:11:24 +00001466 return hasObjCExceptionAttribute(Context, Super);
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00001467 return false;
1468}
1469
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00001470/* *** CGObjCMac Public Interface *** */
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001471
Fariborz Jahanianee0af742009-01-21 22:04:16 +00001472CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
Mike Stump1eb44332009-09-09 15:08:12 +00001473 ObjCTypes(cgm) {
Fariborz Jahanianee0af742009-01-21 22:04:16 +00001474 ObjCABI = 1;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001475 EmitImageInfo();
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001476}
1477
Daniel Dunbarddb2a3d2008-08-16 00:25:02 +00001478/// GetClass - Return a reference to the class for the given interface
1479/// decl.
Daniel Dunbar45d196b2008-11-01 01:53:16 +00001480llvm::Value *CGObjCMac::GetClass(CGBuilderTy &Builder,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001481 const ObjCInterfaceDecl *ID) {
1482 return EmitClassRef(Builder, ID);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001483}
1484
1485/// GetSelector - Return the pointer to the unique'd string for this selector.
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001486llvm::Value *CGObjCMac::GetSelector(CGBuilderTy &Builder, Selector Sel,
1487 bool lval) {
1488 return EmitSelector(Builder, Sel, lval);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001489}
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001490llvm::Value *CGObjCMac::GetSelector(CGBuilderTy &Builder, const ObjCMethodDecl
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001491 *Method) {
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001492 return EmitSelector(Builder, Method->getSelector());
1493}
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001494
John McCall5a180392010-07-24 00:37:23 +00001495llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1496 llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1497 return 0;
1498}
1499
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00001500/// Generate a constant CFString object.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001501/*
1502 struct __builtin_CFString {
1503 const int *isa; // point to __CFConstantStringClassReference
1504 int flags;
1505 const char *str;
1506 long length;
1507 };
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00001508*/
1509
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00001510/// or Generate a constant NSString object.
1511/*
1512 struct __builtin_NSString {
1513 const int *isa; // point to __NSConstantStringClassReference
1514 const char *str;
1515 unsigned int length;
1516 };
1517*/
1518
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00001519llvm::Constant *CGObjCCommonMac::GenerateConstantString(
David Chisnall0d13f6f2010-01-23 02:40:42 +00001520 const StringLiteral *SL) {
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00001521 return (CGM.getLangOptions().NoConstantCFStrings == 0 ?
1522 CGM.GetAddrOfConstantCFString(SL) :
1523 CGM.GetAddrOfConstantNSString(SL));
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001524}
1525
1526/// Generates a message send where the super is the receiver. This is
1527/// a message send to self with special delivery semantics indicating
1528/// which class's method should be called.
Daniel Dunbar8f2926b2008-08-23 03:46:30 +00001529CodeGen::RValue
1530CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00001531 ReturnValueSlot Return,
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +00001532 QualType ResultType,
1533 Selector Sel,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001534 const ObjCInterfaceDecl *Class,
Fariborz Jahanian7ce77922009-02-28 20:07:56 +00001535 bool isCategoryImpl,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001536 llvm::Value *Receiver,
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00001537 bool IsClassMessage,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00001538 const CodeGen::CallArgList &CallArgs,
1539 const ObjCMethodDecl *Method) {
Daniel Dunbare8b470d2008-08-23 04:28:29 +00001540 // Create and init a super structure; this is a (receiver, class)
1541 // pair we will pass to objc_msgSendSuper.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001542 llvm::Value *ObjCSuper =
Daniel Dunbare8b470d2008-08-23 04:28:29 +00001543 CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001544 llvm::Value *ReceiverAsObject =
Daniel Dunbare8b470d2008-08-23 04:28:29 +00001545 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001546 CGF.Builder.CreateStore(ReceiverAsObject,
Daniel Dunbare8b470d2008-08-23 04:28:29 +00001547 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
Daniel Dunbare8b470d2008-08-23 04:28:29 +00001548
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001549 // If this is a class message the metaclass is passed as the target.
1550 llvm::Value *Target;
1551 if (IsClassMessage) {
Fariborz Jahanian7ce77922009-02-28 20:07:56 +00001552 if (isCategoryImpl) {
1553 // Message sent to 'super' in a class method defined in a category
1554 // implementation requires an odd treatment.
1555 // If we are in a class method, we must retrieve the
1556 // _metaclass_ for the current class, pointed at by
1557 // the class's "isa" pointer. The following assumes that
1558 // isa" is the first ivar in a class (which it must be).
1559 Target = EmitClassRef(CGF.Builder, Class->getSuperClass());
1560 Target = CGF.Builder.CreateStructGEP(Target, 0);
1561 Target = CGF.Builder.CreateLoad(Target);
Mike Stumpb3589f42009-07-30 22:28:39 +00001562 } else {
Fariborz Jahanian7ce77922009-02-28 20:07:56 +00001563 llvm::Value *MetaClassPtr = EmitMetaClassRef(Class);
1564 llvm::Value *SuperPtr = CGF.Builder.CreateStructGEP(MetaClassPtr, 1);
1565 llvm::Value *Super = CGF.Builder.CreateLoad(SuperPtr);
1566 Target = Super;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001567 }
Fariborz Jahanian182f2682009-11-14 02:18:31 +00001568 }
1569 else if (isCategoryImpl)
1570 Target = EmitClassRef(CGF.Builder, Class->getSuperClass());
1571 else {
Fariborz Jahanianb0069ee2009-11-12 20:14:24 +00001572 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
1573 ClassPtr = CGF.Builder.CreateStructGEP(ClassPtr, 1);
1574 Target = CGF.Builder.CreateLoad(ClassPtr);
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001575 }
Mike Stumpf5408fe2009-05-16 07:57:57 +00001576 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
1577 // ObjCTypes types.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001578 const llvm::Type *ClassTy =
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00001579 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001580 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001581 CGF.Builder.CreateStore(Target,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001582 CGF.Builder.CreateStructGEP(ObjCSuper, 1));
John McCallef072fd2010-05-22 01:48:05 +00001583 return EmitLegacyMessageSend(CGF, Return, ResultType,
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001584 EmitSelector(CGF.Builder, Sel),
1585 ObjCSuper, ObjCTypes.SuperPtrCTy,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00001586 true, CallArgs, Method, ObjCTypes);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001587}
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001588
1589/// Generate code for a message send expression.
Daniel Dunbar8f2926b2008-08-23 03:46:30 +00001590CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00001591 ReturnValueSlot Return,
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +00001592 QualType ResultType,
1593 Selector Sel,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00001594 llvm::Value *Receiver,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001595 const CallArgList &CallArgs,
David Chisnallc6cd5fd2010-04-28 19:33:36 +00001596 const ObjCInterfaceDecl *Class,
Fariborz Jahaniandf9ccc62009-05-05 21:36:57 +00001597 const ObjCMethodDecl *Method) {
John McCallef072fd2010-05-22 01:48:05 +00001598 return EmitLegacyMessageSend(CGF, Return, ResultType,
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001599 EmitSelector(CGF.Builder, Sel),
1600 Receiver, CGF.getContext().getObjCIdType(),
Daniel Dunbard6c93d72009-09-17 04:01:22 +00001601 false, CallArgs, Method, ObjCTypes);
Daniel Dunbar14c80b72008-08-23 09:25:55 +00001602}
1603
Daniel Dunbard6c93d72009-09-17 04:01:22 +00001604CodeGen::RValue
1605CGObjCCommonMac::EmitLegacyMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00001606 ReturnValueSlot Return,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00001607 QualType ResultType,
1608 llvm::Value *Sel,
1609 llvm::Value *Arg0,
1610 QualType Arg0Ty,
1611 bool IsSuper,
1612 const CallArgList &CallArgs,
1613 const ObjCMethodDecl *Method,
1614 const ObjCCommonTypesHelper &ObjCTypes) {
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00001615 CallArgList ActualArgs;
Fariborz Jahaniand019d962009-04-24 21:07:43 +00001616 if (!IsSuper)
1617 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy, "tmp");
Daniel Dunbar46f45b92008-09-09 01:06:48 +00001618 ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty));
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001619 ActualArgs.push_back(std::make_pair(RValue::get(Sel),
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00001620 CGF.getContext().getObjCSelType()));
1621 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001622
Daniel Dunbar541b63b2009-02-02 23:23:47 +00001623 CodeGenTypes &Types = CGM.getTypes();
John McCall04a67a62010-02-05 21:31:56 +00001624 const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs,
Rafael Espindola264ba482010-03-30 20:24:48 +00001625 FunctionType::ExtInfo());
Daniel Dunbar67939662009-09-17 04:01:40 +00001626 const llvm::FunctionType *FTy =
1627 Types.GetFunctionType(FnInfo, Method ? Method->isVariadic() : false);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001628
Anders Carlsson7e70fb22010-06-21 20:59:55 +00001629 if (Method)
1630 assert(CGM.getContext().getCanonicalType(Method->getResultType()) ==
1631 CGM.getContext().getCanonicalType(ResultType) &&
1632 "Result type mismatch!");
1633
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001634 llvm::Constant *Fn = NULL;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001635 if (CGM.ReturnTypeUsesSRet(FnInfo)) {
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001636 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001637 : ObjCTypes.getSendStretFn(IsSuper);
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001638 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
1639 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
1640 : ObjCTypes.getSendFpretFn(IsSuper);
Daniel Dunbar5669e572008-10-17 03:24:53 +00001641 } else {
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00001642 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001643 : ObjCTypes.getSendFn(IsSuper);
Daniel Dunbar5669e572008-10-17 03:24:53 +00001644 }
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001645 Fn = llvm::ConstantExpr::getBitCast(Fn, llvm::PointerType::getUnqual(FTy));
John McCallef072fd2010-05-22 01:48:05 +00001646 return CGF.EmitCall(FnInfo, Fn, Return, ActualArgs);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001647}
1648
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00001649static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT) {
1650 if (FQT.isObjCGCStrong())
1651 return Qualifiers::Strong;
1652
1653 if (FQT.isObjCGCWeak())
1654 return Qualifiers::Weak;
1655
1656 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
1657 return Qualifiers::Strong;
1658
1659 if (const PointerType *PT = FQT->getAs<PointerType>())
1660 return GetGCAttrTypeForType(Ctx, PT->getPointeeType());
1661
1662 return Qualifiers::GCNone;
1663}
1664
Fariborz Jahanian89ecd412010-08-04 16:57:49 +00001665llvm::Constant *CGObjCCommonMac::GCBlockLayout(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanianc5904b42010-09-11 01:27:29 +00001666 const llvm::SmallVectorImpl<const Expr *> &BlockLayout) {
Fariborz Jahanian44034db2010-08-04 18:44:59 +00001667 llvm::Constant *NullPtr =
1668 llvm::Constant::getNullValue(llvm::Type::getInt8PtrTy(VMContext));
Fariborz Jahanianfb550312010-09-13 16:09:44 +00001669 if (CGM.getLangOptions().getGCMode() == LangOptions::NonGC)
Fariborz Jahanian44034db2010-08-04 18:44:59 +00001670 return NullPtr;
Fariborz Jahaniana1f024c2010-08-06 16:28:55 +00001671 bool hasUnion = false;
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00001672 SkipIvars.clear();
1673 IvarsInfo.clear();
1674 unsigned WordSizeInBits = CGM.getContext().Target.getPointerWidth(0);
1675 unsigned ByteSizeInBits = CGM.getContext().Target.getCharWidth();
1676
Fariborz Jahanian81979822010-09-09 00:21:45 +00001677 // __isa is the first field in block descriptor and must assume by runtime's
1678 // convention that it is GC'able.
1679 IvarsInfo.push_back(GC_IVAR(0, 1));
Fariborz Jahanianc5904b42010-09-11 01:27:29 +00001680 for (size_t i = 0; i < BlockLayout.size(); ++i) {
1681 const Expr *E = BlockLayout[i];
1682 const BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(E);
1683 if (!BDRE)
1684 continue;
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00001685 const ValueDecl *VD = BDRE->getDecl();
1686 CharUnits Offset = CGF.BlockDecls[VD];
1687 uint64_t FieldOffset = Offset.getQuantity();
1688 QualType Ty = VD->getType();
1689 assert(!Ty->isArrayType() &&
1690 "Array block variable should have been caught");
Fariborz Jahaniana1f024c2010-08-06 16:28:55 +00001691 if ((Ty->isRecordType() || Ty->isUnionType()) && !BDRE->isByRef()) {
Fariborz Jahaniane1a48982010-08-05 21:00:25 +00001692 BuildAggrIvarRecordLayout(Ty->getAs<RecordType>(),
1693 FieldOffset,
1694 true,
Fariborz Jahaniana1f024c2010-08-06 16:28:55 +00001695 hasUnion);
Fariborz Jahaniane1a48982010-08-05 21:00:25 +00001696 continue;
1697 }
Fariborz Jahaniana1f024c2010-08-06 16:28:55 +00001698
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00001699 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), Ty);
1700 unsigned FieldSize = CGM.getContext().getTypeSize(Ty);
1701 // __block variables are passed by their descriptior address. So, size
1702 // must reflect this.
1703 if (BDRE->isByRef())
1704 FieldSize = WordSizeInBits;
1705 if (GCAttr == Qualifiers::Strong || BDRE->isByRef())
1706 IvarsInfo.push_back(GC_IVAR(FieldOffset,
1707 FieldSize / WordSizeInBits));
1708 else if (GCAttr == Qualifiers::GCNone || GCAttr == Qualifiers::Weak)
1709 SkipIvars.push_back(GC_IVAR(FieldOffset,
1710 FieldSize / ByteSizeInBits));
1711 }
1712
1713 if (IvarsInfo.empty())
1714 return NullPtr;
Fariborz Jahaniana1f024c2010-08-06 16:28:55 +00001715 // Sort on byte position in case we encounterred a union nested in
1716 // block variable type's aggregate type.
1717 if (hasUnion && !IvarsInfo.empty())
1718 std::sort(IvarsInfo.begin(), IvarsInfo.end());
1719 if (hasUnion && !SkipIvars.empty())
1720 std::sort(SkipIvars.begin(), SkipIvars.end());
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00001721
1722 std::string BitMap;
Fariborz Jahanianb8fd2eb2010-08-05 00:19:48 +00001723 llvm::Constant *C = BuildIvarLayoutBitmap(BitMap);
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00001724 if (CGM.getLangOptions().ObjCGCBitmapPrint) {
1725 printf("\n block variable layout for block: ");
1726 const unsigned char *s = (unsigned char*)BitMap.c_str();
1727 for (unsigned i = 0; i < BitMap.size(); i++)
1728 if (!(s[i] & 0xf0))
1729 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
1730 else
1731 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
1732 printf("\n");
1733 }
1734
1735 return C;
Fariborz Jahanian89ecd412010-08-04 16:57:49 +00001736}
1737
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001738llvm::Value *CGObjCMac::GenerateProtocolRef(CGBuilderTy &Builder,
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +00001739 const ObjCProtocolDecl *PD) {
Daniel Dunbarc67876d2008-09-04 04:33:15 +00001740 // FIXME: I don't understand why gcc generates this, or where it is
Mike Stumpf5408fe2009-05-16 07:57:57 +00001741 // resolved. Investigate. Its also wasteful to look this up over and over.
Daniel Dunbarc67876d2008-09-04 04:33:15 +00001742 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
1743
Owen Anderson3c4972d2009-07-29 18:54:39 +00001744 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001745 ObjCTypes.ExternalProtocolPtrTy);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00001746}
1747
Fariborz Jahanianda320092009-01-29 19:24:30 +00001748void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00001749 // FIXME: We shouldn't need this, the protocol decl should contain enough
1750 // information to tell us whether this was a declaration or a definition.
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001751 DefinedProtocols.insert(PD->getIdentifier());
1752
1753 // If we have generated a forward reference to this protocol, emit
1754 // it now. Otherwise do nothing, the protocol objects are lazily
1755 // emitted.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001756 if (Protocols.count(PD->getIdentifier()))
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001757 GetOrEmitProtocol(PD);
1758}
1759
Fariborz Jahanianda320092009-01-29 19:24:30 +00001760llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001761 if (DefinedProtocols.count(PD->getIdentifier()))
1762 return GetOrEmitProtocol(PD);
1763 return GetOrEmitProtocolRef(PD);
1764}
1765
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001766/*
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001767// APPLE LOCAL radar 4585769 - Objective-C 1.0 extensions
1768struct _objc_protocol {
1769struct _objc_protocol_extension *isa;
1770char *protocol_name;
1771struct _objc_protocol_list *protocol_list;
1772struct _objc__method_prototype_list *instance_methods;
1773struct _objc__method_prototype_list *class_methods
1774};
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001775
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001776See EmitProtocolExtension().
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001777*/
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001778llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
1779 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
1780
1781 // Early exit if a defining object has already been generated.
1782 if (Entry && Entry->hasInitializer())
1783 return Entry;
1784
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00001785 // FIXME: I don't understand why gcc generates this, or where it is
Mike Stumpf5408fe2009-05-16 07:57:57 +00001786 // resolved. Investigate. Its also wasteful to look this up over and over.
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00001787 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
1788
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001789 // Construct method lists.
1790 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
1791 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001792 for (ObjCProtocolDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001793 i = PD->instmeth_begin(), e = PD->instmeth_end(); i != e; ++i) {
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001794 ObjCMethodDecl *MD = *i;
1795 llvm::Constant *C = GetMethodDescriptionConstant(MD);
1796 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
1797 OptInstanceMethods.push_back(C);
1798 } else {
1799 InstanceMethods.push_back(C);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001800 }
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001801 }
1802
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001803 for (ObjCProtocolDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001804 i = PD->classmeth_begin(), e = PD->classmeth_end(); i != e; ++i) {
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001805 ObjCMethodDecl *MD = *i;
1806 llvm::Constant *C = GetMethodDescriptionConstant(MD);
1807 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
1808 OptClassMethods.push_back(C);
1809 } else {
1810 ClassMethods.push_back(C);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001811 }
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001812 }
1813
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001814 std::vector<llvm::Constant*> Values(5);
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001815 Values[0] = EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001816 Values[1] = GetClassName(PD->getIdentifier());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001817 Values[2] =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001818 EmitProtocolList("\01L_OBJC_PROTOCOL_REFS_" + PD->getName(),
Daniel Dunbardbc933702008-08-21 21:57:41 +00001819 PD->protocol_begin(),
1820 PD->protocol_end());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001821 Values[3] =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001822 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_" + PD->getName(),
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001823 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
1824 InstanceMethods);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001825 Values[4] =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001826 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_" + PD->getName(),
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001827 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
1828 ClassMethods);
Owen Anderson08e25242009-07-27 22:29:56 +00001829 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001830 Values);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001831
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001832 if (Entry) {
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001833 // Already created, fix the linkage and update the initializer.
1834 Entry->setLinkage(llvm::GlobalValue::InternalLinkage);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001835 Entry->setInitializer(Init);
1836 } else {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001837 Entry =
Owen Anderson1c431b32009-07-08 19:05:04 +00001838 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, false,
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001839 llvm::GlobalValue::InternalLinkage,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001840 Init,
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001841 "\01L_OBJC_PROTOCOL_" + PD->getName());
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001842 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001843 // FIXME: Is this necessary? Why only for protocol?
1844 Entry->setAlignment(4);
1845 }
Chris Lattnerad64e022009-07-17 23:57:13 +00001846 CGM.AddUsedGlobal(Entry);
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001847
1848 return Entry;
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001849}
1850
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001851llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001852 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
1853
1854 if (!Entry) {
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001855 // We use the initializer as a marker of whether this is a forward
1856 // reference or not. At module finalization we add the empty
1857 // contents for protocols which were referenced but never defined.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001858 Entry =
Owen Anderson1c431b32009-07-08 19:05:04 +00001859 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, false,
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00001860 llvm::GlobalValue::ExternalLinkage,
1861 0,
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001862 "\01L_OBJC_PROTOCOL_" + PD->getName());
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001863 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001864 // FIXME: Is this necessary? Why only for protocol?
1865 Entry->setAlignment(4);
1866 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001867
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001868 return Entry;
1869}
1870
1871/*
1872 struct _objc_protocol_extension {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001873 uint32_t size;
1874 struct objc_method_description_list *optional_instance_methods;
1875 struct objc_method_description_list *optional_class_methods;
1876 struct objc_property_list *instance_properties;
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001877 };
1878*/
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001879llvm::Constant *
1880CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
1881 const ConstantVector &OptInstanceMethods,
1882 const ConstantVector &OptClassMethods) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001883 uint64_t Size =
Duncan Sands9408c452009-05-09 07:08:47 +00001884 CGM.getTargetData().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001885 std::vector<llvm::Constant*> Values(4);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001886 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001887 Values[1] =
1888 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_OPT_"
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001889 + PD->getName(),
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001890 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
1891 OptInstanceMethods);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001892 Values[2] =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001893 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_OPT_" + PD->getName(),
Daniel Dunbarae226fa2008-08-27 02:31:56 +00001894 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
1895 OptClassMethods);
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001896 Values[3] = EmitPropertyList("\01L_OBJC_$_PROP_PROTO_LIST_" + PD->getName(),
Fariborz Jahanian5de14dc2009-01-28 22:18:42 +00001897 0, PD, ObjCTypes);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001898
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001899 // Return null if no extension bits are used.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001900 if (Values[1]->isNullValue() && Values[2]->isNullValue() &&
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001901 Values[3]->isNullValue())
Owen Andersonc9c88b42009-07-31 20:28:54 +00001902 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001903
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001904 llvm::Constant *Init =
Owen Anderson08e25242009-07-27 22:29:56 +00001905 llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001906
Daniel Dunbar63c5b502009-03-09 21:49:58 +00001907 // No special section, but goes in llvm.used
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001908 return CreateMetadataVar("\01L_OBJC_PROTOCOLEXT_" + PD->getName(),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001909 Init,
Daniel Dunbar63c5b502009-03-09 21:49:58 +00001910 0, 0, true);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001911}
1912
1913/*
1914 struct objc_protocol_list {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001915 struct objc_protocol_list *next;
1916 long count;
1917 Protocol *list[];
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001918 };
1919*/
Daniel Dunbardbc933702008-08-21 21:57:41 +00001920llvm::Constant *
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001921CGObjCMac::EmitProtocolList(llvm::Twine Name,
Daniel Dunbardbc933702008-08-21 21:57:41 +00001922 ObjCProtocolDecl::protocol_iterator begin,
1923 ObjCProtocolDecl::protocol_iterator end) {
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001924 std::vector<llvm::Constant*> ProtocolRefs;
1925
Daniel Dunbardbc933702008-08-21 21:57:41 +00001926 for (; begin != end; ++begin)
1927 ProtocolRefs.push_back(GetProtocolRef(*begin));
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001928
1929 // Just return null for empty protocol lists
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001930 if (ProtocolRefs.empty())
Owen Andersonc9c88b42009-07-31 20:28:54 +00001931 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001932
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001933 // This list is null terminated.
Owen Andersonc9c88b42009-07-31 20:28:54 +00001934 ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy));
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001935
1936 std::vector<llvm::Constant*> Values(3);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00001937 // This field is only used by the runtime.
Owen Andersonc9c88b42009-07-31 20:28:54 +00001938 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001939 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001940 ProtocolRefs.size() - 1);
1941 Values[2] =
1942 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy,
1943 ProtocolRefs.size()),
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001944 ProtocolRefs);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001945
Nick Lewycky0d36dd22009-09-19 20:00:52 +00001946 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001947 llvm::GlobalVariable *GV =
Daniel Dunbar63c5b502009-03-09 21:49:58 +00001948 CreateMetadataVar(Name, Init, "__OBJC,__cat_cls_meth,regular,no_dead_strip",
Daniel Dunbar58a29122009-03-09 22:18:41 +00001949 4, false);
Owen Anderson3c4972d2009-07-29 18:54:39 +00001950 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001951}
1952
Fariborz Jahanian191dcd72009-12-12 21:26:21 +00001953void CGObjCCommonMac::PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*, 16> &PropertySet,
1954 std::vector<llvm::Constant*> &Properties,
1955 const Decl *Container,
1956 const ObjCProtocolDecl *PROTO,
1957 const ObjCCommonTypesHelper &ObjCTypes) {
1958 std::vector<llvm::Constant*> Prop(2);
1959 for (ObjCProtocolDecl::protocol_iterator P = PROTO->protocol_begin(),
1960 E = PROTO->protocol_end(); P != E; ++P)
1961 PushProtocolProperties(PropertySet, Properties, Container, (*P), ObjCTypes);
1962 for (ObjCContainerDecl::prop_iterator I = PROTO->prop_begin(),
1963 E = PROTO->prop_end(); I != E; ++I) {
1964 const ObjCPropertyDecl *PD = *I;
1965 if (!PropertySet.insert(PD->getIdentifier()))
1966 continue;
1967 Prop[0] = GetPropertyName(PD->getIdentifier());
1968 Prop[1] = GetPropertyTypeString(PD, Container);
1969 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy, Prop));
1970 }
1971}
1972
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00001973/*
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00001974 struct _objc_property {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001975 const char * const name;
1976 const char * const attributes;
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00001977 };
1978
1979 struct _objc_property_list {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001980 uint32_t entsize; // sizeof (struct _objc_property)
1981 uint32_t prop_count;
1982 struct _objc_property[prop_count];
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00001983 };
1984*/
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00001985llvm::Constant *CGObjCCommonMac::EmitPropertyList(llvm::Twine Name,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001986 const Decl *Container,
1987 const ObjCContainerDecl *OCD,
1988 const ObjCCommonTypesHelper &ObjCTypes) {
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00001989 std::vector<llvm::Constant*> Properties, Prop(2);
Fariborz Jahanian191dcd72009-12-12 21:26:21 +00001990 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00001991 for (ObjCContainerDecl::prop_iterator I = OCD->prop_begin(),
1992 E = OCD->prop_end(); I != E; ++I) {
Steve Naroff93983f82009-01-11 12:47:58 +00001993 const ObjCPropertyDecl *PD = *I;
Fariborz Jahanian191dcd72009-12-12 21:26:21 +00001994 PropertySet.insert(PD->getIdentifier());
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00001995 Prop[0] = GetPropertyName(PD->getIdentifier());
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00001996 Prop[1] = GetPropertyTypeString(PD, Container);
Owen Anderson08e25242009-07-27 22:29:56 +00001997 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy,
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00001998 Prop));
1999 }
Fariborz Jahanian6afbdf52010-06-22 16:33:55 +00002000 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
Ted Kremenek53b94412010-09-01 01:21:15 +00002001 for (ObjCInterfaceDecl::all_protocol_iterator
2002 P = OID->all_referenced_protocol_begin(),
2003 E = OID->all_referenced_protocol_end(); P != E; ++P)
Fariborz Jahanian6afbdf52010-06-22 16:33:55 +00002004 PushProtocolProperties(PropertySet, Properties, Container, (*P),
2005 ObjCTypes);
2006 }
2007 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
2008 for (ObjCCategoryDecl::protocol_iterator P = CD->protocol_begin(),
2009 E = CD->protocol_end(); P != E; ++P)
2010 PushProtocolProperties(PropertySet, Properties, Container, (*P),
2011 ObjCTypes);
2012 }
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00002013
2014 // Return null for empty list.
2015 if (Properties.empty())
Owen Andersonc9c88b42009-07-31 20:28:54 +00002016 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00002017
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002018 unsigned PropertySize =
Duncan Sands9408c452009-05-09 07:08:47 +00002019 CGM.getTargetData().getTypeAllocSize(ObjCTypes.PropertyTy);
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00002020 std::vector<llvm::Constant*> Values(3);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002021 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize);
2022 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002023 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy,
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00002024 Properties.size());
Owen Anderson7db6d832009-07-28 18:33:04 +00002025 Values[2] = llvm::ConstantArray::get(AT, Properties);
Nick Lewycky0d36dd22009-09-19 20:00:52 +00002026 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00002027
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002028 llvm::GlobalVariable *GV =
2029 CreateMetadataVar(Name, Init,
2030 (ObjCABI == 2) ? "__DATA, __objc_const" :
Daniel Dunbar0bf21992009-04-15 02:56:18 +00002031 "__OBJC,__property,regular,no_dead_strip",
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002032 (ObjCABI == 2) ? 8 : 4,
Daniel Dunbar0bf21992009-04-15 02:56:18 +00002033 true);
Owen Anderson3c4972d2009-07-29 18:54:39 +00002034 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00002035}
2036
2037/*
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00002038 struct objc_method_description_list {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002039 int count;
2040 struct objc_method_description list[];
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00002041 };
2042*/
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002043llvm::Constant *
2044CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
2045 std::vector<llvm::Constant*> Desc(2);
Owen Andersona1cf15f2009-07-14 23:10:40 +00002046 Desc[0] =
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002047 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
2048 ObjCTypes.SelectorPtrTy);
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002049 Desc[1] = GetMethodVarType(MD);
Owen Anderson08e25242009-07-27 22:29:56 +00002050 return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy,
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002051 Desc);
2052}
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00002053
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002054llvm::Constant *CGObjCMac::EmitMethodDescList(llvm::Twine Name,
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002055 const char *Section,
2056 const ConstantVector &Methods) {
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00002057 // Return null for empty list.
2058 if (Methods.empty())
Owen Andersonc9c88b42009-07-31 20:28:54 +00002059 return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00002060
2061 std::vector<llvm::Constant*> Values(2);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002062 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002063 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy,
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00002064 Methods.size());
Owen Anderson7db6d832009-07-28 18:33:04 +00002065 Values[1] = llvm::ConstantArray::get(AT, Methods);
Nick Lewycky0d36dd22009-09-19 20:00:52 +00002066 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00002067
Daniel Dunbar0bf21992009-04-15 02:56:18 +00002068 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002069 return llvm::ConstantExpr::getBitCast(GV,
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00002070 ObjCTypes.MethodDescriptionListPtrTy);
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00002071}
2072
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002073/*
2074 struct _objc_category {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002075 char *category_name;
2076 char *class_name;
2077 struct _objc_method_list *instance_methods;
2078 struct _objc_method_list *class_methods;
2079 struct _objc_protocol_list *protocols;
2080 uint32_t size; // <rdar://4585769>
2081 struct _objc_property_list *instance_properties;
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002082 };
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002083*/
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00002084void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
Duncan Sands9408c452009-05-09 07:08:47 +00002085 unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.CategoryTy);
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002086
Mike Stumpf5408fe2009-05-16 07:57:57 +00002087 // FIXME: This is poor design, the OCD should have a pointer to the category
2088 // decl. Additionally, note that Category can be null for the @implementation
2089 // w/o an @interface case. Sema should just create one for us as it does for
2090 // @implementation so everyone else can live life under a clear blue sky.
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002091 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002092 const ObjCCategoryDecl *Category =
Daniel Dunbar86e2f402008-08-26 23:03:11 +00002093 Interface->FindCategoryDeclaration(OCD->getIdentifier());
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002094
2095 llvm::SmallString<256> ExtName;
2096 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
2097 << OCD->getName();
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002098
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002099 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002100 for (ObjCCategoryImplDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002101 i = OCD->instmeth_begin(), e = OCD->instmeth_end(); i != e; ++i) {
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002102 // Instance methods should always be defined.
2103 InstanceMethods.push_back(GetMethodConstant(*i));
2104 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002105 for (ObjCCategoryImplDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002106 i = OCD->classmeth_begin(), e = OCD->classmeth_end(); i != e; ++i) {
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002107 // Class methods should always be defined.
2108 ClassMethods.push_back(GetMethodConstant(*i));
2109 }
2110
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002111 std::vector<llvm::Constant*> Values(7);
2112 Values[0] = GetClassName(OCD->getIdentifier());
2113 Values[1] = GetClassName(Interface->getIdentifier());
Fariborz Jahanian679cd7f2009-04-29 20:40:05 +00002114 LazySymbols.insert(Interface->getIdentifier());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002115 Values[2] =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002116 EmitMethodList("\01L_OBJC_CATEGORY_INSTANCE_METHODS_" + ExtName.str(),
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00002117 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002118 InstanceMethods);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002119 Values[3] =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002120 EmitMethodList("\01L_OBJC_CATEGORY_CLASS_METHODS_" + ExtName.str(),
Daniel Dunbar0bf21992009-04-15 02:56:18 +00002121 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002122 ClassMethods);
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002123 if (Category) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002124 Values[4] =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002125 EmitProtocolList("\01L_OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002126 Category->protocol_begin(),
2127 Category->protocol_end());
2128 } else {
Owen Andersonc9c88b42009-07-31 20:28:54 +00002129 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002130 }
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002131 Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Daniel Dunbar86e2f402008-08-26 23:03:11 +00002132
2133 // If there is no category @interface then there can be no properties.
2134 if (Category) {
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002135 Values[6] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
Fariborz Jahanian5de14dc2009-01-28 22:18:42 +00002136 OCD, Category, ObjCTypes);
Daniel Dunbar86e2f402008-08-26 23:03:11 +00002137 } else {
Owen Andersonc9c88b42009-07-31 20:28:54 +00002138 Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
Daniel Dunbar86e2f402008-08-26 23:03:11 +00002139 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002140
Owen Anderson08e25242009-07-27 22:29:56 +00002141 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy,
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002142 Values);
2143
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002144 llvm::GlobalVariable *GV =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002145 CreateMetadataVar("\01L_OBJC_CATEGORY_" + ExtName.str(), Init,
Daniel Dunbar63c5b502009-03-09 21:49:58 +00002146 "__OBJC,__category,regular,no_dead_strip",
Daniel Dunbar58a29122009-03-09 22:18:41 +00002147 4, true);
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002148 DefinedCategories.push_back(GV);
Fariborz Jahanianb9c5b3d2010-06-21 22:05:18 +00002149 DefinedCategoryNames.insert(ExtName.str());
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00002150}
2151
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002152// FIXME: Get from somewhere?
2153enum ClassFlags {
2154 eClassFlags_Factory = 0x00001,
2155 eClassFlags_Meta = 0x00002,
2156 // <rdr://5142207>
2157 eClassFlags_HasCXXStructors = 0x02000,
2158 eClassFlags_Hidden = 0x20000,
2159 eClassFlags_ABI2_Hidden = 0x00010,
2160 eClassFlags_ABI2_HasCXXStructors = 0x00004 // <rdr://4923634>
2161};
2162
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002163/*
2164 struct _objc_class {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002165 Class isa;
2166 Class super_class;
2167 const char *name;
2168 long version;
2169 long info;
2170 long instance_size;
2171 struct _objc_ivar_list *ivars;
2172 struct _objc_method_list *methods;
2173 struct _objc_cache *cache;
2174 struct _objc_protocol_list *protocols;
2175 // Objective-C 1.0 extensions (<rdr://4585769>)
2176 const char *ivar_layout;
2177 struct _objc_class_ext *ext;
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002178 };
2179
2180 See EmitClassExtension();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002181*/
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002182void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00002183 DefinedSymbols.insert(ID->getIdentifier());
2184
Chris Lattner8ec03f52008-11-24 03:54:41 +00002185 std::string ClassName = ID->getNameAsString();
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002186 // FIXME: Gross
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002187 ObjCInterfaceDecl *Interface =
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002188 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002189 llvm::Constant *Protocols =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002190 EmitProtocolList("\01L_OBJC_CLASS_PROTOCOLS_" + ID->getName(),
Ted Kremenek53b94412010-09-01 01:21:15 +00002191 Interface->all_referenced_protocol_begin(),
2192 Interface->all_referenced_protocol_end());
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002193 unsigned Flags = eClassFlags_Factory;
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002194 if (ID->getNumIvarInitializers())
2195 Flags |= eClassFlags_HasCXXStructors;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002196 unsigned Size =
Daniel Dunbar2bebbf02009-05-03 10:46:44 +00002197 CGM.getContext().getASTObjCImplementationLayout(ID).getSize() / 8;
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002198
2199 // FIXME: Set CXX-structors flag.
Daniel Dunbar04d40782009-04-14 06:00:08 +00002200 if (CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden)
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002201 Flags |= eClassFlags_Hidden;
2202
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002203 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002204 for (ObjCImplementationDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002205 i = ID->instmeth_begin(), e = ID->instmeth_end(); i != e; ++i) {
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002206 // Instance methods should always be defined.
2207 InstanceMethods.push_back(GetMethodConstant(*i));
2208 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002209 for (ObjCImplementationDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002210 i = ID->classmeth_begin(), e = ID->classmeth_end(); i != e; ++i) {
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002211 // Class methods should always be defined.
2212 ClassMethods.push_back(GetMethodConstant(*i));
2213 }
2214
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002215 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002216 i = ID->propimpl_begin(), e = ID->propimpl_end(); i != e; ++i) {
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002217 ObjCPropertyImplDecl *PID = *i;
2218
2219 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2220 ObjCPropertyDecl *PD = PID->getPropertyDecl();
2221
2222 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
2223 if (llvm::Constant *C = GetMethodConstant(MD))
2224 InstanceMethods.push_back(C);
2225 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
2226 if (llvm::Constant *C = GetMethodConstant(MD))
2227 InstanceMethods.push_back(C);
2228 }
2229 }
2230
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002231 std::vector<llvm::Constant*> Values(12);
Daniel Dunbar5384b092009-05-03 08:56:52 +00002232 Values[ 0] = EmitMetaClass(ID, Protocols, ClassMethods);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002233 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00002234 // Record a reference to the super class.
2235 LazySymbols.insert(Super->getIdentifier());
2236
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002237 Values[ 1] =
Owen Anderson3c4972d2009-07-29 18:54:39 +00002238 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002239 ObjCTypes.ClassPtrTy);
2240 } else {
Owen Andersonc9c88b42009-07-31 20:28:54 +00002241 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002242 }
2243 Values[ 2] = GetClassName(ID->getIdentifier());
2244 // Version is always 0.
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002245 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
2246 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
2247 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
Fariborz Jahanian46b86c62009-01-28 19:12:34 +00002248 Values[ 6] = EmitIvarList(ID, false);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002249 Values[ 7] =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002250 EmitMethodList("\01L_OBJC_INSTANCE_METHODS_" + ID->getName(),
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00002251 "__OBJC,__inst_meth,regular,no_dead_strip",
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002252 InstanceMethods);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002253 // cache is always NULL.
Owen Andersonc9c88b42009-07-31 20:28:54 +00002254 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002255 Values[ 9] = Protocols;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002256 Values[10] = BuildIvarLayout(ID, true);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002257 Values[11] = EmitClassExtension(ID);
Owen Anderson08e25242009-07-27 22:29:56 +00002258 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002259 Values);
Fariborz Jahanianb0069ee2009-11-12 20:14:24 +00002260 std::string Name("\01L_OBJC_CLASS_");
2261 Name += ClassName;
2262 const char *Section = "__OBJC,__class,regular,no_dead_strip";
2263 // Check for a forward reference.
2264 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
2265 if (GV) {
2266 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
2267 "Forward metaclass reference has incorrect type.");
2268 GV->setLinkage(llvm::GlobalValue::InternalLinkage);
2269 GV->setInitializer(Init);
2270 GV->setSection(Section);
2271 GV->setAlignment(4);
2272 CGM.AddUsedGlobal(GV);
2273 }
2274 else
2275 GV = CreateMetadataVar(Name, Init, Section, 4, true);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002276 DefinedClasses.push_back(GV);
2277}
2278
2279llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
2280 llvm::Constant *Protocols,
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002281 const ConstantVector &Methods) {
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002282 unsigned Flags = eClassFlags_Meta;
Duncan Sands9408c452009-05-09 07:08:47 +00002283 unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.ClassTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002284
Daniel Dunbar04d40782009-04-14 06:00:08 +00002285 if (CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden)
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002286 Flags |= eClassFlags_Hidden;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002287
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002288 std::vector<llvm::Constant*> Values(12);
2289 // The isa for the metaclass is the root of the hierarchy.
2290 const ObjCInterfaceDecl *Root = ID->getClassInterface();
2291 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
2292 Root = Super;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002293 Values[ 0] =
Owen Anderson3c4972d2009-07-29 18:54:39 +00002294 llvm::ConstantExpr::getBitCast(GetClassName(Root->getIdentifier()),
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002295 ObjCTypes.ClassPtrTy);
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002296 // The super class for the metaclass is emitted as the name of the
2297 // super class. The runtime fixes this up to point to the
2298 // *metaclass* for the super class.
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002299 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002300 Values[ 1] =
Owen Anderson3c4972d2009-07-29 18:54:39 +00002301 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002302 ObjCTypes.ClassPtrTy);
2303 } else {
Owen Andersonc9c88b42009-07-31 20:28:54 +00002304 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002305 }
2306 Values[ 2] = GetClassName(ID->getIdentifier());
2307 // Version is always 0.
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002308 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
2309 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
2310 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
Fariborz Jahanian46b86c62009-01-28 19:12:34 +00002311 Values[ 6] = EmitIvarList(ID, true);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002312 Values[ 7] =
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002313 EmitMethodList("\01L_OBJC_CLASS_METHODS_" + ID->getNameAsString(),
Daniel Dunbar0bf21992009-04-15 02:56:18 +00002314 "__OBJC,__cls_meth,regular,no_dead_strip",
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002315 Methods);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002316 // cache is always NULL.
Owen Andersonc9c88b42009-07-31 20:28:54 +00002317 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002318 Values[ 9] = Protocols;
2319 // ivar_layout for metaclass is always NULL.
Owen Andersonc9c88b42009-07-31 20:28:54 +00002320 Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002321 // The class extension is always unused for metaclasses.
Owen Andersonc9c88b42009-07-31 20:28:54 +00002322 Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
Owen Anderson08e25242009-07-27 22:29:56 +00002323 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002324 Values);
2325
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002326 std::string Name("\01L_OBJC_METACLASS_");
Chris Lattner8ec03f52008-11-24 03:54:41 +00002327 Name += ID->getNameAsCString();
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002328
2329 // Check for a forward reference.
2330 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
2331 if (GV) {
2332 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
2333 "Forward metaclass reference has incorrect type.");
2334 GV->setLinkage(llvm::GlobalValue::InternalLinkage);
2335 GV->setInitializer(Init);
2336 } else {
Owen Anderson1c431b32009-07-08 19:05:04 +00002337 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002338 llvm::GlobalValue::InternalLinkage,
Owen Anderson1c431b32009-07-08 19:05:04 +00002339 Init, Name);
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002340 }
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002341 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
Daniel Dunbar58a29122009-03-09 22:18:41 +00002342 GV->setAlignment(4);
Chris Lattnerad64e022009-07-17 23:57:13 +00002343 CGM.AddUsedGlobal(GV);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002344
2345 return GV;
2346}
2347
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002348llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002349 std::string Name = "\01L_OBJC_METACLASS_" + ID->getNameAsString();
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002350
Mike Stumpf5408fe2009-05-16 07:57:57 +00002351 // FIXME: Should we look these up somewhere other than the module. Its a bit
2352 // silly since we only generate these while processing an implementation, so
2353 // exactly one pointer would work if know when we entered/exitted an
2354 // implementation block.
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002355
2356 // Check for an existing forward reference.
Fariborz Jahanianb0d27942009-01-07 20:11:22 +00002357 // Previously, metaclass with internal linkage may have been defined.
2358 // pass 'true' as 2nd argument so it is returned.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002359 if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name,
2360 true)) {
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002361 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
2362 "Forward metaclass reference has incorrect type.");
2363 return GV;
2364 } else {
2365 // Generate as an external reference to keep a consistent
2366 // module. This will be patched up when we emit the metaclass.
Owen Anderson1c431b32009-07-08 19:05:04 +00002367 return new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002368 llvm::GlobalValue::ExternalLinkage,
2369 0,
Owen Anderson1c431b32009-07-08 19:05:04 +00002370 Name);
Daniel Dunbarf56f1912008-08-25 08:19:24 +00002371 }
2372}
2373
Fariborz Jahanianb0069ee2009-11-12 20:14:24 +00002374llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
2375 std::string Name = "\01L_OBJC_CLASS_" + ID->getNameAsString();
2376
2377 if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name,
2378 true)) {
2379 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
2380 "Forward class metadata reference has incorrect type.");
2381 return GV;
2382 } else {
2383 return new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
2384 llvm::GlobalValue::ExternalLinkage,
2385 0,
2386 Name);
2387 }
2388}
2389
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002390/*
2391 struct objc_class_ext {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002392 uint32_t size;
2393 const char *weak_ivar_layout;
2394 struct _objc_property_list *properties;
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002395 };
2396*/
2397llvm::Constant *
2398CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002399 uint64_t Size =
Duncan Sands9408c452009-05-09 07:08:47 +00002400 CGM.getTargetData().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002401
2402 std::vector<llvm::Constant*> Values(3);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002403 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Fariborz Jahanianc71303d2009-04-22 23:00:43 +00002404 Values[1] = BuildIvarLayout(ID, false);
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002405 Values[2] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getName(),
Fariborz Jahanian5de14dc2009-01-28 22:18:42 +00002406 ID, ID->getClassInterface(), ObjCTypes);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002407
2408 // Return null if no extension bits are used.
2409 if (Values[1]->isNullValue() && Values[2]->isNullValue())
Owen Andersonc9c88b42009-07-31 20:28:54 +00002410 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002411
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002412 llvm::Constant *Init =
Owen Anderson08e25242009-07-27 22:29:56 +00002413 llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values);
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002414 return CreateMetadataVar("\01L_OBJC_CLASSEXT_" + ID->getName(),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002415 Init, "__OBJC,__class_ext,regular,no_dead_strip",
Daniel Dunbar0bf21992009-04-15 02:56:18 +00002416 4, true);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002417}
2418
2419/*
2420 struct objc_ivar {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002421 char *ivar_name;
2422 char *ivar_type;
2423 int ivar_offset;
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002424 };
2425
2426 struct objc_ivar_list {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002427 int ivar_count;
2428 struct objc_ivar list[count];
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002429 };
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002430*/
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002431llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
Fariborz Jahanian46b86c62009-01-28 19:12:34 +00002432 bool ForClass) {
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002433 std::vector<llvm::Constant*> Ivars, Ivar(3);
2434
2435 // When emitting the root class GCC emits ivar entries for the
2436 // actual class structure. It is not clear if we need to follow this
2437 // behavior; for now lets try and get away with not doing it. If so,
2438 // the cleanest solution would be to make up an ObjCInterfaceDecl
2439 // for the class.
2440 if (ForClass)
Owen Andersonc9c88b42009-07-31 20:28:54 +00002441 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002442
2443 ObjCInterfaceDecl *OID =
Fariborz Jahanian46b86c62009-01-28 19:12:34 +00002444 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002445
Daniel Dunbar3e5f0d82009-04-20 06:54:31 +00002446 llvm::SmallVector<ObjCIvarDecl*, 16> OIvars;
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +00002447 CGM.getContext().ShallowCollectObjCIvars(OID, OIvars);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002448
Daniel Dunbar3e5f0d82009-04-20 06:54:31 +00002449 for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
2450 ObjCIvarDecl *IVD = OIvars[i];
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +00002451 // Ignore unnamed bit-fields.
2452 if (!IVD->getDeclName())
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002453 continue;
Daniel Dunbar3fea0c02009-04-22 08:22:17 +00002454 Ivar[0] = GetMethodVarName(IVD->getIdentifier());
2455 Ivar[1] = GetMethodVarType(IVD);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002456 Ivar[2] = llvm::ConstantInt::get(ObjCTypes.IntTy,
Daniel Dunbar97776872009-04-22 07:32:20 +00002457 ComputeIvarBaseOffset(CGM, OID, IVD));
Owen Anderson08e25242009-07-27 22:29:56 +00002458 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy, Ivar));
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002459 }
2460
2461 // Return null for empty list.
2462 if (Ivars.empty())
Owen Andersonc9c88b42009-07-31 20:28:54 +00002463 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002464
2465 std::vector<llvm::Constant*> Values(2);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002466 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
Owen Anderson96e0fc72009-07-29 22:16:19 +00002467 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002468 Ivars.size());
Owen Anderson7db6d832009-07-28 18:33:04 +00002469 Values[1] = llvm::ConstantArray::get(AT, Ivars);
Nick Lewycky0d36dd22009-09-19 20:00:52 +00002470 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002471
Daniel Dunbar63c5b502009-03-09 21:49:58 +00002472 llvm::GlobalVariable *GV;
2473 if (ForClass)
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002474 GV = CreateMetadataVar("\01L_OBJC_CLASS_VARIABLES_" + ID->getName(),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002475 Init, "__OBJC,__class_vars,regular,no_dead_strip",
Daniel Dunbar58a29122009-03-09 22:18:41 +00002476 4, true);
Daniel Dunbar63c5b502009-03-09 21:49:58 +00002477 else
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002478 GV = CreateMetadataVar("\01L_OBJC_INSTANCE_VARIABLES_" + ID->getName(),
Daniel Dunbar63c5b502009-03-09 21:49:58 +00002479 Init, "__OBJC,__instance_vars,regular,no_dead_strip",
Daniel Dunbar0bf21992009-04-15 02:56:18 +00002480 4, true);
Owen Anderson3c4972d2009-07-29 18:54:39 +00002481 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002482}
2483
2484/*
2485 struct objc_method {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002486 SEL method_name;
2487 char *method_types;
2488 void *method;
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002489 };
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002490
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002491 struct objc_method_list {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002492 struct objc_method_list *obsolete;
2493 int count;
2494 struct objc_method methods_list[count];
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002495 };
2496*/
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002497
2498/// GetMethodConstant - Return a struct objc_method constant for the
2499/// given method if it has been defined. The result is null if the
2500/// method has not been defined. The return value has type MethodPtrTy.
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002501llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) {
Argyrios Kyrtzidis9d50c062010-08-09 10:54:20 +00002502 llvm::Function *Fn = GetMethodDefinition(MD);
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002503 if (!Fn)
2504 return 0;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002505
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002506 std::vector<llvm::Constant*> Method(3);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002507 Method[0] =
Owen Anderson3c4972d2009-07-29 18:54:39 +00002508 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002509 ObjCTypes.SelectorPtrTy);
2510 Method[1] = GetMethodVarType(MD);
Owen Anderson3c4972d2009-07-29 18:54:39 +00002511 Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy);
Owen Anderson08e25242009-07-27 22:29:56 +00002512 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002513}
2514
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002515llvm::Constant *CGObjCMac::EmitMethodList(llvm::Twine Name,
Daniel Dunbar86e253a2008-08-22 20:34:54 +00002516 const char *Section,
Daniel Dunbarae226fa2008-08-27 02:31:56 +00002517 const ConstantVector &Methods) {
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002518 // Return null for empty list.
2519 if (Methods.empty())
Owen Andersonc9c88b42009-07-31 20:28:54 +00002520 return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002521
2522 std::vector<llvm::Constant*> Values(3);
Owen Andersonc9c88b42009-07-31 20:28:54 +00002523 Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002524 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
Owen Anderson96e0fc72009-07-29 22:16:19 +00002525 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002526 Methods.size());
Owen Anderson7db6d832009-07-28 18:33:04 +00002527 Values[2] = llvm::ConstantArray::get(AT, Methods);
Nick Lewycky0d36dd22009-09-19 20:00:52 +00002528 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002529
Daniel Dunbar0bf21992009-04-15 02:56:18 +00002530 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true);
Owen Anderson3c4972d2009-07-29 18:54:39 +00002531 return llvm::ConstantExpr::getBitCast(GV,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00002532 ObjCTypes.MethodListPtrTy);
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00002533}
2534
Fariborz Jahanian493dab72009-01-26 21:38:32 +00002535llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002536 const ObjCContainerDecl *CD) {
Daniel Dunbarc575ce72009-10-19 01:21:19 +00002537 llvm::SmallString<256> Name;
Fariborz Jahanian679a5022009-01-10 21:06:09 +00002538 GetNameForMethod(OMD, CD, Name);
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00002539
Daniel Dunbar541b63b2009-02-02 23:23:47 +00002540 CodeGenTypes &Types = CGM.getTypes();
Daniel Dunbar45c25ba2008-09-10 04:01:49 +00002541 const llvm::FunctionType *MethodTy =
Daniel Dunbar541b63b2009-02-02 23:23:47 +00002542 Types.GetFunctionType(Types.getFunctionInfo(OMD), OMD->isVariadic());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002543 llvm::Function *Method =
Daniel Dunbar45c25ba2008-09-10 04:01:49 +00002544 llvm::Function::Create(MethodTy,
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00002545 llvm::GlobalValue::InternalLinkage,
Daniel Dunbarc575ce72009-10-19 01:21:19 +00002546 Name.str(),
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00002547 &CGM.getModule());
Daniel Dunbarc45ef602008-08-26 21:51:14 +00002548 MethodDefinitions.insert(std::make_pair(OMD, Method));
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00002549
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00002550 return Method;
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00002551}
2552
Daniel Dunbarfd65d372009-03-09 20:09:19 +00002553llvm::GlobalVariable *
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00002554CGObjCCommonMac::CreateMetadataVar(llvm::Twine Name,
Daniel Dunbarfd65d372009-03-09 20:09:19 +00002555 llvm::Constant *Init,
2556 const char *Section,
Daniel Dunbar35bd7632009-03-09 20:50:13 +00002557 unsigned Align,
2558 bool AddToUsed) {
Daniel Dunbarfd65d372009-03-09 20:09:19 +00002559 const llvm::Type *Ty = Init->getType();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002560 llvm::GlobalVariable *GV =
Owen Anderson1c431b32009-07-08 19:05:04 +00002561 new llvm::GlobalVariable(CGM.getModule(), Ty, false,
Chris Lattnerad64e022009-07-17 23:57:13 +00002562 llvm::GlobalValue::InternalLinkage, Init, Name);
Daniel Dunbarfd65d372009-03-09 20:09:19 +00002563 if (Section)
2564 GV->setSection(Section);
Daniel Dunbar35bd7632009-03-09 20:50:13 +00002565 if (Align)
2566 GV->setAlignment(Align);
2567 if (AddToUsed)
Chris Lattnerad64e022009-07-17 23:57:13 +00002568 CGM.AddUsedGlobal(GV);
Daniel Dunbarfd65d372009-03-09 20:09:19 +00002569 return GV;
2570}
2571
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002572llvm::Function *CGObjCMac::ModuleInitFunction() {
Daniel Dunbarf77ac862008-08-11 21:35:06 +00002573 // Abuse this interface function as a place to finalize.
2574 FinishModule();
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00002575 return NULL;
2576}
2577
Chris Lattner74391b42009-03-22 21:03:39 +00002578llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
Chris Lattner72db6c32009-04-22 02:44:54 +00002579 return ObjCTypes.getGetPropertyFn();
Daniel Dunbar49f66022008-09-24 03:38:44 +00002580}
2581
Chris Lattner74391b42009-03-22 21:03:39 +00002582llvm::Constant *CGObjCMac::GetPropertySetFunction() {
Chris Lattner72db6c32009-04-22 02:44:54 +00002583 return ObjCTypes.getSetPropertyFn();
Daniel Dunbar49f66022008-09-24 03:38:44 +00002584}
2585
Fariborz Jahanian6cc59062010-04-12 18:18:10 +00002586llvm::Constant *CGObjCMac::GetCopyStructFunction() {
2587 return ObjCTypes.getCopyStructFn();
2588}
2589
Chris Lattner74391b42009-03-22 21:03:39 +00002590llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
Chris Lattner72db6c32009-04-22 02:44:54 +00002591 return ObjCTypes.getEnumerationMutationFn();
Anders Carlsson2abd89c2008-08-31 04:05:03 +00002592}
2593
John McCallf1549f62010-07-06 01:34:17 +00002594void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
2595 return EmitTryOrSynchronizedStmt(CGF, S);
2596}
2597
2598void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
2599 const ObjCAtSynchronizedStmt &S) {
2600 return EmitTryOrSynchronizedStmt(CGF, S);
2601}
2602
John McCallcc505292010-07-21 06:59:36 +00002603namespace {
John McCall1f0fca52010-07-21 07:22:38 +00002604 struct PerformFragileFinally : EHScopeStack::Cleanup {
John McCallcc505292010-07-21 06:59:36 +00002605 const Stmt &S;
John McCall0b251722010-08-04 05:59:32 +00002606 llvm::Value *SyncArgSlot;
John McCallcc505292010-07-21 06:59:36 +00002607 llvm::Value *CallTryExitVar;
2608 llvm::Value *ExceptionData;
2609 ObjCTypesHelper &ObjCTypes;
2610 PerformFragileFinally(const Stmt *S,
John McCall0b251722010-08-04 05:59:32 +00002611 llvm::Value *SyncArgSlot,
John McCallcc505292010-07-21 06:59:36 +00002612 llvm::Value *CallTryExitVar,
2613 llvm::Value *ExceptionData,
2614 ObjCTypesHelper *ObjCTypes)
John McCall0b251722010-08-04 05:59:32 +00002615 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
John McCallcc505292010-07-21 06:59:36 +00002616 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
2617
2618 void Emit(CodeGenFunction &CGF, bool IsForEH) {
2619 // Check whether we need to call objc_exception_try_exit.
2620 // In optimized code, this branch will always be folded.
2621 llvm::BasicBlock *FinallyCallExit =
2622 CGF.createBasicBlock("finally.call_exit");
2623 llvm::BasicBlock *FinallyNoCallExit =
2624 CGF.createBasicBlock("finally.no_call_exit");
2625 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
2626 FinallyCallExit, FinallyNoCallExit);
2627
2628 CGF.EmitBlock(FinallyCallExit);
2629 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryExitFn(), ExceptionData)
2630 ->setDoesNotThrow();
2631
2632 CGF.EmitBlock(FinallyNoCallExit);
2633
2634 if (isa<ObjCAtTryStmt>(S)) {
2635 if (const ObjCAtFinallyStmt* FinallyStmt =
John McCalld96a8e72010-08-11 00:16:14 +00002636 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
2637 // Save the current cleanup destination in case there's
2638 // control flow inside the finally statement.
2639 llvm::Value *CurCleanupDest =
2640 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
2641
John McCallcc505292010-07-21 06:59:36 +00002642 CGF.EmitStmt(FinallyStmt->getFinallyBody());
2643
John McCalld96a8e72010-08-11 00:16:14 +00002644 if (CGF.HaveInsertPoint()) {
2645 CGF.Builder.CreateStore(CurCleanupDest,
2646 CGF.getNormalCleanupDestSlot());
2647 } else {
2648 // Currently, the end of the cleanup must always exist.
2649 CGF.EnsureInsertPoint();
2650 }
2651 }
John McCallcc505292010-07-21 06:59:36 +00002652 } else {
2653 // Emit objc_sync_exit(expr); as finally's sole statement for
2654 // @synchronized.
John McCall0b251722010-08-04 05:59:32 +00002655 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
John McCallcc505292010-07-21 06:59:36 +00002656 CGF.Builder.CreateCall(ObjCTypes.getSyncExitFn(), SyncArg)
2657 ->setDoesNotThrow();
2658 }
2659 }
2660 };
John McCall87bb5822010-07-31 23:20:56 +00002661
2662 class FragileHazards {
2663 CodeGenFunction &CGF;
2664 llvm::SmallVector<llvm::Value*, 20> Locals;
2665 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
2666
2667 llvm::InlineAsm *ReadHazard;
2668 llvm::InlineAsm *WriteHazard;
2669
2670 llvm::FunctionType *GetAsmFnType();
2671
2672 void collectLocals();
2673 void emitReadHazard(CGBuilderTy &Builder);
2674
2675 public:
2676 FragileHazards(CodeGenFunction &CGF);
John McCall0b251722010-08-04 05:59:32 +00002677
John McCall87bb5822010-07-31 23:20:56 +00002678 void emitWriteHazard();
John McCall0b251722010-08-04 05:59:32 +00002679 void emitHazardsInNewBlocks();
John McCall87bb5822010-07-31 23:20:56 +00002680 };
2681}
2682
2683/// Create the fragile-ABI read and write hazards based on the current
2684/// state of the function, which is presumed to be immediately prior
2685/// to a @try block. These hazards are used to maintain correct
2686/// semantics in the face of optimization and the fragile ABI's
2687/// cavalier use of setjmp/longjmp.
2688FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
2689 collectLocals();
2690
2691 if (Locals.empty()) return;
2692
2693 // Collect all the blocks in the function.
2694 for (llvm::Function::iterator
2695 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
2696 BlocksBeforeTry.insert(&*I);
2697
2698 llvm::FunctionType *AsmFnTy = GetAsmFnType();
2699
2700 // Create a read hazard for the allocas. This inhibits dead-store
2701 // optimizations and forces the values to memory. This hazard is
2702 // inserted before any 'throwing' calls in the protected scope to
2703 // reflect the possibility that the variables might be read from the
2704 // catch block if the call throws.
2705 {
2706 std::string Constraint;
2707 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
2708 if (I) Constraint += ',';
2709 Constraint += "*m";
2710 }
2711
2712 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
2713 }
2714
2715 // Create a write hazard for the allocas. This inhibits folding
2716 // loads across the hazard. This hazard is inserted at the
2717 // beginning of the catch path to reflect the possibility that the
2718 // variables might have been written within the protected scope.
2719 {
2720 std::string Constraint;
2721 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
2722 if (I) Constraint += ',';
2723 Constraint += "=*m";
2724 }
2725
2726 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
2727 }
2728}
2729
2730/// Emit a write hazard at the current location.
2731void FragileHazards::emitWriteHazard() {
2732 if (Locals.empty()) return;
2733
2734 CGF.Builder.CreateCall(WriteHazard, Locals.begin(), Locals.end())
2735 ->setDoesNotThrow();
2736}
2737
John McCall87bb5822010-07-31 23:20:56 +00002738void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
2739 assert(!Locals.empty());
2740 Builder.CreateCall(ReadHazard, Locals.begin(), Locals.end())
2741 ->setDoesNotThrow();
2742}
2743
2744/// Emit read hazards in all the protected blocks, i.e. all the blocks
2745/// which have been inserted since the beginning of the try.
John McCall0b251722010-08-04 05:59:32 +00002746void FragileHazards::emitHazardsInNewBlocks() {
John McCall87bb5822010-07-31 23:20:56 +00002747 if (Locals.empty()) return;
2748
2749 CGBuilderTy Builder(CGF.getLLVMContext());
2750
2751 // Iterate through all blocks, skipping those prior to the try.
2752 for (llvm::Function::iterator
2753 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
2754 llvm::BasicBlock &BB = *FI;
2755 if (BlocksBeforeTry.count(&BB)) continue;
2756
2757 // Walk through all the calls in the block.
2758 for (llvm::BasicBlock::iterator
2759 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
2760 llvm::Instruction &I = *BI;
2761
2762 // Ignore instructions that aren't non-intrinsic calls.
2763 // These are the only calls that can possibly call longjmp.
2764 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) continue;
2765 if (isa<llvm::IntrinsicInst>(I))
2766 continue;
2767
2768 // Ignore call sites marked nounwind. This may be questionable,
2769 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
2770 llvm::CallSite CS(&I);
2771 if (CS.doesNotThrow()) continue;
2772
John McCall0b251722010-08-04 05:59:32 +00002773 // Insert a read hazard before the call. This will ensure that
2774 // any writes to the locals are performed before making the
2775 // call. If the call throws, then this is sufficient to
2776 // guarantee correctness as long as it doesn't also write to any
2777 // locals.
John McCall87bb5822010-07-31 23:20:56 +00002778 Builder.SetInsertPoint(&BB, BI);
2779 emitReadHazard(Builder);
2780 }
2781 }
2782}
2783
2784static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, llvm::Value *V) {
2785 if (V) S.insert(V);
2786}
2787
2788void FragileHazards::collectLocals() {
2789 // Compute a set of allocas to ignore.
2790 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
2791 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
2792 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
2793 addIfPresent(AllocasToIgnore, CGF.EHCleanupDest);
2794
2795 // Collect all the allocas currently in the function. This is
2796 // probably way too aggressive.
2797 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
2798 for (llvm::BasicBlock::iterator
2799 I = Entry.begin(), E = Entry.end(); I != E; ++I)
2800 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
2801 Locals.push_back(&*I);
2802}
2803
2804llvm::FunctionType *FragileHazards::GetAsmFnType() {
2805 std::vector<const llvm::Type *> Tys(Locals.size());
2806 for (unsigned I = 0, E = Locals.size(); I != E; ++I)
2807 Tys[I] = Locals[I]->getType();
2808 return llvm::FunctionType::get(CGF.Builder.getVoidTy(), Tys, false);
John McCallcc505292010-07-21 06:59:36 +00002809}
2810
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002811/*
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002812
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002813 Objective-C setjmp-longjmp (sjlj) Exception Handling
2814 --
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002815
John McCallf1549f62010-07-06 01:34:17 +00002816 A catch buffer is a setjmp buffer plus:
2817 - a pointer to the exception that was caught
2818 - a pointer to the previous exception data buffer
2819 - two pointers of reserved storage
2820 Therefore catch buffers form a stack, with a pointer to the top
2821 of the stack kept in thread-local storage.
2822
2823 objc_exception_try_enter pushes a catch buffer onto the EH stack.
2824 objc_exception_try_exit pops the given catch buffer, which is
2825 required to be the top of the EH stack.
2826 objc_exception_throw pops the top of the EH stack, writes the
2827 thrown exception into the appropriate field, and longjmps
2828 to the setjmp buffer. It crashes the process (with a printf
2829 and an abort()) if there are no catch buffers on the stack.
2830 objc_exception_extract just reads the exception pointer out of the
2831 catch buffer.
2832
2833 There's no reason an implementation couldn't use a light-weight
2834 setjmp here --- something like __builtin_setjmp, but API-compatible
2835 with the heavyweight setjmp. This will be more important if we ever
2836 want to implement correct ObjC/C++ exception interactions for the
2837 fragile ABI.
2838
2839 Note that for this use of setjmp/longjmp to be correct, we may need
2840 to mark some local variables volatile: if a non-volatile local
2841 variable is modified between the setjmp and the longjmp, it has
2842 indeterminate value. For the purposes of LLVM IR, it may be
2843 sufficient to make loads and stores within the @try (to variables
2844 declared outside the @try) volatile. This is necessary for
2845 optimized correctness, but is not currently being done; this is
2846 being tracked as rdar://problem/8160285
2847
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002848 The basic framework for a @try-catch-finally is as follows:
2849 {
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002850 objc_exception_data d;
2851 id _rethrow = null;
Anders Carlsson190d00e2009-02-07 21:26:04 +00002852 bool _call_try_exit = true;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002853
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002854 objc_exception_try_enter(&d);
2855 if (!setjmp(d.jmp_buf)) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002856 ... try body ...
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002857 } else {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002858 // exception path
2859 id _caught = objc_exception_extract(&d);
2860
2861 // enter new try scope for handlers
2862 if (!setjmp(d.jmp_buf)) {
2863 ... match exception and execute catch blocks ...
2864
2865 // fell off end, rethrow.
2866 _rethrow = _caught;
2867 ... jump-through-finally to finally_rethrow ...
2868 } else {
2869 // exception in catch block
2870 _rethrow = objc_exception_extract(&d);
2871 _call_try_exit = false;
2872 ... jump-through-finally to finally_rethrow ...
2873 }
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002874 }
Daniel Dunbar898d5082008-09-30 01:06:03 +00002875 ... jump-through-finally to finally_end ...
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002876
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002877 finally:
Anders Carlsson190d00e2009-02-07 21:26:04 +00002878 if (_call_try_exit)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002879 objc_exception_try_exit(&d);
Anders Carlsson190d00e2009-02-07 21:26:04 +00002880
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002881 ... finally block ....
Daniel Dunbar898d5082008-09-30 01:06:03 +00002882 ... dispatch to finally destination ...
2883
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002884 finally_rethrow:
Daniel Dunbar898d5082008-09-30 01:06:03 +00002885 objc_exception_throw(_rethrow);
2886
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002887 finally_end:
2888 }
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002889
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002890 This framework differs slightly from the one gcc uses, in that gcc
2891 uses _rethrow to determine if objc_exception_try_exit should be called
2892 and if the object should be rethrown. This breaks in the face of
2893 throwing nil and introduces unnecessary branches.
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002894
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002895 We specialize this framework for a few particular circumstances:
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002896
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002897 - If there are no catch blocks, then we avoid emitting the second
2898 exception handling context.
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002899
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002900 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
2901 e)) we avoid emitting the code to rethrow an uncaught exception.
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002902
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002903 - FIXME: If there is no @finally block we can do a few more
2904 simplifications.
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002905
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002906 Rethrows and Jumps-Through-Finally
2907 --
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002908
John McCallf1549f62010-07-06 01:34:17 +00002909 '@throw;' is supported by pushing the currently-caught exception
2910 onto ObjCEHStack while the @catch blocks are emitted.
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002911
John McCallf1549f62010-07-06 01:34:17 +00002912 Branches through the @finally block are handled with an ordinary
2913 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
2914 exceptions are not compatible with C++ exceptions, and this is
2915 hardly the only place where this will go wrong.
Daniel Dunbar898d5082008-09-30 01:06:03 +00002916
John McCallf1549f62010-07-06 01:34:17 +00002917 @synchronized(expr) { stmt; } is emitted as if it were:
2918 id synch_value = expr;
2919 objc_sync_enter(synch_value);
2920 @try { stmt; } @finally { objc_sync_exit(synch_value); }
Daniel Dunbar18ccc772008-09-28 01:03:14 +00002921*/
2922
Fariborz Jahanianbd71be42008-11-21 00:49:24 +00002923void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
2924 const Stmt &S) {
2925 bool isTry = isa<ObjCAtTryStmt>(S);
John McCallf1549f62010-07-06 01:34:17 +00002926
2927 // A destination for the fall-through edges of the catch handlers to
2928 // jump to.
2929 CodeGenFunction::JumpDest FinallyEnd =
2930 CGF.getJumpDestInCurrentScope("finally.end");
2931
2932 // A destination for the rethrow edge of the catch handlers to jump
2933 // to.
2934 CodeGenFunction::JumpDest FinallyRethrow =
2935 CGF.getJumpDestInCurrentScope("finally.rethrow");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002936
Daniel Dunbar1c566672009-02-24 01:43:46 +00002937 // For @synchronized, call objc_sync_enter(sync.expr). The
2938 // evaluation of the expression must occur before we enter the
John McCall0b251722010-08-04 05:59:32 +00002939 // @synchronized. We can't avoid a temp here because we need the
2940 // value to be preserved. If the backend ever does liveness
2941 // correctly after setjmp, this will be unnecessary.
2942 llvm::Value *SyncArgSlot = 0;
Daniel Dunbar1c566672009-02-24 01:43:46 +00002943 if (!isTry) {
John McCall0b251722010-08-04 05:59:32 +00002944 llvm::Value *SyncArg =
Daniel Dunbar1c566672009-02-24 01:43:46 +00002945 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
2946 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
John McCallf1549f62010-07-06 01:34:17 +00002947 CGF.Builder.CreateCall(ObjCTypes.getSyncEnterFn(), SyncArg)
2948 ->setDoesNotThrow();
John McCall0b251722010-08-04 05:59:32 +00002949
2950 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(), "sync.arg");
2951 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
Daniel Dunbar1c566672009-02-24 01:43:46 +00002952 }
Daniel Dunbar898d5082008-09-30 01:06:03 +00002953
John McCall0b251722010-08-04 05:59:32 +00002954 // Allocate memory for the setjmp buffer. This needs to be kept
2955 // live throughout the try and catch blocks.
2956 llvm::Value *ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
2957 "exceptiondata.ptr");
2958
John McCall87bb5822010-07-31 23:20:56 +00002959 // Create the fragile hazards. Note that this will not capture any
2960 // of the allocas required for exception processing, but will
2961 // capture the current basic block (which extends all the way to the
2962 // setjmp call) as "before the @try".
2963 FragileHazards Hazards(CGF);
2964
John McCallf1549f62010-07-06 01:34:17 +00002965 // Create a flag indicating whether the cleanup needs to call
2966 // objc_exception_try_exit. This is true except when
2967 // - no catches match and we're branching through the cleanup
2968 // just to rethrow the exception, or
2969 // - a catch matched and we're falling out of the catch handler.
John McCall0b251722010-08-04 05:59:32 +00002970 // The setjmp-safety rule here is that we should always store to this
2971 // variable in a place that dominates the branch through the cleanup
2972 // without passing through any setjmps.
John McCallf1549f62010-07-06 01:34:17 +00002973 llvm::Value *CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
Anders Carlsson190d00e2009-02-07 21:26:04 +00002974 "_call_try_exit");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00002975
John McCall9e2213d2010-10-04 23:42:51 +00002976 // A slot containing the exception to rethrow. Only needed when we
2977 // have both a @catch and a @finally.
2978 llvm::Value *PropagatingExnVar = 0;
2979
John McCallf1549f62010-07-06 01:34:17 +00002980 // Push a normal cleanup to leave the try scope.
John McCall1f0fca52010-07-21 07:22:38 +00002981 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalCleanup, &S,
John McCall0b251722010-08-04 05:59:32 +00002982 SyncArgSlot,
John McCall1f0fca52010-07-21 07:22:38 +00002983 CallTryExitVar,
2984 ExceptionData,
2985 &ObjCTypes);
John McCallf1549f62010-07-06 01:34:17 +00002986
2987 // Enter a try block:
2988 // - Call objc_exception_try_enter to push ExceptionData on top of
2989 // the EH stack.
2990 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryEnterFn(), ExceptionData)
2991 ->setDoesNotThrow();
2992
2993 // - Call setjmp on the exception data buffer.
2994 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
2995 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
2996 llvm::Value *SetJmpBuffer =
2997 CGF.Builder.CreateGEP(ExceptionData, GEPIndexes, GEPIndexes+3, "setjmp_buffer");
2998 llvm::CallInst *SetJmpResult =
2999 CGF.Builder.CreateCall(ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
3000 SetJmpResult->setDoesNotThrow();
3001
3002 // If setjmp returned 0, enter the protected block; otherwise,
3003 // branch to the handler.
Daniel Dunbar55e87422008-11-11 02:29:29 +00003004 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
3005 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
John McCallf1549f62010-07-06 01:34:17 +00003006 llvm::Value *DidCatch =
John McCalld96a8e72010-08-11 00:16:14 +00003007 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
3008 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
Anders Carlsson80f25672008-09-09 17:59:25 +00003009
John McCallf1549f62010-07-06 01:34:17 +00003010 // Emit the protected block.
Anders Carlsson80f25672008-09-09 17:59:25 +00003011 CGF.EmitBlock(TryBlock);
John McCall0b251722010-08-04 05:59:32 +00003012 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003013 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
John McCallf1549f62010-07-06 01:34:17 +00003014 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
John McCall0b251722010-08-04 05:59:32 +00003015
3016 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003017
John McCallf1549f62010-07-06 01:34:17 +00003018 // Emit the exception handler block.
Daniel Dunbare4b5ee02008-09-27 23:30:04 +00003019 CGF.EmitBlock(TryHandler);
Daniel Dunbar55e40722008-09-27 07:03:52 +00003020
John McCall87bb5822010-07-31 23:20:56 +00003021 // Don't optimize loads of the in-scope locals across this point.
3022 Hazards.emitWriteHazard();
3023
John McCallf1549f62010-07-06 01:34:17 +00003024 // For a @synchronized (or a @try with no catches), just branch
3025 // through the cleanup to the rethrow block.
3026 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
3027 // Tell the cleanup not to re-pop the exit.
John McCall0b251722010-08-04 05:59:32 +00003028 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
Anders Carlssonf3a79a92009-02-09 20:38:58 +00003029 CGF.EmitBranchThroughCleanup(FinallyRethrow);
John McCallf1549f62010-07-06 01:34:17 +00003030
3031 // Otherwise, we have to match against the caught exceptions.
3032 } else {
John McCall0b251722010-08-04 05:59:32 +00003033 // Retrieve the exception object. We may emit multiple blocks but
3034 // nothing can cross this so the value is already in SSA form.
3035 llvm::CallInst *Caught =
3036 CGF.Builder.CreateCall(ObjCTypes.getExceptionExtractFn(),
3037 ExceptionData, "caught");
3038 Caught->setDoesNotThrow();
3039
John McCallf1549f62010-07-06 01:34:17 +00003040 // Push the exception to rethrow onto the EH value stack for the
3041 // benefit of any @throws in the handlers.
3042 CGF.ObjCEHValueStack.push_back(Caught);
3043
Douglas Gregor8f5e3dd2010-04-23 22:50:49 +00003044 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003045
John McCall0b251722010-08-04 05:59:32 +00003046 bool HasFinally = (AtTryStmt->getFinallyStmt() != 0);
John McCallf1549f62010-07-06 01:34:17 +00003047
John McCall0b251722010-08-04 05:59:32 +00003048 llvm::BasicBlock *CatchBlock = 0;
3049 llvm::BasicBlock *CatchHandler = 0;
3050 if (HasFinally) {
John McCall9e2213d2010-10-04 23:42:51 +00003051 // Save the currently-propagating exception before
3052 // objc_exception_try_enter clears the exception slot.
3053 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
3054 "propagating_exception");
3055 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
3056
John McCall0b251722010-08-04 05:59:32 +00003057 // Enter a new exception try block (in case a @catch block
3058 // throws an exception).
3059 CGF.Builder.CreateCall(ObjCTypes.getExceptionTryEnterFn(), ExceptionData)
3060 ->setDoesNotThrow();
Anders Carlsson80f25672008-09-09 17:59:25 +00003061
John McCall0b251722010-08-04 05:59:32 +00003062 llvm::CallInst *SetJmpResult =
3063 CGF.Builder.CreateCall(ObjCTypes.getSetJmpFn(), SetJmpBuffer,
3064 "setjmp.result");
3065 SetJmpResult->setDoesNotThrow();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003066
John McCall0b251722010-08-04 05:59:32 +00003067 llvm::Value *Threw =
3068 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
3069
3070 CatchBlock = CGF.createBasicBlock("catch");
3071 CatchHandler = CGF.createBasicBlock("catch_for_catch");
3072 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
3073
3074 CGF.EmitBlock(CatchBlock);
3075 }
3076
3077 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003078
Daniel Dunbar55e40722008-09-27 07:03:52 +00003079 // Handle catch list. As a special case we check if everything is
3080 // matched and avoid generating code for falling off the end if
3081 // so.
3082 bool AllMatched = false;
Douglas Gregor8f5e3dd2010-04-23 22:50:49 +00003083 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
3084 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
Anders Carlsson80f25672008-09-09 17:59:25 +00003085
Douglas Gregorc00d8e12010-04-26 16:46:50 +00003086 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
Steve Naroff14108da2009-07-10 23:34:53 +00003087 const ObjCObjectPointerType *OPT = 0;
Daniel Dunbar129271a2008-09-27 07:36:24 +00003088
Anders Carlsson80f25672008-09-09 17:59:25 +00003089 // catch(...) always matches.
Daniel Dunbar55e40722008-09-27 07:03:52 +00003090 if (!CatchParam) {
3091 AllMatched = true;
3092 } else {
John McCall183700f2009-09-21 23:43:11 +00003093 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003094
John McCallf1549f62010-07-06 01:34:17 +00003095 // catch(id e) always matches under this ABI, since only
3096 // ObjC exceptions end up here in the first place.
Daniel Dunbar97f61d12008-09-27 22:21:14 +00003097 // FIXME: For the time being we also match id<X>; this should
3098 // be rejected by Sema instead.
Eli Friedman818e96f2009-07-11 00:57:02 +00003099 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
Daniel Dunbar55e40722008-09-27 07:03:52 +00003100 AllMatched = true;
Anders Carlsson80f25672008-09-09 17:59:25 +00003101 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003102
John McCallf1549f62010-07-06 01:34:17 +00003103 // If this is a catch-all, we don't need to test anything.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003104 if (AllMatched) {
John McCallf1549f62010-07-06 01:34:17 +00003105 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
3106
Anders Carlssondde0a942008-09-11 09:15:33 +00003107 if (CatchParam) {
John McCallb6bbcc92010-10-15 04:57:14 +00003108 CGF.EmitAutoVarDecl(*CatchParam);
Daniel Dunbara448fb22008-11-11 23:11:34 +00003109 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
John McCallf1549f62010-07-06 01:34:17 +00003110
3111 // These types work out because ConvertType(id) == i8*.
Steve Naroff7ba138a2009-03-03 19:52:17 +00003112 CGF.Builder.CreateStore(Caught, CGF.GetAddrOfLocalVar(CatchParam));
Anders Carlssondde0a942008-09-11 09:15:33 +00003113 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003114
Anders Carlssondde0a942008-09-11 09:15:33 +00003115 CGF.EmitStmt(CatchStmt->getCatchBody());
John McCallf1549f62010-07-06 01:34:17 +00003116
3117 // The scope of the catch variable ends right here.
3118 CatchVarCleanups.ForceCleanup();
3119
Anders Carlssonf3a79a92009-02-09 20:38:58 +00003120 CGF.EmitBranchThroughCleanup(FinallyEnd);
Anders Carlsson80f25672008-09-09 17:59:25 +00003121 break;
3122 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003123
Steve Naroff14108da2009-07-10 23:34:53 +00003124 assert(OPT && "Unexpected non-object pointer type in @catch");
John McCall506b57e2010-05-17 21:00:27 +00003125 const ObjCObjectType *ObjTy = OPT->getObjectType();
John McCallf1549f62010-07-06 01:34:17 +00003126
3127 // FIXME: @catch (Class c) ?
John McCall506b57e2010-05-17 21:00:27 +00003128 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
3129 assert(IDecl && "Catch parameter must have Objective-C type!");
Anders Carlsson80f25672008-09-09 17:59:25 +00003130
3131 // Check if the @catch block matches the exception object.
John McCall506b57e2010-05-17 21:00:27 +00003132 llvm::Value *Class = EmitClassRef(CGF.Builder, IDecl);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003133
John McCallf1549f62010-07-06 01:34:17 +00003134 llvm::CallInst *Match =
Chris Lattner34b02a12009-04-22 02:26:14 +00003135 CGF.Builder.CreateCall2(ObjCTypes.getExceptionMatchFn(),
3136 Class, Caught, "match");
John McCallf1549f62010-07-06 01:34:17 +00003137 Match->setDoesNotThrow();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003138
John McCallf1549f62010-07-06 01:34:17 +00003139 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
3140 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003141
3142 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
Daniel Dunbare4b5ee02008-09-27 23:30:04 +00003143 MatchedBlock, NextCatchBlock);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003144
Anders Carlsson80f25672008-09-09 17:59:25 +00003145 // Emit the @catch block.
3146 CGF.EmitBlock(MatchedBlock);
John McCallf1549f62010-07-06 01:34:17 +00003147
3148 // Collect any cleanups for the catch variable. The scope lasts until
3149 // the end of the catch body.
John McCall0b251722010-08-04 05:59:32 +00003150 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
John McCallf1549f62010-07-06 01:34:17 +00003151
John McCallb6bbcc92010-10-15 04:57:14 +00003152 CGF.EmitAutoVarDecl(*CatchParam);
Daniel Dunbara448fb22008-11-11 23:11:34 +00003153 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
Daniel Dunbar18ccc772008-09-28 01:03:14 +00003154
John McCallf1549f62010-07-06 01:34:17 +00003155 // Initialize the catch variable.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003156 llvm::Value *Tmp =
3157 CGF.Builder.CreateBitCast(Caught,
3158 CGF.ConvertType(CatchParam->getType()),
Daniel Dunbar18ccc772008-09-28 01:03:14 +00003159 "tmp");
Steve Naroff7ba138a2009-03-03 19:52:17 +00003160 CGF.Builder.CreateStore(Tmp, CGF.GetAddrOfLocalVar(CatchParam));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003161
Anders Carlssondde0a942008-09-11 09:15:33 +00003162 CGF.EmitStmt(CatchStmt->getCatchBody());
John McCallf1549f62010-07-06 01:34:17 +00003163
3164 // We're done with the catch variable.
3165 CatchVarCleanups.ForceCleanup();
3166
Anders Carlssonf3a79a92009-02-09 20:38:58 +00003167 CGF.EmitBranchThroughCleanup(FinallyEnd);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003168
Anders Carlsson80f25672008-09-09 17:59:25 +00003169 CGF.EmitBlock(NextCatchBlock);
3170 }
3171
John McCallf1549f62010-07-06 01:34:17 +00003172 CGF.ObjCEHValueStack.pop_back();
3173
John McCall0b251722010-08-04 05:59:32 +00003174 // If nothing wanted anything to do with the caught exception,
3175 // kill the extract call.
3176 if (Caught->use_empty())
3177 Caught->eraseFromParent();
3178
3179 if (!AllMatched)
3180 CGF.EmitBranchThroughCleanup(FinallyRethrow);
3181
3182 if (HasFinally) {
3183 // Emit the exception handler for the @catch blocks.
3184 CGF.EmitBlock(CatchHandler);
3185
3186 // In theory we might now need a write hazard, but actually it's
3187 // unnecessary because there's no local-accessing code between
3188 // the try's write hazard and here.
3189 //Hazards.emitWriteHazard();
3190
John McCall9e2213d2010-10-04 23:42:51 +00003191 // Extract the new exception and save it to the
3192 // propagating-exception slot.
3193 assert(PropagatingExnVar);
3194 llvm::CallInst *NewCaught =
3195 CGF.Builder.CreateCall(ObjCTypes.getExceptionExtractFn(),
3196 ExceptionData, "caught");
3197 NewCaught->setDoesNotThrow();
3198 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
3199
John McCall0b251722010-08-04 05:59:32 +00003200 // Don't pop the catch handler; the throw already did.
3201 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
Anders Carlssonf3a79a92009-02-09 20:38:58 +00003202 CGF.EmitBranchThroughCleanup(FinallyRethrow);
Daniel Dunbar55e40722008-09-27 07:03:52 +00003203 }
Anders Carlsson80f25672008-09-09 17:59:25 +00003204 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003205
John McCall87bb5822010-07-31 23:20:56 +00003206 // Insert read hazards as required in the new blocks.
John McCall0b251722010-08-04 05:59:32 +00003207 Hazards.emitHazardsInNewBlocks();
John McCall87bb5822010-07-31 23:20:56 +00003208
John McCallf1549f62010-07-06 01:34:17 +00003209 // Pop the cleanup.
John McCall0b251722010-08-04 05:59:32 +00003210 CGF.Builder.restoreIP(TryFallthroughIP);
3211 if (CGF.HaveInsertPoint())
3212 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
John McCallf1549f62010-07-06 01:34:17 +00003213 CGF.PopCleanupBlock();
John McCall0b251722010-08-04 05:59:32 +00003214 CGF.EmitBlock(FinallyEnd.getBlock(), true);
Anders Carlssonf3a79a92009-02-09 20:38:58 +00003215
John McCallf1549f62010-07-06 01:34:17 +00003216 // Emit the rethrow block.
John McCall87bb5822010-07-31 23:20:56 +00003217 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
John McCallff8e1152010-07-23 21:56:41 +00003218 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
John McCallf1549f62010-07-06 01:34:17 +00003219 if (CGF.HaveInsertPoint()) {
John McCall9e2213d2010-10-04 23:42:51 +00003220 // If we have a propagating-exception variable, check it.
3221 llvm::Value *PropagatingExn;
3222 if (PropagatingExnVar) {
3223 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
John McCall0b251722010-08-04 05:59:32 +00003224
John McCall9e2213d2010-10-04 23:42:51 +00003225 // Otherwise, just look in the buffer for the exception to throw.
3226 } else {
3227 llvm::CallInst *Caught =
3228 CGF.Builder.CreateCall(ObjCTypes.getExceptionExtractFn(),
3229 ExceptionData);
3230 Caught->setDoesNotThrow();
3231 PropagatingExn = Caught;
3232 }
3233
3234 CGF.Builder.CreateCall(ObjCTypes.getExceptionThrowFn(), PropagatingExn)
John McCallf1549f62010-07-06 01:34:17 +00003235 ->setDoesNotThrow();
3236 CGF.Builder.CreateUnreachable();
Fariborz Jahanianf2878e52008-11-21 19:21:53 +00003237 }
Anders Carlsson80f25672008-09-09 17:59:25 +00003238
John McCall87bb5822010-07-31 23:20:56 +00003239 CGF.Builder.restoreIP(SavedIP);
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00003240}
3241
3242void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar898d5082008-09-30 01:06:03 +00003243 const ObjCAtThrowStmt &S) {
Anders Carlsson2b1e3112008-09-09 16:16:55 +00003244 llvm::Value *ExceptionAsObject;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003245
Anders Carlsson2b1e3112008-09-09 16:16:55 +00003246 if (const Expr *ThrowExpr = S.getThrowExpr()) {
3247 llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003248 ExceptionAsObject =
Anders Carlsson2b1e3112008-09-09 16:16:55 +00003249 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp");
3250 } else {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003251 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
Daniel Dunbar18ccc772008-09-28 01:03:14 +00003252 "Unexpected rethrow outside @catch block.");
Anders Carlsson273558f2009-02-07 21:37:21 +00003253 ExceptionAsObject = CGF.ObjCEHValueStack.back();
Anders Carlsson2b1e3112008-09-09 16:16:55 +00003254 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003255
John McCallf1549f62010-07-06 01:34:17 +00003256 CGF.Builder.CreateCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
3257 ->setDoesNotReturn();
Anders Carlsson80f25672008-09-09 17:59:25 +00003258 CGF.Builder.CreateUnreachable();
Daniel Dunbara448fb22008-11-11 23:11:34 +00003259
3260 // Clear the insertion point to indicate we are in unreachable code.
3261 CGF.Builder.ClearInsertionPoint();
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00003262}
3263
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00003264/// EmitObjCWeakRead - Code gen for loading value of a __weak
Fariborz Jahanian6dc23172008-11-18 21:45:40 +00003265/// object: objc_read_weak (id *src)
3266///
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00003267llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00003268 llvm::Value *AddrWeakObj) {
Eli Friedman8339b352009-03-07 03:57:15 +00003269 const llvm::Type* DestTy =
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003270 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
3271 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
3272 ObjCTypes.PtrObjectPtrTy);
Chris Lattner72db6c32009-04-22 02:44:54 +00003273 llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.getGcReadWeakFn(),
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00003274 AddrWeakObj, "weakread");
Eli Friedman8339b352009-03-07 03:57:15 +00003275 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
Fariborz Jahanian6dc23172008-11-18 21:45:40 +00003276 return read_weak;
3277}
3278
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00003279/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
3280/// objc_assign_weak (id src, id *dst)
3281///
3282void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00003283 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00003284 const llvm::Type * SrcTy = src->getType();
3285 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sands9408c452009-05-09 07:08:47 +00003286 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00003287 assert(Size <= 8 && "does not support size > 8");
3288 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003289 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
Fariborz Jahanian3b8a6522009-03-13 00:42:52 +00003290 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
3291 }
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +00003292 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
3293 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattner96508e12009-04-17 22:12:36 +00003294 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignWeakFn(),
Fariborz Jahanian3e283e32008-11-18 22:37:34 +00003295 src, dst, "weakassign");
3296 return;
3297}
3298
Fariborz Jahanian58626502008-11-19 00:59:10 +00003299/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
3300/// objc_assign_global (id src, id *dst)
3301///
3302void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00003303 llvm::Value *src, llvm::Value *dst,
3304 bool threadlocal) {
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00003305 const llvm::Type * SrcTy = src->getType();
3306 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sands9408c452009-05-09 07:08:47 +00003307 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00003308 assert(Size <= 8 && "does not support size > 8");
3309 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003310 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
Fariborz Jahanian3b8a6522009-03-13 00:42:52 +00003311 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
3312 }
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +00003313 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
3314 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00003315 if (!threadlocal)
3316 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignGlobalFn(),
3317 src, dst, "globalassign");
3318 else
3319 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignThreadLocalFn(),
3320 src, dst, "threadlocalassign");
Fariborz Jahanian58626502008-11-19 00:59:10 +00003321 return;
3322}
3323
Fariborz Jahanian7eda8362008-11-20 19:23:36 +00003324/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00003325/// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
Fariborz Jahanian7eda8362008-11-20 19:23:36 +00003326///
3327void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00003328 llvm::Value *src, llvm::Value *dst,
3329 llvm::Value *ivarOffset) {
3330 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00003331 const llvm::Type * SrcTy = src->getType();
3332 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sands9408c452009-05-09 07:08:47 +00003333 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00003334 assert(Size <= 8 && "does not support size > 8");
3335 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003336 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
Fariborz Jahanian3b8a6522009-03-13 00:42:52 +00003337 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
3338 }
Fariborz Jahanian7eda8362008-11-20 19:23:36 +00003339 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
3340 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00003341 CGF.Builder.CreateCall3(ObjCTypes.getGcAssignIvarFn(),
3342 src, dst, ivarOffset);
Fariborz Jahanian7eda8362008-11-20 19:23:36 +00003343 return;
3344}
3345
Fariborz Jahanian58626502008-11-19 00:59:10 +00003346/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
3347/// objc_assign_strongCast (id src, id *dst)
3348///
3349void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00003350 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00003351 const llvm::Type * SrcTy = src->getType();
3352 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sands9408c452009-05-09 07:08:47 +00003353 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00003354 assert(Size <= 8 && "does not support size > 8");
3355 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003356 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
Fariborz Jahanian3b8a6522009-03-13 00:42:52 +00003357 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
3358 }
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +00003359 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
3360 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattnerbbccd612009-04-22 02:38:11 +00003361 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignStrongCastFn(),
Fariborz Jahanian58626502008-11-19 00:59:10 +00003362 src, dst, "weakassign");
3363 return;
3364}
3365
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00003366void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003367 llvm::Value *DestPtr,
3368 llvm::Value *SrcPtr,
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00003369 llvm::Value *size) {
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00003370 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
3371 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00003372 CGF.Builder.CreateCall3(ObjCTypes.GcMemmoveCollectableFn(),
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00003373 DestPtr, SrcPtr, size);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00003374 return;
3375}
3376
Fariborz Jahanian0bb20362009-02-02 20:02:29 +00003377/// EmitObjCValueForIvar - Code Gen for ivar reference.
3378///
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00003379LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
3380 QualType ObjectTy,
3381 llvm::Value *BaseValue,
3382 const ObjCIvarDecl *Ivar,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00003383 unsigned CVRQualifiers) {
John McCallc12c5bb2010-05-15 11:32:37 +00003384 const ObjCInterfaceDecl *ID =
3385 ObjectTy->getAs<ObjCObjectType>()->getInterface();
Daniel Dunbar97776872009-04-22 07:32:20 +00003386 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
3387 EmitIvarOffset(CGF, ID, Ivar));
Fariborz Jahanian0bb20362009-02-02 20:02:29 +00003388}
3389
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00003390llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
Daniel Dunbar2a031922009-04-22 05:08:15 +00003391 const ObjCInterfaceDecl *Interface,
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00003392 const ObjCIvarDecl *Ivar) {
Daniel Dunbar97776872009-04-22 07:32:20 +00003393 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00003394 return llvm::ConstantInt::get(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003395 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
3396 Offset);
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00003397}
3398
Daniel Dunbarf77ac862008-08-11 21:35:06 +00003399/* *** Private Interface *** */
3400
3401/// EmitImageInfo - Emit the image info marker used to encode some module
3402/// level information.
3403///
3404/// See: <rdr://4810609&4810587&4810587>
3405/// struct IMAGE_INFO {
3406/// unsigned version;
3407/// unsigned flags;
3408/// };
3409enum ImageInfoFlags {
Daniel Dunbarfce176b2010-04-25 20:39:01 +00003410 eImageInfo_FixAndContinue = (1 << 0),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003411 eImageInfo_GarbageCollected = (1 << 1),
3412 eImageInfo_GCOnly = (1 << 2),
Daniel Dunbarc7c6dc02009-04-20 07:11:47 +00003413 eImageInfo_OptimizedByDyld = (1 << 3), // FIXME: When is this set.
3414
Daniel Dunbarfce176b2010-04-25 20:39:01 +00003415 // A flag indicating that the module has no instances of a @synthesize of a
3416 // superclass variable. <rdar://problem/6803242>
Daniel Dunbarc7c6dc02009-04-20 07:11:47 +00003417 eImageInfo_CorrectedSynthesize = (1 << 4)
Daniel Dunbarf77ac862008-08-11 21:35:06 +00003418};
3419
Daniel Dunbarfce176b2010-04-25 20:39:01 +00003420void CGObjCCommonMac::EmitImageInfo() {
Daniel Dunbarf77ac862008-08-11 21:35:06 +00003421 unsigned version = 0; // Version is unused?
3422 unsigned flags = 0;
3423
3424 // FIXME: Fix and continue?
3425 if (CGM.getLangOptions().getGCMode() != LangOptions::NonGC)
3426 flags |= eImageInfo_GarbageCollected;
3427 if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly)
3428 flags |= eImageInfo_GCOnly;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003429
Daniel Dunbarc7c6dc02009-04-20 07:11:47 +00003430 // We never allow @synthesize of a superclass property.
3431 flags |= eImageInfo_CorrectedSynthesize;
Daniel Dunbarf77ac862008-08-11 21:35:06 +00003432
Chris Lattner77b89b82010-06-27 07:15:29 +00003433 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
3434
Daniel Dunbarf77ac862008-08-11 21:35:06 +00003435 // Emitted as int[2];
3436 llvm::Constant *values[2] = {
Chris Lattner77b89b82010-06-27 07:15:29 +00003437 llvm::ConstantInt::get(Int32Ty, version),
3438 llvm::ConstantInt::get(Int32Ty, flags)
Daniel Dunbarf77ac862008-08-11 21:35:06 +00003439 };
Chris Lattner77b89b82010-06-27 07:15:29 +00003440 llvm::ArrayType *AT = llvm::ArrayType::get(Int32Ty, 2);
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003441
3442 const char *Section;
3443 if (ObjCABI == 1)
3444 Section = "__OBJC, __image_info,regular";
3445 else
3446 Section = "__DATA, __objc_imageinfo, regular, no_dead_strip";
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003447 llvm::GlobalVariable *GV =
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003448 CreateMetadataVar("\01L_OBJC_IMAGE_INFO",
Owen Anderson7db6d832009-07-28 18:33:04 +00003449 llvm::ConstantArray::get(AT, values, 2),
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003450 Section,
3451 0,
3452 true);
3453 GV->setConstant(true);
Daniel Dunbarf77ac862008-08-11 21:35:06 +00003454}
3455
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003456
3457// struct objc_module {
3458// unsigned long version;
3459// unsigned long size;
3460// const char *name;
3461// Symtab symtab;
3462// };
3463
3464// FIXME: Get from somewhere
3465static const int ModuleVersion = 7;
3466
3467void CGObjCMac::EmitModuleInfo() {
Duncan Sands9408c452009-05-09 07:08:47 +00003468 uint64_t Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.ModuleTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003469
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003470 std::vector<llvm::Constant*> Values(4);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00003471 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion);
3472 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
Daniel Dunbar7ded7f42008-08-15 22:20:32 +00003473 // This used to be the filename, now it is unused. <rdr://4327263>
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00003474 Values[2] = GetClassName(&CGM.getContext().Idents.get(""));
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003475 Values[3] = EmitModuleSymbols();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003476 CreateMetadataVar("\01L_OBJC_MODULES",
Owen Anderson08e25242009-07-27 22:29:56 +00003477 llvm::ConstantStruct::get(ObjCTypes.ModuleTy, Values),
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003478 "__OBJC,__module_info,regular,no_dead_strip",
Daniel Dunbar58a29122009-03-09 22:18:41 +00003479 4, true);
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003480}
3481
3482llvm::Constant *CGObjCMac::EmitModuleSymbols() {
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003483 unsigned NumClasses = DefinedClasses.size();
3484 unsigned NumCategories = DefinedCategories.size();
3485
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00003486 // Return null if no symbols were defined.
3487 if (!NumClasses && !NumCategories)
Owen Andersonc9c88b42009-07-31 20:28:54 +00003488 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00003489
3490 std::vector<llvm::Constant*> Values(5);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00003491 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
Owen Andersonc9c88b42009-07-31 20:28:54 +00003492 Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00003493 Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
3494 Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003495
Daniel Dunbar86e253a2008-08-22 20:34:54 +00003496 // The runtime expects exactly the list of defined classes followed
3497 // by the list of defined categories, in a single array.
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003498 std::vector<llvm::Constant*> Symbols(NumClasses + NumCategories);
Daniel Dunbar86e253a2008-08-22 20:34:54 +00003499 for (unsigned i=0; i<NumClasses; i++)
Owen Anderson3c4972d2009-07-29 18:54:39 +00003500 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
Daniel Dunbar86e253a2008-08-22 20:34:54 +00003501 ObjCTypes.Int8PtrTy);
3502 for (unsigned i=0; i<NumCategories; i++)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003503 Symbols[NumClasses + i] =
Owen Anderson3c4972d2009-07-29 18:54:39 +00003504 llvm::ConstantExpr::getBitCast(DefinedCategories[i],
Daniel Dunbar86e253a2008-08-22 20:34:54 +00003505 ObjCTypes.Int8PtrTy);
3506
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003507 Values[4] =
Owen Anderson96e0fc72009-07-29 22:16:19 +00003508 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003509 NumClasses + NumCategories),
3510 Symbols);
3511
Nick Lewycky0d36dd22009-09-19 20:00:52 +00003512 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003513
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003514 llvm::GlobalVariable *GV =
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003515 CreateMetadataVar("\01L_OBJC_SYMBOLS", Init,
3516 "__OBJC,__symbols,regular,no_dead_strip",
Daniel Dunbar0bf21992009-04-15 02:56:18 +00003517 4, true);
Owen Anderson3c4972d2009-07-29 18:54:39 +00003518 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003519}
3520
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003521llvm::Value *CGObjCMac::EmitClassRef(CGBuilderTy &Builder,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003522 const ObjCInterfaceDecl *ID) {
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00003523 LazySymbols.insert(ID->getIdentifier());
3524
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003525 llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()];
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003526
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003527 if (!Entry) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003528 llvm::Constant *Casted =
Owen Anderson3c4972d2009-07-29 18:54:39 +00003529 llvm::ConstantExpr::getBitCast(GetClassName(ID->getIdentifier()),
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003530 ObjCTypes.ClassPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003531 Entry =
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003532 CreateMetadataVar("\01L_OBJC_CLASS_REFERENCES_", Casted,
3533 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
Daniel Dunbar0bf21992009-04-15 02:56:18 +00003534 4, true);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003535 }
3536
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00003537 return Builder.CreateLoad(Entry, "tmp");
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003538}
3539
Fariborz Jahanian03b29602010-06-17 19:56:20 +00003540llvm::Value *CGObjCMac::EmitSelector(CGBuilderTy &Builder, Selector Sel,
3541 bool lvalue) {
Daniel Dunbar259d93d2008-08-12 03:39:23 +00003542 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003543
Daniel Dunbar259d93d2008-08-12 03:39:23 +00003544 if (!Entry) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003545 llvm::Constant *Casted =
Owen Anderson3c4972d2009-07-29 18:54:39 +00003546 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
Daniel Dunbar259d93d2008-08-12 03:39:23 +00003547 ObjCTypes.SelectorPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003548 Entry =
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003549 CreateMetadataVar("\01L_OBJC_SELECTOR_REFERENCES_", Casted,
3550 "__OBJC,__message_refs,literal_pointers,no_dead_strip",
Daniel Dunbar0bf21992009-04-15 02:56:18 +00003551 4, true);
Daniel Dunbar259d93d2008-08-12 03:39:23 +00003552 }
3553
Fariborz Jahanian03b29602010-06-17 19:56:20 +00003554 if (lvalue)
3555 return Entry;
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00003556 return Builder.CreateLoad(Entry, "tmp");
Daniel Dunbar259d93d2008-08-12 03:39:23 +00003557}
3558
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00003559llvm::Constant *CGObjCCommonMac::GetClassName(IdentifierInfo *Ident) {
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00003560 llvm::GlobalVariable *&Entry = ClassNames[Ident];
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003561
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003562 if (!Entry)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003563 Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00003564 llvm::ConstantArray::get(VMContext,
3565 Ident->getNameStart()),
Daniel Dunbar6633e3c2010-07-29 22:57:21 +00003566 "__TEXT,__cstring,cstring_literals",
Daniel Dunbarb90bb002009-04-14 23:14:47 +00003567 1, true);
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003568
Owen Andersona1cf15f2009-07-14 23:10:40 +00003569 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00003570}
3571
Argyrios Kyrtzidis9d50c062010-08-09 10:54:20 +00003572llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
3573 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
3574 I = MethodDefinitions.find(MD);
3575 if (I != MethodDefinitions.end())
3576 return I->second;
3577
3578 if (MD->hasBody() && MD->getPCHLevel() > 0) {
3579 // MD isn't emitted yet because it comes from PCH.
3580 CGM.EmitTopLevelDecl(const_cast<ObjCMethodDecl*>(MD));
3581 assert(MethodDefinitions[MD] && "EmitTopLevelDecl didn't emit the method!");
3582 return MethodDefinitions[MD];
3583 }
3584
3585 return NULL;
3586}
3587
Fariborz Jahaniand80d81b2009-03-05 19:17:31 +00003588/// GetIvarLayoutName - Returns a unique constant for the given
3589/// ivar layout bitmap.
3590llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003591 const ObjCCommonTypesHelper &ObjCTypes) {
Owen Andersonc9c88b42009-07-31 20:28:54 +00003592 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
Fariborz Jahaniand80d81b2009-03-05 19:17:31 +00003593}
3594
Daniel Dunbard58edcb2009-05-03 14:10:34 +00003595void CGObjCCommonMac::BuildAggrIvarRecordLayout(const RecordType *RT,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003596 unsigned int BytePos,
Daniel Dunbard58edcb2009-05-03 14:10:34 +00003597 bool ForStrongLayout,
3598 bool &HasUnion) {
3599 const RecordDecl *RD = RT->getDecl();
3600 // FIXME - Use iterator.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003601 llvm::SmallVector<FieldDecl*, 16> Fields(RD->field_begin(), RD->field_end());
Daniel Dunbard58edcb2009-05-03 14:10:34 +00003602 const llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003603 const llvm::StructLayout *RecLayout =
Daniel Dunbard58edcb2009-05-03 14:10:34 +00003604 CGM.getTargetData().getStructLayout(cast<llvm::StructType>(Ty));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003605
Daniel Dunbard58edcb2009-05-03 14:10:34 +00003606 BuildAggrIvarLayout(0, RecLayout, RD, Fields, BytePos,
3607 ForStrongLayout, HasUnion);
3608}
3609
Daniel Dunbar5a5a8032009-05-03 21:05:10 +00003610void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCImplementationDecl *OI,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003611 const llvm::StructLayout *Layout,
3612 const RecordDecl *RD,
Chris Lattnerf1690852009-03-31 08:48:01 +00003613 const llvm::SmallVectorImpl<FieldDecl*> &RecFields,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003614 unsigned int BytePos, bool ForStrongLayout,
3615 bool &HasUnion) {
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003616 bool IsUnion = (RD && RD->isUnion());
3617 uint64_t MaxUnionIvarSize = 0;
3618 uint64_t MaxSkippedUnionIvarSize = 0;
3619 FieldDecl *MaxField = 0;
3620 FieldDecl *MaxSkippedField = 0;
Argyrios Kyrtzidis0dc75092010-09-06 12:00:10 +00003621 FieldDecl *LastFieldBitfieldOrUnnamed = 0;
Daniel Dunbar900c1982009-05-03 23:31:46 +00003622 uint64_t MaxFieldOffset = 0;
3623 uint64_t MaxSkippedFieldOffset = 0;
Argyrios Kyrtzidis0dc75092010-09-06 12:00:10 +00003624 uint64_t LastBitfieldOrUnnamedOffset = 0;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003625
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +00003626 if (RecFields.empty())
3627 return;
Chris Lattnerf1690852009-03-31 08:48:01 +00003628 unsigned WordSizeInBits = CGM.getContext().Target.getPointerWidth(0);
3629 unsigned ByteSizeInBits = CGM.getContext().Target.getCharWidth();
3630
Chris Lattnerf1690852009-03-31 08:48:01 +00003631 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +00003632 FieldDecl *Field = RecFields[i];
Daniel Dunbare05cc982009-05-03 23:35:23 +00003633 uint64_t FieldOffset;
Anders Carlssonfc514ab2009-07-24 17:23:54 +00003634 if (RD) {
Daniel Dunbarf8f8eba2010-04-14 17:02:21 +00003635 // Note that 'i' here is actually the field index inside RD of Field,
3636 // although this dependency is hidden.
3637 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
3638 FieldOffset = RL.getFieldOffset(i) / 8;
Anders Carlssonfc514ab2009-07-24 17:23:54 +00003639 } else
Daniel Dunbare05cc982009-05-03 23:35:23 +00003640 FieldOffset = ComputeIvarBaseOffset(CGM, OI, cast<ObjCIvarDecl>(Field));
Daniel Dunbar25d583e2009-05-03 14:17:18 +00003641
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +00003642 // Skip over unnamed or bitfields
Fariborz Jahanian7fb16272009-04-21 18:33:06 +00003643 if (!Field->getIdentifier() || Field->isBitField()) {
Argyrios Kyrtzidis0dc75092010-09-06 12:00:10 +00003644 LastFieldBitfieldOrUnnamed = Field;
3645 LastBitfieldOrUnnamedOffset = FieldOffset;
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +00003646 continue;
Fariborz Jahanian7fb16272009-04-21 18:33:06 +00003647 }
Daniel Dunbar25d583e2009-05-03 14:17:18 +00003648
Argyrios Kyrtzidis0dc75092010-09-06 12:00:10 +00003649 LastFieldBitfieldOrUnnamed = 0;
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +00003650 QualType FQT = Field->getType();
Fariborz Jahanian667423a2009-03-25 22:36:49 +00003651 if (FQT->isRecordType() || FQT->isUnionType()) {
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +00003652 if (FQT->isUnionType())
3653 HasUnion = true;
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003654
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003655 BuildAggrIvarRecordLayout(FQT->getAs<RecordType>(),
Daniel Dunbar25d583e2009-05-03 14:17:18 +00003656 BytePos + FieldOffset,
Daniel Dunbard58edcb2009-05-03 14:10:34 +00003657 ForStrongLayout, HasUnion);
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +00003658 continue;
3659 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003660
Chris Lattnerf1690852009-03-31 08:48:01 +00003661 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003662 const ConstantArrayType *CArray =
Daniel Dunbar5e563dd2009-05-03 13:55:09 +00003663 dyn_cast_or_null<ConstantArrayType>(Array);
Fariborz Jahanian7fb16272009-04-21 18:33:06 +00003664 uint64_t ElCount = CArray->getSize().getZExtValue();
Daniel Dunbar5e563dd2009-05-03 13:55:09 +00003665 assert(CArray && "only array with known element size is supported");
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003666 FQT = CArray->getElementType();
Fariborz Jahanian667423a2009-03-25 22:36:49 +00003667 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
3668 const ConstantArrayType *CArray =
Daniel Dunbar5e563dd2009-05-03 13:55:09 +00003669 dyn_cast_or_null<ConstantArrayType>(Array);
Fariborz Jahanian7fb16272009-04-21 18:33:06 +00003670 ElCount *= CArray->getSize().getZExtValue();
Fariborz Jahanian667423a2009-03-25 22:36:49 +00003671 FQT = CArray->getElementType();
3672 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003673
3674 assert(!FQT->isUnionType() &&
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003675 "layout for array of unions not supported");
3676 if (FQT->isRecordType()) {
Fariborz Jahanian81adc052009-04-24 16:17:09 +00003677 int OldIndex = IvarsInfo.size() - 1;
3678 int OldSkIndex = SkipIvars.size() -1;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003679
Ted Kremenek6217b802009-07-29 21:53:49 +00003680 const RecordType *RT = FQT->getAs<RecordType>();
Daniel Dunbar25d583e2009-05-03 14:17:18 +00003681 BuildAggrIvarRecordLayout(RT, BytePos + FieldOffset,
Daniel Dunbard58edcb2009-05-03 14:10:34 +00003682 ForStrongLayout, HasUnion);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003683
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003684 // Replicate layout information for each array element. Note that
3685 // one element is already done.
3686 uint64_t ElIx = 1;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003687 for (int FirstIndex = IvarsInfo.size() - 1,
3688 FirstSkIndex = SkipIvars.size() - 1 ;ElIx < ElCount; ElIx++) {
Fariborz Jahanianc8ce9c82009-03-12 22:50:49 +00003689 uint64_t Size = CGM.getContext().getTypeSize(RT)/ByteSizeInBits;
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003690 for (int i = OldIndex+1; i <= FirstIndex; ++i)
3691 IvarsInfo.push_back(GC_IVAR(IvarsInfo[i].ivar_bytepos + Size*ElIx,
3692 IvarsInfo[i].ivar_size));
3693 for (int i = OldSkIndex+1; i <= FirstSkIndex; ++i)
3694 SkipIvars.push_back(GC_IVAR(SkipIvars[i].ivar_bytepos + Size*ElIx,
3695 SkipIvars[i].ivar_size));
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003696 }
3697 continue;
3698 }
Fariborz Jahaniana5a10c32009-03-10 16:22:08 +00003699 }
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003700 // At this point, we are done with Record/Union and array there of.
3701 // For other arrays we are down to its element type.
John McCall0953e762009-09-24 19:53:00 +00003702 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), FQT);
Daniel Dunbar5e563dd2009-05-03 13:55:09 +00003703
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003704 unsigned FieldSize = CGM.getContext().getTypeSize(Field->getType());
John McCall0953e762009-09-24 19:53:00 +00003705 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
3706 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
Daniel Dunbar487993b2009-05-03 13:32:01 +00003707 if (IsUnion) {
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003708 uint64_t UnionIvarSize = FieldSize / WordSizeInBits;
Daniel Dunbar487993b2009-05-03 13:32:01 +00003709 if (UnionIvarSize > MaxUnionIvarSize) {
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003710 MaxUnionIvarSize = UnionIvarSize;
3711 MaxField = Field;
Daniel Dunbar900c1982009-05-03 23:31:46 +00003712 MaxFieldOffset = FieldOffset;
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003713 }
Daniel Dunbar487993b2009-05-03 13:32:01 +00003714 } else {
Daniel Dunbar25d583e2009-05-03 14:17:18 +00003715 IvarsInfo.push_back(GC_IVAR(BytePos + FieldOffset,
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003716 FieldSize / WordSizeInBits));
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003717 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003718 } else if ((ForStrongLayout &&
John McCall0953e762009-09-24 19:53:00 +00003719 (GCAttr == Qualifiers::GCNone || GCAttr == Qualifiers::Weak))
3720 || (!ForStrongLayout && GCAttr != Qualifiers::Weak)) {
Daniel Dunbar487993b2009-05-03 13:32:01 +00003721 if (IsUnion) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00003722 // FIXME: Why the asymmetry? We divide by word size in bits on other
3723 // side.
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003724 uint64_t UnionIvarSize = FieldSize;
Daniel Dunbar487993b2009-05-03 13:32:01 +00003725 if (UnionIvarSize > MaxSkippedUnionIvarSize) {
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003726 MaxSkippedUnionIvarSize = UnionIvarSize;
3727 MaxSkippedField = Field;
Daniel Dunbar900c1982009-05-03 23:31:46 +00003728 MaxSkippedFieldOffset = FieldOffset;
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003729 }
Daniel Dunbar487993b2009-05-03 13:32:01 +00003730 } else {
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003731 // FIXME: Why the asymmetry, we divide by byte size in bits here?
Daniel Dunbar25d583e2009-05-03 14:17:18 +00003732 SkipIvars.push_back(GC_IVAR(BytePos + FieldOffset,
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003733 FieldSize / ByteSizeInBits));
Fariborz Jahanian820e0202009-03-11 00:07:04 +00003734 }
3735 }
3736 }
Daniel Dunbard58edcb2009-05-03 14:10:34 +00003737
Argyrios Kyrtzidis0dc75092010-09-06 12:00:10 +00003738 if (LastFieldBitfieldOrUnnamed) {
3739 if (LastFieldBitfieldOrUnnamed->isBitField()) {
3740 // Last field was a bitfield. Must update skip info.
3741 Expr *BitWidth = LastFieldBitfieldOrUnnamed->getBitWidth();
3742 uint64_t BitFieldSize =
3743 BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue();
3744 GC_IVAR skivar;
3745 skivar.ivar_bytepos = BytePos + LastBitfieldOrUnnamedOffset;
3746 skivar.ivar_size = (BitFieldSize / ByteSizeInBits)
3747 + ((BitFieldSize % ByteSizeInBits) != 0);
3748 SkipIvars.push_back(skivar);
3749 } else {
3750 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
3751 // Last field was unnamed. Must update skip info.
3752 unsigned FieldSize
3753 = CGM.getContext().getTypeSize(LastFieldBitfieldOrUnnamed->getType());
3754 SkipIvars.push_back(GC_IVAR(BytePos + LastBitfieldOrUnnamedOffset,
3755 FieldSize / ByteSizeInBits));
3756 }
Fariborz Jahanian7fb16272009-04-21 18:33:06 +00003757 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003758
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003759 if (MaxField)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003760 IvarsInfo.push_back(GC_IVAR(BytePos + MaxFieldOffset,
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003761 MaxUnionIvarSize));
3762 if (MaxSkippedField)
Daniel Dunbar900c1982009-05-03 23:31:46 +00003763 SkipIvars.push_back(GC_IVAR(BytePos + MaxSkippedFieldOffset,
Daniel Dunbar8b2926c2009-05-03 13:44:42 +00003764 MaxSkippedUnionIvarSize));
Fariborz Jahaniand61a50a2009-03-05 22:39:55 +00003765}
3766
Fariborz Jahanianb8fd2eb2010-08-05 00:19:48 +00003767/// BuildIvarLayoutBitmap - This routine is the horsework for doing all
3768/// the computations and returning the layout bitmap (for ivar or blocks) in
3769/// the given argument BitMap string container. Routine reads
3770/// two containers, IvarsInfo and SkipIvars which are assumed to be
3771/// filled already by the caller.
3772llvm::Constant *CGObjCCommonMac::BuildIvarLayoutBitmap(std::string& BitMap) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003773 unsigned int WordsToScan, WordsToSkip;
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +00003774 const llvm::Type *PtrTy = llvm::Type::getInt8PtrTy(VMContext);
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003775
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003776 // Build the string of skip/scan nibbles
Fariborz Jahanian8c2f2d12009-04-24 17:15:27 +00003777 llvm::SmallVector<SKIP_SCAN, 32> SkipScanIvars;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003778 unsigned int WordSize =
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003779 CGM.getTypes().getTargetData().getTypeAllocSize(PtrTy);
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003780 if (IvarsInfo[0].ivar_bytepos == 0) {
3781 WordsToSkip = 0;
3782 WordsToScan = IvarsInfo[0].ivar_size;
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003783 } else {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003784 WordsToSkip = IvarsInfo[0].ivar_bytepos/WordSize;
3785 WordsToScan = IvarsInfo[0].ivar_size;
3786 }
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003787 for (unsigned int i=1, Last=IvarsInfo.size(); i != Last; i++) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003788 unsigned int TailPrevGCObjC =
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003789 IvarsInfo[i-1].ivar_bytepos + IvarsInfo[i-1].ivar_size * WordSize;
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003790 if (IvarsInfo[i].ivar_bytepos == TailPrevGCObjC) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003791 // consecutive 'scanned' object pointers.
3792 WordsToScan += IvarsInfo[i].ivar_size;
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003793 } else {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003794 // Skip over 'gc'able object pointer which lay over each other.
3795 if (TailPrevGCObjC > IvarsInfo[i].ivar_bytepos)
3796 continue;
3797 // Must skip over 1 or more words. We save current skip/scan values
3798 // and start a new pair.
Fariborz Jahanianc8ce9c82009-03-12 22:50:49 +00003799 SKIP_SCAN SkScan;
3800 SkScan.skip = WordsToSkip;
3801 SkScan.scan = WordsToScan;
Fariborz Jahanian81adc052009-04-24 16:17:09 +00003802 SkipScanIvars.push_back(SkScan);
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003803
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003804 // Skip the hole.
Fariborz Jahanianc8ce9c82009-03-12 22:50:49 +00003805 SkScan.skip = (IvarsInfo[i].ivar_bytepos - TailPrevGCObjC) / WordSize;
3806 SkScan.scan = 0;
Fariborz Jahanian81adc052009-04-24 16:17:09 +00003807 SkipScanIvars.push_back(SkScan);
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003808 WordsToSkip = 0;
3809 WordsToScan = IvarsInfo[i].ivar_size;
3810 }
3811 }
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003812 if (WordsToScan > 0) {
Fariborz Jahanianc8ce9c82009-03-12 22:50:49 +00003813 SKIP_SCAN SkScan;
3814 SkScan.skip = WordsToSkip;
3815 SkScan.scan = WordsToScan;
Fariborz Jahanian81adc052009-04-24 16:17:09 +00003816 SkipScanIvars.push_back(SkScan);
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003817 }
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003818
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003819 if (!SkipIvars.empty()) {
Fariborz Jahanian81adc052009-04-24 16:17:09 +00003820 unsigned int LastIndex = SkipIvars.size()-1;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003821 int LastByteSkipped =
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003822 SkipIvars[LastIndex].ivar_bytepos + SkipIvars[LastIndex].ivar_size;
Fariborz Jahanian81adc052009-04-24 16:17:09 +00003823 LastIndex = IvarsInfo.size()-1;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003824 int LastByteScanned =
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003825 IvarsInfo[LastIndex].ivar_bytepos +
3826 IvarsInfo[LastIndex].ivar_size * WordSize;
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003827 // Compute number of bytes to skip at the tail end of the last ivar scanned.
Benjamin Kramer54d76db2009-12-25 15:43:36 +00003828 if (LastByteSkipped > LastByteScanned) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003829 unsigned int TotalWords = (LastByteSkipped + (WordSize -1)) / WordSize;
Fariborz Jahanianc8ce9c82009-03-12 22:50:49 +00003830 SKIP_SCAN SkScan;
3831 SkScan.skip = TotalWords - (LastByteScanned/WordSize);
3832 SkScan.scan = 0;
Fariborz Jahanian81adc052009-04-24 16:17:09 +00003833 SkipScanIvars.push_back(SkScan);
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003834 }
3835 }
3836 // Mini optimization of nibbles such that an 0xM0 followed by 0x0N is produced
3837 // as 0xMN.
Fariborz Jahanian81adc052009-04-24 16:17:09 +00003838 int SkipScan = SkipScanIvars.size()-1;
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003839 for (int i = 0; i <= SkipScan; i++) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003840 if ((i < SkipScan) && SkipScanIvars[i].skip && SkipScanIvars[i].scan == 0
3841 && SkipScanIvars[i+1].skip == 0 && SkipScanIvars[i+1].scan) {
3842 // 0xM0 followed by 0x0N detected.
3843 SkipScanIvars[i].scan = SkipScanIvars[i+1].scan;
3844 for (int j = i+1; j < SkipScan; j++)
3845 SkipScanIvars[j] = SkipScanIvars[j+1];
3846 --SkipScan;
3847 }
3848 }
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003849
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003850 // Generate the string.
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003851 for (int i = 0; i <= SkipScan; i++) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003852 unsigned char byte;
3853 unsigned int skip_small = SkipScanIvars[i].skip % 0xf;
3854 unsigned int scan_small = SkipScanIvars[i].scan % 0xf;
3855 unsigned int skip_big = SkipScanIvars[i].skip / 0xf;
3856 unsigned int scan_big = SkipScanIvars[i].scan / 0xf;
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003857
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003858 // first skip big.
3859 for (unsigned int ix = 0; ix < skip_big; ix++)
3860 BitMap += (unsigned char)(0xf0);
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003861
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003862 // next (skip small, scan)
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003863 if (skip_small) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003864 byte = skip_small << 4;
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003865 if (scan_big > 0) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003866 byte |= 0xf;
3867 --scan_big;
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003868 } else if (scan_small) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003869 byte |= scan_small;
3870 scan_small = 0;
3871 }
3872 BitMap += byte;
3873 }
3874 // next scan big
3875 for (unsigned int ix = 0; ix < scan_big; ix++)
3876 BitMap += (unsigned char)(0x0f);
3877 // last scan small
Daniel Dunbar31682fd2009-05-03 23:21:22 +00003878 if (scan_small) {
Fariborz Jahanian9397e1d2009-03-11 20:59:05 +00003879 byte = scan_small;
3880 BitMap += byte;
3881 }
3882 }
3883 // null terminate string.
Fariborz Jahanian667423a2009-03-25 22:36:49 +00003884 unsigned char zero = 0;
3885 BitMap += zero;
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003886
3887 llvm::GlobalVariable * Entry =
3888 CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
3889 llvm::ConstantArray::get(VMContext, BitMap.c_str()),
3890 "__TEXT,__cstring,cstring_literals",
3891 1, true);
3892 return getConstantGEP(VMContext, Entry, 0, 0);
3893}
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003894
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003895/// BuildIvarLayout - Builds ivar layout bitmap for the class
3896/// implementation for the __strong or __weak case.
3897/// The layout map displays which words in ivar list must be skipped
3898/// and which must be scanned by GC (see below). String is built of bytes.
3899/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
3900/// of words to skip and right nibble is count of words to scan. So, each
3901/// nibble represents up to 15 workds to skip or scan. Skipping the rest is
3902/// represented by a 0x00 byte which also ends the string.
3903/// 1. when ForStrongLayout is true, following ivars are scanned:
3904/// - id, Class
3905/// - object *
3906/// - __strong anything
3907///
3908/// 2. When ForStrongLayout is false, following ivars are scanned:
3909/// - __weak anything
3910///
3911llvm::Constant *CGObjCCommonMac::BuildIvarLayout(
3912 const ObjCImplementationDecl *OMD,
3913 bool ForStrongLayout) {
3914 bool hasUnion = false;
3915
3916 const llvm::Type *PtrTy = llvm::Type::getInt8PtrTy(VMContext);
3917 if (CGM.getLangOptions().getGCMode() == LangOptions::NonGC)
3918 return llvm::Constant::getNullValue(PtrTy);
3919
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00003920 llvm::SmallVector<ObjCIvarDecl*, 32> Ivars;
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003921 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00003922 CGM.getContext().DeepCollectObjCIvars(OI, true, Ivars);
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003923
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00003924 llvm::SmallVector<FieldDecl*, 32> RecFields;
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003925 for (unsigned k = 0, e = Ivars.size(); k != e; ++k)
3926 RecFields.push_back(cast<FieldDecl>(Ivars[k]));
3927
3928 if (RecFields.empty())
3929 return llvm::Constant::getNullValue(PtrTy);
3930
3931 SkipIvars.clear();
3932 IvarsInfo.clear();
3933
3934 BuildAggrIvarLayout(OMD, 0, 0, RecFields, 0, ForStrongLayout, hasUnion);
3935 if (IvarsInfo.empty())
3936 return llvm::Constant::getNullValue(PtrTy);
Fariborz Jahanianb8fd2eb2010-08-05 00:19:48 +00003937 // Sort on byte position in case we encounterred a union nested in
3938 // the ivar list.
3939 if (hasUnion && !IvarsInfo.empty())
3940 std::sort(IvarsInfo.begin(), IvarsInfo.end());
3941 if (hasUnion && !SkipIvars.empty())
3942 std::sort(SkipIvars.begin(), SkipIvars.end());
3943
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003944 std::string BitMap;
Fariborz Jahanianb8fd2eb2010-08-05 00:19:48 +00003945 llvm::Constant *C = BuildIvarLayoutBitmap(BitMap);
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003946
3947 if (CGM.getLangOptions().ObjCGCBitmapPrint) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003948 printf("\n%s ivar layout for class '%s': ",
Fariborz Jahanian3d2ad662009-04-20 22:03:45 +00003949 ForStrongLayout ? "strong" : "weak",
Daniel Dunbar4087f272010-08-17 22:39:59 +00003950 OMD->getClassInterface()->getName().data());
Fariborz Jahanian3d2ad662009-04-20 22:03:45 +00003951 const unsigned char *s = (unsigned char*)BitMap.c_str();
3952 for (unsigned i = 0; i < BitMap.size(); i++)
3953 if (!(s[i] & 0xf0))
3954 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
3955 else
3956 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
3957 printf("\n");
3958 }
Fariborz Jahanian93ce50d2010-08-04 23:55:24 +00003959 return C;
Fariborz Jahaniand61a50a2009-03-05 22:39:55 +00003960}
3961
Fariborz Jahanian56210f72009-01-21 23:34:32 +00003962llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
Daniel Dunbar259d93d2008-08-12 03:39:23 +00003963 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
3964
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003965 // FIXME: Avoid std::string copying.
3966 if (!Entry)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003967 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_NAME_",
Owen Anderson0032b272009-08-13 21:57:51 +00003968 llvm::ConstantArray::get(VMContext, Sel.getAsString()),
Daniel Dunbar6633e3c2010-07-29 22:57:21 +00003969 "__TEXT,__cstring,cstring_literals",
Daniel Dunbarb90bb002009-04-14 23:14:47 +00003970 1, true);
Daniel Dunbar259d93d2008-08-12 03:39:23 +00003971
Owen Andersona1cf15f2009-07-14 23:10:40 +00003972 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00003973}
3974
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003975// FIXME: Merge into a single cstring creation function.
Fariborz Jahanian56210f72009-01-21 23:34:32 +00003976llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003977 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
3978}
3979
Daniel Dunbar3e5f0d82009-04-20 06:54:31 +00003980llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
Devang Patel7794bb82009-03-04 18:21:39 +00003981 std::string TypeStr;
3982 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
3983
3984 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00003985
Daniel Dunbar63c5b502009-03-09 21:49:58 +00003986 if (!Entry)
3987 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
Owen Anderson0032b272009-08-13 21:57:51 +00003988 llvm::ConstantArray::get(VMContext, TypeStr),
Daniel Dunbar6633e3c2010-07-29 22:57:21 +00003989 "__TEXT,__cstring,cstring_literals",
Daniel Dunbarb90bb002009-04-14 23:14:47 +00003990 1, true);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00003991
Owen Andersona1cf15f2009-07-14 23:10:40 +00003992 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbar259d93d2008-08-12 03:39:23 +00003993}
3994
Fariborz Jahanian56210f72009-01-21 23:34:32 +00003995llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D) {
Daniel Dunbar27f9d772008-08-21 04:36:09 +00003996 std::string TypeStr;
Daniel Dunbarc45ef602008-08-26 21:51:14 +00003997 CGM.getContext().getObjCEncodingForMethodDecl(const_cast<ObjCMethodDecl*>(D),
3998 TypeStr);
Devang Patel7794bb82009-03-04 18:21:39 +00003999
4000 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
4001
Daniel Dunbarb90bb002009-04-14 23:14:47 +00004002 if (!Entry)
4003 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
Owen Anderson0032b272009-08-13 21:57:51 +00004004 llvm::ConstantArray::get(VMContext, TypeStr),
Daniel Dunbar6633e3c2010-07-29 22:57:21 +00004005 "__TEXT,__cstring,cstring_literals",
Daniel Dunbarb90bb002009-04-14 23:14:47 +00004006 1, true);
Devang Patel7794bb82009-03-04 18:21:39 +00004007
Owen Andersona1cf15f2009-07-14 23:10:40 +00004008 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004009}
4010
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00004011// FIXME: Merge into a single cstring creation function.
Fariborz Jahanian56210f72009-01-21 23:34:32 +00004012llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00004013 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004014
Daniel Dunbar63c5b502009-03-09 21:49:58 +00004015 if (!Entry)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004016 Entry = CreateMetadataVar("\01L_OBJC_PROP_NAME_ATTR_",
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00004017 llvm::ConstantArray::get(VMContext,
4018 Ident->getNameStart()),
Daniel Dunbar63c5b502009-03-09 21:49:58 +00004019 "__TEXT,__cstring,cstring_literals",
Daniel Dunbarb90bb002009-04-14 23:14:47 +00004020 1, true);
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00004021
Owen Andersona1cf15f2009-07-14 23:10:40 +00004022 return getConstantGEP(VMContext, Entry, 0, 0);
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00004023}
4024
4025// FIXME: Merge into a single cstring creation function.
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00004026// FIXME: This Decl should be more precise.
Daniel Dunbar63c5b502009-03-09 21:49:58 +00004027llvm::Constant *
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004028CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
4029 const Decl *Container) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00004030 std::string TypeStr;
4031 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
Daniel Dunbarc8ef5512008-08-23 00:19:03 +00004032 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
4033}
4034
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004035void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
Fariborz Jahanian56210f72009-01-21 23:34:32 +00004036 const ObjCContainerDecl *CD,
Daniel Dunbarc575ce72009-10-19 01:21:19 +00004037 llvm::SmallVectorImpl<char> &Name) {
4038 llvm::raw_svector_ostream OS(Name);
Fariborz Jahanian679a5022009-01-10 21:06:09 +00004039 assert (CD && "Missing container decl in GetNameForMethod");
Daniel Dunbarc575ce72009-10-19 01:21:19 +00004040 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
4041 << '[' << CD->getName();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004042 if (const ObjCCategoryImplDecl *CID =
Daniel Dunbarc575ce72009-10-19 01:21:19 +00004043 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
Benjamin Kramer900fc632010-04-17 09:33:03 +00004044 OS << '(' << CID << ')';
Daniel Dunbarc575ce72009-10-19 01:21:19 +00004045 OS << ' ' << D->getSelector().getAsString() << ']';
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00004046}
4047
Daniel Dunbarf77ac862008-08-11 21:35:06 +00004048void CGObjCMac::FinishModule() {
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00004049 EmitModuleInfo();
4050
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00004051 // Emit the dummy bodies for any protocols which were referenced but
4052 // never defined.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004053 for (llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*>::iterator
Chris Lattnerad64e022009-07-17 23:57:13 +00004054 I = Protocols.begin(), e = Protocols.end(); I != e; ++I) {
4055 if (I->second->hasInitializer())
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00004056 continue;
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00004057
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00004058 std::vector<llvm::Constant*> Values(5);
Owen Andersonc9c88b42009-07-31 20:28:54 +00004059 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
Chris Lattnerad64e022009-07-17 23:57:13 +00004060 Values[1] = GetClassName(I->first);
Owen Andersonc9c88b42009-07-31 20:28:54 +00004061 Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00004062 Values[3] = Values[4] =
Owen Andersonc9c88b42009-07-31 20:28:54 +00004063 llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
Chris Lattnerad64e022009-07-17 23:57:13 +00004064 I->second->setLinkage(llvm::GlobalValue::InternalLinkage);
Owen Anderson08e25242009-07-27 22:29:56 +00004065 I->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00004066 Values));
Chris Lattnerad64e022009-07-17 23:57:13 +00004067 CGM.AddUsedGlobal(I->second);
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00004068 }
4069
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00004070 // Add assembler directives to add lazy undefined symbol references
4071 // for classes which are referenced but not defined. This is
4072 // important for correct linker interaction.
Daniel Dunbar33063492009-09-07 00:20:42 +00004073 //
4074 // FIXME: It would be nice if we had an LLVM construct for this.
4075 if (!LazySymbols.empty() || !DefinedSymbols.empty()) {
4076 llvm::SmallString<256> Asm;
4077 Asm += CGM.getModule().getModuleInlineAsm();
4078 if (!Asm.empty() && Asm.back() != '\n')
4079 Asm += '\n';
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00004080
Daniel Dunbar33063492009-09-07 00:20:42 +00004081 llvm::raw_svector_ostream OS(Asm);
Daniel Dunbar33063492009-09-07 00:20:42 +00004082 for (llvm::SetVector<IdentifierInfo*>::iterator I = DefinedSymbols.begin(),
4083 e = DefinedSymbols.end(); I != e; ++I)
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00004084 OS << "\t.objc_class_name_" << (*I)->getName() << "=0\n"
4085 << "\t.globl .objc_class_name_" << (*I)->getName() << "\n";
Chris Lattnerafd5eda2010-04-17 18:26:20 +00004086 for (llvm::SetVector<IdentifierInfo*>::iterator I = LazySymbols.begin(),
Fariborz Jahanianb9c5b3d2010-06-21 22:05:18 +00004087 e = LazySymbols.end(); I != e; ++I) {
Chris Lattnerafd5eda2010-04-17 18:26:20 +00004088 OS << "\t.lazy_reference .objc_class_name_" << (*I)->getName() << "\n";
Fariborz Jahanianb9c5b3d2010-06-21 22:05:18 +00004089 }
4090
4091 for (size_t i = 0; i < DefinedCategoryNames.size(); ++i) {
4092 OS << "\t.objc_category_name_" << DefinedCategoryNames[i] << "=0\n"
4093 << "\t.globl .objc_category_name_" << DefinedCategoryNames[i] << "\n";
4094 }
Chris Lattnerafd5eda2010-04-17 18:26:20 +00004095
Daniel Dunbar33063492009-09-07 00:20:42 +00004096 CGM.getModule().setModuleInlineAsm(OS.str());
Daniel Dunbar242d4dc2008-08-25 06:02:07 +00004097 }
Daniel Dunbarf77ac862008-08-11 21:35:06 +00004098}
4099
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004100CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004101 : CGObjCCommonMac(cgm),
Mike Stump1eb44332009-09-09 15:08:12 +00004102 ObjCTypes(cgm) {
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004103 ObjCEmptyCacheVar = ObjCEmptyVtableVar = NULL;
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004104 ObjCABI = 2;
4105}
4106
Daniel Dunbarf77ac862008-08-11 21:35:06 +00004107/* *** */
4108
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004109ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
Mike Stump1eb44332009-09-09 15:08:12 +00004110 : VMContext(cgm.getLLVMContext()), CGM(cgm) {
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00004111 CodeGen::CodeGenTypes &Types = CGM.getTypes();
4112 ASTContext &Ctx = CGM.getContext();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004113
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004114 ShortTy = Types.ConvertType(Ctx.ShortTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004115 IntTy = Types.ConvertType(Ctx.IntTy);
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00004116 LongTy = Types.ConvertType(Ctx.LongTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00004117 LongLongTy = Types.ConvertType(Ctx.LongLongTy);
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +00004118 Int8PtrTy = llvm::Type::getInt8PtrTy(VMContext);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004119
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00004120 ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType());
Owen Anderson96e0fc72009-07-29 22:16:19 +00004121 PtrObjectPtrTy = llvm::PointerType::getUnqual(ObjectPtrTy);
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00004122 SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004123
Mike Stumpf5408fe2009-05-16 07:57:57 +00004124 // FIXME: It would be nice to unify this with the opaque type, so that the IR
4125 // comes out a bit cleaner.
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004126 const llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
Owen Anderson96e0fc72009-07-29 22:16:19 +00004127 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004128
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004129 // I'm not sure I like this. The implicit coordination is a bit
4130 // gross. We should solve this in a reasonable fashion because this
4131 // is a pretty common task (match some runtime data structure with
4132 // an LLVM data structure).
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004133
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004134 // FIXME: This is leaked.
4135 // FIXME: Merge with rewriter code?
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004136
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004137 // struct _objc_super {
4138 // id self;
4139 // Class cls;
4140 // }
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004141 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
Daniel Dunbardaa3ac52010-04-29 16:29:11 +00004142 Ctx.getTranslationUnitDecl(),
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004143 SourceLocation(),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004144 &Ctx.Idents.get("_objc_super"));
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004145 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00004146 Ctx.getObjCIdType(), 0, 0, false));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004147 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00004148 Ctx.getObjCClassType(), 0, 0, false));
Douglas Gregor838db382010-02-11 01:19:42 +00004149 RD->completeDefinition();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004150
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004151 SuperCTy = Ctx.getTagDeclType(RD);
4152 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004153
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004154 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004155 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
4156
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004157 // struct _prop_t {
4158 // char *name;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004159 // char *attributes;
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004160 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004161 PropertyTy = llvm::StructType::get(VMContext, Int8PtrTy, Int8PtrTy, NULL);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004162 CGM.getModule().addTypeName("struct._prop_t",
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004163 PropertyTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004164
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004165 // struct _prop_list_t {
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004166 // uint32_t entsize; // sizeof(struct _prop_t)
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004167 // uint32_t count_of_properties;
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004168 // struct _prop_t prop_list[count_of_properties];
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004169 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004170 PropertyListTy = llvm::StructType::get(VMContext, IntTy,
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004171 IntTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00004172 llvm::ArrayType::get(PropertyTy, 0),
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004173 NULL);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004174 CGM.getModule().addTypeName("struct._prop_list_t",
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004175 PropertyListTy);
4176 // struct _prop_list_t *
Owen Anderson96e0fc72009-07-29 22:16:19 +00004177 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004178
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004179 // struct _objc_method {
4180 // SEL _cmd;
4181 // char *method_type;
4182 // char *_imp;
4183 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004184 MethodTy = llvm::StructType::get(VMContext, SelectorPtrTy,
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004185 Int8PtrTy,
4186 Int8PtrTy,
4187 NULL);
4188 CGM.getModule().addTypeName("struct._objc_method", MethodTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004189
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004190 // struct _objc_cache *
Owen Anderson8c8f69e2009-08-13 23:27:53 +00004191 CacheTy = llvm::OpaqueType::get(VMContext);
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004192 CGM.getModule().addTypeName("struct._objc_cache", CacheTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004193 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004194}
Daniel Dunbar4e2d7d02008-08-12 06:48:42 +00004195
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004196ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
Mike Stump1eb44332009-09-09 15:08:12 +00004197 : ObjCCommonTypesHelper(cgm) {
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004198 // struct _objc_method_description {
4199 // SEL name;
4200 // char *types;
4201 // }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004202 MethodDescriptionTy =
Owen Anderson47a434f2009-08-05 23:18:46 +00004203 llvm::StructType::get(VMContext, SelectorPtrTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004204 Int8PtrTy,
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004205 NULL);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004206 CGM.getModule().addTypeName("struct._objc_method_description",
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004207 MethodDescriptionTy);
4208
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004209 // struct _objc_method_description_list {
4210 // int count;
4211 // struct _objc_method_description[1];
4212 // }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004213 MethodDescriptionListTy =
Owen Anderson47a434f2009-08-05 23:18:46 +00004214 llvm::StructType::get(VMContext, IntTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00004215 llvm::ArrayType::get(MethodDescriptionTy, 0),
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004216 NULL);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004217 CGM.getModule().addTypeName("struct._objc_method_description_list",
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004218 MethodDescriptionListTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004219
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004220 // struct _objc_method_description_list *
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004221 MethodDescriptionListPtrTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +00004222 llvm::PointerType::getUnqual(MethodDescriptionListTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004223
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004224 // Protocol description structures
4225
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004226 // struct _objc_protocol_extension {
4227 // uint32_t size; // sizeof(struct _objc_protocol_extension)
4228 // struct _objc_method_description_list *optional_instance_methods;
4229 // struct _objc_method_description_list *optional_class_methods;
4230 // struct _objc_property_list *instance_properties;
4231 // }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004232 ProtocolExtensionTy =
Owen Anderson47a434f2009-08-05 23:18:46 +00004233 llvm::StructType::get(VMContext, IntTy,
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004234 MethodDescriptionListPtrTy,
4235 MethodDescriptionListPtrTy,
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004236 PropertyListPtrTy,
4237 NULL);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004238 CGM.getModule().addTypeName("struct._objc_protocol_extension",
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004239 ProtocolExtensionTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004240
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004241 // struct _objc_protocol_extension *
Owen Anderson96e0fc72009-07-29 22:16:19 +00004242 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004243
Daniel Dunbar0c0e7a62008-10-29 22:36:39 +00004244 // Handle recursive construction of Protocol and ProtocolList types
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004245
Owen Anderson8c8f69e2009-08-13 23:27:53 +00004246 llvm::PATypeHolder ProtocolTyHolder = llvm::OpaqueType::get(VMContext);
4247 llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get(VMContext);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004248
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004249 const llvm::Type *T =
Mike Stump1eb44332009-09-09 15:08:12 +00004250 llvm::StructType::get(VMContext,
Owen Anderson47a434f2009-08-05 23:18:46 +00004251 llvm::PointerType::getUnqual(ProtocolListTyHolder),
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004252 LongTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00004253 llvm::ArrayType::get(ProtocolTyHolder, 0),
Fariborz Jahanianee0af742009-01-21 22:04:16 +00004254 NULL);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004255 cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(T);
4256
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004257 // struct _objc_protocol {
4258 // struct _objc_protocol_extension *isa;
4259 // char *protocol_name;
4260 // struct _objc_protocol **_objc_protocol_list;
4261 // struct _objc_method_description_list *instance_methods;
4262 // struct _objc_method_description_list *class_methods;
4263 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004264 T = llvm::StructType::get(VMContext, ProtocolExtensionPtrTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004265 Int8PtrTy,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004266 llvm::PointerType::getUnqual(ProtocolListTyHolder),
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004267 MethodDescriptionListPtrTy,
4268 MethodDescriptionListPtrTy,
4269 NULL);
4270 cast<llvm::OpaqueType>(ProtocolTyHolder.get())->refineAbstractTypeTo(T);
4271
4272 ProtocolListTy = cast<llvm::StructType>(ProtocolListTyHolder.get());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004273 CGM.getModule().addTypeName("struct._objc_protocol_list",
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004274 ProtocolListTy);
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004275 // struct _objc_protocol_list *
Owen Anderson96e0fc72009-07-29 22:16:19 +00004276 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00004277
4278 ProtocolTy = cast<llvm::StructType>(ProtocolTyHolder.get());
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004279 CGM.getModule().addTypeName("struct._objc_protocol", ProtocolTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004280 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004281
4282 // Class description structures
4283
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004284 // struct _objc_ivar {
4285 // char *ivar_name;
4286 // char *ivar_type;
4287 // int ivar_offset;
4288 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004289 IvarTy = llvm::StructType::get(VMContext, Int8PtrTy,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004290 Int8PtrTy,
4291 IntTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004292 NULL);
4293 CGM.getModule().addTypeName("struct._objc_ivar", IvarTy);
4294
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004295 // struct _objc_ivar_list *
Owen Anderson8c8f69e2009-08-13 23:27:53 +00004296 IvarListTy = llvm::OpaqueType::get(VMContext);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004297 CGM.getModule().addTypeName("struct._objc_ivar_list", IvarListTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004298 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004299
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004300 // struct _objc_method_list *
Owen Anderson8c8f69e2009-08-13 23:27:53 +00004301 MethodListTy = llvm::OpaqueType::get(VMContext);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004302 CGM.getModule().addTypeName("struct._objc_method_list", MethodListTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004303 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004304
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004305 // struct _objc_class_extension *
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004306 ClassExtensionTy =
Owen Anderson47a434f2009-08-05 23:18:46 +00004307 llvm::StructType::get(VMContext, IntTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004308 Int8PtrTy,
4309 PropertyListPtrTy,
4310 NULL);
4311 CGM.getModule().addTypeName("struct._objc_class_extension", ClassExtensionTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004312 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004313
Owen Anderson8c8f69e2009-08-13 23:27:53 +00004314 llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get(VMContext);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004315
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004316 // struct _objc_class {
4317 // Class isa;
4318 // Class super_class;
4319 // char *name;
4320 // long version;
4321 // long info;
4322 // long instance_size;
4323 // struct _objc_ivar_list *ivars;
4324 // struct _objc_method_list *methods;
4325 // struct _objc_cache *cache;
4326 // struct _objc_protocol_list *protocols;
4327 // char *ivar_layout;
4328 // struct _objc_class_ext *ext;
4329 // };
Owen Anderson47a434f2009-08-05 23:18:46 +00004330 T = llvm::StructType::get(VMContext,
4331 llvm::PointerType::getUnqual(ClassTyHolder),
Owen Anderson96e0fc72009-07-29 22:16:19 +00004332 llvm::PointerType::getUnqual(ClassTyHolder),
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004333 Int8PtrTy,
4334 LongTy,
4335 LongTy,
4336 LongTy,
4337 IvarListPtrTy,
4338 MethodListPtrTy,
4339 CachePtrTy,
4340 ProtocolListPtrTy,
4341 Int8PtrTy,
4342 ClassExtensionPtrTy,
4343 NULL);
4344 cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(T);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004345
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004346 ClassTy = cast<llvm::StructType>(ClassTyHolder.get());
4347 CGM.getModule().addTypeName("struct._objc_class", ClassTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004348 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004349
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004350 // struct _objc_category {
4351 // char *category_name;
4352 // char *class_name;
4353 // struct _objc_method_list *instance_method;
4354 // struct _objc_method_list *class_method;
4355 // uint32_t size; // sizeof(struct _objc_category)
4356 // struct _objc_property_list *instance_properties;// category's @property
4357 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004358 CategoryTy = llvm::StructType::get(VMContext, Int8PtrTy,
Daniel Dunbar86e253a2008-08-22 20:34:54 +00004359 Int8PtrTy,
4360 MethodListPtrTy,
4361 MethodListPtrTy,
4362 ProtocolListPtrTy,
4363 IntTy,
4364 PropertyListPtrTy,
4365 NULL);
4366 CGM.getModule().addTypeName("struct._objc_category", CategoryTy);
4367
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004368 // Global metadata structures
4369
Fariborz Jahanian10a42312009-01-21 00:39:53 +00004370 // struct _objc_symtab {
4371 // long sel_ref_cnt;
4372 // SEL *refs;
4373 // short cls_def_cnt;
4374 // short cat_def_cnt;
4375 // char *defs[cls_def_cnt + cat_def_cnt];
4376 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004377 SymtabTy = llvm::StructType::get(VMContext, LongTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004378 SelectorPtrTy,
4379 ShortTy,
4380 ShortTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00004381 llvm::ArrayType::get(Int8PtrTy, 0),
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004382 NULL);
4383 CGM.getModule().addTypeName("struct._objc_symtab", SymtabTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004384 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004385
Fariborz Jahaniandb286862009-01-22 00:37:21 +00004386 // struct _objc_module {
4387 // long version;
4388 // long size; // sizeof(struct _objc_module)
4389 // char *name;
4390 // struct _objc_symtab* symtab;
4391 // }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004392 ModuleTy =
Owen Anderson47a434f2009-08-05 23:18:46 +00004393 llvm::StructType::get(VMContext, LongTy,
Daniel Dunbar27f9d772008-08-21 04:36:09 +00004394 LongTy,
4395 Int8PtrTy,
4396 SymtabPtrTy,
4397 NULL);
4398 CGM.getModule().addTypeName("struct._objc_module", ModuleTy);
Daniel Dunbar14c80b72008-08-23 09:25:55 +00004399
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004400
Mike Stumpf5408fe2009-05-16 07:57:57 +00004401 // FIXME: This is the size of the setjmp buffer and should be target
4402 // specific. 18 is what's used on 32-bit X86.
Anders Carlsson124526b2008-09-09 10:10:21 +00004403 uint64_t SetJmpBufferSize = 18;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004404
Anders Carlsson124526b2008-09-09 10:10:21 +00004405 // Exceptions
Owen Anderson96e0fc72009-07-29 22:16:19 +00004406 const llvm::Type *StackPtrTy = llvm::ArrayType::get(
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +00004407 llvm::Type::getInt8PtrTy(VMContext), 4);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004408
4409 ExceptionDataTy =
Chris Lattner77b89b82010-06-27 07:15:29 +00004410 llvm::StructType::get(VMContext,
4411 llvm::ArrayType::get(llvm::Type::getInt32Ty(VMContext),
4412 SetJmpBufferSize),
Anders Carlsson124526b2008-09-09 10:10:21 +00004413 StackPtrTy, NULL);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004414 CGM.getModule().addTypeName("struct._objc_exception_data",
Anders Carlsson124526b2008-09-09 10:10:21 +00004415 ExceptionDataTy);
4416
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00004417}
4418
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004419ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
Mike Stump1eb44332009-09-09 15:08:12 +00004420 : ObjCCommonTypesHelper(cgm) {
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004421 // struct _method_list_t {
4422 // uint32_t entsize; // sizeof(struct _objc_method)
4423 // uint32_t method_count;
4424 // struct _objc_method method_list[method_count];
4425 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004426 MethodListnfABITy = llvm::StructType::get(VMContext, IntTy,
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004427 IntTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00004428 llvm::ArrayType::get(MethodTy, 0),
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004429 NULL);
4430 CGM.getModule().addTypeName("struct.__method_list_t",
4431 MethodListnfABITy);
4432 // struct method_list_t *
Owen Anderson96e0fc72009-07-29 22:16:19 +00004433 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004434
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004435 // struct _protocol_t {
4436 // id isa; // NULL
4437 // const char * const protocol_name;
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004438 // const struct _protocol_list_t * protocol_list; // super protocols
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004439 // const struct method_list_t * const instance_methods;
4440 // const struct method_list_t * const class_methods;
4441 // const struct method_list_t *optionalInstanceMethods;
4442 // const struct method_list_t *optionalClassMethods;
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004443 // const struct _prop_list_t * properties;
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004444 // const uint32_t size; // sizeof(struct _protocol_t)
4445 // const uint32_t flags; // = 0
4446 // }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004447
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004448 // Holder for struct _protocol_list_t *
Owen Anderson8c8f69e2009-08-13 23:27:53 +00004449 llvm::PATypeHolder ProtocolListTyHolder = llvm::OpaqueType::get(VMContext);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004450
Owen Anderson47a434f2009-08-05 23:18:46 +00004451 ProtocolnfABITy = llvm::StructType::get(VMContext, ObjectPtrTy,
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004452 Int8PtrTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00004453 llvm::PointerType::getUnqual(
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004454 ProtocolListTyHolder),
4455 MethodListnfABIPtrTy,
4456 MethodListnfABIPtrTy,
4457 MethodListnfABIPtrTy,
4458 MethodListnfABIPtrTy,
4459 PropertyListPtrTy,
4460 IntTy,
4461 IntTy,
4462 NULL);
4463 CGM.getModule().addTypeName("struct._protocol_t",
4464 ProtocolnfABITy);
Daniel Dunbar948e2582009-02-15 07:36:20 +00004465
4466 // struct _protocol_t*
Owen Anderson96e0fc72009-07-29 22:16:19 +00004467 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004468
Fariborz Jahanianda320092009-01-29 19:24:30 +00004469 // struct _protocol_list_t {
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004470 // long protocol_count; // Note, this is 32/64 bit
Daniel Dunbar948e2582009-02-15 07:36:20 +00004471 // struct _protocol_t *[protocol_count];
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004472 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004473 ProtocolListnfABITy = llvm::StructType::get(VMContext, LongTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00004474 llvm::ArrayType::get(
Daniel Dunbar948e2582009-02-15 07:36:20 +00004475 ProtocolnfABIPtrTy, 0),
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004476 NULL);
4477 CGM.getModule().addTypeName("struct._objc_protocol_list",
4478 ProtocolListnfABITy);
Daniel Dunbar948e2582009-02-15 07:36:20 +00004479 cast<llvm::OpaqueType>(ProtocolListTyHolder.get())->refineAbstractTypeTo(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004480 ProtocolListnfABITy);
4481
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004482 // struct _objc_protocol_list*
Owen Anderson96e0fc72009-07-29 22:16:19 +00004483 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004484
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004485 // struct _ivar_t {
4486 // unsigned long int *offset; // pointer to ivar offset location
4487 // char *name;
4488 // char *type;
4489 // uint32_t alignment;
4490 // uint32_t size;
4491 // }
Mike Stump1eb44332009-09-09 15:08:12 +00004492 IvarnfABITy = llvm::StructType::get(VMContext,
Owen Anderson47a434f2009-08-05 23:18:46 +00004493 llvm::PointerType::getUnqual(LongTy),
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004494 Int8PtrTy,
4495 Int8PtrTy,
4496 IntTy,
4497 IntTy,
4498 NULL);
4499 CGM.getModule().addTypeName("struct._ivar_t", IvarnfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004500
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004501 // struct _ivar_list_t {
4502 // uint32 entsize; // sizeof(struct _ivar_t)
4503 // uint32 count;
4504 // struct _iver_t list[count];
4505 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004506 IvarListnfABITy = llvm::StructType::get(VMContext, IntTy,
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004507 IntTy,
Owen Anderson96e0fc72009-07-29 22:16:19 +00004508 llvm::ArrayType::get(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004509 IvarnfABITy, 0),
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004510 NULL);
4511 CGM.getModule().addTypeName("struct._ivar_list_t", IvarListnfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004512
Owen Anderson96e0fc72009-07-29 22:16:19 +00004513 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004514
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004515 // struct _class_ro_t {
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00004516 // uint32_t const flags;
4517 // uint32_t const instanceStart;
4518 // uint32_t const instanceSize;
4519 // uint32_t const reserved; // only when building for 64bit targets
4520 // const uint8_t * const ivarLayout;
4521 // const char *const name;
4522 // const struct _method_list_t * const baseMethods;
4523 // const struct _objc_protocol_list *const baseProtocols;
4524 // const struct _ivar_list_t *const ivars;
4525 // const uint8_t * const weakIvarLayout;
4526 // const struct _prop_list_t * const properties;
4527 // }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004528
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004529 // FIXME. Add 'reserved' field in 64bit abi mode!
Owen Anderson47a434f2009-08-05 23:18:46 +00004530 ClassRonfABITy = llvm::StructType::get(VMContext, IntTy,
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004531 IntTy,
4532 IntTy,
4533 Int8PtrTy,
4534 Int8PtrTy,
4535 MethodListnfABIPtrTy,
4536 ProtocolListnfABIPtrTy,
4537 IvarListnfABIPtrTy,
4538 Int8PtrTy,
4539 PropertyListPtrTy,
4540 NULL);
4541 CGM.getModule().addTypeName("struct._class_ro_t",
4542 ClassRonfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004543
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004544 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
4545 std::vector<const llvm::Type*> Params;
4546 Params.push_back(ObjectPtrTy);
4547 Params.push_back(SelectorPtrTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004548 ImpnfABITy = llvm::PointerType::getUnqual(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004549 llvm::FunctionType::get(ObjectPtrTy, Params, false));
4550
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004551 // struct _class_t {
4552 // struct _class_t *isa;
4553 // struct _class_t * const superclass;
4554 // void *cache;
4555 // IMP *vtable;
4556 // struct class_ro_t *ro;
4557 // }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004558
Owen Anderson8c8f69e2009-08-13 23:27:53 +00004559 llvm::PATypeHolder ClassTyHolder = llvm::OpaqueType::get(VMContext);
Owen Andersona1cf15f2009-07-14 23:10:40 +00004560 ClassnfABITy =
Owen Anderson47a434f2009-08-05 23:18:46 +00004561 llvm::StructType::get(VMContext,
4562 llvm::PointerType::getUnqual(ClassTyHolder),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004563 llvm::PointerType::getUnqual(ClassTyHolder),
4564 CachePtrTy,
4565 llvm::PointerType::getUnqual(ImpnfABITy),
4566 llvm::PointerType::getUnqual(ClassRonfABITy),
4567 NULL);
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004568 CGM.getModule().addTypeName("struct._class_t", ClassnfABITy);
4569
4570 cast<llvm::OpaqueType>(ClassTyHolder.get())->refineAbstractTypeTo(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004571 ClassnfABITy);
4572
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004573 // LLVM for struct _class_t *
Owen Anderson96e0fc72009-07-29 22:16:19 +00004574 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004575
Fariborz Jahaniand55b6fc2009-01-23 01:46:23 +00004576 // struct _category_t {
4577 // const char * const name;
4578 // struct _class_t *const cls;
4579 // const struct _method_list_t * const instance_methods;
4580 // const struct _method_list_t * const class_methods;
4581 // const struct _protocol_list_t * const protocols;
4582 // const struct _prop_list_t * const properties;
Fariborz Jahanian45c2ba02009-01-23 17:41:22 +00004583 // }
Owen Anderson47a434f2009-08-05 23:18:46 +00004584 CategorynfABITy = llvm::StructType::get(VMContext, Int8PtrTy,
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004585 ClassnfABIPtrTy,
Fariborz Jahanian45c2ba02009-01-23 17:41:22 +00004586 MethodListnfABIPtrTy,
4587 MethodListnfABIPtrTy,
4588 ProtocolListnfABIPtrTy,
4589 PropertyListPtrTy,
4590 NULL);
4591 CGM.getModule().addTypeName("struct._category_t", CategorynfABITy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004592
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +00004593 // New types for nonfragile abi messaging.
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00004594 CodeGen::CodeGenTypes &Types = CGM.getTypes();
4595 ASTContext &Ctx = CGM.getContext();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004596
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +00004597 // MessageRefTy - LLVM for:
4598 // struct _message_ref_t {
4599 // IMP messenger;
4600 // SEL name;
4601 // };
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004602
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00004603 // First the clang type for struct _message_ref_t
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004604 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
Daniel Dunbardaa3ac52010-04-29 16:29:11 +00004605 Ctx.getTranslationUnitDecl(),
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00004606 SourceLocation(),
4607 &Ctx.Idents.get("_message_ref_t"));
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004608 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00004609 Ctx.VoidPtrTy, 0, 0, false));
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004610 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00004611 Ctx.getObjCSelType(), 0, 0, false));
Douglas Gregor838db382010-02-11 01:19:42 +00004612 RD->completeDefinition();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004613
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00004614 MessageRefCTy = Ctx.getTagDeclType(RD);
4615 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
4616 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004617
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +00004618 // MessageRefPtrTy - LLVM for struct _message_ref_t*
Owen Anderson96e0fc72009-07-29 22:16:19 +00004619 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004620
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +00004621 // SuperMessageRefTy - LLVM for:
4622 // struct _super_message_ref_t {
4623 // SUPER_IMP messenger;
4624 // SEL name;
4625 // };
Owen Anderson47a434f2009-08-05 23:18:46 +00004626 SuperMessageRefTy = llvm::StructType::get(VMContext, ImpnfABITy,
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +00004627 SelectorPtrTy,
4628 NULL);
4629 CGM.getModule().addTypeName("struct._super_message_ref_t", SuperMessageRefTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004630
Fariborz Jahanian2e4672b2009-02-03 23:49:23 +00004631 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004632 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
4633
Daniel Dunbare588b992009-03-01 04:46:24 +00004634
4635 // struct objc_typeinfo {
4636 // const void** vtable; // objc_ehtype_vtable + 2
4637 // const char* name; // c++ typeinfo string
4638 // Class cls;
4639 // };
Owen Anderson47a434f2009-08-05 23:18:46 +00004640 EHTypeTy = llvm::StructType::get(VMContext,
4641 llvm::PointerType::getUnqual(Int8PtrTy),
Daniel Dunbare588b992009-03-01 04:46:24 +00004642 Int8PtrTy,
4643 ClassnfABIPtrTy,
4644 NULL);
Daniel Dunbar4ff36842009-03-02 06:08:11 +00004645 CGM.getModule().addTypeName("struct._objc_typeinfo", EHTypeTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00004646 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00004647}
4648
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004649llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004650 FinishNonFragileABIModule();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004651
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004652 return NULL;
4653}
4654
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004655void CGObjCNonFragileABIMac::AddModuleClassList(const
4656 std::vector<llvm::GlobalValue*>
4657 &Container,
Daniel Dunbar463b8762009-05-15 21:48:48 +00004658 const char *SymbolName,
4659 const char *SectionName) {
4660 unsigned NumClasses = Container.size();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004661
Daniel Dunbar463b8762009-05-15 21:48:48 +00004662 if (!NumClasses)
4663 return;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004664
Daniel Dunbar463b8762009-05-15 21:48:48 +00004665 std::vector<llvm::Constant*> Symbols(NumClasses);
4666 for (unsigned i=0; i<NumClasses; i++)
Owen Anderson3c4972d2009-07-29 18:54:39 +00004667 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
Daniel Dunbar463b8762009-05-15 21:48:48 +00004668 ObjCTypes.Int8PtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004669 llvm::Constant* Init =
Owen Anderson96e0fc72009-07-29 22:16:19 +00004670 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
Daniel Dunbar463b8762009-05-15 21:48:48 +00004671 NumClasses),
4672 Symbols);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004673
Daniel Dunbar463b8762009-05-15 21:48:48 +00004674 llvm::GlobalVariable *GV =
Owen Anderson1c431b32009-07-08 19:05:04 +00004675 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Daniel Dunbar463b8762009-05-15 21:48:48 +00004676 llvm::GlobalValue::InternalLinkage,
4677 Init,
Owen Anderson1c431b32009-07-08 19:05:04 +00004678 SymbolName);
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00004679 GV->setAlignment(CGM.getTargetData().getABITypeAlignment(Init->getType()));
Daniel Dunbar463b8762009-05-15 21:48:48 +00004680 GV->setSection(SectionName);
Chris Lattnerad64e022009-07-17 23:57:13 +00004681 CGM.AddUsedGlobal(GV);
Daniel Dunbar463b8762009-05-15 21:48:48 +00004682}
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004683
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004684void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
4685 // nonfragile abi has no module definition.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004686
Daniel Dunbar463b8762009-05-15 21:48:48 +00004687 // Build list of all implemented class addresses in array
Fariborz Jahanianf87a0cc2009-01-30 20:55:31 +00004688 // L_OBJC_LABEL_CLASS_$.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004689 AddModuleClassList(DefinedClasses,
Daniel Dunbar463b8762009-05-15 21:48:48 +00004690 "\01L_OBJC_LABEL_CLASS_$",
4691 "__DATA, __objc_classlist, regular, no_dead_strip");
Fariborz Jahaniana03d0dd2009-11-17 21:37:35 +00004692
Fariborz Jahaniana03d0dd2009-11-17 21:37:35 +00004693 for (unsigned i = 0; i < DefinedClasses.size(); i++) {
4694 llvm::GlobalValue *IMPLGV = DefinedClasses[i];
4695 if (IMPLGV->getLinkage() != llvm::GlobalValue::ExternalWeakLinkage)
4696 continue;
4697 IMPLGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
Fariborz Jahaniana03d0dd2009-11-17 21:37:35 +00004698 }
4699
Fariborz Jahanian0e93d252009-12-01 18:25:24 +00004700 for (unsigned i = 0; i < DefinedMetaClasses.size(); i++) {
4701 llvm::GlobalValue *IMPLGV = DefinedMetaClasses[i];
4702 if (IMPLGV->getLinkage() != llvm::GlobalValue::ExternalWeakLinkage)
4703 continue;
4704 IMPLGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
4705 }
Fariborz Jahaniana03d0dd2009-11-17 21:37:35 +00004706
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004707 AddModuleClassList(DefinedNonLazyClasses,
Daniel Dunbar74d4b122009-05-15 22:33:15 +00004708 "\01L_OBJC_LABEL_NONLAZY_CLASS_$",
4709 "__DATA, __objc_nlclslist, regular, no_dead_strip");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004710
Fariborz Jahanianf87a0cc2009-01-30 20:55:31 +00004711 // Build list of all implemented category addresses in array
4712 // L_OBJC_LABEL_CATEGORY_$.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004713 AddModuleClassList(DefinedCategories,
Daniel Dunbar463b8762009-05-15 21:48:48 +00004714 "\01L_OBJC_LABEL_CATEGORY_$",
4715 "__DATA, __objc_catlist, regular, no_dead_strip");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004716 AddModuleClassList(DefinedNonLazyCategories,
Daniel Dunbar74d4b122009-05-15 22:33:15 +00004717 "\01L_OBJC_LABEL_NONLAZY_CATEGORY_$",
4718 "__DATA, __objc_nlcatlist, regular, no_dead_strip");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004719
Daniel Dunbarfce176b2010-04-25 20:39:01 +00004720 EmitImageInfo();
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004721}
4722
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00004723/// LegacyDispatchedSelector - Returns true if SEL is not in the list of
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00004724/// NonLegacyDispatchMethods; false otherwise. What this means is that
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004725/// except for the 19 selectors in the list, we generate 32bit-style
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00004726/// message dispatch call for all the rest.
4727///
4728bool CGObjCNonFragileABIMac::LegacyDispatchedSelector(Selector Sel) {
Daniel Dunbarf643b9b2010-04-24 17:56:46 +00004729 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
4730 default:
4731 assert(0 && "Invalid dispatch method!");
4732 case CodeGenOptions::Legacy:
Daniel Dunbar2feefe82010-02-01 21:07:33 +00004733 return true;
Daniel Dunbarf643b9b2010-04-24 17:56:46 +00004734 case CodeGenOptions::NonLegacy:
Fariborz Jahanian776dbf92010-04-19 17:53:30 +00004735 return false;
Daniel Dunbarf643b9b2010-04-24 17:56:46 +00004736 case CodeGenOptions::Mixed:
4737 break;
4738 }
4739
4740 // If so, see whether this selector is in the white-list of things which must
4741 // use the new dispatch convention. We lazily build a dense set for this.
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00004742 if (NonLegacyDispatchMethods.empty()) {
4743 NonLegacyDispatchMethods.insert(GetNullarySelector("alloc"));
4744 NonLegacyDispatchMethods.insert(GetNullarySelector("class"));
4745 NonLegacyDispatchMethods.insert(GetNullarySelector("self"));
4746 NonLegacyDispatchMethods.insert(GetNullarySelector("isFlipped"));
4747 NonLegacyDispatchMethods.insert(GetNullarySelector("length"));
4748 NonLegacyDispatchMethods.insert(GetNullarySelector("count"));
4749 NonLegacyDispatchMethods.insert(GetNullarySelector("retain"));
4750 NonLegacyDispatchMethods.insert(GetNullarySelector("release"));
4751 NonLegacyDispatchMethods.insert(GetNullarySelector("autorelease"));
4752 NonLegacyDispatchMethods.insert(GetNullarySelector("hash"));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004753
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00004754 NonLegacyDispatchMethods.insert(GetUnarySelector("allocWithZone"));
4755 NonLegacyDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
4756 NonLegacyDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
4757 NonLegacyDispatchMethods.insert(GetUnarySelector("objectForKey"));
4758 NonLegacyDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
4759 NonLegacyDispatchMethods.insert(GetUnarySelector("isEqualToString"));
4760 NonLegacyDispatchMethods.insert(GetUnarySelector("isEqual"));
4761 NonLegacyDispatchMethods.insert(GetUnarySelector("addObject"));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004762 // "countByEnumeratingWithState:objects:count"
Fariborz Jahanianbe53be42009-05-13 16:19:02 +00004763 IdentifierInfo *KeyIdents[] = {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004764 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
4765 &CGM.getContext().Idents.get("objects"),
4766 &CGM.getContext().Idents.get("count")
Fariborz Jahanianbe53be42009-05-13 16:19:02 +00004767 };
4768 NonLegacyDispatchMethods.insert(
4769 CGM.getContext().Selectors.getSelector(3, KeyIdents));
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00004770 }
Daniel Dunbarf643b9b2010-04-24 17:56:46 +00004771
Fariborz Jahanian4523eb02009-05-12 20:06:41 +00004772 return (NonLegacyDispatchMethods.count(Sel) == 0);
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00004773}
4774
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004775// Metadata flags
4776enum MetaDataDlags {
4777 CLS = 0x0,
4778 CLS_META = 0x1,
4779 CLS_ROOT = 0x2,
Fariborz Jahanian493dab72009-01-26 21:38:32 +00004780 OBJC2_CLS_HIDDEN = 0x10,
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004781 CLS_EXCEPTION = 0x20
4782};
4783/// BuildClassRoTInitializer - generate meta-data for:
4784/// struct _class_ro_t {
4785/// uint32_t const flags;
4786/// uint32_t const instanceStart;
4787/// uint32_t const instanceSize;
4788/// uint32_t const reserved; // only when building for 64bit targets
4789/// const uint8_t * const ivarLayout;
4790/// const char *const name;
4791/// const struct _method_list_t * const baseMethods;
Fariborz Jahanianda320092009-01-29 19:24:30 +00004792/// const struct _protocol_list_t *const baseProtocols;
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004793/// const struct _ivar_list_t *const ivars;
4794/// const uint8_t * const weakIvarLayout;
4795/// const struct _prop_list_t * const properties;
4796/// }
4797///
4798llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004799 unsigned flags,
4800 unsigned InstanceStart,
4801 unsigned InstanceSize,
4802 const ObjCImplementationDecl *ID) {
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004803 std::string ClassName = ID->getNameAsString();
4804 std::vector<llvm::Constant*> Values(10); // 11 for 64bit targets!
Owen Anderson4a28d5d2009-07-24 23:12:58 +00004805 Values[ 0] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags);
4806 Values[ 1] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceStart);
4807 Values[ 2] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceSize);
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004808 // FIXME. For 64bit targets add 0 here.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004809 Values[ 3] = (flags & CLS_META) ? GetIvarLayoutName(0, ObjCTypes)
4810 : BuildIvarLayout(ID, true);
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004811 Values[ 4] = GetClassName(ID->getIdentifier());
Fariborz Jahanian493dab72009-01-26 21:38:32 +00004812 // const struct _method_list_t * const baseMethods;
4813 std::vector<llvm::Constant*> Methods;
4814 std::string MethodListName("\01l_OBJC_$_");
4815 if (flags & CLS_META) {
4816 MethodListName += "CLASS_METHODS_" + ID->getNameAsString();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004817 for (ObjCImplementationDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004818 i = ID->classmeth_begin(), e = ID->classmeth_end(); i != e; ++i) {
Fariborz Jahanian493dab72009-01-26 21:38:32 +00004819 // Class methods should always be defined.
4820 Methods.push_back(GetMethodConstant(*i));
4821 }
4822 } else {
4823 MethodListName += "INSTANCE_METHODS_" + ID->getNameAsString();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004824 for (ObjCImplementationDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004825 i = ID->instmeth_begin(), e = ID->instmeth_end(); i != e; ++i) {
Fariborz Jahanian493dab72009-01-26 21:38:32 +00004826 // Instance methods should always be defined.
4827 Methods.push_back(GetMethodConstant(*i));
4828 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004829 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004830 i = ID->propimpl_begin(), e = ID->propimpl_end(); i != e; ++i) {
Fariborz Jahanian939abce2009-01-28 22:46:49 +00004831 ObjCPropertyImplDecl *PID = *i;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004832
Fariborz Jahanian939abce2009-01-28 22:46:49 +00004833 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
4834 ObjCPropertyDecl *PD = PID->getPropertyDecl();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004835
Fariborz Jahanian939abce2009-01-28 22:46:49 +00004836 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
4837 if (llvm::Constant *C = GetMethodConstant(MD))
4838 Methods.push_back(C);
4839 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
4840 if (llvm::Constant *C = GetMethodConstant(MD))
4841 Methods.push_back(C);
4842 }
4843 }
Fariborz Jahanian493dab72009-01-26 21:38:32 +00004844 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004845 Values[ 5] = EmitMethodList(MethodListName,
4846 "__DATA, __objc_const", Methods);
4847
Fariborz Jahanianda320092009-01-29 19:24:30 +00004848 const ObjCInterfaceDecl *OID = ID->getClassInterface();
4849 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004850 Values[ 6] = EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00004851 + OID->getName(),
Ted Kremenek53b94412010-09-01 01:21:15 +00004852 OID->all_referenced_protocol_begin(),
4853 OID->all_referenced_protocol_end());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004854
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00004855 if (flags & CLS_META)
Owen Andersonc9c88b42009-07-31 20:28:54 +00004856 Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00004857 else
4858 Values[ 7] = EmitIvarList(ID);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004859 Values[ 8] = (flags & CLS_META) ? GetIvarLayoutName(0, ObjCTypes)
4860 : BuildIvarLayout(ID, false);
Fariborz Jahanian5de14dc2009-01-28 22:18:42 +00004861 if (flags & CLS_META)
Owen Andersonc9c88b42009-07-31 20:28:54 +00004862 Values[ 9] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
Fariborz Jahanian5de14dc2009-01-28 22:18:42 +00004863 else
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00004864 Values[ 9] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getName(),
4865 ID, ID->getClassInterface(), ObjCTypes);
Owen Anderson08e25242009-07-27 22:29:56 +00004866 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassRonfABITy,
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004867 Values);
4868 llvm::GlobalVariable *CLASS_RO_GV =
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004869 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassRonfABITy, false,
4870 llvm::GlobalValue::InternalLinkage,
4871 Init,
4872 (flags & CLS_META) ?
4873 std::string("\01l_OBJC_METACLASS_RO_$_")+ClassName :
4874 std::string("\01l_OBJC_CLASS_RO_$_")+ClassName);
Fariborz Jahanian09796d62009-01-31 02:43:27 +00004875 CLASS_RO_GV->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00004876 CGM.getTargetData().getABITypeAlignment(ObjCTypes.ClassRonfABITy));
Fariborz Jahanian1bf0afb2009-01-28 01:05:23 +00004877 CLASS_RO_GV->setSection("__DATA, __objc_const");
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004878 return CLASS_RO_GV;
Fariborz Jahanianf6317dd2009-01-26 22:58:07 +00004879
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004880}
4881
4882/// BuildClassMetaData - This routine defines that to-level meta-data
4883/// for the given ClassName for:
4884/// struct _class_t {
4885/// struct _class_t *isa;
4886/// struct _class_t * const superclass;
4887/// void *cache;
4888/// IMP *vtable;
4889/// struct class_ro_t *ro;
4890/// }
4891///
Fariborz Jahanian84394a52009-01-24 21:21:53 +00004892llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassMetaData(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004893 std::string &ClassName,
4894 llvm::Constant *IsAGV,
4895 llvm::Constant *SuperClassGV,
4896 llvm::Constant *ClassRoGV,
4897 bool HiddenVisibility) {
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004898 std::vector<llvm::Constant*> Values(5);
4899 Values[0] = IsAGV;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004900 Values[1] = SuperClassGV;
4901 if (!Values[1])
4902 Values[1] = llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy);
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004903 Values[2] = ObjCEmptyCacheVar; // &ObjCEmptyCacheVar
4904 Values[3] = ObjCEmptyVtableVar; // &ObjCEmptyVtableVar
4905 Values[4] = ClassRoGV; // &CLASS_RO_GV
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004906 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy,
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004907 Values);
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00004908 llvm::GlobalVariable *GV = GetClassGlobal(ClassName);
4909 GV->setInitializer(Init);
Fariborz Jahaniandd0db2a2009-01-31 01:07:39 +00004910 GV->setSection("__DATA, __objc_data");
Fariborz Jahanian09796d62009-01-31 02:43:27 +00004911 GV->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00004912 CGM.getTargetData().getABITypeAlignment(ObjCTypes.ClassnfABITy));
Fariborz Jahaniancf555162009-01-31 00:59:10 +00004913 if (HiddenVisibility)
4914 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Fariborz Jahanian84394a52009-01-24 21:21:53 +00004915 return GV;
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004916}
4917
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004918bool
Fariborz Jahanianecfbdcb2009-05-21 01:03:45 +00004919CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00004920 return OD->getClassMethod(GetNullarySelector("load")) != 0;
Daniel Dunbar74d4b122009-05-15 22:33:15 +00004921}
4922
Daniel Dunbar9f89f2b2009-05-03 12:57:56 +00004923void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
Daniel Dunbarb02532a2009-04-19 23:41:48 +00004924 uint32_t &InstanceStart,
4925 uint32_t &InstanceSize) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004926 const ASTRecordLayout &RL =
Daniel Dunbarb4c79e02009-05-04 21:26:30 +00004927 CGM.getContext().getASTObjCImplementationLayout(OID);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004928
Daniel Dunbar6e8575b2009-05-04 23:23:09 +00004929 // InstanceSize is really instance end.
Anders Carlsson243a6852009-07-18 21:26:44 +00004930 InstanceSize = llvm::RoundUpToAlignment(RL.getDataSize(), 8) / 8;
Daniel Dunbar6e8575b2009-05-04 23:23:09 +00004931
4932 // If there are no fields, the start is the same as the end.
4933 if (!RL.getFieldCount())
4934 InstanceStart = InstanceSize;
4935 else
4936 InstanceStart = RL.getFieldOffset(0) / 8;
Daniel Dunbarb02532a2009-04-19 23:41:48 +00004937}
4938
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004939void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
4940 std::string ClassName = ID->getNameAsString();
4941 if (!ObjCEmptyCacheVar) {
4942 ObjCEmptyCacheVar = new llvm::GlobalVariable(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004943 CGM.getModule(),
4944 ObjCTypes.CacheTy,
4945 false,
4946 llvm::GlobalValue::ExternalLinkage,
4947 0,
4948 "_objc_empty_cache");
4949
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004950 ObjCEmptyVtableVar = new llvm::GlobalVariable(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004951 CGM.getModule(),
4952 ObjCTypes.ImpnfABITy,
4953 false,
4954 llvm::GlobalValue::ExternalLinkage,
4955 0,
4956 "_objc_empty_vtable");
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00004957 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004958 assert(ID->getClassInterface() &&
Fariborz Jahanian493dab72009-01-26 21:38:32 +00004959 "CGObjCNonFragileABIMac::GenerateClass - class is 0");
Daniel Dunbar6c1aac82009-04-20 20:18:54 +00004960 // FIXME: Is this correct (that meta class size is never computed)?
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004961 uint32_t InstanceStart =
Duncan Sands9408c452009-05-09 07:08:47 +00004962 CGM.getTargetData().getTypeAllocSize(ObjCTypes.ClassnfABITy);
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004963 uint32_t InstanceSize = InstanceStart;
4964 uint32_t flags = CLS_META;
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00004965 std::string ObjCMetaClassName(getMetaclassSymbolPrefix());
4966 std::string ObjCClassName(getClassSymbolPrefix());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004967
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004968 llvm::GlobalVariable *SuperClassGV, *IsAGV;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004969
4970 bool classIsHidden =
Daniel Dunbar04d40782009-04-14 06:00:08 +00004971 CGM.getDeclVisibilityMode(ID->getClassInterface()) == LangOptions::Hidden;
Fariborz Jahaniancf555162009-01-31 00:59:10 +00004972 if (classIsHidden)
Fariborz Jahanian493dab72009-01-26 21:38:32 +00004973 flags |= OBJC2_CLS_HIDDEN;
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00004974 if (ID->getNumIvarInitializers())
4975 flags |= eClassFlags_ABI2_HasCXXStructors;
Fariborz Jahanian493dab72009-01-26 21:38:32 +00004976 if (!ID->getClassInterface()->getSuperClass()) {
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004977 // class is root
4978 flags |= CLS_ROOT;
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00004979 SuperClassGV = GetClassGlobal(ObjCClassName + ClassName);
Fariborz Jahanian0f902942009-04-14 18:41:56 +00004980 IsAGV = GetClassGlobal(ObjCMetaClassName + ClassName);
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004981 } else {
Fariborz Jahanian84394a52009-01-24 21:21:53 +00004982 // Has a root. Current class is not a root.
Fariborz Jahanianfab98c42009-02-26 18:23:47 +00004983 const ObjCInterfaceDecl *Root = ID->getClassInterface();
4984 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
4985 Root = Super;
Fariborz Jahanian0f902942009-04-14 18:41:56 +00004986 IsAGV = GetClassGlobal(ObjCMetaClassName + Root->getNameAsString());
Fariborz Jahanian0e93d252009-12-01 18:25:24 +00004987 if (Root->hasAttr<WeakImportAttr>())
4988 IsAGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Fariborz Jahanianfab98c42009-02-26 18:23:47 +00004989 // work on super class metadata symbol.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00004990 std::string SuperClassName =
Fariborz Jahanian0e93d252009-12-01 18:25:24 +00004991 ObjCMetaClassName +
4992 ID->getClassInterface()->getSuperClass()->getNameAsString();
Fariborz Jahanian0f902942009-04-14 18:41:56 +00004993 SuperClassGV = GetClassGlobal(SuperClassName);
Fariborz Jahaniana03d0dd2009-11-17 21:37:35 +00004994 if (ID->getClassInterface()->getSuperClass()->hasAttr<WeakImportAttr>())
4995 SuperClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Fariborz Jahanian058a1b72009-01-24 20:21:50 +00004996 }
4997 llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags,
4998 InstanceStart,
4999 InstanceSize,ID);
Fariborz Jahanian84394a52009-01-24 21:21:53 +00005000 std::string TClassName = ObjCMetaClassName + ClassName;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005001 llvm::GlobalVariable *MetaTClass =
Fariborz Jahaniancf555162009-01-31 00:59:10 +00005002 BuildClassMetaData(TClassName, IsAGV, SuperClassGV, CLASS_RO_GV,
5003 classIsHidden);
Fariborz Jahaniana03d0dd2009-11-17 21:37:35 +00005004 DefinedMetaClasses.push_back(MetaTClass);
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00005005
Fariborz Jahanian84394a52009-01-24 21:21:53 +00005006 // Metadata for the class
5007 flags = CLS;
Fariborz Jahaniancf555162009-01-31 00:59:10 +00005008 if (classIsHidden)
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005009 flags |= OBJC2_CLS_HIDDEN;
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00005010 if (ID->getNumIvarInitializers())
5011 flags |= eClassFlags_ABI2_HasCXXStructors;
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00005012
Douglas Gregor68584ed2009-06-18 16:11:24 +00005013 if (hasObjCExceptionAttribute(CGM.getContext(), ID->getClassInterface()))
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00005014 flags |= CLS_EXCEPTION;
5015
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005016 if (!ID->getClassInterface()->getSuperClass()) {
Fariborz Jahanian84394a52009-01-24 21:21:53 +00005017 flags |= CLS_ROOT;
5018 SuperClassGV = 0;
Chris Lattnerb7b58b12009-04-19 06:02:28 +00005019 } else {
Fariborz Jahanian84394a52009-01-24 21:21:53 +00005020 // Has a root. Current class is not a root.
Fariborz Jahanianfab98c42009-02-26 18:23:47 +00005021 std::string RootClassName =
Fariborz Jahanian84394a52009-01-24 21:21:53 +00005022 ID->getClassInterface()->getSuperClass()->getNameAsString();
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00005023 SuperClassGV = GetClassGlobal(ObjCClassName + RootClassName);
Fariborz Jahaniana03d0dd2009-11-17 21:37:35 +00005024 if (ID->getClassInterface()->getSuperClass()->hasAttr<WeakImportAttr>())
5025 SuperClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Fariborz Jahanian84394a52009-01-24 21:21:53 +00005026 }
Daniel Dunbar9f89f2b2009-05-03 12:57:56 +00005027 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
Fariborz Jahanian84394a52009-01-24 21:21:53 +00005028 CLASS_RO_GV = BuildClassRoTInitializer(flags,
Fariborz Jahanianf6a077e2009-01-24 23:43:01 +00005029 InstanceStart,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005030 InstanceSize,
Fariborz Jahanianf6a077e2009-01-24 23:43:01 +00005031 ID);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005032
Fariborz Jahanian84394a52009-01-24 21:21:53 +00005033 TClassName = ObjCClassName + ClassName;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005034 llvm::GlobalVariable *ClassMD =
Fariborz Jahaniancf555162009-01-31 00:59:10 +00005035 BuildClassMetaData(TClassName, MetaTClass, SuperClassGV, CLASS_RO_GV,
5036 classIsHidden);
Fariborz Jahanianf87a0cc2009-01-30 20:55:31 +00005037 DefinedClasses.push_back(ClassMD);
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00005038
Daniel Dunbar74d4b122009-05-15 22:33:15 +00005039 // Determine if this class is also "non-lazy".
5040 if (ImplementationIsNonLazy(ID))
5041 DefinedNonLazyClasses.push_back(ClassMD);
5042
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00005043 // Force the definition of the EHType if necessary.
5044 if (flags & CLS_EXCEPTION)
5045 GetInterfaceEHType(ID->getClassInterface(), true);
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00005046}
5047
Fariborz Jahanian8cfd3972009-01-30 18:58:59 +00005048/// GenerateProtocolRef - This routine is called to generate code for
5049/// a protocol reference expression; as in:
5050/// @code
5051/// @protocol(Proto1);
5052/// @endcode
5053/// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
5054/// which will hold address of the protocol meta-data.
5055///
5056llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CGBuilderTy &Builder,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005057 const ObjCProtocolDecl *PD) {
5058
Fariborz Jahanian960cd062009-04-10 18:47:34 +00005059 // This routine is called for @protocol only. So, we must build definition
5060 // of protocol's meta-data (not a reference to it!)
5061 //
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005062 llvm::Constant *Init =
5063 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
5064 ObjCTypes.ExternalProtocolPtrTy);
5065
Fariborz Jahanian8cfd3972009-01-30 18:58:59 +00005066 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
Daniel Dunbar4087f272010-08-17 22:39:59 +00005067 ProtocolName += PD->getName();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005068
Fariborz Jahanian8cfd3972009-01-30 18:58:59 +00005069 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
5070 if (PTGV)
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00005071 return Builder.CreateLoad(PTGV, "tmp");
Fariborz Jahanian8cfd3972009-01-30 18:58:59 +00005072 PTGV = new llvm::GlobalVariable(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005073 CGM.getModule(),
5074 Init->getType(), false,
5075 llvm::GlobalValue::WeakAnyLinkage,
5076 Init,
5077 ProtocolName);
Fariborz Jahanian8cfd3972009-01-30 18:58:59 +00005078 PTGV->setSection("__DATA, __objc_protorefs, coalesced, no_dead_strip");
5079 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Chris Lattnerad64e022009-07-17 23:57:13 +00005080 CGM.AddUsedGlobal(PTGV);
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00005081 return Builder.CreateLoad(PTGV, "tmp");
Fariborz Jahanian8cfd3972009-01-30 18:58:59 +00005082}
5083
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00005084/// GenerateCategory - Build metadata for a category implementation.
5085/// struct _category_t {
5086/// const char * const name;
5087/// struct _class_t *const cls;
5088/// const struct _method_list_t * const instance_methods;
5089/// const struct _method_list_t * const class_methods;
5090/// const struct _protocol_list_t * const protocols;
5091/// const struct _prop_list_t * const properties;
5092/// }
5093///
Daniel Dunbar74d4b122009-05-15 22:33:15 +00005094void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00005095 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
Fariborz Jahanianf6317dd2009-01-26 22:58:07 +00005096 const char *Prefix = "\01l_OBJC_$_CATEGORY_";
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005097 std::string ExtCatName(Prefix + Interface->getNameAsString()+
5098 "_$_" + OCD->getNameAsString());
5099 std::string ExtClassName(getClassSymbolPrefix() +
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00005100 Interface->getNameAsString());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005101
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00005102 std::vector<llvm::Constant*> Values(6);
5103 Values[0] = GetClassName(OCD->getIdentifier());
5104 // meta-class entry symbol
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00005105 llvm::GlobalVariable *ClassGV = GetClassGlobal(ExtClassName);
Fariborz Jahanian2cdcc4c2009-11-17 22:02:21 +00005106 if (Interface->hasAttr<WeakImportAttr>())
5107 ClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
5108
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00005109 Values[1] = ClassGV;
Fariborz Jahanianf6317dd2009-01-26 22:58:07 +00005110 std::vector<llvm::Constant*> Methods;
5111 std::string MethodListName(Prefix);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005112 MethodListName += "INSTANCE_METHODS_" + Interface->getNameAsString() +
Fariborz Jahanianf6317dd2009-01-26 22:58:07 +00005113 "_$_" + OCD->getNameAsString();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005114
5115 for (ObjCCategoryImplDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005116 i = OCD->instmeth_begin(), e = OCD->instmeth_end(); i != e; ++i) {
Fariborz Jahanianf6317dd2009-01-26 22:58:07 +00005117 // Instance methods should always be defined.
5118 Methods.push_back(GetMethodConstant(*i));
5119 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005120
5121 Values[2] = EmitMethodList(MethodListName,
5122 "__DATA, __objc_const",
Fariborz Jahanianf6317dd2009-01-26 22:58:07 +00005123 Methods);
5124
5125 MethodListName = Prefix;
5126 MethodListName += "CLASS_METHODS_" + Interface->getNameAsString() + "_$_" +
5127 OCD->getNameAsString();
5128 Methods.clear();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005129 for (ObjCCategoryImplDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005130 i = OCD->classmeth_begin(), e = OCD->classmeth_end(); i != e; ++i) {
Fariborz Jahanianf6317dd2009-01-26 22:58:07 +00005131 // Class methods should always be defined.
5132 Methods.push_back(GetMethodConstant(*i));
5133 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005134
5135 Values[3] = EmitMethodList(MethodListName,
5136 "__DATA, __objc_const",
Fariborz Jahanianf6317dd2009-01-26 22:58:07 +00005137 Methods);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005138 const ObjCCategoryDecl *Category =
Fariborz Jahanian5de14dc2009-01-28 22:18:42 +00005139 Interface->FindCategoryDeclaration(OCD->getIdentifier());
Fariborz Jahanian943ed6f2009-02-13 17:52:22 +00005140 if (Category) {
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005141 llvm::SmallString<256> ExtName;
5142 llvm::raw_svector_ostream(ExtName) << Interface->getName() << "_$_"
5143 << OCD->getName();
Fariborz Jahanian943ed6f2009-02-13 17:52:22 +00005144 Values[4] = EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005145 + Interface->getName() + "_$_"
5146 + Category->getName(),
Fariborz Jahanian943ed6f2009-02-13 17:52:22 +00005147 Category->protocol_begin(),
5148 Category->protocol_end());
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005149 Values[5] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
5150 OCD, Category, ObjCTypes);
Mike Stumpb3589f42009-07-30 22:28:39 +00005151 } else {
Owen Andersonc9c88b42009-07-31 20:28:54 +00005152 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
5153 Values[5] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
Fariborz Jahanian943ed6f2009-02-13 17:52:22 +00005154 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005155
5156 llvm::Constant *Init =
5157 llvm::ConstantStruct::get(ObjCTypes.CategorynfABITy,
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00005158 Values);
5159 llvm::GlobalVariable *GCATV
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005160 = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CategorynfABITy,
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00005161 false,
5162 llvm::GlobalValue::InternalLinkage,
5163 Init,
Owen Anderson1c431b32009-07-08 19:05:04 +00005164 ExtCatName);
Fariborz Jahanian09796d62009-01-31 02:43:27 +00005165 GCATV->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005166 CGM.getTargetData().getABITypeAlignment(ObjCTypes.CategorynfABITy));
Fariborz Jahanian1bf0afb2009-01-28 01:05:23 +00005167 GCATV->setSection("__DATA, __objc_const");
Chris Lattnerad64e022009-07-17 23:57:13 +00005168 CGM.AddUsedGlobal(GCATV);
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00005169 DefinedCategories.push_back(GCATV);
Daniel Dunbar74d4b122009-05-15 22:33:15 +00005170
5171 // Determine if this category is also "non-lazy".
5172 if (ImplementationIsNonLazy(OCD))
5173 DefinedNonLazyCategories.push_back(GCATV);
Fariborz Jahanianeb062d92009-01-26 18:32:24 +00005174}
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005175
5176/// GetMethodConstant - Return a struct objc_method constant for the
5177/// given method if it has been defined. The result is null if the
5178/// method has not been defined. The return value has type MethodPtrTy.
5179llvm::Constant *CGObjCNonFragileABIMac::GetMethodConstant(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005180 const ObjCMethodDecl *MD) {
Argyrios Kyrtzidis9d50c062010-08-09 10:54:20 +00005181 llvm::Function *Fn = GetMethodDefinition(MD);
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005182 if (!Fn)
5183 return 0;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005184
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005185 std::vector<llvm::Constant*> Method(3);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005186 Method[0] =
Owen Anderson3c4972d2009-07-29 18:54:39 +00005187 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005188 ObjCTypes.SelectorPtrTy);
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005189 Method[1] = GetMethodVarType(MD);
Owen Anderson3c4972d2009-07-29 18:54:39 +00005190 Method[2] = llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy);
Owen Anderson08e25242009-07-27 22:29:56 +00005191 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005192}
5193
5194/// EmitMethodList - Build meta-data for method declarations
5195/// struct _method_list_t {
5196/// uint32_t entsize; // sizeof(struct _objc_method)
5197/// uint32_t method_count;
5198/// struct _objc_method method_list[method_count];
5199/// }
5200///
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005201llvm::Constant *CGObjCNonFragileABIMac::EmitMethodList(llvm::Twine Name,
5202 const char *Section,
5203 const ConstantVector &Methods) {
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005204 // Return null for empty list.
5205 if (Methods.empty())
Owen Andersonc9c88b42009-07-31 20:28:54 +00005206 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005207
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005208 std::vector<llvm::Constant*> Values(3);
5209 // sizeof(struct _objc_method)
Duncan Sands9408c452009-05-09 07:08:47 +00005210 unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.MethodTy);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00005211 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005212 // method_count
Owen Anderson4a28d5d2009-07-24 23:12:58 +00005213 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
Owen Anderson96e0fc72009-07-29 22:16:19 +00005214 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005215 Methods.size());
Owen Anderson7db6d832009-07-28 18:33:04 +00005216 Values[2] = llvm::ConstantArray::get(AT, Methods);
Nick Lewycky0d36dd22009-09-19 20:00:52 +00005217 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005218
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005219 llvm::GlobalVariable *GV =
Owen Anderson1c431b32009-07-08 19:05:04 +00005220 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005221 llvm::GlobalValue::InternalLinkage,
5222 Init,
Owen Anderson1c431b32009-07-08 19:05:04 +00005223 Name);
Fariborz Jahanian09796d62009-01-31 02:43:27 +00005224 GV->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005225 CGM.getTargetData().getABITypeAlignment(Init->getType()));
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005226 GV->setSection(Section);
Chris Lattnerad64e022009-07-17 23:57:13 +00005227 CGM.AddUsedGlobal(GV);
Owen Anderson3c4972d2009-07-29 18:54:39 +00005228 return llvm::ConstantExpr::getBitCast(GV,
Fariborz Jahanian493dab72009-01-26 21:38:32 +00005229 ObjCTypes.MethodListnfABIPtrTy);
5230}
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005231
Fariborz Jahanianed157d32009-02-10 20:21:06 +00005232/// ObjCIvarOffsetVariable - Returns the ivar offset variable for
5233/// the given ivar.
Daniel Dunbare83be122010-04-02 21:14:02 +00005234llvm::GlobalVariable *
5235CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
5236 const ObjCIvarDecl *Ivar) {
5237 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
Daniel Dunbara81419d2009-05-05 00:36:57 +00005238 std::string Name = "OBJC_IVAR_$_" + Container->getNameAsString() +
Douglas Gregor6ab35242009-04-09 21:40:53 +00005239 '.' + Ivar->getNameAsString();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005240 llvm::GlobalVariable *IvarOffsetGV =
Fariborz Jahanianed157d32009-02-10 20:21:06 +00005241 CGM.getModule().getGlobalVariable(Name);
5242 if (!IvarOffsetGV)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005243 IvarOffsetGV =
Owen Anderson1c431b32009-07-08 19:05:04 +00005244 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.LongTy,
Fariborz Jahanianed157d32009-02-10 20:21:06 +00005245 false,
5246 llvm::GlobalValue::ExternalLinkage,
5247 0,
Owen Anderson1c431b32009-07-08 19:05:04 +00005248 Name);
Fariborz Jahanianed157d32009-02-10 20:21:06 +00005249 return IvarOffsetGV;
5250}
5251
Daniel Dunbare83be122010-04-02 21:14:02 +00005252llvm::Constant *
5253CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
5254 const ObjCIvarDecl *Ivar,
5255 unsigned long int Offset) {
Daniel Dunbar737c5022009-04-19 00:44:02 +00005256 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005257 IvarOffsetGV->setInitializer(llvm::ConstantInt::get(ObjCTypes.LongTy,
Daniel Dunbar737c5022009-04-19 00:44:02 +00005258 Offset));
Fariborz Jahanian09796d62009-01-31 02:43:27 +00005259 IvarOffsetGV->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005260 CGM.getTargetData().getABITypeAlignment(ObjCTypes.LongTy));
Daniel Dunbar737c5022009-04-19 00:44:02 +00005261
Mike Stumpf5408fe2009-05-16 07:57:57 +00005262 // FIXME: This matches gcc, but shouldn't the visibility be set on the use as
5263 // well (i.e., in ObjCIvarOffsetVariable).
Daniel Dunbar737c5022009-04-19 00:44:02 +00005264 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
5265 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
5266 CGM.getDeclVisibilityMode(ID) == LangOptions::Hidden)
Fariborz Jahanian2fa5a272009-01-28 01:36:42 +00005267 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Daniel Dunbar04d40782009-04-14 06:00:08 +00005268 else
Fariborz Jahanian77c9fd22009-04-06 18:30:00 +00005269 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Fariborz Jahanian1bf0afb2009-01-28 01:05:23 +00005270 IvarOffsetGV->setSection("__DATA, __objc_const");
Fariborz Jahanian45012a72009-02-03 00:09:52 +00005271 return IvarOffsetGV;
Fariborz Jahanian1bf0afb2009-01-28 01:05:23 +00005272}
5273
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005274/// EmitIvarList - Emit the ivar list for the given
Daniel Dunbar11394522009-04-18 08:51:00 +00005275/// implementation. The return value has type
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005276/// IvarListnfABIPtrTy.
5277/// struct _ivar_t {
5278/// unsigned long int *offset; // pointer to ivar offset location
5279/// char *name;
5280/// char *type;
5281/// uint32_t alignment;
5282/// uint32_t size;
5283/// }
5284/// struct _ivar_list_t {
5285/// uint32 entsize; // sizeof(struct _ivar_t)
5286/// uint32 count;
5287/// struct _iver_t list[count];
5288/// }
5289///
Daniel Dunbar3e5f0d82009-04-20 06:54:31 +00005290
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005291llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005292 const ObjCImplementationDecl *ID) {
5293
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005294 std::vector<llvm::Constant*> Ivars, Ivar(5);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005295
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005296 const ObjCInterfaceDecl *OID = ID->getClassInterface();
5297 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005298
Fariborz Jahanian1bf0afb2009-01-28 01:05:23 +00005299 // FIXME. Consolidate this with similar code in GenerateClass.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005300
Daniel Dunbar91636d62009-04-20 00:33:43 +00005301 // Collect declared and synthesized ivars in a small vector.
Fariborz Jahanian18191882009-03-31 18:11:23 +00005302 llvm::SmallVector<ObjCIvarDecl*, 16> OIvars;
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +00005303 CGM.getContext().ShallowCollectObjCIvars(OID, OIvars);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005304
Daniel Dunbar3e5f0d82009-04-20 06:54:31 +00005305 for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
5306 ObjCIvarDecl *IVD = OIvars[i];
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +00005307 // Ignore unnamed bit-fields.
5308 if (!IVD->getDeclName())
5309 continue;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005310 Ivar[0] = EmitIvarOffsetVar(ID->getClassInterface(), IVD,
Daniel Dunbar9f89f2b2009-05-03 12:57:56 +00005311 ComputeIvarBaseOffset(CGM, ID, IVD));
Daniel Dunbar3fea0c02009-04-22 08:22:17 +00005312 Ivar[1] = GetMethodVarName(IVD->getIdentifier());
5313 Ivar[2] = GetMethodVarType(IVD);
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005314 const llvm::Type *FieldTy =
Daniel Dunbar3fea0c02009-04-22 08:22:17 +00005315 CGM.getTypes().ConvertTypeForMem(IVD->getType());
Duncan Sands9408c452009-05-09 07:08:47 +00005316 unsigned Size = CGM.getTargetData().getTypeAllocSize(FieldTy);
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005317 unsigned Align = CGM.getContext().getPreferredTypeAlign(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005318 IVD->getType().getTypePtr()) >> 3;
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005319 Align = llvm::Log2_32(Align);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00005320 Ivar[3] = llvm::ConstantInt::get(ObjCTypes.IntTy, Align);
Daniel Dunbar91636d62009-04-20 00:33:43 +00005321 // NOTE. Size of a bitfield does not match gcc's, because of the
5322 // way bitfields are treated special in each. But I am told that
5323 // 'size' for bitfield ivars is ignored by the runtime so it does
5324 // not matter. If it matters, there is enough info to get the
5325 // bitfield right!
Owen Anderson4a28d5d2009-07-24 23:12:58 +00005326 Ivar[4] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Owen Anderson08e25242009-07-27 22:29:56 +00005327 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarnfABITy, Ivar));
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005328 }
5329 // Return null for empty list.
5330 if (Ivars.empty())
Owen Andersonc9c88b42009-07-31 20:28:54 +00005331 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005332 std::vector<llvm::Constant*> Values(3);
Duncan Sands9408c452009-05-09 07:08:47 +00005333 unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.IvarnfABITy);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00005334 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
5335 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
Owen Anderson96e0fc72009-07-29 22:16:19 +00005336 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarnfABITy,
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005337 Ivars.size());
Owen Anderson7db6d832009-07-28 18:33:04 +00005338 Values[2] = llvm::ConstantArray::get(AT, Ivars);
Nick Lewycky0d36dd22009-09-19 20:00:52 +00005339 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005340 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
5341 llvm::GlobalVariable *GV =
Owen Anderson1c431b32009-07-08 19:05:04 +00005342 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Fariborz Jahanian98abf4b2009-01-27 19:38:51 +00005343 llvm::GlobalValue::InternalLinkage,
5344 Init,
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005345 Prefix + OID->getName());
Fariborz Jahanian09796d62009-01-31 02:43:27 +00005346 GV->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005347 CGM.getTargetData().getABITypeAlignment(Init->getType()));
Fariborz Jahanian1bf0afb2009-01-28 01:05:23 +00005348 GV->setSection("__DATA, __objc_const");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005349
Chris Lattnerad64e022009-07-17 23:57:13 +00005350 CGM.AddUsedGlobal(GV);
Owen Anderson3c4972d2009-07-29 18:54:39 +00005351 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005352}
5353
5354llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005355 const ObjCProtocolDecl *PD) {
Fariborz Jahanianda320092009-01-29 19:24:30 +00005356 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005357
Fariborz Jahanianda320092009-01-29 19:24:30 +00005358 if (!Entry) {
5359 // We use the initializer as a marker of whether this is a forward
5360 // reference or not. At module finalization we add the empty
5361 // contents for protocols which were referenced but never defined.
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005362 Entry =
5363 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy, false,
5364 llvm::GlobalValue::ExternalLinkage,
5365 0,
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005366 "\01l_OBJC_PROTOCOL_$_" + PD->getName());
Fariborz Jahanianda320092009-01-29 19:24:30 +00005367 Entry->setSection("__DATA,__datacoal_nt,coalesced");
Fariborz Jahanianda320092009-01-29 19:24:30 +00005368 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005369
Fariborz Jahanianda320092009-01-29 19:24:30 +00005370 return Entry;
5371}
5372
5373/// GetOrEmitProtocol - Generate the protocol meta-data:
5374/// @code
5375/// struct _protocol_t {
5376/// id isa; // NULL
5377/// const char * const protocol_name;
5378/// const struct _protocol_list_t * protocol_list; // super protocols
5379/// const struct method_list_t * const instance_methods;
5380/// const struct method_list_t * const class_methods;
5381/// const struct method_list_t *optionalInstanceMethods;
5382/// const struct method_list_t *optionalClassMethods;
5383/// const struct _prop_list_t * properties;
5384/// const uint32_t size; // sizeof(struct _protocol_t)
5385/// const uint32_t flags; // = 0
5386/// }
5387/// @endcode
5388///
5389
5390llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005391 const ObjCProtocolDecl *PD) {
Fariborz Jahanianda320092009-01-29 19:24:30 +00005392 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005393
Fariborz Jahanianda320092009-01-29 19:24:30 +00005394 // Early exit if a defining object has already been generated.
5395 if (Entry && Entry->hasInitializer())
5396 return Entry;
5397
Fariborz Jahanianda320092009-01-29 19:24:30 +00005398 // Construct method lists.
5399 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
5400 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005401 for (ObjCProtocolDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005402 i = PD->instmeth_begin(), e = PD->instmeth_end(); i != e; ++i) {
Fariborz Jahanianda320092009-01-29 19:24:30 +00005403 ObjCMethodDecl *MD = *i;
Fariborz Jahanian3819a0b2009-01-30 00:46:37 +00005404 llvm::Constant *C = GetMethodDescriptionConstant(MD);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005405 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
5406 OptInstanceMethods.push_back(C);
5407 } else {
5408 InstanceMethods.push_back(C);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005409 }
Fariborz Jahanianda320092009-01-29 19:24:30 +00005410 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005411
5412 for (ObjCProtocolDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005413 i = PD->classmeth_begin(), e = PD->classmeth_end(); i != e; ++i) {
Fariborz Jahanianda320092009-01-29 19:24:30 +00005414 ObjCMethodDecl *MD = *i;
Fariborz Jahanian3819a0b2009-01-30 00:46:37 +00005415 llvm::Constant *C = GetMethodDescriptionConstant(MD);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005416 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
5417 OptClassMethods.push_back(C);
5418 } else {
5419 ClassMethods.push_back(C);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005420 }
Fariborz Jahanianda320092009-01-29 19:24:30 +00005421 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005422
Fariborz Jahanianda320092009-01-29 19:24:30 +00005423 std::vector<llvm::Constant*> Values(10);
5424 // isa is NULL
Owen Andersonc9c88b42009-07-31 20:28:54 +00005425 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005426 Values[1] = GetClassName(PD->getIdentifier());
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005427 Values[2] = EmitProtocolList("\01l_OBJC_$_PROTOCOL_REFS_" + PD->getName(),
5428 PD->protocol_begin(),
5429 PD->protocol_end());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005430
Fariborz Jahanian3819a0b2009-01-30 00:46:37 +00005431 Values[3] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_"
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005432 + PD->getName(),
Fariborz Jahanianda320092009-01-29 19:24:30 +00005433 "__DATA, __objc_const",
5434 InstanceMethods);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005435 Values[4] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_"
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005436 + PD->getName(),
Fariborz Jahanianda320092009-01-29 19:24:30 +00005437 "__DATA, __objc_const",
5438 ClassMethods);
Fariborz Jahanian3819a0b2009-01-30 00:46:37 +00005439 Values[5] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_"
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005440 + PD->getName(),
Fariborz Jahanianda320092009-01-29 19:24:30 +00005441 "__DATA, __objc_const",
5442 OptInstanceMethods);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005443 Values[6] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_"
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005444 + PD->getName(),
Fariborz Jahanianda320092009-01-29 19:24:30 +00005445 "__DATA, __objc_const",
5446 OptClassMethods);
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005447 Values[7] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + PD->getName(),
Fariborz Jahanianda320092009-01-29 19:24:30 +00005448 0, PD, ObjCTypes);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005449 uint32_t Size =
Duncan Sands9408c452009-05-09 07:08:47 +00005450 CGM.getTargetData().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
Owen Anderson4a28d5d2009-07-24 23:12:58 +00005451 Values[8] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
Owen Andersonc9c88b42009-07-31 20:28:54 +00005452 Values[9] = llvm::Constant::getNullValue(ObjCTypes.IntTy);
Owen Anderson08e25242009-07-27 22:29:56 +00005453 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolnfABITy,
Fariborz Jahanianda320092009-01-29 19:24:30 +00005454 Values);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005455
Fariborz Jahanianda320092009-01-29 19:24:30 +00005456 if (Entry) {
5457 // Already created, fix the linkage and update the initializer.
Mike Stump286acbd2009-03-07 16:33:28 +00005458 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005459 Entry->setInitializer(Init);
5460 } else {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005461 Entry =
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005462 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
5463 false, llvm::GlobalValue::WeakAnyLinkage, Init,
5464 "\01l_OBJC_PROTOCOL_$_" + PD->getName());
Fariborz Jahanian09796d62009-01-31 02:43:27 +00005465 Entry->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005466 CGM.getTargetData().getABITypeAlignment(ObjCTypes.ProtocolnfABITy));
Fariborz Jahanianda320092009-01-29 19:24:30 +00005467 Entry->setSection("__DATA,__datacoal_nt,coalesced");
Fariborz Jahanianda320092009-01-29 19:24:30 +00005468 }
Fariborz Jahanian8448c2c2009-01-29 20:10:59 +00005469 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
Chris Lattnerad64e022009-07-17 23:57:13 +00005470 CGM.AddUsedGlobal(Entry);
5471
Fariborz Jahanian8448c2c2009-01-29 20:10:59 +00005472 // Use this protocol meta-data to build protocol list table in section
5473 // __DATA, __objc_protolist
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005474 llvm::GlobalVariable *PTGV =
5475 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
5476 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
5477 "\01l_OBJC_LABEL_PROTOCOL_$_" + PD->getName());
Fariborz Jahanian09796d62009-01-31 02:43:27 +00005478 PTGV->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005479 CGM.getTargetData().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
Daniel Dunbar0bf21992009-04-15 02:56:18 +00005480 PTGV->setSection("__DATA, __objc_protolist, coalesced, no_dead_strip");
Fariborz Jahanian8448c2c2009-01-29 20:10:59 +00005481 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Chris Lattnerad64e022009-07-17 23:57:13 +00005482 CGM.AddUsedGlobal(PTGV);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005483 return Entry;
5484}
5485
5486/// EmitProtocolList - Generate protocol list meta-data:
5487/// @code
5488/// struct _protocol_list_t {
5489/// long protocol_count; // Note, this is 32/64 bit
5490/// struct _protocol_t[protocol_count];
5491/// }
5492/// @endcode
5493///
5494llvm::Constant *
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005495CGObjCNonFragileABIMac::EmitProtocolList(llvm::Twine Name,
5496 ObjCProtocolDecl::protocol_iterator begin,
5497 ObjCProtocolDecl::protocol_iterator end) {
Fariborz Jahanianda320092009-01-29 19:24:30 +00005498 std::vector<llvm::Constant*> ProtocolRefs;
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005499
Fariborz Jahanianda320092009-01-29 19:24:30 +00005500 // Just return null for empty protocol lists
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005501 if (begin == end)
Owen Andersonc9c88b42009-07-31 20:28:54 +00005502 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005503
Daniel Dunbar948e2582009-02-15 07:36:20 +00005504 // FIXME: We shouldn't need to do this lookup here, should we?
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005505 llvm::SmallString<256> TmpName;
5506 Name.toVector(TmpName);
5507 llvm::GlobalVariable *GV =
5508 CGM.getModule().getGlobalVariable(TmpName.str(), true);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005509 if (GV)
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00005510 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005511
Daniel Dunbar948e2582009-02-15 07:36:20 +00005512 for (; begin != end; ++begin)
5513 ProtocolRefs.push_back(GetProtocolRef(*begin)); // Implemented???
5514
Fariborz Jahanianda320092009-01-29 19:24:30 +00005515 // This list is null terminated.
Owen Andersonc9c88b42009-07-31 20:28:54 +00005516 ProtocolRefs.push_back(llvm::Constant::getNullValue(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005517 ObjCTypes.ProtocolnfABIPtrTy));
5518
Fariborz Jahanianda320092009-01-29 19:24:30 +00005519 std::vector<llvm::Constant*> Values(2);
Owen Andersona1cf15f2009-07-14 23:10:40 +00005520 Values[0] =
Owen Anderson4a28d5d2009-07-24 23:12:58 +00005521 llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005522 Values[1] =
Owen Anderson7db6d832009-07-28 18:33:04 +00005523 llvm::ConstantArray::get(
Owen Anderson96e0fc72009-07-29 22:16:19 +00005524 llvm::ArrayType::get(ObjCTypes.ProtocolnfABIPtrTy,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005525 ProtocolRefs.size()),
5526 ProtocolRefs);
5527
Nick Lewycky0d36dd22009-09-19 20:00:52 +00005528 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Owen Anderson1c431b32009-07-08 19:05:04 +00005529 GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Fariborz Jahanianda320092009-01-29 19:24:30 +00005530 llvm::GlobalValue::InternalLinkage,
5531 Init,
Owen Anderson1c431b32009-07-08 19:05:04 +00005532 Name);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005533 GV->setSection("__DATA, __objc_const");
Fariborz Jahanian09796d62009-01-31 02:43:27 +00005534 GV->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005535 CGM.getTargetData().getABITypeAlignment(Init->getType()));
Chris Lattnerad64e022009-07-17 23:57:13 +00005536 CGM.AddUsedGlobal(GV);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005537 return llvm::ConstantExpr::getBitCast(GV,
Daniel Dunbar948e2582009-02-15 07:36:20 +00005538 ObjCTypes.ProtocolListnfABIPtrTy);
Fariborz Jahanianda320092009-01-29 19:24:30 +00005539}
5540
Fariborz Jahanian3819a0b2009-01-30 00:46:37 +00005541/// GetMethodDescriptionConstant - This routine build following meta-data:
5542/// struct _objc_method {
5543/// SEL _cmd;
5544/// char *method_type;
5545/// char *_imp;
5546/// }
5547
5548llvm::Constant *
5549CGObjCNonFragileABIMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
5550 std::vector<llvm::Constant*> Desc(3);
Owen Andersona1cf15f2009-07-14 23:10:40 +00005551 Desc[0] =
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005552 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
5553 ObjCTypes.SelectorPtrTy);
Fariborz Jahanian3819a0b2009-01-30 00:46:37 +00005554 Desc[1] = GetMethodVarType(MD);
Fariborz Jahanian8cfd3972009-01-30 18:58:59 +00005555 // Protocol methods have no implementation. So, this entry is always NULL.
Owen Andersonc9c88b42009-07-31 20:28:54 +00005556 Desc[2] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
Owen Anderson08e25242009-07-27 22:29:56 +00005557 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Desc);
Fariborz Jahanian3819a0b2009-01-30 00:46:37 +00005558}
Fariborz Jahanian45012a72009-02-03 00:09:52 +00005559
5560/// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
5561/// This code gen. amounts to generating code for:
5562/// @code
5563/// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
5564/// @encode
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005565///
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00005566LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
John McCall506b57e2010-05-17 21:00:27 +00005567 CodeGen::CodeGenFunction &CGF,
5568 QualType ObjectTy,
5569 llvm::Value *BaseValue,
5570 const ObjCIvarDecl *Ivar,
5571 unsigned CVRQualifiers) {
5572 ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
Daniel Dunbar97776872009-04-22 07:32:20 +00005573 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
5574 EmitIvarOffset(CGF, ID, Ivar));
Fariborz Jahanian45012a72009-02-03 00:09:52 +00005575}
5576
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00005577llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005578 CodeGen::CodeGenFunction &CGF,
5579 const ObjCInterfaceDecl *Interface,
5580 const ObjCIvarDecl *Ivar) {
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00005581 return CGF.Builder.CreateLoad(ObjCIvarOffsetVariable(Interface, Ivar),"ivar");
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00005582}
5583
Fariborz Jahanian46551122009-02-04 00:22:57 +00005584CodeGen::RValue CGObjCNonFragileABIMac::EmitMessageSend(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005585 CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00005586 ReturnValueSlot Return,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005587 QualType ResultType,
5588 Selector Sel,
5589 llvm::Value *Receiver,
5590 QualType Arg0Ty,
5591 bool IsSuper,
5592 const CallArgList &CallArgs) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00005593 // FIXME. Even though IsSuper is passes. This function doese not handle calls
5594 // to 'super' receivers.
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005595 CodeGenTypes &Types = CGM.getTypes();
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005596 llvm::Value *Arg0 = Receiver;
5597 if (!IsSuper)
5598 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy, "tmp");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005599
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005600 // Find the message function name.
Mike Stumpf5408fe2009-05-16 07:57:57 +00005601 // FIXME. This is too much work to get the ABI-specific result type needed to
5602 // find the message name.
John McCallead608a2010-02-26 00:48:12 +00005603 const CGFunctionInfo &FnInfo
Rafael Espindola264ba482010-03-30 20:24:48 +00005604 = Types.getFunctionInfo(ResultType, CallArgList(),
5605 FunctionType::ExtInfo());
Fariborz Jahanian70b51c72009-04-30 23:08:58 +00005606 llvm::Constant *Fn = 0;
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005607 std::string Name("\01l_");
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00005608 if (CGM.ReturnTypeUsesSRet(FnInfo)) {
Chris Lattner9b7d6702010-08-18 16:09:06 +00005609 if (IsSuper) {
5610 Fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
5611 Name += "objc_msgSendSuper2_stret_fixup";
5612 } else {
5613 Fn = ObjCTypes.getMessageSendStretFixupFn();
5614 Name += "objc_msgSend_stret_fixup";
5615 }
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00005616 } else if (!IsSuper && CGM.ReturnTypeUsesFPRet(ResultType)) {
5617 Fn = ObjCTypes.getMessageSendFpretFixupFn();
5618 Name += "objc_msgSend_fpret_fixup";
Mike Stumpb3589f42009-07-30 22:28:39 +00005619 } else {
Chris Lattner9b7d6702010-08-18 16:09:06 +00005620 if (IsSuper) {
5621 Fn = ObjCTypes.getMessageSendSuper2FixupFn();
5622 Name += "objc_msgSendSuper2_fixup";
5623 } else {
5624 Fn = ObjCTypes.getMessageSendFixupFn();
5625 Name += "objc_msgSend_fixup";
5626 }
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005627 }
Fariborz Jahanian70b51c72009-04-30 23:08:58 +00005628 assert(Fn && "CGObjCNonFragileABIMac::EmitMessageSend");
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005629 Name += '_';
5630 std::string SelName(Sel.getAsString());
5631 // Replace all ':' in selector name with '_' ouch!
Mike Stump1eb44332009-09-09 15:08:12 +00005632 for (unsigned i = 0; i < SelName.size(); i++)
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005633 if (SelName[i] == ':')
5634 SelName[i] = '_';
5635 Name += SelName;
5636 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
5637 if (!GV) {
Daniel Dunbar33af70f2009-04-15 19:03:14 +00005638 // Build message ref table entry.
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005639 std::vector<llvm::Constant*> Values(2);
5640 Values[0] = Fn;
5641 Values[1] = GetMethodVarName(Sel);
Nick Lewycky0d36dd22009-09-19 20:00:52 +00005642 llvm::Constant *Init = llvm::ConstantStruct::get(VMContext, Values, false);
Owen Anderson1c431b32009-07-08 19:05:04 +00005643 GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
Mike Stump286acbd2009-03-07 16:33:28 +00005644 llvm::GlobalValue::WeakAnyLinkage,
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005645 Init,
Owen Anderson1c431b32009-07-08 19:05:04 +00005646 Name);
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005647 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Daniel Dunbarf59c1a62009-04-15 19:04:46 +00005648 GV->setAlignment(16);
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005649 GV->setSection("__DATA, __objc_msgrefs, coalesced");
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005650 }
5651 llvm::Value *Arg1 = CGF.Builder.CreateBitCast(GV, ObjCTypes.MessageRefPtrTy);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005652
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005653 CallArgList ActualArgs;
5654 ActualArgs.push_back(std::make_pair(RValue::get(Arg0), Arg0Ty));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005655 ActualArgs.push_back(std::make_pair(RValue::get(Arg1),
Fariborz Jahanian83a8a752009-02-04 20:42:28 +00005656 ObjCTypes.MessageRefCPtrTy));
5657 ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
John McCall04a67a62010-02-05 21:31:56 +00005658 const CGFunctionInfo &FnInfo1 = Types.getFunctionInfo(ResultType, ActualArgs,
Rafael Espindola264ba482010-03-30 20:24:48 +00005659 FunctionType::ExtInfo());
Fariborz Jahanianef163782009-02-05 01:13:09 +00005660 llvm::Value *Callee = CGF.Builder.CreateStructGEP(Arg1, 0);
5661 Callee = CGF.Builder.CreateLoad(Callee);
Fariborz Jahanian3ab75bd2009-02-14 21:25:36 +00005662 const llvm::FunctionType *FTy = Types.GetFunctionType(FnInfo1, true);
Fariborz Jahanianef163782009-02-05 01:13:09 +00005663 Callee = CGF.Builder.CreateBitCast(Callee,
Owen Anderson96e0fc72009-07-29 22:16:19 +00005664 llvm::PointerType::getUnqual(FTy));
John McCallef072fd2010-05-22 01:48:05 +00005665 return CGF.EmitCall(FnInfo1, Callee, Return, ActualArgs);
Fariborz Jahanian46551122009-02-04 00:22:57 +00005666}
5667
5668/// Generate code for a message send expression in the nonfragile abi.
Daniel Dunbard6c93d72009-09-17 04:01:22 +00005669CodeGen::RValue
5670CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00005671 ReturnValueSlot Return,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00005672 QualType ResultType,
5673 Selector Sel,
5674 llvm::Value *Receiver,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00005675 const CallArgList &CallArgs,
David Chisnallc6cd5fd2010-04-28 19:33:36 +00005676 const ObjCInterfaceDecl *Class,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00005677 const ObjCMethodDecl *Method) {
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00005678 return LegacyDispatchedSelector(Sel)
John McCallef072fd2010-05-22 01:48:05 +00005679 ? EmitLegacyMessageSend(CGF, Return, ResultType,
5680 EmitSelector(CGF.Builder, Sel),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005681 Receiver, CGF.getContext().getObjCIdType(),
Daniel Dunbard6c93d72009-09-17 04:01:22 +00005682 false, CallArgs, Method, ObjCTypes)
John McCallef072fd2010-05-22 01:48:05 +00005683 : EmitMessageSend(CGF, Return, ResultType, Sel,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005684 Receiver, CGF.getContext().getObjCIdType(),
5685 false, CallArgs);
Fariborz Jahanian46551122009-02-04 00:22:57 +00005686}
5687
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00005688llvm::GlobalVariable *
Fariborz Jahanian0f902942009-04-14 18:41:56 +00005689CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name) {
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00005690 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
5691
Daniel Dunbardfff2302009-03-02 05:18:14 +00005692 if (!GV) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005693 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
Owen Anderson1c431b32009-07-08 19:05:04 +00005694 false, llvm::GlobalValue::ExternalLinkage,
5695 0, Name);
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00005696 }
5697
5698 return GV;
5699}
5700
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005701llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CGBuilderTy &Builder,
5702 const ObjCInterfaceDecl *ID) {
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00005703 llvm::GlobalVariable *&Entry = ClassReferences[ID->getIdentifier()];
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005704
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00005705 if (!Entry) {
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00005706 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
Daniel Dunbar5a7379a2009-03-01 04:40:10 +00005707 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005708 Entry =
5709 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
Owen Anderson1c431b32009-07-08 19:05:04 +00005710 false, llvm::GlobalValue::InternalLinkage,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005711 ClassGV,
Owen Anderson1c431b32009-07-08 19:05:04 +00005712 "\01L_OBJC_CLASSLIST_REFERENCES_$_");
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00005713 Entry->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005714 CGM.getTargetData().getABITypeAlignment(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005715 ObjCTypes.ClassnfABIPtrTy));
Daniel Dunbar11394522009-04-18 08:51:00 +00005716 Entry->setSection("__DATA, __objc_classrefs, regular, no_dead_strip");
Chris Lattnerad64e022009-07-17 23:57:13 +00005717 CGM.AddUsedGlobal(Entry);
Daniel Dunbar11394522009-04-18 08:51:00 +00005718 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005719
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00005720 return Builder.CreateLoad(Entry, "tmp");
Daniel Dunbar11394522009-04-18 08:51:00 +00005721}
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00005722
Daniel Dunbar11394522009-04-18 08:51:00 +00005723llvm::Value *
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005724CGObjCNonFragileABIMac::EmitSuperClassRef(CGBuilderTy &Builder,
Daniel Dunbar11394522009-04-18 08:51:00 +00005725 const ObjCInterfaceDecl *ID) {
5726 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005727
Daniel Dunbar11394522009-04-18 08:51:00 +00005728 if (!Entry) {
5729 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
5730 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005731 Entry =
5732 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
Owen Anderson1c431b32009-07-08 19:05:04 +00005733 false, llvm::GlobalValue::InternalLinkage,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005734 ClassGV,
Owen Anderson1c431b32009-07-08 19:05:04 +00005735 "\01L_OBJC_CLASSLIST_SUP_REFS_$_");
Daniel Dunbar11394522009-04-18 08:51:00 +00005736 Entry->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005737 CGM.getTargetData().getABITypeAlignment(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005738 ObjCTypes.ClassnfABIPtrTy));
Daniel Dunbar11394522009-04-18 08:51:00 +00005739 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
Chris Lattnerad64e022009-07-17 23:57:13 +00005740 CGM.AddUsedGlobal(Entry);
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00005741 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005742
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00005743 return Builder.CreateLoad(Entry, "tmp");
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00005744}
5745
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005746/// EmitMetaClassRef - Return a Value * of the address of _class_t
5747/// meta-data
5748///
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005749llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CGBuilderTy &Builder,
5750 const ObjCInterfaceDecl *ID) {
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005751 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
5752 if (Entry)
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00005753 return Builder.CreateLoad(Entry, "tmp");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005754
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00005755 std::string MetaClassName(getMetaclassSymbolPrefix() + ID->getNameAsString());
Fariborz Jahanian0f902942009-04-14 18:41:56 +00005756 llvm::GlobalVariable *MetaClassGV = GetClassGlobal(MetaClassName);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005757 Entry =
Owen Anderson1c431b32009-07-08 19:05:04 +00005758 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy, false,
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005759 llvm::GlobalValue::InternalLinkage,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005760 MetaClassGV,
Owen Anderson1c431b32009-07-08 19:05:04 +00005761 "\01L_OBJC_CLASSLIST_SUP_REFS_$_");
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005762 Entry->setAlignment(
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00005763 CGM.getTargetData().getABITypeAlignment(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005764 ObjCTypes.ClassnfABIPtrTy));
5765
Daniel Dunbar33af70f2009-04-15 19:03:14 +00005766 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
Chris Lattnerad64e022009-07-17 23:57:13 +00005767 CGM.AddUsedGlobal(Entry);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005768
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00005769 return Builder.CreateLoad(Entry, "tmp");
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005770}
5771
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00005772/// GetClass - Return a reference to the class for the given interface
5773/// decl.
5774llvm::Value *CGObjCNonFragileABIMac::GetClass(CGBuilderTy &Builder,
5775 const ObjCInterfaceDecl *ID) {
Fariborz Jahanian269f8bc2009-11-17 22:42:00 +00005776 if (ID->hasAttr<WeakImportAttr>()) {
5777 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
5778 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
5779 ClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
5780 }
5781
Fariborz Jahanian0e81f4b2009-02-05 20:41:40 +00005782 return EmitClassRef(Builder, ID);
5783}
5784
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005785/// Generates a message send where the super is the receiver. This is
5786/// a message send to self with special delivery semantics indicating
5787/// which class's method should be called.
5788CodeGen::RValue
5789CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
John McCallef072fd2010-05-22 01:48:05 +00005790 ReturnValueSlot Return,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005791 QualType ResultType,
5792 Selector Sel,
5793 const ObjCInterfaceDecl *Class,
5794 bool isCategoryImpl,
5795 llvm::Value *Receiver,
5796 bool IsClassMessage,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00005797 const CodeGen::CallArgList &CallArgs,
5798 const ObjCMethodDecl *Method) {
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005799 // ...
5800 // Create and init a super structure; this is a (receiver, class)
5801 // pair we will pass to objc_msgSendSuper.
5802 llvm::Value *ObjCSuper =
5803 CGF.Builder.CreateAlloca(ObjCTypes.SuperTy, 0, "objc_super");
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005804
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005805 llvm::Value *ReceiverAsObject =
5806 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
5807 CGF.Builder.CreateStore(ReceiverAsObject,
5808 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005809
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005810 // If this is a class message the metaclass is passed as the target.
Fariborz Jahanian7ce77922009-02-28 20:07:56 +00005811 llvm::Value *Target;
5812 if (IsClassMessage) {
5813 if (isCategoryImpl) {
5814 // Message sent to "super' in a class method defined in
5815 // a category implementation.
Daniel Dunbar11394522009-04-18 08:51:00 +00005816 Target = EmitClassRef(CGF.Builder, Class);
Fariborz Jahanian7ce77922009-02-28 20:07:56 +00005817 Target = CGF.Builder.CreateStructGEP(Target, 0);
5818 Target = CGF.Builder.CreateLoad(Target);
Mike Stumpb3589f42009-07-30 22:28:39 +00005819 } else
Fariborz Jahanian7ce77922009-02-28 20:07:56 +00005820 Target = EmitMetaClassRef(CGF.Builder, Class);
Mike Stumpb3589f42009-07-30 22:28:39 +00005821 } else
Daniel Dunbar11394522009-04-18 08:51:00 +00005822 Target = EmitSuperClassRef(CGF.Builder, Class);
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005823
Mike Stumpf5408fe2009-05-16 07:57:57 +00005824 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
5825 // ObjCTypes types.
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005826 const llvm::Type *ClassTy =
5827 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
5828 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
5829 CGF.Builder.CreateStore(Target,
5830 CGF.Builder.CreateStructGEP(ObjCSuper, 1));
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005831
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00005832 return (LegacyDispatchedSelector(Sel))
John McCallef072fd2010-05-22 01:48:05 +00005833 ? EmitLegacyMessageSend(CGF, Return, ResultType,
5834 EmitSelector(CGF.Builder, Sel),
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005835 ObjCSuper, ObjCTypes.SuperPtrCTy,
Daniel Dunbard6c93d72009-09-17 04:01:22 +00005836 true, CallArgs, Method, ObjCTypes)
John McCallef072fd2010-05-22 01:48:05 +00005837 : EmitMessageSend(CGF, Return, ResultType, Sel,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005838 ObjCSuper, ObjCTypes.SuperPtrCTy,
5839 true, CallArgs);
Fariborz Jahanian7a06aae2009-02-06 20:09:23 +00005840}
Fariborz Jahanian26cc89f2009-02-11 20:51:17 +00005841
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005842llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CGBuilderTy &Builder,
Fariborz Jahanian03b29602010-06-17 19:56:20 +00005843 Selector Sel, bool lval) {
Fariborz Jahanian26cc89f2009-02-11 20:51:17 +00005844 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005845
Fariborz Jahanian26cc89f2009-02-11 20:51:17 +00005846 if (!Entry) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005847 llvm::Constant *Casted =
5848 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5849 ObjCTypes.SelectorPtrTy);
5850 Entry =
5851 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
5852 llvm::GlobalValue::InternalLinkage,
5853 Casted, "\01L_OBJC_SELECTOR_REFERENCES_");
Fariborz Jahaniand0f8a8d2009-05-11 19:25:47 +00005854 Entry->setSection("__DATA, __objc_selrefs, literal_pointers, no_dead_strip");
Chris Lattnerad64e022009-07-17 23:57:13 +00005855 CGM.AddUsedGlobal(Entry);
Fariborz Jahanian26cc89f2009-02-11 20:51:17 +00005856 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005857
Fariborz Jahanian03b29602010-06-17 19:56:20 +00005858 if (lval)
5859 return Entry;
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00005860 return Builder.CreateLoad(Entry, "tmp");
Fariborz Jahanian26cc89f2009-02-11 20:51:17 +00005861}
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005862/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00005863/// objc_assign_ivar (id src, id *dst, ptrdiff_t)
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005864///
5865void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00005866 llvm::Value *src,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00005867 llvm::Value *dst,
5868 llvm::Value *ivarOffset) {
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00005869 const llvm::Type * SrcTy = src->getType();
5870 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sands9408c452009-05-09 07:08:47 +00005871 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00005872 assert(Size <= 8 && "does not support size > 8");
5873 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
5874 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
Fariborz Jahanian3b8a6522009-03-13 00:42:52 +00005875 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5876 }
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005877 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5878 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00005879 CGF.Builder.CreateCall3(ObjCTypes.getGcAssignIvarFn(),
5880 src, dst, ivarOffset);
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005881 return;
5882}
5883
5884/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5885/// objc_assign_strongCast (id src, id *dst)
5886///
5887void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005888 CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00005889 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00005890 const llvm::Type * SrcTy = src->getType();
5891 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sands9408c452009-05-09 07:08:47 +00005892 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00005893 assert(Size <= 8 && "does not support size > 8");
5894 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005895 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
Fariborz Jahanian3b8a6522009-03-13 00:42:52 +00005896 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5897 }
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005898 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5899 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattnerbbccd612009-04-22 02:38:11 +00005900 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignStrongCastFn(),
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005901 src, dst, "weakassign");
5902 return;
5903}
5904
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00005905void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005906 CodeGen::CodeGenFunction &CGF,
5907 llvm::Value *DestPtr,
5908 llvm::Value *SrcPtr,
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00005909 llvm::Value *Size) {
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00005910 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
5911 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00005912 CGF.Builder.CreateCall3(ObjCTypes.GcMemmoveCollectableFn(),
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00005913 DestPtr, SrcPtr, Size);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00005914 return;
5915}
5916
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005917/// EmitObjCWeakRead - Code gen for loading value of a __weak
5918/// object: objc_read_weak (id *src)
5919///
5920llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005921 CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00005922 llvm::Value *AddrWeakObj) {
Eli Friedman8339b352009-03-07 03:57:15 +00005923 const llvm::Type* DestTy =
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005924 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
5925 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
Chris Lattner72db6c32009-04-22 02:44:54 +00005926 llvm::Value *read_weak = CGF.Builder.CreateCall(ObjCTypes.getGcReadWeakFn(),
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005927 AddrWeakObj, "weakread");
Eli Friedman8339b352009-03-07 03:57:15 +00005928 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005929 return read_weak;
5930}
5931
5932/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
5933/// objc_assign_weak (id src, id *dst)
5934///
5935void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
Mike Stump1eb44332009-09-09 15:08:12 +00005936 llvm::Value *src, llvm::Value *dst) {
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00005937 const llvm::Type * SrcTy = src->getType();
5938 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sands9408c452009-05-09 07:08:47 +00005939 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00005940 assert(Size <= 8 && "does not support size > 8");
5941 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
5942 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
Fariborz Jahanian3b8a6522009-03-13 00:42:52 +00005943 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5944 }
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005945 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5946 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Chris Lattner96508e12009-04-17 22:12:36 +00005947 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignWeakFn(),
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005948 src, dst, "weakassign");
5949 return;
5950}
5951
5952/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
5953/// objc_assign_global (id src, id *dst)
5954///
5955void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00005956 llvm::Value *src, llvm::Value *dst,
5957 bool threadlocal) {
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00005958 const llvm::Type * SrcTy = src->getType();
5959 if (!isa<llvm::PointerType>(SrcTy)) {
Duncan Sands9408c452009-05-09 07:08:47 +00005960 unsigned Size = CGM.getTargetData().getTypeAllocSize(SrcTy);
Fariborz Jahanian0a855d02009-03-23 19:10:40 +00005961 assert(Size <= 8 && "does not support size > 8");
5962 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
5963 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
Fariborz Jahanian3b8a6522009-03-13 00:42:52 +00005964 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5965 }
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005966 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5967 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00005968 if (!threadlocal)
5969 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignGlobalFn(),
5970 src, dst, "globalassign");
5971 else
5972 CGF.Builder.CreateCall2(ObjCTypes.getGcAssignThreadLocalFn(),
5973 src, dst, "threadlocalassign");
Fariborz Jahanian6948aea2009-02-16 22:52:32 +00005974 return;
5975}
Fariborz Jahanian26cc89f2009-02-11 20:51:17 +00005976
John McCall740e8072010-07-21 00:41:47 +00005977namespace {
John McCall1f0fca52010-07-21 07:22:38 +00005978 struct CallSyncExit : EHScopeStack::Cleanup {
John McCall740e8072010-07-21 00:41:47 +00005979 llvm::Value *SyncExitFn;
5980 llvm::Value *SyncArg;
5981 CallSyncExit(llvm::Value *SyncExitFn, llvm::Value *SyncArg)
5982 : SyncExitFn(SyncExitFn), SyncArg(SyncArg) {}
5983
5984 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
5985 CGF.Builder.CreateCall(SyncExitFn, SyncArg)->setDoesNotThrow();
5986 }
5987 };
5988}
5989
Daniel Dunbar6bff2512009-08-03 17:06:42 +00005990void
John McCallf1549f62010-07-06 01:34:17 +00005991CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
5992 const ObjCAtSynchronizedStmt &S) {
5993 // Evaluate the lock operand. This should dominate the cleanup.
5994 llvm::Value *SyncArg = CGF.EmitScalarExpr(S.getSynchExpr());
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00005995
John McCallf1549f62010-07-06 01:34:17 +00005996 // Acquire the lock.
5997 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
5998 CGF.Builder.CreateCall(ObjCTypes.getSyncEnterFn(), SyncArg)
5999 ->setDoesNotThrow();
6000
6001 // Register an all-paths cleanup to release the lock.
John McCall1f0fca52010-07-21 07:22:38 +00006002 CGF.EHStack.pushCleanup<CallSyncExit>(NormalAndEHCleanup,
6003 ObjCTypes.getSyncExitFn(),
6004 SyncArg);
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006005
John McCallf1549f62010-07-06 01:34:17 +00006006 // Emit the body of the statement.
6007 CGF.EmitStmt(S.getSynchBody());
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006008
John McCallf1549f62010-07-06 01:34:17 +00006009 // Pop the lock-release cleanup.
6010 CGF.PopCleanupBlock();
6011}
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006012
John McCallf1549f62010-07-06 01:34:17 +00006013namespace {
6014 struct CatchHandler {
6015 const VarDecl *Variable;
6016 const Stmt *Body;
6017 llvm::BasicBlock *Block;
6018 llvm::Value *TypeInfo;
6019 };
John McCall8e3f8612010-07-13 22:12:14 +00006020
John McCall1f0fca52010-07-21 07:22:38 +00006021 struct CallObjCEndCatch : EHScopeStack::Cleanup {
John McCall8e3f8612010-07-13 22:12:14 +00006022 CallObjCEndCatch(bool MightThrow, llvm::Value *Fn) :
6023 MightThrow(MightThrow), Fn(Fn) {}
6024 bool MightThrow;
6025 llvm::Value *Fn;
6026
6027 void Emit(CodeGenFunction &CGF, bool IsForEH) {
6028 if (!MightThrow) {
6029 CGF.Builder.CreateCall(Fn)->setDoesNotThrow();
6030 return;
6031 }
6032
6033 CGF.EmitCallOrInvoke(Fn, 0, 0);
6034 }
6035 };
John McCallf1549f62010-07-06 01:34:17 +00006036}
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006037
John McCall5a180392010-07-24 00:37:23 +00006038llvm::Constant *
6039CGObjCNonFragileABIMac::GetEHType(QualType T) {
6040 // There's a particular fixed type info for 'id'.
6041 if (T->isObjCIdType() ||
6042 T->isObjCQualifiedIdType()) {
6043 llvm::Constant *IDEHType =
6044 CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
6045 if (!IDEHType)
6046 IDEHType =
6047 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
6048 false,
6049 llvm::GlobalValue::ExternalLinkage,
6050 0, "OBJC_EHTYPE_id");
6051 return IDEHType;
6052 }
6053
6054 // All other types should be Objective-C interface pointer types.
6055 const ObjCObjectPointerType *PT =
6056 T->getAs<ObjCObjectPointerType>();
6057 assert(PT && "Invalid @catch type.");
6058 const ObjCInterfaceType *IT = PT->getInterfaceType();
6059 assert(IT && "Invalid @catch type.");
6060 return GetInterfaceEHType(IT->getDecl(), false);
6061}
6062
John McCallf1549f62010-07-06 01:34:17 +00006063void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
6064 const ObjCAtTryStmt &S) {
6065 // Jump destination for falling out of catch bodies.
6066 CodeGenFunction::JumpDest Cont;
6067 if (S.getNumCatchStmts())
6068 Cont = CGF.getJumpDestInCurrentScope("eh.cont");
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006069
John McCallf1549f62010-07-06 01:34:17 +00006070 CodeGenFunction::FinallyInfo FinallyInfo;
6071 if (const ObjCAtFinallyStmt *Finally = S.getFinallyStmt())
6072 FinallyInfo = CGF.EnterFinallyBlock(Finally->getFinallyBody(),
6073 ObjCTypes.getObjCBeginCatchFn(),
6074 ObjCTypes.getObjCEndCatchFn(),
6075 ObjCTypes.getExceptionRethrowFn());
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006076
John McCallf1549f62010-07-06 01:34:17 +00006077 llvm::SmallVector<CatchHandler, 8> Handlers;
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006078
John McCallf1549f62010-07-06 01:34:17 +00006079 // Enter the catch, if there is one.
6080 if (S.getNumCatchStmts()) {
6081 for (unsigned I = 0, N = S.getNumCatchStmts(); I != N; ++I) {
6082 const ObjCAtCatchStmt *CatchStmt = S.getCatchStmt(I);
Douglas Gregorc00d8e12010-04-26 16:46:50 +00006083 const VarDecl *CatchDecl = CatchStmt->getCatchParamDecl();
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006084
John McCallf1549f62010-07-06 01:34:17 +00006085 Handlers.push_back(CatchHandler());
6086 CatchHandler &Handler = Handlers.back();
6087 Handler.Variable = CatchDecl;
6088 Handler.Body = CatchStmt->getCatchBody();
6089 Handler.Block = CGF.createBasicBlock("catch");
6090
6091 // @catch(...) always matches.
Douglas Gregor8f5e3dd2010-04-23 22:50:49 +00006092 if (!CatchDecl) {
John McCallf1549f62010-07-06 01:34:17 +00006093 Handler.TypeInfo = 0; // catch-all
6094 // Don't consider any other catches.
Douglas Gregor8f5e3dd2010-04-23 22:50:49 +00006095 break;
6096 }
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006097
John McCall5a180392010-07-24 00:37:23 +00006098 Handler.TypeInfo = GetEHType(CatchDecl->getType());
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006099 }
John McCallf1549f62010-07-06 01:34:17 +00006100
6101 EHCatchScope *Catch = CGF.EHStack.pushCatch(Handlers.size());
6102 for (unsigned I = 0, E = Handlers.size(); I != E; ++I)
6103 Catch->setHandler(I, Handlers[I].TypeInfo, Handlers[I].Block);
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006104 }
John McCallf1549f62010-07-06 01:34:17 +00006105
6106 // Emit the try body.
6107 CGF.EmitStmt(S.getTryBody());
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006108
John McCallf1549f62010-07-06 01:34:17 +00006109 // Leave the try.
6110 if (S.getNumCatchStmts())
6111 CGF.EHStack.popCatch();
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006112
John McCallf1549f62010-07-06 01:34:17 +00006113 // Remember where we were.
6114 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006115
John McCallf1549f62010-07-06 01:34:17 +00006116 // Emit the handlers.
6117 for (unsigned I = 0, E = Handlers.size(); I != E; ++I) {
6118 CatchHandler &Handler = Handlers[I];
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006119
John McCallf1549f62010-07-06 01:34:17 +00006120 CGF.EmitBlock(Handler.Block);
6121 llvm::Value *RawExn = CGF.Builder.CreateLoad(CGF.getExceptionSlot());
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006122
John McCallf1549f62010-07-06 01:34:17 +00006123 // Enter the catch.
6124 llvm::CallInst *Exn =
6125 CGF.Builder.CreateCall(ObjCTypes.getObjCBeginCatchFn(), RawExn,
6126 "exn.adjusted");
6127 Exn->setDoesNotThrow();
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006128
John McCallf1549f62010-07-06 01:34:17 +00006129 // Add a cleanup to leave the catch.
John McCall8e3f8612010-07-13 22:12:14 +00006130 bool EndCatchMightThrow = (Handler.Variable == 0);
John McCall1f0fca52010-07-21 07:22:38 +00006131 CGF.EHStack.pushCleanup<CallObjCEndCatch>(NormalAndEHCleanup,
6132 EndCatchMightThrow,
6133 ObjCTypes.getObjCEndCatchFn());
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006134
John McCallf1549f62010-07-06 01:34:17 +00006135 // Bind the catch parameter if it exists.
6136 if (const VarDecl *CatchParam = Handler.Variable) {
6137 const llvm::Type *CatchType = CGF.ConvertType(CatchParam->getType());
6138 llvm::Value *CastExn = CGF.Builder.CreateBitCast(Exn, CatchType);
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006139
John McCallb6bbcc92010-10-15 04:57:14 +00006140 CGF.EmitAutoVarDecl(*CatchParam);
John McCallf1549f62010-07-06 01:34:17 +00006141 CGF.Builder.CreateStore(CastExn, CGF.GetAddrOfLocalVar(CatchParam));
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006142 }
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006143
John McCallf1549f62010-07-06 01:34:17 +00006144 CGF.ObjCEHValueStack.push_back(Exn);
6145 CGF.EmitStmt(Handler.Body);
6146 CGF.ObjCEHValueStack.pop_back();
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006147
John McCallf1549f62010-07-06 01:34:17 +00006148 // Leave the earlier cleanup.
6149 CGF.PopCleanupBlock();
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006150
John McCallf1549f62010-07-06 01:34:17 +00006151 CGF.EmitBranchThroughCleanup(Cont);
6152 }
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006153
John McCallf1549f62010-07-06 01:34:17 +00006154 // Go back to the try-statement fallthrough.
6155 CGF.Builder.restoreIP(SavedIP);
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006156
John McCallf1549f62010-07-06 01:34:17 +00006157 // Pop out of the normal cleanup on the finally.
6158 if (S.getFinallyStmt())
6159 CGF.ExitFinallyBlock(FinallyInfo);
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006160
John McCallff8e1152010-07-23 21:56:41 +00006161 if (Cont.isValid())
6162 CGF.EmitBlock(Cont.getBlock());
Daniel Dunbar8ecbaf22009-02-24 07:47:38 +00006163}
6164
Anders Carlssonf57c5b22009-02-16 22:59:18 +00006165/// EmitThrowStmt - Generate code for a throw statement.
6166void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
6167 const ObjCAtThrowStmt &S) {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006168 llvm::Value *Exception;
Fariborz Jahanian69677ea2010-05-28 17:34:43 +00006169 llvm::Constant *FunctionThrowOrRethrow;
Anders Carlssonf57c5b22009-02-16 22:59:18 +00006170 if (const Expr *ThrowExpr = S.getThrowExpr()) {
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006171 Exception = CGF.EmitScalarExpr(ThrowExpr);
Fariborz Jahanian69677ea2010-05-28 17:34:43 +00006172 FunctionThrowOrRethrow = ObjCTypes.getExceptionThrowFn();
Anders Carlssonf57c5b22009-02-16 22:59:18 +00006173 } else {
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006174 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006175 "Unexpected rethrow outside @catch block.");
6176 Exception = CGF.ObjCEHValueStack.back();
Fariborz Jahanian69677ea2010-05-28 17:34:43 +00006177 FunctionThrowOrRethrow = ObjCTypes.getExceptionRethrowFn();
Anders Carlssonf57c5b22009-02-16 22:59:18 +00006178 }
6179
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006180 llvm::Value *ExceptionAsObject =
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006181 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy, "tmp");
6182 llvm::BasicBlock *InvokeDest = CGF.getInvokeDest();
6183 if (InvokeDest) {
Fariborz Jahanian69677ea2010-05-28 17:34:43 +00006184 CGF.Builder.CreateInvoke(FunctionThrowOrRethrow,
John McCallf1549f62010-07-06 01:34:17 +00006185 CGF.getUnreachableBlock(), InvokeDest,
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006186 &ExceptionAsObject, &ExceptionAsObject + 1);
John McCallf1549f62010-07-06 01:34:17 +00006187 } else {
6188 CGF.Builder.CreateCall(FunctionThrowOrRethrow, ExceptionAsObject)
6189 ->setDoesNotReturn();
6190 CGF.Builder.CreateUnreachable();
6191 }
Daniel Dunbar4ff36842009-03-02 06:08:11 +00006192
Anders Carlssonf57c5b22009-02-16 22:59:18 +00006193 // Clear the insertion point to indicate we are in unreachable code.
6194 CGF.Builder.ClearInsertionPoint();
6195}
Daniel Dunbare588b992009-03-01 04:46:24 +00006196
John McCall5a180392010-07-24 00:37:23 +00006197llvm::Constant *
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006198CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006199 bool ForDefinition) {
Daniel Dunbare588b992009-03-01 04:46:24 +00006200 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
Daniel Dunbare588b992009-03-01 04:46:24 +00006201
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006202 // If we don't need a definition, return the entry if found or check
6203 // if we use an external reference.
6204 if (!ForDefinition) {
6205 if (Entry)
6206 return Entry;
Daniel Dunbar7e075cb2009-04-07 06:43:45 +00006207
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006208 // If this type (or a super class) has the __objc_exception__
6209 // attribute, emit an external reference.
Douglas Gregor68584ed2009-06-18 16:11:24 +00006210 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006211 return Entry =
Owen Anderson1c431b32009-07-08 19:05:04 +00006212 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006213 llvm::GlobalValue::ExternalLinkage,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006214 0,
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00006215 ("OBJC_EHTYPE_$_" +
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00006216 ID->getIdentifier()->getName()));
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006217 }
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006218
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006219 // Otherwise we need to either make a new entry or fill in the
6220 // initializer.
6221 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00006222 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
Daniel Dunbare588b992009-03-01 04:46:24 +00006223 std::string VTableName = "objc_ehtype_vtable";
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006224 llvm::GlobalVariable *VTableGV =
Daniel Dunbare588b992009-03-01 04:46:24 +00006225 CGM.getModule().getGlobalVariable(VTableName);
6226 if (!VTableGV)
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006227 VTableGV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy,
6228 false,
Daniel Dunbare588b992009-03-01 04:46:24 +00006229 llvm::GlobalValue::ExternalLinkage,
Owen Anderson1c431b32009-07-08 19:05:04 +00006230 0, VTableName);
Daniel Dunbare588b992009-03-01 04:46:24 +00006231
Chris Lattner77b89b82010-06-27 07:15:29 +00006232 llvm::Value *VTableIdx =
6233 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 2);
Daniel Dunbare588b992009-03-01 04:46:24 +00006234
6235 std::vector<llvm::Constant*> Values(3);
Owen Anderson3c4972d2009-07-29 18:54:39 +00006236 Values[0] = llvm::ConstantExpr::getGetElementPtr(VTableGV, &VTableIdx, 1);
Daniel Dunbare588b992009-03-01 04:46:24 +00006237 Values[1] = GetClassName(ID->getIdentifier());
Fariborz Jahanian0f902942009-04-14 18:41:56 +00006238 Values[2] = GetClassGlobal(ClassName);
Owen Andersona1cf15f2009-07-14 23:10:40 +00006239 llvm::Constant *Init =
Owen Anderson08e25242009-07-27 22:29:56 +00006240 llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values);
Daniel Dunbare588b992009-03-01 04:46:24 +00006241
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006242 if (Entry) {
6243 Entry->setInitializer(Init);
6244 } else {
Owen Anderson1c431b32009-07-08 19:05:04 +00006245 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006246 llvm::GlobalValue::WeakAnyLinkage,
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006247 Init,
Daniel Dunbar9c29bf52009-10-18 20:48:59 +00006248 ("OBJC_EHTYPE_$_" +
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00006249 ID->getIdentifier()->getName()));
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006250 }
6251
Daniel Dunbar04d40782009-04-14 06:00:08 +00006252 if (CGM.getLangOptions().getVisibilityMode() == LangOptions::Hidden)
Daniel Dunbar6ab187a2009-04-07 05:48:37 +00006253 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
Daniel Dunbar4b429ae2010-04-25 20:39:32 +00006254 Entry->setAlignment(CGM.getTargetData().getABITypeAlignment(
6255 ObjCTypes.EHTypeTy));
Daniel Dunbar8158a2f2009-04-08 04:21:03 +00006256
6257 if (ForDefinition) {
6258 Entry->setSection("__DATA,__objc_const");
6259 Entry->setLinkage(llvm::GlobalValue::ExternalLinkage);
6260 } else {
6261 Entry->setSection("__DATA,__datacoal_nt,coalesced");
6262 }
Daniel Dunbare588b992009-03-01 04:46:24 +00006263
6264 return Entry;
6265}
Daniel Dunbar6bff2512009-08-03 17:06:42 +00006266
Daniel Dunbarbbce49b2008-08-12 00:12:39 +00006267/* *** */
6268
Daniel Dunbar6efc0c52008-08-13 03:21:16 +00006269CodeGen::CGObjCRuntime *
6270CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
Daniel Dunbarc17a4d32008-08-11 02:45:11 +00006271 return new CGObjCMac(CGM);
6272}
Fariborz Jahanianee0af742009-01-21 22:04:16 +00006273
6274CodeGen::CGObjCRuntime *
Fariborz Jahanian30bc5712009-01-22 23:02:58 +00006275CodeGen::CreateMacNonFragileABIObjCRuntime(CodeGen::CodeGenModule &CGM) {
Fariborz Jahanianaa23b572009-01-23 23:53:38 +00006276 return new CGObjCNonFragileABIMac(CGM);
Fariborz Jahanianee0af742009-01-21 22:04:16 +00006277}