blob: 1fa422f29e1cfc08254bc31f70c1148315fa442a [file] [log] [blame]
Anders Carlssonacfde802009-02-12 00:39:25 +00001//===--- CGBlocks.cpp - Emit LLVM Code for declarations -------------------===//
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 contains code to emit blocks.
11//
12//===----------------------------------------------------------------------===//
13
Mike Stumpb1a6e682009-09-30 02:43:10 +000014#include "CGDebugInfo.h"
Anders Carlssonacfde802009-02-12 00:39:25 +000015#include "CodeGenFunction.h"
16#include "CodeGenModule.h"
Mike Stump6cc88f72009-03-20 21:53:12 +000017#include "clang/AST/DeclObjC.h"
Anders Carlssonacfde802009-02-12 00:39:25 +000018#include "llvm/Module.h"
Anders Carlssond5cab542009-02-12 17:55:02 +000019#include "llvm/Target/TargetData.h"
Anders Carlssonacfde802009-02-12 00:39:25 +000020#include <algorithm>
Torok Edwinf42e4a62009-08-24 13:25:12 +000021#include <cstdio>
22
Anders Carlssonacfde802009-02-12 00:39:25 +000023using namespace clang;
24using namespace CodeGen;
25
Mike Stumpcf62d392009-03-06 18:42:23 +000026llvm::Constant *CodeGenFunction::
Ken Dyck199c3d62010-01-11 17:06:35 +000027BuildDescriptorBlockDecl(bool BlockHasCopyDispose, CharUnits Size,
Mike Stumpa803b0e2009-03-25 17:58:24 +000028 const llvm::StructType* Ty,
Mike Stump08920992009-03-07 02:35:30 +000029 std::vector<HelperInfo> *NoteForHelper) {
Mike Stump56129b12009-02-13 16:55:51 +000030 const llvm::Type *UnsignedLongTy
31 = CGM.getTypes().ConvertType(getContext().UnsignedLongTy);
Mike Stumpe5fee252009-02-13 16:19:19 +000032 llvm::Constant *C;
33 std::vector<llvm::Constant*> Elts;
34
35 // reserved
Owen Anderson4a28d5d2009-07-24 23:12:58 +000036 C = llvm::ConstantInt::get(UnsignedLongTy, 0);
Mike Stumpe5fee252009-02-13 16:19:19 +000037 Elts.push_back(C);
38
39 // Size
Mike Stumpd6840002009-02-21 20:07:44 +000040 // FIXME: What is the right way to say this doesn't fit? We should give
41 // a user diagnostic in that case. Better fix would be to change the
42 // API to size_t.
Ken Dyck199c3d62010-01-11 17:06:35 +000043 C = llvm::ConstantInt::get(UnsignedLongTy, Size.getQuantity());
Mike Stumpe5fee252009-02-13 16:19:19 +000044 Elts.push_back(C);
45
46 if (BlockHasCopyDispose) {
47 // copy_func_helper_decl
Mike Stumpb7477cf2009-04-10 18:52:28 +000048 Elts.push_back(BuildCopyHelper(Ty, NoteForHelper));
Mike Stumpe5fee252009-02-13 16:19:19 +000049
50 // destroy_func_decl
Mike Stumpb7477cf2009-04-10 18:52:28 +000051 Elts.push_back(BuildDestroyHelper(Ty, NoteForHelper));
Mike Stumpe5fee252009-02-13 16:19:19 +000052 }
53
Nick Lewycky0d36dd22009-09-19 20:00:52 +000054 C = llvm::ConstantStruct::get(VMContext, Elts, false);
Mike Stumpe5fee252009-02-13 16:19:19 +000055
Owen Anderson1c431b32009-07-08 19:05:04 +000056 C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), true,
Mike Stumpe5fee252009-02-13 16:19:19 +000057 llvm::GlobalValue::InternalLinkage,
Owen Anderson1c431b32009-07-08 19:05:04 +000058 C, "__block_descriptor_tmp");
Mike Stumpe5fee252009-02-13 16:19:19 +000059 return C;
60}
61
Mike Stump2a998142009-03-04 18:17:45 +000062llvm::Constant *BlockModule::getNSConcreteGlobalBlock() {
Chris Lattnere2f79b62009-05-13 02:50:56 +000063 if (NSConcreteGlobalBlock == 0)
Mike Stump1eb44332009-09-09 15:08:12 +000064 NSConcreteGlobalBlock = CGM.CreateRuntimeVariable(PtrToInt8Ty,
Chris Lattnere2f79b62009-05-13 02:50:56 +000065 "_NSConcreteGlobalBlock");
Mike Stumpf99f1d02009-02-13 17:23:42 +000066 return NSConcreteGlobalBlock;
67}
68
Mike Stump2a998142009-03-04 18:17:45 +000069llvm::Constant *BlockModule::getNSConcreteStackBlock() {
Chris Lattnere2f79b62009-05-13 02:50:56 +000070 if (NSConcreteStackBlock == 0)
Mike Stump1eb44332009-09-09 15:08:12 +000071 NSConcreteStackBlock = CGM.CreateRuntimeVariable(PtrToInt8Ty,
Chris Lattnere2f79b62009-05-13 02:50:56 +000072 "_NSConcreteStackBlock");
Mike Stump59c5b112009-02-13 19:29:27 +000073 return NSConcreteStackBlock;
74}
75
Mike Stump38e16272009-10-21 22:01:24 +000076static void CollectBlockDeclRefInfo(
77 const Stmt *S, CodeGenFunction::BlockInfo &Info,
78 llvm::SmallSet<const DeclContext *, 16> &InnerContexts) {
Anders Carlsson4de9fce2009-03-01 01:09:12 +000079 for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end();
80 I != E; ++I)
Daniel Dunbar82573ee2009-03-02 07:00:57 +000081 if (*I)
Mike Stump38e16272009-10-21 22:01:24 +000082 CollectBlockDeclRefInfo(*I, Info, InnerContexts);
Mike Stump00470a12009-03-05 08:32:30 +000083
Mike Stumpea26cb52009-10-21 03:49:08 +000084 // We want to ensure we walk down into block literals so we can find
85 // all nested BlockDeclRefExprs.
Mike Stump38e16272009-10-21 22:01:24 +000086 if (const BlockExpr *BE = dyn_cast<BlockExpr>(S)) {
87 InnerContexts.insert(cast<DeclContext>(BE->getBlockDecl()));
88 CollectBlockDeclRefInfo(BE->getBody(), Info, InnerContexts);
89 }
Mike Stumpea26cb52009-10-21 03:49:08 +000090
Mike Stump38e16272009-10-21 22:01:24 +000091 if (const BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(S)) {
Anders Carlsson4de9fce2009-03-01 01:09:12 +000092 // FIXME: Handle enums.
Mike Stump38e16272009-10-21 22:01:24 +000093 if (isa<FunctionDecl>(BDRE->getDecl()))
Anders Carlsson4de9fce2009-03-01 01:09:12 +000094 return;
Mike Stump00470a12009-03-05 08:32:30 +000095
Mike Stump38e16272009-10-21 22:01:24 +000096 // Only Decls that escape are added.
97 if (!InnerContexts.count(BDRE->getDecl()->getDeclContext()))
98 Info.DeclRefs.push_back(BDRE);
Anders Carlsson4de9fce2009-03-01 01:09:12 +000099 }
100}
101
Mike Stump58a85142009-03-04 22:48:06 +0000102/// CanBlockBeGlobal - Given a BlockInfo struct, determines if a block can be
103/// declared as a global variable instead of on the stack.
Chris Lattnere2f79b62009-05-13 02:50:56 +0000104static bool CanBlockBeGlobal(const CodeGenFunction::BlockInfo &Info) {
Mike Stumpea26cb52009-10-21 03:49:08 +0000105 return Info.DeclRefs.empty();
106}
107
108/// AllocateAllBlockDeclRefs - Preallocate all nested BlockDeclRefExprs to
109/// ensure we can generate the debug information for the parameter for the block
110/// invoke function.
111static void AllocateAllBlockDeclRefs(const CodeGenFunction::BlockInfo &Info,
112 CodeGenFunction *CGF) {
113 // Always allocate self, as it is often handy in the debugger, even if there
114 // is no codegen in the block that uses it. This is also useful to always do
115 // this as if we didn't, we'd have to figure out all code that uses a self
116 // pointer, including implicit uses.
117 if (const ObjCMethodDecl *OMD
118 = dyn_cast_or_null<ObjCMethodDecl>(CGF->CurFuncDecl)) {
119 ImplicitParamDecl *SelfDecl = OMD->getSelfDecl();
120 BlockDeclRefExpr *BDRE = new (CGF->getContext())
121 BlockDeclRefExpr(SelfDecl,
122 SelfDecl->getType(), SourceLocation(), false);
123 CGF->AllocateBlockDecl(BDRE);
124 }
125
126 // FIXME: Also always forward the this pointer in C++ as well.
127
128 for (size_t i = 0; i < Info.DeclRefs.size(); ++i)
129 CGF->AllocateBlockDecl(Info.DeclRefs[i]);
Anders Carlsson4de9fce2009-03-01 01:09:12 +0000130}
131
Mike Stump58a85142009-03-04 22:48:06 +0000132// FIXME: Push most into CGM, passing down a few bits, like current function
133// name.
Mike Stump8a2b4b12009-02-25 23:33:13 +0000134llvm::Value *CodeGenFunction::BuildBlockLiteralTmp(const BlockExpr *BE) {
Mike Stumpe5fee252009-02-13 16:19:19 +0000135
Anders Carlsson4de9fce2009-03-01 01:09:12 +0000136 std::string Name = CurFn->getName();
137 CodeGenFunction::BlockInfo Info(0, Name.c_str());
Mike Stump38e16272009-10-21 22:01:24 +0000138 llvm::SmallSet<const DeclContext *, 16> InnerContexts;
139 InnerContexts.insert(BE->getBlockDecl());
140 CollectBlockDeclRefInfo(BE->getBody(), Info, InnerContexts);
Anders Carlsson4de9fce2009-03-01 01:09:12 +0000141
142 // Check if the block can be global.
Mike Stump58a85142009-03-04 22:48:06 +0000143 // FIXME: This test doesn't work for nested blocks yet. Longer term, I'd like
144 // to just have one code path. We should move this function into CGM and pass
145 // CGF, then we can just check to see if CGF is 0.
Mike Stumpdab514f2009-03-04 03:23:46 +0000146 if (0 && CanBlockBeGlobal(Info))
Anders Carlsson4de9fce2009-03-01 01:09:12 +0000147 return CGM.GetAddrOfGlobalBlock(BE, Name.c_str());
Mike Stump00470a12009-03-05 08:32:30 +0000148
David Chisnall5e530af2009-11-17 19:33:30 +0000149 size_t BlockFields = 5;
150
151 bool hasIntrospection = CGM.getContext().getLangOptions().BlockIntrospection;
152
153 if (hasIntrospection) {
154 BlockFields++;
155 }
156 std::vector<llvm::Constant*> Elts(BlockFields);
157
158 if (hasIntrospection) {
159 std::string BlockTypeEncoding;
160 CGM.getContext().getObjCEncodingForBlock(BE, BlockTypeEncoding);
161
162 Elts[5] = llvm::ConstantExpr::getBitCast(
163 CGM.GetAddrOfConstantCString(BlockTypeEncoding), PtrToInt8Ty);
164 }
165
Mike Stumpe5fee252009-02-13 16:19:19 +0000166 llvm::Constant *C;
Mike Stump8a2b4b12009-02-25 23:33:13 +0000167 llvm::Value *V;
Mike Stumpe5fee252009-02-13 16:19:19 +0000168
Mike Stumpe5fee252009-02-13 16:19:19 +0000169 {
170 // C = BuildBlockStructInitlist();
171 unsigned int flags = BLOCK_HAS_DESCRIPTOR;
172
David Chisnall5e530af2009-11-17 19:33:30 +0000173 if (hasIntrospection)
174 flags |= BLOCK_HAS_OBJC_TYPE;
175
Mike Stump00470a12009-03-05 08:32:30 +0000176 // We run this first so that we set BlockHasCopyDispose from the entire
177 // block literal.
178 // __invoke
Ken Dyck199c3d62010-01-11 17:06:35 +0000179 CharUnits subBlockSize;
180 uint64_t subBlockAlign;
Mike Stump00470a12009-03-05 08:32:30 +0000181 llvm::SmallVector<const Expr *, 8> subBlockDeclRefDecls;
Mike Stumpa803b0e2009-03-25 17:58:24 +0000182 bool subBlockHasCopyDispose = false;
Mike Stump00470a12009-03-05 08:32:30 +0000183 llvm::Function *Fn
Mike Stumpbb304192009-09-24 22:31:14 +0000184 = CodeGenFunction(CGM).GenerateBlockFunction(BE, Info, CurFuncDecl,
185 LocalDeclMap,
Mike Stump7f28a9c2009-03-13 23:34:28 +0000186 subBlockSize,
Mike Stump00470a12009-03-05 08:32:30 +0000187 subBlockAlign,
188 subBlockDeclRefDecls,
Mike Stumpa803b0e2009-03-25 17:58:24 +0000189 subBlockHasCopyDispose);
190 BlockHasCopyDispose |= subBlockHasCopyDispose;
Mike Stump00470a12009-03-05 08:32:30 +0000191 Elts[3] = Fn;
192
Mike Stumpf5408fe2009-05-16 07:57:57 +0000193 // FIXME: Don't use BlockHasCopyDispose, it is set more often then
194 // necessary, for example: { ^{ __block int i; ^{ i = 1; }(); }(); }
Mike Stumpa803b0e2009-03-25 17:58:24 +0000195 if (subBlockHasCopyDispose)
Mike Stumpe5fee252009-02-13 16:19:19 +0000196 flags |= BLOCK_HAS_COPY_DISPOSE;
197
Mike Stump7d6dc4f2009-02-13 20:17:16 +0000198 // __isa
Mike Stump59c5b112009-02-13 19:29:27 +0000199 C = CGM.getNSConcreteStackBlock();
Owen Anderson3c4972d2009-07-29 18:54:39 +0000200 C = llvm::ConstantExpr::getBitCast(C, PtrToInt8Ty);
Mike Stump00470a12009-03-05 08:32:30 +0000201 Elts[0] = C;
Mike Stumpe5fee252009-02-13 16:19:19 +0000202
203 // __flags
204 const llvm::IntegerType *IntTy = cast<llvm::IntegerType>(
205 CGM.getTypes().ConvertType(CGM.getContext().IntTy));
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000206 C = llvm::ConstantInt::get(IntTy, flags);
Mike Stump00470a12009-03-05 08:32:30 +0000207 Elts[1] = C;
Mike Stumpe5fee252009-02-13 16:19:19 +0000208
209 // __reserved
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000210 C = llvm::ConstantInt::get(IntTy, 0);
Mike Stump00470a12009-03-05 08:32:30 +0000211 Elts[2] = C;
Mike Stumpe5fee252009-02-13 16:19:19 +0000212
Mike Stump8a2b4b12009-02-25 23:33:13 +0000213 if (subBlockDeclRefDecls.size() == 0) {
Mike Stumpcf62d392009-03-06 18:42:23 +0000214 // __descriptor
Mike Stumpea26cb52009-10-21 03:49:08 +0000215 Elts[4] = BuildDescriptorBlockDecl(subBlockHasCopyDispose, subBlockSize,
216 0, 0);
Mike Stumpcf62d392009-03-06 18:42:23 +0000217
Mike Stump5570cfe2009-03-01 20:07:53 +0000218 // Optimize to being a global block.
219 Elts[0] = CGM.getNSConcreteGlobalBlock();
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000220 Elts[1] = llvm::ConstantInt::get(IntTy, flags|BLOCK_IS_GLOBAL);
Mike Stump5570cfe2009-03-01 20:07:53 +0000221
Nick Lewycky0d36dd22009-09-19 20:00:52 +0000222 C = llvm::ConstantStruct::get(VMContext, Elts, false);
Mike Stump8a2b4b12009-02-25 23:33:13 +0000223
224 char Name[32];
225 sprintf(Name, "__block_holder_tmp_%d", CGM.getGlobalUniqueCount());
Owen Anderson1c431b32009-07-08 19:05:04 +0000226 C = new llvm::GlobalVariable(CGM.getModule(), C->getType(), true,
Mike Stump8a2b4b12009-02-25 23:33:13 +0000227 llvm::GlobalValue::InternalLinkage,
Owen Anderson1c431b32009-07-08 19:05:04 +0000228 C, Name);
Mike Stump8a2b4b12009-02-25 23:33:13 +0000229 QualType BPT = BE->getType();
Owen Anderson3c4972d2009-07-29 18:54:39 +0000230 C = llvm::ConstantExpr::getBitCast(C, ConvertType(BPT));
Mike Stump8a2b4b12009-02-25 23:33:13 +0000231 return C;
232 }
Mike Stump00470a12009-03-05 08:32:30 +0000233
David Chisnall5e530af2009-11-17 19:33:30 +0000234 std::vector<const llvm::Type *> Types(BlockFields+subBlockDeclRefDecls.size());
Mike Stump08920992009-03-07 02:35:30 +0000235 for (int i=0; i<4; ++i)
Mike Stump8a2b4b12009-02-25 23:33:13 +0000236 Types[i] = Elts[i]->getType();
Mike Stump08920992009-03-07 02:35:30 +0000237 Types[4] = PtrToInt8Ty;
David Chisnall5e530af2009-11-17 19:33:30 +0000238 if (hasIntrospection)
239 Types[5] = PtrToInt8Ty;
Mike Stump8a2b4b12009-02-25 23:33:13 +0000240
Mike Stumpa99038c2009-02-28 09:07:16 +0000241 for (unsigned i=0; i < subBlockDeclRefDecls.size(); ++i) {
242 const Expr *E = subBlockDeclRefDecls[i];
243 const BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(E);
244 QualType Ty = E->getType();
Mike Stumpdab514f2009-03-04 03:23:46 +0000245 if (BDRE && BDRE->isByRef()) {
David Chisnall5e530af2009-11-17 19:33:30 +0000246 Types[i+BlockFields] = llvm::PointerType::get(BuildByRefType(BDRE->getDecl()), 0);
Mike Stumpdab514f2009-03-04 03:23:46 +0000247 } else
David Chisnall5e530af2009-11-17 19:33:30 +0000248 Types[i+BlockFields] = ConvertType(Ty);
Mike Stumpa99038c2009-02-28 09:07:16 +0000249 }
Mike Stump8a2b4b12009-02-25 23:33:13 +0000250
Owen Anderson47a434f2009-08-05 23:18:46 +0000251 llvm::StructType *Ty = llvm::StructType::get(VMContext, Types, true);
Mike Stump8a2b4b12009-02-25 23:33:13 +0000252
253 llvm::AllocaInst *A = CreateTempAlloca(Ty);
254 A->setAlignment(subBlockAlign);
255 V = A;
256
Mike Stump08920992009-03-07 02:35:30 +0000257 std::vector<HelperInfo> NoteForHelper(subBlockDeclRefDecls.size());
258 int helpersize = 0;
259
260 for (unsigned i=0; i<4; ++i)
Mike Stump8a2b4b12009-02-25 23:33:13 +0000261 Builder.CreateStore(Elts[i], Builder.CreateStructGEP(V, i, "block.tmp"));
David Chisnall5e530af2009-11-17 19:33:30 +0000262 if (hasIntrospection)
263 Builder.CreateStore(Elts[5], Builder.CreateStructGEP(V, 5, "block.tmp"));
Mike Stump00470a12009-03-05 08:32:30 +0000264
Mike Stump8a2b4b12009-02-25 23:33:13 +0000265 for (unsigned i=0; i < subBlockDeclRefDecls.size(); ++i)
266 {
Mike Stumpa99038c2009-02-28 09:07:16 +0000267 // FIXME: Push const down.
268 Expr *E = const_cast<Expr*>(subBlockDeclRefDecls[i]);
269 DeclRefExpr *DR;
270 ValueDecl *VD;
Mike Stump8a2b4b12009-02-25 23:33:13 +0000271
Mike Stumpa99038c2009-02-28 09:07:16 +0000272 DR = dyn_cast<DeclRefExpr>(E);
273 // Skip padding.
274 if (DR) continue;
275
276 BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(E);
277 VD = BDRE->getDecl();
278
David Chisnall5e530af2009-11-17 19:33:30 +0000279 llvm::Value* Addr = Builder.CreateStructGEP(V, i+BlockFields, "tmp");
Mike Stump08920992009-03-07 02:35:30 +0000280 NoteForHelper[helpersize].index = i+5;
Mike Stump39605b42009-09-22 02:12:52 +0000281 NoteForHelper[helpersize].RequiresCopying
282 = BlockRequiresCopying(VD->getType());
Mike Stump08920992009-03-07 02:35:30 +0000283 NoteForHelper[helpersize].flag
Mike Stump39605b42009-09-22 02:12:52 +0000284 = (VD->getType()->isBlockPointerType()
285 ? BLOCK_FIELD_IS_BLOCK
286 : BLOCK_FIELD_IS_OBJECT);
Mike Stump08920992009-03-07 02:35:30 +0000287
Mike Stumpa99038c2009-02-28 09:07:16 +0000288 if (LocalDeclMap[VD]) {
Mike Stumpdab514f2009-03-04 03:23:46 +0000289 if (BDRE->isByRef()) {
Mike Stump08920992009-03-07 02:35:30 +0000290 NoteForHelper[helpersize].flag = BLOCK_FIELD_IS_BYREF |
Mike Stumpf4bc3122009-03-07 06:04:31 +0000291 // FIXME: Someone double check this.
292 (VD->getType().isObjCGCWeak() ? BLOCK_FIELD_IS_WEAK : 0);
Mike Stumpdab514f2009-03-04 03:23:46 +0000293 llvm::Value *Loc = LocalDeclMap[VD];
294 Loc = Builder.CreateStructGEP(Loc, 1, "forwarding");
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000295 Loc = Builder.CreateLoad(Loc);
Mike Stumpdab514f2009-03-04 03:23:46 +0000296 Builder.CreateStore(Loc, Addr);
Mike Stump08920992009-03-07 02:35:30 +0000297 ++helpersize;
Mike Stumpdab514f2009-03-04 03:23:46 +0000298 continue;
299 } else
John McCalldbd872f2009-12-08 09:08:17 +0000300 E = new (getContext()) DeclRefExpr (VD,
Douglas Gregor0da76df2009-11-23 11:41:28 +0000301 VD->getType(),
302 SourceLocation());
Mike Stumpa99038c2009-02-28 09:07:16 +0000303 }
Mike Stumpdab514f2009-03-04 03:23:46 +0000304 if (BDRE->isByRef()) {
Mike Stumpa8b60c92009-03-21 21:00:35 +0000305 NoteForHelper[helpersize].flag = BLOCK_FIELD_IS_BYREF |
306 // FIXME: Someone double check this.
307 (VD->getType().isObjCGCWeak() ? BLOCK_FIELD_IS_WEAK : 0);
Mike Stumpa99038c2009-02-28 09:07:16 +0000308 E = new (getContext())
309 UnaryOperator(E, UnaryOperator::AddrOf,
310 getContext().getPointerType(E->getType()),
311 SourceLocation());
Mike Stumpdab514f2009-03-04 03:23:46 +0000312 }
Mike Stump08920992009-03-07 02:35:30 +0000313 ++helpersize;
Mike Stumpa99038c2009-02-28 09:07:16 +0000314
Mike Stumpa99038c2009-02-28 09:07:16 +0000315 RValue r = EmitAnyExpr(E, Addr, false);
Mike Stumpdab514f2009-03-04 03:23:46 +0000316 if (r.isScalar()) {
317 llvm::Value *Loc = r.getScalarVal();
David Chisnall5e530af2009-11-17 19:33:30 +0000318 const llvm::Type *Ty = Types[i+BlockFields];
Mike Stumpdab514f2009-03-04 03:23:46 +0000319 if (BDRE->isByRef()) {
Mike Stump58a85142009-03-04 22:48:06 +0000320 // E is now the address of the value field, instead, we want the
321 // address of the actual ByRef struct. We optimize this slightly
322 // compared to gcc by not grabbing the forwarding slot as this must
323 // be done during Block_copy for us, and we can postpone the work
324 // until then.
Ken Dyck199c3d62010-01-11 17:06:35 +0000325 CharUnits offset = BlockDecls[BDRE->getDecl()];
Mike Stump00470a12009-03-05 08:32:30 +0000326
Mike Stump58a85142009-03-04 22:48:06 +0000327 llvm::Value *BlockLiteral = LoadBlockStruct();
Mike Stump00470a12009-03-05 08:32:30 +0000328
Mike Stump58a85142009-03-04 22:48:06 +0000329 Loc = Builder.CreateGEP(BlockLiteral,
Mike Stumpea26cb52009-10-21 03:49:08 +0000330 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
Ken Dyck199c3d62010-01-11 17:06:35 +0000331 offset.getQuantity()),
Mike Stump58a85142009-03-04 22:48:06 +0000332 "block.literal");
Owen Anderson96e0fc72009-07-29 22:16:19 +0000333 Ty = llvm::PointerType::get(Ty, 0);
Mike Stumpdab514f2009-03-04 03:23:46 +0000334 Loc = Builder.CreateBitCast(Loc, Ty);
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000335 Loc = Builder.CreateLoad(Loc);
Mike Stump58a85142009-03-04 22:48:06 +0000336 // Loc = Builder.CreateBitCast(Loc, Ty);
Mike Stumpdab514f2009-03-04 03:23:46 +0000337 }
338 Builder.CreateStore(Loc, Addr);
339 } else if (r.isComplex())
Mike Stump8a2b4b12009-02-25 23:33:13 +0000340 // FIXME: implement
341 ErrorUnsupported(BE, "complex in block literal");
342 else if (r.isAggregate())
343 ; // Already created into the destination
344 else
345 assert (0 && "bad block variable");
346 // FIXME: Ensure that the offset created by the backend for
347 // the struct matches the previously computed offset in BlockDecls.
348 }
Mike Stump08920992009-03-07 02:35:30 +0000349 NoteForHelper.resize(helpersize);
Mike Stumpcf62d392009-03-06 18:42:23 +0000350
351 // __descriptor
Mike Stumpa803b0e2009-03-25 17:58:24 +0000352 llvm::Value *Descriptor = BuildDescriptorBlockDecl(subBlockHasCopyDispose,
353 subBlockSize, Ty,
Mike Stump08920992009-03-07 02:35:30 +0000354 &NoteForHelper);
355 Descriptor = Builder.CreateBitCast(Descriptor, PtrToInt8Ty);
356 Builder.CreateStore(Descriptor, Builder.CreateStructGEP(V, 4, "block.tmp"));
Mike Stumpe5fee252009-02-13 16:19:19 +0000357 }
Mike Stump00470a12009-03-05 08:32:30 +0000358
Mike Stumpbd65cac2009-02-19 01:01:04 +0000359 QualType BPT = BE->getType();
Mike Stump8a2b4b12009-02-25 23:33:13 +0000360 return Builder.CreateBitCast(V, ConvertType(BPT));
Mike Stumpe5fee252009-02-13 16:19:19 +0000361}
362
363
Mike Stump2a998142009-03-04 18:17:45 +0000364const llvm::Type *BlockModule::getBlockDescriptorType() {
Mike Stumpab695142009-02-13 15:16:56 +0000365 if (BlockDescriptorType)
366 return BlockDescriptorType;
367
Mike Stumpa5448542009-02-13 15:32:32 +0000368 const llvm::Type *UnsignedLongTy =
Mike Stumpab695142009-02-13 15:16:56 +0000369 getTypes().ConvertType(getContext().UnsignedLongTy);
Mike Stumpa5448542009-02-13 15:32:32 +0000370
Mike Stumpab695142009-02-13 15:16:56 +0000371 // struct __block_descriptor {
372 // unsigned long reserved;
373 // unsigned long block_size;
374 // };
Owen Anderson47a434f2009-08-05 23:18:46 +0000375 BlockDescriptorType = llvm::StructType::get(UnsignedLongTy->getContext(),
376 UnsignedLongTy,
Mike Stumpa5448542009-02-13 15:32:32 +0000377 UnsignedLongTy,
Mike Stumpab695142009-02-13 15:16:56 +0000378 NULL);
379
380 getModule().addTypeName("struct.__block_descriptor",
381 BlockDescriptorType);
382
383 return BlockDescriptorType;
Anders Carlssonacfde802009-02-12 00:39:25 +0000384}
385
Mike Stump2a998142009-03-04 18:17:45 +0000386const llvm::Type *BlockModule::getGenericBlockLiteralType() {
Mike Stump9b8a7972009-02-13 15:25:34 +0000387 if (GenericBlockLiteralType)
388 return GenericBlockLiteralType;
389
Mike Stumpa5448542009-02-13 15:32:32 +0000390 const llvm::Type *BlockDescPtrTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000391 llvm::PointerType::getUnqual(getBlockDescriptorType());
Mike Stumpa5448542009-02-13 15:32:32 +0000392
Mike Stump7cbb3602009-02-13 16:01:35 +0000393 const llvm::IntegerType *IntTy = cast<llvm::IntegerType>(
394 getTypes().ConvertType(getContext().IntTy));
395
Mike Stump9b8a7972009-02-13 15:25:34 +0000396 // struct __block_literal_generic {
Mike Stumpbd65cac2009-02-19 01:01:04 +0000397 // void *__isa;
398 // int __flags;
399 // int __reserved;
400 // void (*__invoke)(void *);
401 // struct __block_descriptor *__descriptor;
David Chisnall5e530af2009-11-17 19:33:30 +0000402 // // GNU runtime only:
403 // const char *types;
Mike Stump9b8a7972009-02-13 15:25:34 +0000404 // };
David Chisnall5e530af2009-11-17 19:33:30 +0000405 if (CGM.getContext().getLangOptions().BlockIntrospection)
406 GenericBlockLiteralType = llvm::StructType::get(IntTy->getContext(),
407 PtrToInt8Ty,
408 IntTy,
409 IntTy,
410 PtrToInt8Ty,
411 BlockDescPtrTy,
412 PtrToInt8Ty,
413 NULL);
414 else
415 GenericBlockLiteralType = llvm::StructType::get(IntTy->getContext(),
Owen Anderson47a434f2009-08-05 23:18:46 +0000416 PtrToInt8Ty,
Mike Stump7cbb3602009-02-13 16:01:35 +0000417 IntTy,
418 IntTy,
Mike Stump797b6322009-03-05 01:23:13 +0000419 PtrToInt8Ty,
Mike Stump9b8a7972009-02-13 15:25:34 +0000420 BlockDescPtrTy,
421 NULL);
Mike Stumpa5448542009-02-13 15:32:32 +0000422
Mike Stump9b8a7972009-02-13 15:25:34 +0000423 getModule().addTypeName("struct.__block_literal_generic",
424 GenericBlockLiteralType);
Mike Stumpa5448542009-02-13 15:32:32 +0000425
Mike Stump9b8a7972009-02-13 15:25:34 +0000426 return GenericBlockLiteralType;
Anders Carlssonacfde802009-02-12 00:39:25 +0000427}
428
Mike Stump2a998142009-03-04 18:17:45 +0000429const llvm::Type *BlockModule::getGenericExtendedBlockLiteralType() {
Mike Stumpbd65cac2009-02-19 01:01:04 +0000430 if (GenericExtendedBlockLiteralType)
431 return GenericExtendedBlockLiteralType;
432
Mike Stumpbd65cac2009-02-19 01:01:04 +0000433 const llvm::Type *BlockDescPtrTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000434 llvm::PointerType::getUnqual(getBlockDescriptorType());
Mike Stumpbd65cac2009-02-19 01:01:04 +0000435
436 const llvm::IntegerType *IntTy = cast<llvm::IntegerType>(
437 getTypes().ConvertType(getContext().IntTy));
438
439 // struct __block_literal_generic {
440 // void *__isa;
441 // int __flags;
442 // int __reserved;
443 // void (*__invoke)(void *);
444 // struct __block_descriptor *__descriptor;
445 // void *__copy_func_helper_decl;
446 // void *__destroy_func_decl;
447 // };
Owen Anderson47a434f2009-08-05 23:18:46 +0000448 GenericExtendedBlockLiteralType = llvm::StructType::get(IntTy->getContext(),
449 PtrToInt8Ty,
Mike Stumpbd65cac2009-02-19 01:01:04 +0000450 IntTy,
451 IntTy,
Mike Stump797b6322009-03-05 01:23:13 +0000452 PtrToInt8Ty,
Mike Stumpbd65cac2009-02-19 01:01:04 +0000453 BlockDescPtrTy,
Mike Stump797b6322009-03-05 01:23:13 +0000454 PtrToInt8Ty,
455 PtrToInt8Ty,
Mike Stumpbd65cac2009-02-19 01:01:04 +0000456 NULL);
457
458 getModule().addTypeName("struct.__block_literal_extended_generic",
459 GenericExtendedBlockLiteralType);
460
461 return GenericExtendedBlockLiteralType;
462}
463
Anders Carlssona1736c02009-12-24 21:13:40 +0000464RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr* E,
465 ReturnValueSlot ReturnValue) {
Mike Stumpa5448542009-02-13 15:32:32 +0000466 const BlockPointerType *BPT =
Ted Kremenek6217b802009-07-29 21:53:49 +0000467 E->getCallee()->getType()->getAs<BlockPointerType>();
Mike Stumpa5448542009-02-13 15:32:32 +0000468
Anders Carlssonacfde802009-02-12 00:39:25 +0000469 llvm::Value *Callee = EmitScalarExpr(E->getCallee());
470
471 // Get a pointer to the generic block literal.
472 const llvm::Type *BlockLiteralTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000473 llvm::PointerType::getUnqual(CGM.getGenericBlockLiteralType());
Anders Carlssonacfde802009-02-12 00:39:25 +0000474
475 // Bitcast the callee to a block literal.
Mike Stumpa5448542009-02-13 15:32:32 +0000476 llvm::Value *BlockLiteral =
Anders Carlssonacfde802009-02-12 00:39:25 +0000477 Builder.CreateBitCast(Callee, BlockLiteralTy, "block.literal");
478
479 // Get the function pointer from the literal.
480 llvm::Value *FuncPtr = Builder.CreateStructGEP(BlockLiteral, 3, "tmp");
Anders Carlssonacfde802009-02-12 00:39:25 +0000481
Mike Stumpa5448542009-02-13 15:32:32 +0000482 BlockLiteral =
483 Builder.CreateBitCast(BlockLiteral,
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +0000484 llvm::Type::getInt8PtrTy(VMContext),
Anders Carlssonacfde802009-02-12 00:39:25 +0000485 "tmp");
Mike Stumpa5448542009-02-13 15:32:32 +0000486
Anders Carlssonacfde802009-02-12 00:39:25 +0000487 // Add the block literal.
488 QualType VoidPtrTy = getContext().getPointerType(getContext().VoidTy);
489 CallArgList Args;
490 Args.push_back(std::make_pair(RValue::get(BlockLiteral), VoidPtrTy));
Mike Stumpa5448542009-02-13 15:32:32 +0000491
Anders Carlsson782f3972009-04-08 23:13:16 +0000492 QualType FnType = BPT->getPointeeType();
493
Anders Carlssonacfde802009-02-12 00:39:25 +0000494 // And the rest of the arguments.
John McCall183700f2009-09-21 23:43:11 +0000495 EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(),
Anders Carlsson782f3972009-04-08 23:13:16 +0000496 E->arg_begin(), E->arg_end());
Mike Stumpa5448542009-02-13 15:32:32 +0000497
Anders Carlsson6e460ff2009-04-07 22:10:22 +0000498 // Load the function.
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000499 llvm::Value *Func = Builder.CreateLoad(FuncPtr, "tmp");
Anders Carlsson6e460ff2009-04-07 22:10:22 +0000500
John McCall183700f2009-09-21 23:43:11 +0000501 QualType ResultType = FnType->getAs<FunctionType>()->getResultType();
Anders Carlssona17d7cc2009-04-08 02:55:55 +0000502
Mike Stump1eb44332009-09-09 15:08:12 +0000503 const CGFunctionInfo &FnInfo =
Anders Carlssona17d7cc2009-04-08 02:55:55 +0000504 CGM.getTypes().getFunctionInfo(ResultType, Args);
Mike Stump1eb44332009-09-09 15:08:12 +0000505
Anders Carlsson6e460ff2009-04-07 22:10:22 +0000506 // Cast the function pointer to the right type.
Mike Stump1eb44332009-09-09 15:08:12 +0000507 const llvm::Type *BlockFTy =
Anders Carlssona17d7cc2009-04-08 02:55:55 +0000508 CGM.getTypes().GetFunctionType(FnInfo, false);
Mike Stump1eb44332009-09-09 15:08:12 +0000509
Owen Anderson96e0fc72009-07-29 22:16:19 +0000510 const llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy);
Anders Carlsson6e460ff2009-04-07 22:10:22 +0000511 Func = Builder.CreateBitCast(Func, BlockFTyPtr);
Mike Stump1eb44332009-09-09 15:08:12 +0000512
Anders Carlssonacfde802009-02-12 00:39:25 +0000513 // And call the block.
Anders Carlssona1736c02009-12-24 21:13:40 +0000514 return EmitCall(FnInfo, Func, ReturnValue, Args);
Anders Carlssonacfde802009-02-12 00:39:25 +0000515}
Anders Carlssond5cab542009-02-12 17:55:02 +0000516
Ken Dyck199c3d62010-01-11 17:06:35 +0000517CharUnits CodeGenFunction::AllocateBlockDecl(const BlockDeclRefExpr *E) {
Anders Carlsson7dfa4072009-09-12 02:14:24 +0000518 const ValueDecl *VD = E->getDecl();
Ken Dyck199c3d62010-01-11 17:06:35 +0000519 CharUnits &offset = BlockDecls[VD];
Mike Stumpdab514f2009-03-04 03:23:46 +0000520
Mike Stumpdab514f2009-03-04 03:23:46 +0000521 // See if we have already allocated an offset for this variable.
Ken Dyck199c3d62010-01-11 17:06:35 +0000522 if (offset.isPositive())
Mike Stumpea26cb52009-10-21 03:49:08 +0000523 return offset;
524
525 // Don't run the expensive check, unless we have to.
Mike Stump083c25e2009-10-22 00:49:09 +0000526 if (!BlockHasCopyDispose)
527 if (E->isByRef()
528 || BlockRequiresCopying(E->getType()))
529 BlockHasCopyDispose = true;
Mike Stumpea26cb52009-10-21 03:49:08 +0000530
531 // if not, allocate one now.
532 offset = getBlockOffset(E);
533
534 return offset;
535}
536
537llvm::Value *CodeGenFunction::GetAddrOfBlockDecl(const BlockDeclRefExpr *E) {
538 const ValueDecl *VD = E->getDecl();
Ken Dyck199c3d62010-01-11 17:06:35 +0000539 CharUnits offset = AllocateBlockDecl(E);
Mike Stumpea26cb52009-10-21 03:49:08 +0000540
Mike Stumpdab514f2009-03-04 03:23:46 +0000541
542 llvm::Value *BlockLiteral = LoadBlockStruct();
543 llvm::Value *V = Builder.CreateGEP(BlockLiteral,
Mike Stumpea26cb52009-10-21 03:49:08 +0000544 llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
Ken Dyck199c3d62010-01-11 17:06:35 +0000545 offset.getQuantity()),
Mike Stump58a85142009-03-04 22:48:06 +0000546 "block.literal");
Mike Stumpdab514f2009-03-04 03:23:46 +0000547 if (E->isByRef()) {
Mike Stumpdab514f2009-03-04 03:23:46 +0000548 const llvm::Type *PtrStructTy
Anders Carlsson7dfa4072009-09-12 02:14:24 +0000549 = llvm::PointerType::get(BuildByRefType(VD), 0);
Mike Stumpa8b60c92009-03-21 21:00:35 +0000550 // The block literal will need a copy/destroy helper.
551 BlockHasCopyDispose = true;
Anders Carlsson7dfa4072009-09-12 02:14:24 +0000552
553 const llvm::Type *Ty = PtrStructTy;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000554 Ty = llvm::PointerType::get(Ty, 0);
Mike Stumpdab514f2009-03-04 03:23:46 +0000555 V = Builder.CreateBitCast(V, Ty);
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000556 V = Builder.CreateLoad(V);
Mike Stumpdab514f2009-03-04 03:23:46 +0000557 V = Builder.CreateStructGEP(V, 1, "forwarding");
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000558 V = Builder.CreateLoad(V);
Mike Stumpdab514f2009-03-04 03:23:46 +0000559 V = Builder.CreateBitCast(V, PtrStructTy);
Anders Carlsson7dfa4072009-09-12 02:14:24 +0000560 V = Builder.CreateStructGEP(V, getByRefValueLLVMField(VD),
561 VD->getNameAsString());
Mike Stumpdab514f2009-03-04 03:23:46 +0000562 } else {
Anders Carlsson7dfa4072009-09-12 02:14:24 +0000563 const llvm::Type *Ty = CGM.getTypes().ConvertType(VD->getType());
564
Owen Anderson96e0fc72009-07-29 22:16:19 +0000565 Ty = llvm::PointerType::get(Ty, 0);
Mike Stumpdab514f2009-03-04 03:23:46 +0000566 V = Builder.CreateBitCast(V, Ty);
567 }
568 return V;
569}
570
Mike Stump6cc88f72009-03-20 21:53:12 +0000571void CodeGenFunction::BlockForwardSelf() {
572 const ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(CurFuncDecl);
573 ImplicitParamDecl *SelfDecl = OMD->getSelfDecl();
574 llvm::Value *&DMEntry = LocalDeclMap[SelfDecl];
575 if (DMEntry)
576 return;
577 // FIXME - Eliminate BlockDeclRefExprs, clients don't need/want to care
578 BlockDeclRefExpr *BDRE = new (getContext())
579 BlockDeclRefExpr(SelfDecl,
580 SelfDecl->getType(), SourceLocation(), false);
581 DMEntry = GetAddrOfBlockDecl(BDRE);
582}
583
Mike Stump67a64482009-02-14 22:16:35 +0000584llvm::Constant *
Mike Stump90a90432009-03-04 18:47:42 +0000585BlockModule::GetAddrOfGlobalBlock(const BlockExpr *BE, const char * n) {
Anders Carlssond5cab542009-02-12 17:55:02 +0000586 // Generate the block descriptor.
587 const llvm::Type *UnsignedLongTy = Types.ConvertType(Context.UnsignedLongTy);
Mike Stump7cbb3602009-02-13 16:01:35 +0000588 const llvm::IntegerType *IntTy = cast<llvm::IntegerType>(
589 getTypes().ConvertType(getContext().IntTy));
Mike Stumpa5448542009-02-13 15:32:32 +0000590
Anders Carlssond5cab542009-02-12 17:55:02 +0000591 llvm::Constant *DescriptorFields[2];
Mike Stumpa5448542009-02-13 15:32:32 +0000592
Anders Carlssond5cab542009-02-12 17:55:02 +0000593 // Reserved
Owen Andersonc9c88b42009-07-31 20:28:54 +0000594 DescriptorFields[0] = llvm::Constant::getNullValue(UnsignedLongTy);
Mike Stumpa5448542009-02-13 15:32:32 +0000595
Anders Carlssond5cab542009-02-12 17:55:02 +0000596 // Block literal size. For global blocks we just use the size of the generic
597 // block literal struct.
Ken Dyck199c3d62010-01-11 17:06:35 +0000598 CharUnits BlockLiteralSize = CharUnits::fromQuantity(
599 TheTargetData.getTypeStoreSizeInBits(getGenericBlockLiteralType()) / 8);
Owen Andersona1cf15f2009-07-14 23:10:40 +0000600 DescriptorFields[1] =
Ken Dyck199c3d62010-01-11 17:06:35 +0000601 llvm::ConstantInt::get(UnsignedLongTy,BlockLiteralSize.getQuantity());
Mike Stumpa5448542009-02-13 15:32:32 +0000602
603 llvm::Constant *DescriptorStruct =
Nick Lewycky0d36dd22009-09-19 20:00:52 +0000604 llvm::ConstantStruct::get(VMContext, &DescriptorFields[0], 2, false);
Mike Stumpa5448542009-02-13 15:32:32 +0000605
Anders Carlssond5cab542009-02-12 17:55:02 +0000606 llvm::GlobalVariable *Descriptor =
Owen Anderson1c431b32009-07-08 19:05:04 +0000607 new llvm::GlobalVariable(getModule(), DescriptorStruct->getType(), true,
Mike Stumpa5448542009-02-13 15:32:32 +0000608 llvm::GlobalVariable::InternalLinkage,
Owen Anderson1c431b32009-07-08 19:05:04 +0000609 DescriptorStruct, "__block_descriptor_global");
Mike Stumpa5448542009-02-13 15:32:32 +0000610
David Chisnall5e530af2009-11-17 19:33:30 +0000611 int FieldCount = 5;
Anders Carlssond5cab542009-02-12 17:55:02 +0000612 // Generate the constants for the block literal.
David Chisnall5e530af2009-11-17 19:33:30 +0000613 if (CGM.getContext().getLangOptions().BlockIntrospection)
614 FieldCount = 6;
615
616 std::vector<llvm::Constant*> LiteralFields(FieldCount);
Mike Stumpa5448542009-02-13 15:32:32 +0000617
Mike Stump67a64482009-02-14 22:16:35 +0000618 CodeGenFunction::BlockInfo Info(0, n);
Ken Dyck199c3d62010-01-11 17:06:35 +0000619 CharUnits subBlockSize;
620 uint64_t subBlockAlign;
Mike Stumpa99038c2009-02-28 09:07:16 +0000621 llvm::SmallVector<const Expr *, 8> subBlockDeclRefDecls;
Daniel Dunbard67b09a2009-03-12 03:07:24 +0000622 bool subBlockHasCopyDispose = false;
Mike Stump7f28a9c2009-03-13 23:34:28 +0000623 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
Mike Stump4e7a1f72009-02-21 20:00:35 +0000624 llvm::Function *Fn
Mike Stump6cc88f72009-03-20 21:53:12 +0000625 = CodeGenFunction(CGM).GenerateBlockFunction(BE, Info, 0, LocalDeclMap,
Mike Stump7f28a9c2009-03-13 23:34:28 +0000626 subBlockSize,
Mike Stump90a90432009-03-04 18:47:42 +0000627 subBlockAlign,
Mike Stump00470a12009-03-05 08:32:30 +0000628 subBlockDeclRefDecls,
629 subBlockHasCopyDispose);
Mike Stump4e7a1f72009-02-21 20:00:35 +0000630 assert(subBlockSize == BlockLiteralSize
631 && "no imports allowed for global block");
Mike Stumpa5448542009-02-13 15:32:32 +0000632
Anders Carlssond5cab542009-02-12 17:55:02 +0000633 // isa
Mike Stumpf99f1d02009-02-13 17:23:42 +0000634 LiteralFields[0] = getNSConcreteGlobalBlock();
Mike Stumpa5448542009-02-13 15:32:32 +0000635
Anders Carlssond5cab542009-02-12 17:55:02 +0000636 // Flags
David Chisnall5e530af2009-11-17 19:33:30 +0000637 LiteralFields[1] = CGM.getContext().getLangOptions().BlockIntrospection ?
638 llvm::ConstantInt::get(IntTy, BLOCK_IS_GLOBAL | BLOCK_HAS_DESCRIPTOR |
639 BLOCK_HAS_OBJC_TYPE) :
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000640 llvm::ConstantInt::get(IntTy, BLOCK_IS_GLOBAL | BLOCK_HAS_DESCRIPTOR);
Mike Stumpa5448542009-02-13 15:32:32 +0000641
Anders Carlssond5cab542009-02-12 17:55:02 +0000642 // Reserved
Owen Andersonc9c88b42009-07-31 20:28:54 +0000643 LiteralFields[2] = llvm::Constant::getNullValue(IntTy);
Mike Stumpa5448542009-02-13 15:32:32 +0000644
Anders Carlssond5cab542009-02-12 17:55:02 +0000645 // Function
646 LiteralFields[3] = Fn;
Mike Stumpa5448542009-02-13 15:32:32 +0000647
Anders Carlssond5cab542009-02-12 17:55:02 +0000648 // Descriptor
649 LiteralFields[4] = Descriptor;
David Chisnall5e530af2009-11-17 19:33:30 +0000650
651 // Type encoding
652 if (CGM.getContext().getLangOptions().BlockIntrospection) {
653 std::string BlockTypeEncoding;
654 CGM.getContext().getObjCEncodingForBlock(BE, BlockTypeEncoding);
655
656 LiteralFields[5] = CGM.GetAddrOfConstantCString(BlockTypeEncoding);
657 }
Mike Stumpa5448542009-02-13 15:32:32 +0000658
659 llvm::Constant *BlockLiteralStruct =
David Chisnall5e530af2009-11-17 19:33:30 +0000660 llvm::ConstantStruct::get(VMContext, LiteralFields, false);
Mike Stumpa5448542009-02-13 15:32:32 +0000661
662 llvm::GlobalVariable *BlockLiteral =
Owen Anderson1c431b32009-07-08 19:05:04 +0000663 new llvm::GlobalVariable(getModule(), BlockLiteralStruct->getType(), true,
Mike Stumpa5448542009-02-13 15:32:32 +0000664 llvm::GlobalVariable::InternalLinkage,
Owen Anderson1c431b32009-07-08 19:05:04 +0000665 BlockLiteralStruct, "__block_literal_global");
Mike Stumpa5448542009-02-13 15:32:32 +0000666
Anders Carlssond5cab542009-02-12 17:55:02 +0000667 return BlockLiteral;
668}
669
Mike Stump4e7a1f72009-02-21 20:00:35 +0000670llvm::Value *CodeGenFunction::LoadBlockStruct() {
Mike Stumpbf1914b2009-10-20 20:30:01 +0000671 llvm::Value *V = Builder.CreateLoad(LocalDeclMap[getBlockStructDecl()],
672 "self");
673 // For now, we codegen based upon byte offsets.
674 return Builder.CreateBitCast(V, PtrToInt8Ty);
Mike Stump4e7a1f72009-02-21 20:00:35 +0000675}
676
Mike Stump00470a12009-03-05 08:32:30 +0000677llvm::Function *
678CodeGenFunction::GenerateBlockFunction(const BlockExpr *BExpr,
679 const BlockInfo& Info,
Mike Stump6cc88f72009-03-20 21:53:12 +0000680 const Decl *OuterFuncDecl,
Mike Stump7f28a9c2009-03-13 23:34:28 +0000681 llvm::DenseMap<const Decl*, llvm::Value*> ldm,
Ken Dyck199c3d62010-01-11 17:06:35 +0000682 CharUnits &Size,
Mike Stump00470a12009-03-05 08:32:30 +0000683 uint64_t &Align,
684 llvm::SmallVector<const Expr *, 8> &subBlockDeclRefDecls,
685 bool &subBlockHasCopyDispose) {
Devang Patel963dfbd2009-04-15 21:51:44 +0000686
687 // Check if we should generate debug info for this block.
688 if (CGM.getDebugInfo())
689 DebugInfo = CGM.getDebugInfo();
Mike Stump1eb44332009-09-09 15:08:12 +0000690
Mike Stump7f28a9c2009-03-13 23:34:28 +0000691 // Arrange for local static and local extern declarations to appear
692 // to be local to this function as well, as they are directly referenced
693 // in a block.
694 for (llvm::DenseMap<const Decl *, llvm::Value*>::iterator i = ldm.begin();
695 i != ldm.end();
696 ++i) {
697 const VarDecl *VD = dyn_cast<VarDecl>(i->first);
Mike Stump1eb44332009-09-09 15:08:12 +0000698
Daniel Dunbar5466c7b2009-04-14 02:25:56 +0000699 if (VD->getStorageClass() == VarDecl::Static || VD->hasExternalStorage())
Mike Stump7f28a9c2009-03-13 23:34:28 +0000700 LocalDeclMap[VD] = i->second;
701 }
702
Ken Dyck199c3d62010-01-11 17:06:35 +0000703 BlockOffset = CharUnits::fromQuantity(
704 CGM.getTargetData()
705 .getTypeStoreSizeInBits(CGM.getGenericBlockLiteralType()) / 8);
Eli Friedman48f91222009-03-28 03:24:54 +0000706 BlockAlign = getContext().getTypeAlign(getContext().VoidPtrTy) / 8;
707
Fariborz Jahanian140fb262009-04-11 17:55:15 +0000708 const FunctionType *BlockFunctionType = BExpr->getFunctionType();
709 QualType ResultType;
710 bool IsVariadic;
Mike Stump1eb44332009-09-09 15:08:12 +0000711 if (const FunctionProtoType *FTy =
Fariborz Jahanianda0895d2009-04-11 18:54:57 +0000712 dyn_cast<FunctionProtoType>(BlockFunctionType)) {
Fariborz Jahanian140fb262009-04-11 17:55:15 +0000713 ResultType = FTy->getResultType();
714 IsVariadic = FTy->isVariadic();
Mike Stumpb3589f42009-07-30 22:28:39 +0000715 } else {
Fariborz Jahanian140fb262009-04-11 17:55:15 +0000716 // K&R style block.
717 ResultType = BlockFunctionType->getResultType();
718 IsVariadic = false;
719 }
Mike Stumpa5448542009-02-13 15:32:32 +0000720
Anders Carlssond5cab542009-02-12 17:55:02 +0000721 FunctionArgList Args;
Mike Stumpa5448542009-02-13 15:32:32 +0000722
Mike Stumpea26cb52009-10-21 03:49:08 +0000723 CurFuncDecl = OuterFuncDecl;
724
Chris Lattner161d36d2009-02-28 19:01:03 +0000725 const BlockDecl *BD = BExpr->getBlockDecl();
Anders Carlssond5cab542009-02-12 17:55:02 +0000726
Mike Stumpea26cb52009-10-21 03:49:08 +0000727 IdentifierInfo *II = &CGM.getContext().Idents.get(".block_descriptor");
Mike Stumpadaaad32009-10-20 02:12:22 +0000728
Mike Stumpbfbd5df2009-10-21 18:24:18 +0000729 // Allocate all BlockDeclRefDecls, so we can calculate the right ParmTy below.
Mike Stump0298d382009-10-21 22:02:08 +0000730 AllocateAllBlockDeclRefs(Info, this);
Mike Stumpea26cb52009-10-21 03:49:08 +0000731
Mike Stump083c25e2009-10-22 00:49:09 +0000732 QualType ParmTy = getContext().getBlockParmType(BlockHasCopyDispose,
733 BlockDeclRefDecls);
Anders Carlssond5cab542009-02-12 17:55:02 +0000734 // FIXME: This leaks
Mike Stumpa5448542009-02-13 15:32:32 +0000735 ImplicitParamDecl *SelfDecl =
Anders Carlssond5cab542009-02-12 17:55:02 +0000736 ImplicitParamDecl::Create(getContext(), 0,
Mike Stumpadaaad32009-10-20 02:12:22 +0000737 SourceLocation(), II,
738 ParmTy);
Mike Stumpa5448542009-02-13 15:32:32 +0000739
Anders Carlssond5cab542009-02-12 17:55:02 +0000740 Args.push_back(std::make_pair(SelfDecl, SelfDecl->getType()));
Mike Stump4e7a1f72009-02-21 20:00:35 +0000741 BlockStructDecl = SelfDecl;
Mike Stumpa5448542009-02-13 15:32:32 +0000742
Steve Naroffe78b8092009-03-13 16:56:44 +0000743 for (BlockDecl::param_const_iterator i = BD->param_begin(),
Anders Carlssond5cab542009-02-12 17:55:02 +0000744 e = BD->param_end(); i != e; ++i)
Mike Stump19050612009-02-17 23:25:52 +0000745 Args.push_back(std::make_pair(*i, (*i)->getType()));
Mike Stumpa5448542009-02-13 15:32:32 +0000746
747 const CGFunctionInfo &FI =
Fariborz Jahanian140fb262009-04-11 17:55:15 +0000748 CGM.getTypes().getFunctionInfo(ResultType, Args);
Anders Carlssond5cab542009-02-12 17:55:02 +0000749
Mike Stump67a64482009-02-14 22:16:35 +0000750 std::string Name = std::string("__") + Info.Name + "_block_invoke_";
Anders Carlssond5cab542009-02-12 17:55:02 +0000751 CodeGenTypes &Types = CGM.getTypes();
Fariborz Jahanian140fb262009-04-11 17:55:15 +0000752 const llvm::FunctionType *LTy = Types.GetFunctionType(FI, IsVariadic);
Mike Stumpa5448542009-02-13 15:32:32 +0000753
754 llvm::Function *Fn =
Anders Carlssond5cab542009-02-12 17:55:02 +0000755 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
756 Name,
757 &CGM.getModule());
Mike Stumpa5448542009-02-13 15:32:32 +0000758
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000759 CGM.SetInternalFunctionAttributes(BD, Fn, FI);
760
Chris Lattner4863db42009-04-23 07:18:56 +0000761 StartFunction(BD, ResultType, Fn, Args,
Chris Lattner161d36d2009-02-28 19:01:03 +0000762 BExpr->getBody()->getLocEnd());
Mike Stumpb1a6e682009-09-30 02:43:10 +0000763
Chris Lattner4863db42009-04-23 07:18:56 +0000764 CurFuncDecl = OuterFuncDecl;
Chris Lattnerb5437d22009-04-23 05:30:27 +0000765 CurCodeDecl = BD;
Mike Stumpb289b3f2009-10-01 22:29:41 +0000766
767 // Save a spot to insert the debug information for all the BlockDeclRefDecls.
768 llvm::BasicBlock *entry = Builder.GetInsertBlock();
769 llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint();
770 --entry_ptr;
771
Chris Lattner161d36d2009-02-28 19:01:03 +0000772 EmitStmt(BExpr->getBody());
Mike Stumpb289b3f2009-10-01 22:29:41 +0000773
Mike Stumpde8c5c72009-10-01 00:27:30 +0000774 // Remember where we were...
775 llvm::BasicBlock *resume = Builder.GetInsertBlock();
Mike Stumpb289b3f2009-10-01 22:29:41 +0000776
Mike Stumpde8c5c72009-10-01 00:27:30 +0000777 // Go back to the entry.
Mike Stumpb289b3f2009-10-01 22:29:41 +0000778 ++entry_ptr;
779 Builder.SetInsertPoint(entry, entry_ptr);
780
Mike Stumpb1a6e682009-09-30 02:43:10 +0000781 if (CGDebugInfo *DI = getDebugInfo()) {
Mike Stumpb1a6e682009-09-30 02:43:10 +0000782 // Emit debug information for all the BlockDeclRefDecls.
Mike Stumpb1a6e682009-09-30 02:43:10 +0000783 for (unsigned i=0; i < BlockDeclRefDecls.size(); ++i) {
784 const Expr *E = BlockDeclRefDecls[i];
785 const BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(E);
786 if (BDRE) {
787 const ValueDecl *D = BDRE->getDecl();
788 DI->setLocation(D->getLocation());
789 DI->EmitDeclareOfBlockDeclRefVariable(BDRE,
790 LocalDeclMap[getBlockStructDecl()],
791 Builder, this);
792 }
793 }
Mike Stumpb1a6e682009-09-30 02:43:10 +0000794 }
Mike Stumpde8c5c72009-10-01 00:27:30 +0000795 // And resume where we left off.
796 if (resume == 0)
797 Builder.ClearInsertionPoint();
798 else
799 Builder.SetInsertPoint(resume);
Mike Stumpb1a6e682009-09-30 02:43:10 +0000800
Chris Lattner161d36d2009-02-28 19:01:03 +0000801 FinishFunction(cast<CompoundStmt>(BExpr->getBody())->getRBracLoc());
Anders Carlssond5cab542009-02-12 17:55:02 +0000802
Mike Stump8a2b4b12009-02-25 23:33:13 +0000803 // The runtime needs a minimum alignment of a void *.
804 uint64_t MinAlign = getContext().getTypeAlign(getContext().VoidPtrTy) / 8;
Ken Dyck199c3d62010-01-11 17:06:35 +0000805 BlockOffset = CharUnits::fromQuantity(
806 llvm::RoundUpToAlignment(BlockOffset.getQuantity(), MinAlign));
Mike Stump8a2b4b12009-02-25 23:33:13 +0000807
Mike Stump4e7a1f72009-02-21 20:00:35 +0000808 Size = BlockOffset;
Mike Stump8a2b4b12009-02-25 23:33:13 +0000809 Align = BlockAlign;
810 subBlockDeclRefDecls = BlockDeclRefDecls;
Mike Stump00470a12009-03-05 08:32:30 +0000811 subBlockHasCopyDispose |= BlockHasCopyDispose;
Anders Carlssond5cab542009-02-12 17:55:02 +0000812 return Fn;
813}
Mike Stumpa99038c2009-02-28 09:07:16 +0000814
Ken Dyck199c3d62010-01-11 17:06:35 +0000815CharUnits BlockFunction::getBlockOffset(const BlockDeclRefExpr *BDRE) {
Mike Stumpa99038c2009-02-28 09:07:16 +0000816 const ValueDecl *D = dyn_cast<ValueDecl>(BDRE->getDecl());
817
Ken Dyck199c3d62010-01-11 17:06:35 +0000818 CharUnits Size = getContext().getTypeSizeInChars(D->getType());
Mike Stumpa99038c2009-02-28 09:07:16 +0000819 uint64_t Align = getContext().getDeclAlignInBytes(D);
820
821 if (BDRE->isByRef()) {
Ken Dyck199c3d62010-01-11 17:06:35 +0000822 Size = getContext().getTypeSizeInChars(getContext().VoidPtrTy);
Mike Stumpa99038c2009-02-28 09:07:16 +0000823 Align = getContext().getTypeAlign(getContext().VoidPtrTy) / 8;
824 }
825
826 assert ((Align > 0) && "alignment must be 1 byte or more");
827
Ken Dyck199c3d62010-01-11 17:06:35 +0000828 CharUnits OldOffset = BlockOffset;
Mike Stumpa99038c2009-02-28 09:07:16 +0000829
830 // Ensure proper alignment, even if it means we have to have a gap
Ken Dyck199c3d62010-01-11 17:06:35 +0000831 BlockOffset = CharUnits::fromQuantity(
832 llvm::RoundUpToAlignment(BlockOffset.getQuantity(), Align));
Mike Stumpa99038c2009-02-28 09:07:16 +0000833 BlockAlign = std::max(Align, BlockAlign);
Mike Stump00470a12009-03-05 08:32:30 +0000834
Ken Dyck199c3d62010-01-11 17:06:35 +0000835 CharUnits Pad = BlockOffset - OldOffset;
836 if (Pad.isPositive()) {
837 llvm::ArrayType::get(llvm::Type::getInt8Ty(VMContext), Pad.getQuantity());
Mike Stumpa99038c2009-02-28 09:07:16 +0000838 QualType PadTy = getContext().getConstantArrayType(getContext().CharTy,
Ken Dyck199c3d62010-01-11 17:06:35 +0000839 llvm::APInt(32,
840 Pad.getQuantity()),
Mike Stumpa99038c2009-02-28 09:07:16 +0000841 ArrayType::Normal, 0);
842 ValueDecl *PadDecl = VarDecl::Create(getContext(), 0, SourceLocation(),
Argyrios Kyrtzidisa5d82002009-08-21 00:31:54 +0000843 0, QualType(PadTy), 0, VarDecl::None);
Mike Stumpa99038c2009-02-28 09:07:16 +0000844 Expr *E;
845 E = new (getContext()) DeclRefExpr(PadDecl, PadDecl->getType(),
Douglas Gregor0da76df2009-11-23 11:41:28 +0000846 SourceLocation());
Mike Stumpa99038c2009-02-28 09:07:16 +0000847 BlockDeclRefDecls.push_back(E);
848 }
849 BlockDeclRefDecls.push_back(BDRE);
850
851 BlockOffset += Size;
852 return BlockOffset-Size;
853}
Mike Stumpdab514f2009-03-04 03:23:46 +0000854
Mike Stump08920992009-03-07 02:35:30 +0000855llvm::Constant *BlockFunction::
856GenerateCopyHelperFunction(bool BlockHasCopyDispose, const llvm::StructType *T,
Mike Stumpb7477cf2009-04-10 18:52:28 +0000857 std::vector<HelperInfo> *NoteForHelperp) {
Mike Stumpa4f668f2009-03-06 01:33:24 +0000858 QualType R = getContext().VoidTy;
859
860 FunctionArgList Args;
861 // FIXME: This leaks
Mike Stump08920992009-03-07 02:35:30 +0000862 ImplicitParamDecl *Dst =
Mike Stumpea26cb52009-10-21 03:49:08 +0000863 ImplicitParamDecl::Create(getContext(), 0,
864 SourceLocation(), 0,
Mike Stump08920992009-03-07 02:35:30 +0000865 getContext().getPointerType(getContext().VoidTy));
866 Args.push_back(std::make_pair(Dst, Dst->getType()));
Mike Stumpa4f668f2009-03-06 01:33:24 +0000867 ImplicitParamDecl *Src =
Mike Stumpea26cb52009-10-21 03:49:08 +0000868 ImplicitParamDecl::Create(getContext(), 0,
869 SourceLocation(), 0,
Mike Stumpa4f668f2009-03-06 01:33:24 +0000870 getContext().getPointerType(getContext().VoidTy));
Mike Stumpa4f668f2009-03-06 01:33:24 +0000871 Args.push_back(std::make_pair(Src, Src->getType()));
Mike Stump1eb44332009-09-09 15:08:12 +0000872
Mike Stumpa4f668f2009-03-06 01:33:24 +0000873 const CGFunctionInfo &FI =
874 CGM.getTypes().getFunctionInfo(R, Args);
875
Mike Stump3899a7f2009-06-05 23:26:36 +0000876 // FIXME: We'd like to put these into a mergable by content, with
877 // internal linkage.
Mike Stumpa4f668f2009-03-06 01:33:24 +0000878 std::string Name = std::string("__copy_helper_block_");
879 CodeGenTypes &Types = CGM.getTypes();
880 const llvm::FunctionType *LTy = Types.GetFunctionType(FI, false);
881
882 llvm::Function *Fn =
883 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
884 Name,
885 &CGM.getModule());
886
887 IdentifierInfo *II
888 = &CGM.getContext().Idents.get("__copy_helper_block_");
889
890 FunctionDecl *FD = FunctionDecl::Create(getContext(),
891 getContext().getTranslationUnitDecl(),
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000892 SourceLocation(), II, R, 0,
Mike Stumpa4f668f2009-03-06 01:33:24 +0000893 FunctionDecl::Static, false,
894 true);
895 CGF.StartFunction(FD, R, Fn, Args, SourceLocation());
Mike Stump08920992009-03-07 02:35:30 +0000896
897 llvm::Value *SrcObj = CGF.GetAddrOfLocalVar(Src);
898 llvm::Type *PtrPtrT;
Mike Stump08920992009-03-07 02:35:30 +0000899
Mike Stumpb7477cf2009-04-10 18:52:28 +0000900 if (NoteForHelperp) {
901 std::vector<HelperInfo> &NoteForHelper = *NoteForHelperp;
Mike Stump08920992009-03-07 02:35:30 +0000902
Owen Anderson96e0fc72009-07-29 22:16:19 +0000903 PtrPtrT = llvm::PointerType::get(llvm::PointerType::get(T, 0), 0);
Mike Stumpb7477cf2009-04-10 18:52:28 +0000904 SrcObj = Builder.CreateBitCast(SrcObj, PtrPtrT);
905 SrcObj = Builder.CreateLoad(SrcObj);
Mike Stump08920992009-03-07 02:35:30 +0000906
Mike Stumpb7477cf2009-04-10 18:52:28 +0000907 llvm::Value *DstObj = CGF.GetAddrOfLocalVar(Dst);
Mike Stumpc2f4c342009-04-15 22:11:36 +0000908 llvm::Type *PtrPtrT;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000909 PtrPtrT = llvm::PointerType::get(llvm::PointerType::get(T, 0), 0);
Mike Stumpc2f4c342009-04-15 22:11:36 +0000910 DstObj = Builder.CreateBitCast(DstObj, PtrPtrT);
911 DstObj = Builder.CreateLoad(DstObj);
Mike Stump08920992009-03-07 02:35:30 +0000912
Mike Stumpb7477cf2009-04-10 18:52:28 +0000913 for (unsigned i=0; i < NoteForHelper.size(); ++i) {
914 int flag = NoteForHelper[i].flag;
915 int index = NoteForHelper[i].index;
Mike Stump08920992009-03-07 02:35:30 +0000916
Mike Stumpb7477cf2009-04-10 18:52:28 +0000917 if ((NoteForHelper[i].flag & BLOCK_FIELD_IS_BYREF)
918 || NoteForHelper[i].RequiresCopying) {
919 llvm::Value *Srcv = SrcObj;
920 Srcv = Builder.CreateStructGEP(Srcv, index);
921 Srcv = Builder.CreateBitCast(Srcv,
Owen Anderson96e0fc72009-07-29 22:16:19 +0000922 llvm::PointerType::get(PtrToInt8Ty, 0));
Mike Stumpb7477cf2009-04-10 18:52:28 +0000923 Srcv = Builder.CreateLoad(Srcv);
924
925 llvm::Value *Dstv = Builder.CreateStructGEP(DstObj, index);
926 Dstv = Builder.CreateBitCast(Dstv, PtrToInt8Ty);
927
Owen Anderson0032b272009-08-13 21:57:51 +0000928 llvm::Value *N = llvm::ConstantInt::get(
929 llvm::Type::getInt32Ty(T->getContext()), flag);
Mike Stumpb7477cf2009-04-10 18:52:28 +0000930 llvm::Value *F = getBlockObjectAssign();
931 Builder.CreateCall3(F, Dstv, Srcv, N);
932 }
Mike Stump08920992009-03-07 02:35:30 +0000933 }
934 }
935
Mike Stumpa4f668f2009-03-06 01:33:24 +0000936 CGF.FinishFunction();
937
Owen Anderson3c4972d2009-07-29 18:54:39 +0000938 return llvm::ConstantExpr::getBitCast(Fn, PtrToInt8Ty);
Mike Stumpdab514f2009-03-04 03:23:46 +0000939}
940
Mike Stumpcf62d392009-03-06 18:42:23 +0000941llvm::Constant *BlockFunction::
Mike Stump08920992009-03-07 02:35:30 +0000942GenerateDestroyHelperFunction(bool BlockHasCopyDispose,
943 const llvm::StructType* T,
Mike Stumpb7477cf2009-04-10 18:52:28 +0000944 std::vector<HelperInfo> *NoteForHelperp) {
Mike Stumpa4f668f2009-03-06 01:33:24 +0000945 QualType R = getContext().VoidTy;
946
947 FunctionArgList Args;
948 // FIXME: This leaks
949 ImplicitParamDecl *Src =
Mike Stumpea26cb52009-10-21 03:49:08 +0000950 ImplicitParamDecl::Create(getContext(), 0,
951 SourceLocation(), 0,
Mike Stumpa4f668f2009-03-06 01:33:24 +0000952 getContext().getPointerType(getContext().VoidTy));
953
954 Args.push_back(std::make_pair(Src, Src->getType()));
Mike Stump1eb44332009-09-09 15:08:12 +0000955
Mike Stumpa4f668f2009-03-06 01:33:24 +0000956 const CGFunctionInfo &FI =
957 CGM.getTypes().getFunctionInfo(R, Args);
958
Mike Stump3899a7f2009-06-05 23:26:36 +0000959 // FIXME: We'd like to put these into a mergable by content, with
960 // internal linkage.
Mike Stumpa4f668f2009-03-06 01:33:24 +0000961 std::string Name = std::string("__destroy_helper_block_");
962 CodeGenTypes &Types = CGM.getTypes();
963 const llvm::FunctionType *LTy = Types.GetFunctionType(FI, false);
964
965 llvm::Function *Fn =
966 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
967 Name,
968 &CGM.getModule());
969
970 IdentifierInfo *II
971 = &CGM.getContext().Idents.get("__destroy_helper_block_");
972
973 FunctionDecl *FD = FunctionDecl::Create(getContext(),
974 getContext().getTranslationUnitDecl(),
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000975 SourceLocation(), II, R, 0,
Mike Stumpa4f668f2009-03-06 01:33:24 +0000976 FunctionDecl::Static, false,
977 true);
978 CGF.StartFunction(FD, R, Fn, Args, SourceLocation());
Mike Stump1edf6b62009-03-07 02:53:18 +0000979
Mike Stumpb7477cf2009-04-10 18:52:28 +0000980 if (NoteForHelperp) {
981 std::vector<HelperInfo> &NoteForHelper = *NoteForHelperp;
Mike Stump1edf6b62009-03-07 02:53:18 +0000982
Mike Stumpb7477cf2009-04-10 18:52:28 +0000983 llvm::Value *SrcObj = CGF.GetAddrOfLocalVar(Src);
984 llvm::Type *PtrPtrT;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000985 PtrPtrT = llvm::PointerType::get(llvm::PointerType::get(T, 0), 0);
Mike Stumpb7477cf2009-04-10 18:52:28 +0000986 SrcObj = Builder.CreateBitCast(SrcObj, PtrPtrT);
987 SrcObj = Builder.CreateLoad(SrcObj);
Mike Stump1edf6b62009-03-07 02:53:18 +0000988
Mike Stumpb7477cf2009-04-10 18:52:28 +0000989 for (unsigned i=0; i < NoteForHelper.size(); ++i) {
990 int flag = NoteForHelper[i].flag;
991 int index = NoteForHelper[i].index;
Mike Stump1edf6b62009-03-07 02:53:18 +0000992
Mike Stumpb7477cf2009-04-10 18:52:28 +0000993 if ((NoteForHelper[i].flag & BLOCK_FIELD_IS_BYREF)
994 || NoteForHelper[i].RequiresCopying) {
995 llvm::Value *Srcv = SrcObj;
996 Srcv = Builder.CreateStructGEP(Srcv, index);
997 Srcv = Builder.CreateBitCast(Srcv,
Owen Anderson96e0fc72009-07-29 22:16:19 +0000998 llvm::PointerType::get(PtrToInt8Ty, 0));
Mike Stumpb7477cf2009-04-10 18:52:28 +0000999 Srcv = Builder.CreateLoad(Srcv);
1000
1001 BuildBlockRelease(Srcv, flag);
1002 }
Mike Stump1edf6b62009-03-07 02:53:18 +00001003 }
1004 }
1005
Mike Stumpa4f668f2009-03-06 01:33:24 +00001006 CGF.FinishFunction();
1007
Owen Anderson3c4972d2009-07-29 18:54:39 +00001008 return llvm::ConstantExpr::getBitCast(Fn, PtrToInt8Ty);
Mike Stumpa4f668f2009-03-06 01:33:24 +00001009}
1010
Mike Stump08920992009-03-07 02:35:30 +00001011llvm::Constant *BlockFunction::BuildCopyHelper(const llvm::StructType *T,
Mike Stumpb7477cf2009-04-10 18:52:28 +00001012 std::vector<HelperInfo> *NoteForHelper) {
Mike Stump08920992009-03-07 02:35:30 +00001013 return CodeGenFunction(CGM).GenerateCopyHelperFunction(BlockHasCopyDispose,
1014 T, NoteForHelper);
Mike Stumpa4f668f2009-03-06 01:33:24 +00001015}
1016
Mike Stump08920992009-03-07 02:35:30 +00001017llvm::Constant *BlockFunction::BuildDestroyHelper(const llvm::StructType *T,
Mike Stumpb7477cf2009-04-10 18:52:28 +00001018 std::vector<HelperInfo> *NoteForHelperp) {
Mike Stump08920992009-03-07 02:35:30 +00001019 return CodeGenFunction(CGM).GenerateDestroyHelperFunction(BlockHasCopyDispose,
Mike Stumpb7477cf2009-04-10 18:52:28 +00001020 T, NoteForHelperp);
Mike Stumpdab514f2009-03-04 03:23:46 +00001021}
Mike Stump797b6322009-03-05 01:23:13 +00001022
Mike Stumpee094222009-03-06 06:12:24 +00001023llvm::Constant *BlockFunction::
1024GeneratebyrefCopyHelperFunction(const llvm::Type *T, int flag) {
Mike Stump45031c02009-03-06 02:29:21 +00001025 QualType R = getContext().VoidTy;
1026
1027 FunctionArgList Args;
1028 // FIXME: This leaks
Mike Stumpee094222009-03-06 06:12:24 +00001029 ImplicitParamDecl *Dst =
Mike Stumpea26cb52009-10-21 03:49:08 +00001030 ImplicitParamDecl::Create(getContext(), 0,
1031 SourceLocation(), 0,
Mike Stumpee094222009-03-06 06:12:24 +00001032 getContext().getPointerType(getContext().VoidTy));
1033 Args.push_back(std::make_pair(Dst, Dst->getType()));
1034
1035 // FIXME: This leaks
Mike Stump45031c02009-03-06 02:29:21 +00001036 ImplicitParamDecl *Src =
Mike Stumpea26cb52009-10-21 03:49:08 +00001037 ImplicitParamDecl::Create(getContext(), 0,
1038 SourceLocation(), 0,
Mike Stump45031c02009-03-06 02:29:21 +00001039 getContext().getPointerType(getContext().VoidTy));
Mike Stump45031c02009-03-06 02:29:21 +00001040 Args.push_back(std::make_pair(Src, Src->getType()));
Mike Stump1eb44332009-09-09 15:08:12 +00001041
Mike Stump45031c02009-03-06 02:29:21 +00001042 const CGFunctionInfo &FI =
1043 CGM.getTypes().getFunctionInfo(R, Args);
1044
1045 std::string Name = std::string("__Block_byref_id_object_copy_");
1046 CodeGenTypes &Types = CGM.getTypes();
1047 const llvm::FunctionType *LTy = Types.GetFunctionType(FI, false);
1048
Mike Stump3899a7f2009-06-05 23:26:36 +00001049 // FIXME: We'd like to put these into a mergable by content, with
1050 // internal linkage.
Mike Stump45031c02009-03-06 02:29:21 +00001051 llvm::Function *Fn =
1052 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
1053 Name,
1054 &CGM.getModule());
1055
1056 IdentifierInfo *II
1057 = &CGM.getContext().Idents.get("__Block_byref_id_object_copy_");
1058
1059 FunctionDecl *FD = FunctionDecl::Create(getContext(),
1060 getContext().getTranslationUnitDecl(),
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00001061 SourceLocation(), II, R, 0,
Mike Stump45031c02009-03-06 02:29:21 +00001062 FunctionDecl::Static, false,
1063 true);
1064 CGF.StartFunction(FD, R, Fn, Args, SourceLocation());
Mike Stumpee094222009-03-06 06:12:24 +00001065
1066 // dst->x
1067 llvm::Value *V = CGF.GetAddrOfLocalVar(Dst);
Owen Anderson96e0fc72009-07-29 22:16:19 +00001068 V = Builder.CreateBitCast(V, llvm::PointerType::get(T, 0));
Mike Stumpc2f4c342009-04-15 22:11:36 +00001069 V = Builder.CreateLoad(V);
Mike Stumpee094222009-03-06 06:12:24 +00001070 V = Builder.CreateStructGEP(V, 6, "x");
1071 llvm::Value *DstObj = Builder.CreateBitCast(V, PtrToInt8Ty);
1072
1073 // src->x
1074 V = CGF.GetAddrOfLocalVar(Src);
1075 V = Builder.CreateLoad(V);
1076 V = Builder.CreateBitCast(V, T);
1077 V = Builder.CreateStructGEP(V, 6, "x");
Owen Anderson96e0fc72009-07-29 22:16:19 +00001078 V = Builder.CreateBitCast(V, llvm::PointerType::get(PtrToInt8Ty, 0));
Mike Stumpee094222009-03-06 06:12:24 +00001079 llvm::Value *SrcObj = Builder.CreateLoad(V);
Mike Stump1eb44332009-09-09 15:08:12 +00001080
Mike Stumpee094222009-03-06 06:12:24 +00001081 flag |= BLOCK_BYREF_CALLER;
1082
Owen Anderson0032b272009-08-13 21:57:51 +00001083 llvm::Value *N = llvm::ConstantInt::get(
1084 llvm::Type::getInt32Ty(T->getContext()), flag);
Mike Stumpee094222009-03-06 06:12:24 +00001085 llvm::Value *F = getBlockObjectAssign();
1086 Builder.CreateCall3(F, DstObj, SrcObj, N);
1087
Mike Stump45031c02009-03-06 02:29:21 +00001088 CGF.FinishFunction();
1089
Owen Anderson3c4972d2009-07-29 18:54:39 +00001090 return llvm::ConstantExpr::getBitCast(Fn, PtrToInt8Ty);
Mike Stump45031c02009-03-06 02:29:21 +00001091}
1092
Mike Stump1851b682009-03-06 04:53:30 +00001093llvm::Constant *
1094BlockFunction::GeneratebyrefDestroyHelperFunction(const llvm::Type *T,
1095 int flag) {
Mike Stump45031c02009-03-06 02:29:21 +00001096 QualType R = getContext().VoidTy;
1097
1098 FunctionArgList Args;
1099 // FIXME: This leaks
1100 ImplicitParamDecl *Src =
Mike Stumpea26cb52009-10-21 03:49:08 +00001101 ImplicitParamDecl::Create(getContext(), 0,
1102 SourceLocation(), 0,
Mike Stump45031c02009-03-06 02:29:21 +00001103 getContext().getPointerType(getContext().VoidTy));
1104
1105 Args.push_back(std::make_pair(Src, Src->getType()));
Mike Stump1eb44332009-09-09 15:08:12 +00001106
Mike Stump45031c02009-03-06 02:29:21 +00001107 const CGFunctionInfo &FI =
1108 CGM.getTypes().getFunctionInfo(R, Args);
1109
1110 std::string Name = std::string("__Block_byref_id_object_dispose_");
1111 CodeGenTypes &Types = CGM.getTypes();
1112 const llvm::FunctionType *LTy = Types.GetFunctionType(FI, false);
1113
Mike Stump3899a7f2009-06-05 23:26:36 +00001114 // FIXME: We'd like to put these into a mergable by content, with
1115 // internal linkage.
Mike Stump45031c02009-03-06 02:29:21 +00001116 llvm::Function *Fn =
1117 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
1118 Name,
1119 &CGM.getModule());
1120
1121 IdentifierInfo *II
1122 = &CGM.getContext().Idents.get("__Block_byref_id_object_dispose_");
1123
1124 FunctionDecl *FD = FunctionDecl::Create(getContext(),
1125 getContext().getTranslationUnitDecl(),
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00001126 SourceLocation(), II, R, 0,
Mike Stump45031c02009-03-06 02:29:21 +00001127 FunctionDecl::Static, false,
1128 true);
1129 CGF.StartFunction(FD, R, Fn, Args, SourceLocation());
Mike Stump1851b682009-03-06 04:53:30 +00001130
1131 llvm::Value *V = CGF.GetAddrOfLocalVar(Src);
Owen Anderson96e0fc72009-07-29 22:16:19 +00001132 V = Builder.CreateBitCast(V, llvm::PointerType::get(T, 0));
Mike Stumpc2f4c342009-04-15 22:11:36 +00001133 V = Builder.CreateLoad(V);
Mike Stump1851b682009-03-06 04:53:30 +00001134 V = Builder.CreateStructGEP(V, 6, "x");
Owen Anderson96e0fc72009-07-29 22:16:19 +00001135 V = Builder.CreateBitCast(V, llvm::PointerType::get(PtrToInt8Ty, 0));
Mike Stumpc2f4c342009-04-15 22:11:36 +00001136 V = Builder.CreateLoad(V);
Mike Stump1851b682009-03-06 04:53:30 +00001137
Mike Stump1851b682009-03-06 04:53:30 +00001138 flag |= BLOCK_BYREF_CALLER;
1139 BuildBlockRelease(V, flag);
Mike Stump45031c02009-03-06 02:29:21 +00001140 CGF.FinishFunction();
1141
Owen Anderson3c4972d2009-07-29 18:54:39 +00001142 return llvm::ConstantExpr::getBitCast(Fn, PtrToInt8Ty);
Mike Stump45031c02009-03-06 02:29:21 +00001143}
1144
Mike Stumpee094222009-03-06 06:12:24 +00001145llvm::Constant *BlockFunction::BuildbyrefCopyHelper(const llvm::Type *T,
Chris Lattner10976d92009-12-05 08:21:30 +00001146 int Flag, unsigned Align) {
1147 // All alignments below that of pointer alignment collapse down to just
Mike Stump3899a7f2009-06-05 23:26:36 +00001148 // pointer alignment, as we always have at least that much alignment to begin
1149 // with.
1150 Align /= unsigned(CGF.Target.getPointerAlign(0)/8);
Chris Lattner10976d92009-12-05 08:21:30 +00001151
Mike Stump3899a7f2009-06-05 23:26:36 +00001152 // As an optimization, we only generate a single function of each kind we
1153 // might need. We need a different one for each alignment and for each
1154 // setting of flags. We mix Align and flag to get the kind.
Chris Lattner10976d92009-12-05 08:21:30 +00001155 uint64_t Kind = (uint64_t)Align*BLOCK_BYREF_CURRENT_MAX + Flag;
1156 llvm::Constant *&Entry = CGM.AssignCache[Kind];
Mike Stump3899a7f2009-06-05 23:26:36 +00001157 if (Entry)
1158 return Entry;
Chris Lattner10976d92009-12-05 08:21:30 +00001159 return Entry = CodeGenFunction(CGM).GeneratebyrefCopyHelperFunction(T, Flag);
Mike Stump45031c02009-03-06 02:29:21 +00001160}
1161
Mike Stump1851b682009-03-06 04:53:30 +00001162llvm::Constant *BlockFunction::BuildbyrefDestroyHelper(const llvm::Type *T,
Chris Lattner10976d92009-12-05 08:21:30 +00001163 int Flag,
Mike Stump3899a7f2009-06-05 23:26:36 +00001164 unsigned Align) {
1165 // All alignments below that of pointer alignment collpase down to just
1166 // pointer alignment, as we always have at least that much alignment to begin
1167 // with.
1168 Align /= unsigned(CGF.Target.getPointerAlign(0)/8);
Chris Lattner10976d92009-12-05 08:21:30 +00001169
Mike Stump3899a7f2009-06-05 23:26:36 +00001170 // As an optimization, we only generate a single function of each kind we
1171 // might need. We need a different one for each alignment and for each
1172 // setting of flags. We mix Align and flag to get the kind.
Chris Lattner10976d92009-12-05 08:21:30 +00001173 uint64_t Kind = (uint64_t)Align*BLOCK_BYREF_CURRENT_MAX + Flag;
1174 llvm::Constant *&Entry = CGM.DestroyCache[Kind];
Mike Stump3899a7f2009-06-05 23:26:36 +00001175 if (Entry)
1176 return Entry;
Chris Lattner10976d92009-12-05 08:21:30 +00001177 return Entry=CodeGenFunction(CGM).GeneratebyrefDestroyHelperFunction(T, Flag);
Mike Stump45031c02009-03-06 02:29:21 +00001178}
1179
Mike Stump797b6322009-03-05 01:23:13 +00001180llvm::Value *BlockFunction::getBlockObjectDispose() {
1181 if (CGM.BlockObjectDispose == 0) {
1182 const llvm::FunctionType *FTy;
1183 std::vector<const llvm::Type*> ArgTys;
Owen Anderson0032b272009-08-13 21:57:51 +00001184 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
Mike Stump797b6322009-03-05 01:23:13 +00001185 ArgTys.push_back(PtrToInt8Ty);
Owen Anderson0032b272009-08-13 21:57:51 +00001186 ArgTys.push_back(llvm::Type::getInt32Ty(VMContext));
Owen Anderson96e0fc72009-07-29 22:16:19 +00001187 FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
Mike Stump00470a12009-03-05 08:32:30 +00001188 CGM.BlockObjectDispose
Mike Stump797b6322009-03-05 01:23:13 +00001189 = CGM.CreateRuntimeFunction(FTy, "_Block_object_dispose");
1190 }
1191 return CGM.BlockObjectDispose;
1192}
1193
Mike Stumpee094222009-03-06 06:12:24 +00001194llvm::Value *BlockFunction::getBlockObjectAssign() {
1195 if (CGM.BlockObjectAssign == 0) {
1196 const llvm::FunctionType *FTy;
1197 std::vector<const llvm::Type*> ArgTys;
Owen Anderson0032b272009-08-13 21:57:51 +00001198 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
Mike Stumpee094222009-03-06 06:12:24 +00001199 ArgTys.push_back(PtrToInt8Ty);
1200 ArgTys.push_back(PtrToInt8Ty);
Owen Anderson0032b272009-08-13 21:57:51 +00001201 ArgTys.push_back(llvm::Type::getInt32Ty(VMContext));
Owen Anderson96e0fc72009-07-29 22:16:19 +00001202 FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
Mike Stumpee094222009-03-06 06:12:24 +00001203 CGM.BlockObjectAssign
1204 = CGM.CreateRuntimeFunction(FTy, "_Block_object_assign");
1205 }
1206 return CGM.BlockObjectAssign;
1207}
1208
Mike Stump1851b682009-03-06 04:53:30 +00001209void BlockFunction::BuildBlockRelease(llvm::Value *V, int flag) {
Mike Stump797b6322009-03-05 01:23:13 +00001210 llvm::Value *F = getBlockObjectDispose();
Mike Stump1851b682009-03-06 04:53:30 +00001211 llvm::Value *N;
Mike Stump797b6322009-03-05 01:23:13 +00001212 V = Builder.CreateBitCast(V, PtrToInt8Ty);
Owen Anderson0032b272009-08-13 21:57:51 +00001213 N = llvm::ConstantInt::get(llvm::Type::getInt32Ty(V->getContext()), flag);
Mike Stump797b6322009-03-05 01:23:13 +00001214 Builder.CreateCall2(F, V, N);
1215}
Mike Stump00470a12009-03-05 08:32:30 +00001216
1217ASTContext &BlockFunction::getContext() const { return CGM.getContext(); }
Mike Stump08920992009-03-07 02:35:30 +00001218
1219BlockFunction::BlockFunction(CodeGenModule &cgm, CodeGenFunction &cgf,
1220 CGBuilderTy &B)
Owen Andersona1cf15f2009-07-14 23:10:40 +00001221 : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()), Builder(B) {
Owen Anderson0032b272009-08-13 21:57:51 +00001222 PtrToInt8Ty = llvm::PointerType::getUnqual(
1223 llvm::Type::getInt8Ty(VMContext));
Mike Stump08920992009-03-07 02:35:30 +00001224
1225 BlockHasCopyDispose = false;
1226}