1//===--- CGBlocks.cpp - Emit LLVM Code for declarations ---------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This contains code to emit blocks.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGBlocks.h"
14#include "CGCXXABI.h"
15#include "CGDebugInfo.h"
16#include "CGObjCRuntime.h"
17#include "CGOpenCLRuntime.h"
18#include "CodeGenFunction.h"
19#include "CodeGenModule.h"
20#include "ConstantEmitter.h"
21#include "TargetInfo.h"
22#include "clang/AST/Attr.h"
23#include "clang/AST/DeclObjC.h"
24#include "clang/CodeGen/ConstantInitBuilder.h"
25#include "llvm/ADT/SmallSet.h"
26#include "llvm/IR/DataLayout.h"
27#include "llvm/IR/Module.h"
28#include "llvm/Support/ScopedPrinter.h"
29#include <algorithm>
30#include <cstdio>
31
32using namespace clang;
33using namespace CodeGen;
34
35CGBlockInfo::CGBlockInfo(const BlockDecl *block, StringRef name)
36 : Name(name), CXXThisIndex(0), CanBeGlobal(false), NeedsCopyDispose(false),
37 HasCXXObject(false), UsesStret(false), HasCapturedVariableLayout(false),
38 CapturesNonExternalType(false), LocalAddress(Address::invalid()),
39 StructureType(nullptr), Block(block) {
40
41 // Skip asm prefix, if any. 'name' is usually taken directly from
42 // the mangled name of the enclosing function.
43 if (!name.empty() && name[0] == '\01')
44 name = name.substr(1);
45}
46
47// Anchor the vtable to this translation unit.
48BlockByrefHelpers::~BlockByrefHelpers() {}
49
50/// Build the given block as a global block.
51static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM,
52 const CGBlockInfo &blockInfo,
53 llvm::Constant *blockFn);
54
55/// Build the helper function to copy a block.
56static llvm::Constant *buildCopyHelper(CodeGenModule &CGM,
57 const CGBlockInfo &blockInfo) {
58 return CodeGenFunction(CGM).GenerateCopyHelperFunction(blockInfo);
59}
60
61/// Build the helper function to dispose of a block.
62static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM,
63 const CGBlockInfo &blockInfo) {
64 return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo);
65}
66
67namespace {
68
69/// Represents a type of copy/destroy operation that should be performed for an
70/// entity that's captured by a block.
71enum class BlockCaptureEntityKind {
72 CXXRecord, // Copy or destroy
73 ARCWeak,
74 ARCStrong,
75 NonTrivialCStruct,
76 BlockObject, // Assign or release
77 None
78};
79
80/// Represents a captured entity that requires extra operations in order for
81/// this entity to be copied or destroyed correctly.
82struct BlockCaptureManagedEntity {
83 BlockCaptureEntityKind CopyKind, DisposeKind;
84 BlockFieldFlags CopyFlags, DisposeFlags;
85 const BlockDecl::Capture *CI;
86 const CGBlockInfo::Capture *Capture;
87
88 BlockCaptureManagedEntity(BlockCaptureEntityKind CopyType,
89 BlockCaptureEntityKind DisposeType,
90 BlockFieldFlags CopyFlags,
91 BlockFieldFlags DisposeFlags,
92 const BlockDecl::Capture &CI,
93 const CGBlockInfo::Capture &Capture)
94 : CopyKind(CopyType), DisposeKind(DisposeType), CopyFlags(CopyFlags),
95 DisposeFlags(DisposeFlags), CI(&CI), Capture(&Capture) {}
96
97 bool operator<(const BlockCaptureManagedEntity &Other) const {
98 return Capture->getOffset() < Other.Capture->getOffset();
99 }
100};
101
102enum class CaptureStrKind {
103 // String for the copy helper.
104 CopyHelper,
105 // String for the dispose helper.
106 DisposeHelper,
107 // Merge the strings for the copy helper and dispose helper.
108 Merged
109};
110
111} // end anonymous namespace
112
113static void findBlockCapturedManagedEntities(
114 const CGBlockInfo &BlockInfo, const LangOptions &LangOpts,
115 SmallVectorImpl<BlockCaptureManagedEntity> &ManagedCaptures);
116
117static std::string getBlockCaptureStr(const BlockCaptureManagedEntity &E,
118 CaptureStrKind StrKind,
119 CharUnits BlockAlignment,
120 CodeGenModule &CGM);
121
122static std::string getBlockDescriptorName(const CGBlockInfo &BlockInfo,
123 CodeGenModule &CGM) {
124 std::string Name = "__block_descriptor_";
125 Name += llvm::to_string(BlockInfo.BlockSize.getQuantity()) + "_";
126
127 if (BlockInfo.needsCopyDisposeHelpers()) {
128 if (CGM.getLangOpts().Exceptions)
129 Name += "e";
130 if (CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
131 Name += "a";
132 Name += llvm::to_string(BlockInfo.BlockAlign.getQuantity()) + "_";
133
134 SmallVector<BlockCaptureManagedEntity, 4> ManagedCaptures;
135 findBlockCapturedManagedEntities(BlockInfo, CGM.getContext().getLangOpts(),
136 ManagedCaptures);
137
138 for (const BlockCaptureManagedEntity &E : ManagedCaptures) {
139 Name += llvm::to_string(E.Capture->getOffset().getQuantity());
140
141 if (E.CopyKind == E.DisposeKind) {
142 // If CopyKind and DisposeKind are the same, merge the capture
143 // information.
144 assert(E.CopyKind != BlockCaptureEntityKind::None &&
145 "shouldn't see BlockCaptureManagedEntity that is None");
146 Name += getBlockCaptureStr(E, CaptureStrKind::Merged,
147 BlockInfo.BlockAlign, CGM);
148 } else {
149 // If CopyKind and DisposeKind are not the same, which can happen when
150 // either Kind is None or the captured object is a __strong block,
151 // concatenate the copy and dispose strings.
152 Name += getBlockCaptureStr(E, CaptureStrKind::CopyHelper,
153 BlockInfo.BlockAlign, CGM);
154 Name += getBlockCaptureStr(E, CaptureStrKind::DisposeHelper,
155 BlockInfo.BlockAlign, CGM);
156 }
157 }
158 Name += "_";
159 }
160
161 std::string TypeAtEncoding =
162 CGM.getContext().getObjCEncodingForBlock(BlockInfo.getBlockExpr());
163 /// Replace occurrences of '@' with '\1'. '@' is reserved on ELF platforms as
164 /// a separator between symbol name and symbol version.
165 std::replace(TypeAtEncoding.begin(), TypeAtEncoding.end(), '@', '\1');
166 Name += "e" + llvm::to_string(TypeAtEncoding.size()) + "_" + TypeAtEncoding;
167 Name += "l" + CGM.getObjCRuntime().getRCBlockLayoutStr(CGM, BlockInfo);
168 return Name;
169}
170
171/// buildBlockDescriptor - Build the block descriptor meta-data for a block.
172/// buildBlockDescriptor is accessed from 5th field of the Block_literal
173/// meta-data and contains stationary information about the block literal.
174/// Its definition will have 4 (or optionally 6) words.
175/// \code
176/// struct Block_descriptor {
177/// unsigned long reserved;
178/// unsigned long size; // size of Block_literal metadata in bytes.
179/// void *copy_func_helper_decl; // optional copy helper.
180/// void *destroy_func_decl; // optional destructor helper.
181/// void *block_method_encoding_address; // @encode for block literal signature.
182/// void *block_layout_info; // encoding of captured block variables.
183/// };
184/// \endcode
185static llvm::Constant *buildBlockDescriptor(CodeGenModule &CGM,
186 const CGBlockInfo &blockInfo) {
187 ASTContext &C = CGM.getContext();
188
189 llvm::IntegerType *ulong =
190 cast<llvm::IntegerType>(CGM.getTypes().ConvertType(C.UnsignedLongTy));
191 llvm::PointerType *i8p = nullptr;
192 if (CGM.getLangOpts().OpenCL)
193 i8p =
194 llvm::Type::getInt8PtrTy(
195 CGM.getLLVMContext(), C.getTargetAddressSpace(LangAS::opencl_constant));
196 else
197 i8p = CGM.VoidPtrTy;
198
199 std::string descName;
200
201 // If an equivalent block descriptor global variable exists, return it.
202 if (C.getLangOpts().ObjC &&
203 CGM.getLangOpts().getGC() == LangOptions::NonGC) {
204 descName = getBlockDescriptorName(blockInfo, CGM);
205 if (llvm::GlobalValue *desc = CGM.getModule().getNamedValue(descName))
206 return llvm::ConstantExpr::getBitCast(desc,
207 CGM.getBlockDescriptorType());
208 }
209
210 // If there isn't an equivalent block descriptor global variable, create a new
211 // one.
212 ConstantInitBuilder builder(CGM);
213 auto elements = builder.beginStruct();
214
215 // reserved
216 elements.addInt(ulong, 0);
217
218 // Size
219 // FIXME: What is the right way to say this doesn't fit? We should give
220 // a user diagnostic in that case. Better fix would be to change the
221 // API to size_t.
222 elements.addInt(ulong, blockInfo.BlockSize.getQuantity());
223
224 // Optional copy/dispose helpers.
225 bool hasInternalHelper = false;
226 if (blockInfo.needsCopyDisposeHelpers()) {
227 // copy_func_helper_decl
228 llvm::Constant *copyHelper = buildCopyHelper(CGM, blockInfo);
229 elements.add(copyHelper);
230
231 // destroy_func_decl
232 llvm::Constant *disposeHelper = buildDisposeHelper(CGM, blockInfo);
233 elements.add(disposeHelper);
234
235 if (cast<llvm::Function>(copyHelper->getOperand(0))->hasInternalLinkage() ||
236 cast<llvm::Function>(disposeHelper->getOperand(0))
237 ->hasInternalLinkage())
238 hasInternalHelper = true;
239 }
240
241 // Signature. Mandatory ObjC-style method descriptor @encode sequence.
242 std::string typeAtEncoding =
243 CGM.getContext().getObjCEncodingForBlock(blockInfo.getBlockExpr());
244 elements.add(llvm::ConstantExpr::getBitCast(
245 CGM.GetAddrOfConstantCString(typeAtEncoding).getPointer(), i8p));
246
247 // GC layout.
248 if (C.getLangOpts().ObjC) {
249 if (CGM.getLangOpts().getGC() != LangOptions::NonGC)
250 elements.add(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo));
251 else
252 elements.add(CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo));
253 }
254 else
255 elements.addNullPointer(i8p);
256
257 unsigned AddrSpace = 0;
258 if (C.getLangOpts().OpenCL)
259 AddrSpace = C.getTargetAddressSpace(LangAS::opencl_constant);
260
261 llvm::GlobalValue::LinkageTypes linkage;
262 if (descName.empty()) {
263 linkage = llvm::GlobalValue::InternalLinkage;
264 descName = "__block_descriptor_tmp";
265 } else if (hasInternalHelper) {
266 // If either the copy helper or the dispose helper has internal linkage,
267 // the block descriptor must have internal linkage too.
268 linkage = llvm::GlobalValue::InternalLinkage;
269 } else {
270 linkage = llvm::GlobalValue::LinkOnceODRLinkage;
271 }
272
273 llvm::GlobalVariable *global =
274 elements.finishAndCreateGlobal(descName, CGM.getPointerAlign(),
275 /*constant*/ true, linkage, AddrSpace);
276
277 if (linkage == llvm::GlobalValue::LinkOnceODRLinkage) {
278 if (CGM.supportsCOMDAT())
279 global->setComdat(CGM.getModule().getOrInsertComdat(descName));
280 global->setVisibility(llvm::GlobalValue::HiddenVisibility);
281 global->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
282 }
283
284 return llvm::ConstantExpr::getBitCast(global, CGM.getBlockDescriptorType());
285}
286
287/*
288 Purely notional variadic template describing the layout of a block.
289
290 template <class _ResultType, class... _ParamTypes, class... _CaptureTypes>
291 struct Block_literal {
292 /// Initialized to one of:
293 /// extern void *_NSConcreteStackBlock[];
294 /// extern void *_NSConcreteGlobalBlock[];
295 ///
296 /// In theory, we could start one off malloc'ed by setting
297 /// BLOCK_NEEDS_FREE, giving it a refcount of 1, and using
298 /// this isa:
299 /// extern void *_NSConcreteMallocBlock[];
300 struct objc_class *isa;
301
302 /// These are the flags (with corresponding bit number) that the
303 /// compiler is actually supposed to know about.
304 /// 23. BLOCK_IS_NOESCAPE - indicates that the block is non-escaping
305 /// 25. BLOCK_HAS_COPY_DISPOSE - indicates that the block
306 /// descriptor provides copy and dispose helper functions
307 /// 26. BLOCK_HAS_CXX_OBJ - indicates that there's a captured
308 /// object with a nontrivial destructor or copy constructor
309 /// 28. BLOCK_IS_GLOBAL - indicates that the block is allocated
310 /// as global memory
311 /// 29. BLOCK_USE_STRET - indicates that the block function
312 /// uses stret, which objc_msgSend needs to know about
313 /// 30. BLOCK_HAS_SIGNATURE - indicates that the block has an
314 /// @encoded signature string
315 /// And we're not supposed to manipulate these:
316 /// 24. BLOCK_NEEDS_FREE - indicates that the block has been moved
317 /// to malloc'ed memory
318 /// 27. BLOCK_IS_GC - indicates that the block has been moved to
319 /// to GC-allocated memory
320 /// Additionally, the bottom 16 bits are a reference count which
321 /// should be zero on the stack.
322 int flags;
323
324 /// Reserved; should be zero-initialized.
325 int reserved;
326
327 /// Function pointer generated from block literal.
328 _ResultType (*invoke)(Block_literal *, _ParamTypes...);
329
330 /// Block description metadata generated from block literal.
331 struct Block_descriptor *block_descriptor;
332
333 /// Captured values follow.
334 _CapturesTypes captures...;
335 };
336 */
337
338namespace {
339 /// A chunk of data that we actually have to capture in the block.
340 struct BlockLayoutChunk {
341 CharUnits Alignment;
342 CharUnits Size;
343 Qualifiers::ObjCLifetime Lifetime;
344 const BlockDecl::Capture *Capture; // null for 'this'
345 llvm::Type *Type;
346 QualType FieldType;
347
348 BlockLayoutChunk(CharUnits align, CharUnits size,
349 Qualifiers::ObjCLifetime lifetime,
350 const BlockDecl::Capture *capture,
351 llvm::Type *type, QualType fieldType)
352 : Alignment(align), Size(size), Lifetime(lifetime),
353 Capture(capture), Type(type), FieldType(fieldType) {}
354
355 /// Tell the block info that this chunk has the given field index.
356 void setIndex(CGBlockInfo &info, unsigned index, CharUnits offset) {
357 if (!Capture) {
358 info.CXXThisIndex = index;
359 info.CXXThisOffset = offset;
360 } else {
361 auto C = CGBlockInfo::Capture::makeIndex(index, offset, FieldType);
362 info.Captures.insert({Capture->getVariable(), C});
363 }
364 }
365 };
366
367 /// Order by 1) all __strong together 2) next, all byfref together 3) next,
368 /// all __weak together. Preserve descending alignment in all situations.
369 bool operator<(const BlockLayoutChunk &left, const BlockLayoutChunk &right) {
370 if (left.Alignment != right.Alignment)
371 return left.Alignment > right.Alignment;
372
373 auto getPrefOrder = [](const BlockLayoutChunk &chunk) {
374 if (chunk.Capture && chunk.Capture->isByRef())
375 return 1;
376 if (chunk.Lifetime == Qualifiers::OCL_Strong)
377 return 0;
378 if (chunk.Lifetime == Qualifiers::OCL_Weak)
379 return 2;
380 return 3;
381 };
382
383 return getPrefOrder(left) < getPrefOrder(right);
384 }
385} // end anonymous namespace
386
387/// Determines if the given type is safe for constant capture in C++.
388static bool isSafeForCXXConstantCapture(QualType type) {
389 const RecordType *recordType =
390 type->getBaseElementTypeUnsafe()->getAs<RecordType>();
391
392 // Only records can be unsafe.
393 if (!recordType) return true;
394
395 const auto *record = cast<CXXRecordDecl>(recordType->getDecl());
396
397 // Maintain semantics for classes with non-trivial dtors or copy ctors.
398 if (!record->hasTrivialDestructor()) return false;
399 if (record->hasNonTrivialCopyConstructor()) return false;
400
401 // Otherwise, we just have to make sure there aren't any mutable
402 // fields that might have changed since initialization.
403 return !record->hasMutableFields();
404}
405
406/// It is illegal to modify a const object after initialization.
407/// Therefore, if a const object has a constant initializer, we don't
408/// actually need to keep storage for it in the block; we'll just
409/// rematerialize it at the start of the block function. This is
410/// acceptable because we make no promises about address stability of
411/// captured variables.
412static llvm::Constant *tryCaptureAsConstant(CodeGenModule &CGM,
413 CodeGenFunction *CGF,
414 const VarDecl *var) {
415 // Return if this is a function parameter. We shouldn't try to
416 // rematerialize default arguments of function parameters.
417 if (isa<ParmVarDecl>(var))
418 return nullptr;
419
420 QualType type = var->getType();
421
422 // We can only do this if the variable is const.
423 if (!type.isConstQualified()) return nullptr;
424
425 // Furthermore, in C++ we have to worry about mutable fields:
426 // C++ [dcl.type.cv]p4:
427 // Except that any class member declared mutable can be
428 // modified, any attempt to modify a const object during its
429 // lifetime results in undefined behavior.
430 if (CGM.getLangOpts().CPlusPlus && !isSafeForCXXConstantCapture(type))
431 return nullptr;
432
433 // If the variable doesn't have any initializer (shouldn't this be
434 // invalid?), it's not clear what we should do. Maybe capture as
435 // zero?
436 const Expr *init = var->getInit();
437 if (!init) return nullptr;
438
439 return ConstantEmitter(CGM, CGF).tryEmitAbstractForInitializer(*var);
440}
441
442/// Get the low bit of a nonzero character count. This is the
443/// alignment of the nth byte if the 0th byte is universally aligned.
444static CharUnits getLowBit(CharUnits v) {
445 return CharUnits::fromQuantity(v.getQuantity() & (~v.getQuantity() + 1));
446}
447
448static void initializeForBlockHeader(CodeGenModule &CGM, CGBlockInfo &info,
449 SmallVectorImpl<llvm::Type*> &elementTypes) {
450
451 assert(elementTypes.empty());
452 if (CGM.getLangOpts().OpenCL) {
453 // The header is basically 'struct { int; int; generic void *;
454 // custom_fields; }'. Assert that struct is packed.
455 auto GenericAS =
456 CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic);
457 auto GenPtrAlign =
458 CharUnits::fromQuantity(CGM.getTarget().getPointerAlign(GenericAS) / 8);
459 auto GenPtrSize =
460 CharUnits::fromQuantity(CGM.getTarget().getPointerWidth(GenericAS) / 8);
461 assert(CGM.getIntSize() <= GenPtrSize);
462 assert(CGM.getIntAlign() <= GenPtrAlign);
463 assert((2 * CGM.getIntSize()).isMultipleOf(GenPtrAlign));
464 elementTypes.push_back(CGM.IntTy); /* total size */
465 elementTypes.push_back(CGM.IntTy); /* align */
466 elementTypes.push_back(
467 CGM.getOpenCLRuntime()
468 .getGenericVoidPointerType()); /* invoke function */
469 unsigned Offset =
470 2 * CGM.getIntSize().getQuantity() + GenPtrSize.getQuantity();
471 unsigned BlockAlign = GenPtrAlign.getQuantity();
472 if (auto *Helper =
473 CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) {
474 for (auto I : Helper->getCustomFieldTypes()) /* custom fields */ {
475 // TargetOpenCLBlockHelp needs to make sure the struct is packed.
476 // If necessary, add padding fields to the custom fields.
477 unsigned Align = CGM.getDataLayout().getABITypeAlignment(I);
478 if (BlockAlign < Align)
479 BlockAlign = Align;
480 assert(Offset % Align == 0);
481 Offset += CGM.getDataLayout().getTypeAllocSize(I);
482 elementTypes.push_back(I);
483 }
484 }
485 info.BlockAlign = CharUnits::fromQuantity(BlockAlign);
486 info.BlockSize = CharUnits::fromQuantity(Offset);
487 } else {
488 // The header is basically 'struct { void *; int; int; void *; void *; }'.
489 // Assert that the struct is packed.
490 assert(CGM.getIntSize() <= CGM.getPointerSize());
491 assert(CGM.getIntAlign() <= CGM.getPointerAlign());
492 assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign()));
493 info.BlockAlign = CGM.getPointerAlign();
494 info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize();
495 elementTypes.push_back(CGM.VoidPtrTy);
496 elementTypes.push_back(CGM.IntTy);
497 elementTypes.push_back(CGM.IntTy);
498 elementTypes.push_back(CGM.VoidPtrTy);
499 elementTypes.push_back(CGM.getBlockDescriptorType());
500 }
501}
502
503static QualType getCaptureFieldType(const CodeGenFunction &CGF,
504 const BlockDecl::Capture &CI) {
505 const VarDecl *VD = CI.getVariable();
506
507 // If the variable is captured by an enclosing block or lambda expression,
508 // use the type of the capture field.
509 if (CGF.BlockInfo && CI.isNested())
510 return CGF.BlockInfo->getCapture(VD).fieldType();
511 if (auto *FD = CGF.LambdaCaptureFields.lookup(VD))
512 return FD->getType();
513 // If the captured variable is a non-escaping __block variable, the field
514 // type is the reference type. If the variable is a __block variable that
515 // already has a reference type, the field type is the variable's type.
516 return VD->isNonEscapingByref() ?
517 CGF.getContext().getLValueReferenceType(VD->getType()) : VD->getType();
518}
519
520/// Compute the layout of the given block. Attempts to lay the block
521/// out with minimal space requirements.
522static void computeBlockInfo(CodeGenModule &CGM, CodeGenFunction *CGF,
523 CGBlockInfo &info) {
524 ASTContext &C = CGM.getContext();
525 const BlockDecl *block = info.getBlockDecl();
526
527 SmallVector<llvm::Type*, 8> elementTypes;
528 initializeForBlockHeader(CGM, info, elementTypes);
529 bool hasNonConstantCustomFields = false;
530 if (auto *OpenCLHelper =
531 CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper())
532 hasNonConstantCustomFields =
533 !OpenCLHelper->areAllCustomFieldValuesConstant(info);
534 if (!block->hasCaptures() && !hasNonConstantCustomFields) {
535 info.StructureType =
536 llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
537 info.CanBeGlobal = true;
538 return;
539 }
540 else if (C.getLangOpts().ObjC &&
541 CGM.getLangOpts().getGC() == LangOptions::NonGC)
542 info.HasCapturedVariableLayout = true;
543
544 // Collect the layout chunks.
545 SmallVector<BlockLayoutChunk, 16> layout;
546 layout.reserve(block->capturesCXXThis() +
547 (block->capture_end() - block->capture_begin()));
548
549 CharUnits maxFieldAlign;
550
551 // First, 'this'.
552 if (block->capturesCXXThis()) {
553 assert(CGF && CGF->CurFuncDecl && isa<CXXMethodDecl>(CGF->CurFuncDecl) &&
554 "Can't capture 'this' outside a method");
555 QualType thisType = cast<CXXMethodDecl>(CGF->CurFuncDecl)->getThisType();
556
557 // Theoretically, this could be in a different address space, so
558 // don't assume standard pointer size/align.
559 llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType);
560 auto TInfo = CGM.getContext().getTypeInfoInChars(thisType);
561 maxFieldAlign = std::max(maxFieldAlign, TInfo.Align);
562
563 layout.push_back(BlockLayoutChunk(TInfo.Align, TInfo.Width,
564 Qualifiers::OCL_None,
565 nullptr, llvmType, thisType));
566 }
567
568 // Next, all the block captures.
569 for (const auto &CI : block->captures()) {
570 const VarDecl *variable = CI.getVariable();
571
572 if (CI.isEscapingByref()) {
573 // We have to copy/dispose of the __block reference.
574 info.NeedsCopyDispose = true;
575
576 // Just use void* instead of a pointer to the byref type.
577 CharUnits align = CGM.getPointerAlign();
578 maxFieldAlign = std::max(maxFieldAlign, align);
579
580 // Since a __block variable cannot be captured by lambdas, its type and
581 // the capture field type should always match.
582 assert(CGF && getCaptureFieldType(*CGF, CI) == variable->getType() &&
583 "capture type differs from the variable type");
584 layout.push_back(BlockLayoutChunk(align, CGM.getPointerSize(),
585 Qualifiers::OCL_None, &CI,
586 CGM.VoidPtrTy, variable->getType()));
587 continue;
588 }
589
590 // Otherwise, build a layout chunk with the size and alignment of
591 // the declaration.
592 if (llvm::Constant *constant = tryCaptureAsConstant(CGM, CGF, variable)) {
593 info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant);
594 continue;
595 }
596
597 QualType VT = getCaptureFieldType(*CGF, CI);
598
599 // If we have a lifetime qualifier, honor it for capture purposes.
600 // That includes *not* copying it if it's __unsafe_unretained.
601 Qualifiers::ObjCLifetime lifetime = VT.getObjCLifetime();
602 if (lifetime) {
603 switch (lifetime) {
604 case Qualifiers::OCL_None: llvm_unreachable("impossible");
605 case Qualifiers::OCL_ExplicitNone:
606 case Qualifiers::OCL_Autoreleasing:
607 break;
608
609 case Qualifiers::OCL_Strong:
610 case Qualifiers::OCL_Weak:
611 info.NeedsCopyDispose = true;
612 }
613
614 // Block pointers require copy/dispose. So do Objective-C pointers.
615 } else if (VT->isObjCRetainableType()) {
616 // But honor the inert __unsafe_unretained qualifier, which doesn't
617 // actually make it into the type system.
618 if (VT->isObjCInertUnsafeUnretainedType()) {
619 lifetime = Qualifiers::OCL_ExplicitNone;
620 } else {
621 info.NeedsCopyDispose = true;
622 // used for mrr below.
623 lifetime = Qualifiers::OCL_Strong;
624 }
625
626 // So do types that require non-trivial copy construction.
627 } else if (CI.hasCopyExpr()) {
628 info.NeedsCopyDispose = true;
629 info.HasCXXObject = true;
630 if (!VT->getAsCXXRecordDecl()->isExternallyVisible())
631 info.CapturesNonExternalType = true;
632
633 // So do C structs that require non-trivial copy construction or
634 // destruction.
635 } else if (VT.isNonTrivialToPrimitiveCopy() == QualType::PCK_Struct ||
636 VT.isDestructedType() == QualType::DK_nontrivial_c_struct) {
637 info.NeedsCopyDispose = true;
638
639 // And so do types with destructors.
640 } else if (CGM.getLangOpts().CPlusPlus) {
641 if (const CXXRecordDecl *record = VT->getAsCXXRecordDecl()) {
642 if (!record->hasTrivialDestructor()) {
643 info.HasCXXObject = true;
644 info.NeedsCopyDispose = true;
645 if (!record->isExternallyVisible())
646 info.CapturesNonExternalType = true;
647 }
648 }
649 }
650
651 CharUnits size = C.getTypeSizeInChars(VT);
652 CharUnits align = C.getDeclAlign(variable);
653
654 maxFieldAlign = std::max(maxFieldAlign, align);
655
656 llvm::Type *llvmType =
657 CGM.getTypes().ConvertTypeForMem(VT);
658
659 layout.push_back(
660 BlockLayoutChunk(align, size, lifetime, &CI, llvmType, VT));
661 }
662
663 // If that was everything, we're done here.
664 if (layout.empty()) {
665 info.StructureType =
666 llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
667 info.CanBeGlobal = true;
668 return;
669 }
670
671 // Sort the layout by alignment. We have to use a stable sort here
672 // to get reproducible results. There should probably be an
673 // llvm::array_pod_stable_sort.
674 llvm::stable_sort(layout);
675
676 // Needed for blocks layout info.
677 info.BlockHeaderForcedGapOffset = info.BlockSize;
678 info.BlockHeaderForcedGapSize = CharUnits::Zero();
679
680 CharUnits &blockSize = info.BlockSize;
681 info.BlockAlign = std::max(maxFieldAlign, info.BlockAlign);
682
683 // Assuming that the first byte in the header is maximally aligned,
684 // get the alignment of the first byte following the header.
685 CharUnits endAlign = getLowBit(blockSize);
686
687 // If the end of the header isn't satisfactorily aligned for the
688 // maximum thing, look for things that are okay with the header-end
689 // alignment, and keep appending them until we get something that's
690 // aligned right. This algorithm is only guaranteed optimal if
691 // that condition is satisfied at some point; otherwise we can get
692 // things like:
693 // header // next byte has alignment 4
694 // something_with_size_5; // next byte has alignment 1
695 // something_with_alignment_8;
696 // which has 7 bytes of padding, as opposed to the naive solution
697 // which might have less (?).
698 if (endAlign < maxFieldAlign) {
699 SmallVectorImpl<BlockLayoutChunk>::iterator
700 li = layout.begin() + 1, le = layout.end();
701
702 // Look for something that the header end is already
703 // satisfactorily aligned for.
704 for (; li != le && endAlign < li->Alignment; ++li)
705 ;
706
707 // If we found something that's naturally aligned for the end of
708 // the header, keep adding things...
709 if (li != le) {
710 SmallVectorImpl<BlockLayoutChunk>::iterator first = li;
711 for (; li != le; ++li) {
712 assert(endAlign >= li->Alignment);
713
714 li->setIndex(info, elementTypes.size(), blockSize);
715 elementTypes.push_back(li->Type);
716 blockSize += li->Size;
717 endAlign = getLowBit(blockSize);
718
719 // ...until we get to the alignment of the maximum field.
720 if (endAlign >= maxFieldAlign) {
721 break;
722 }
723 }
724 // Don't re-append everything we just appended.
725 layout.erase(first, li);
726 }
727 }
728
729 assert(endAlign == getLowBit(blockSize));
730
731 // At this point, we just have to add padding if the end align still
732 // isn't aligned right.
733 if (endAlign < maxFieldAlign) {
734 CharUnits newBlockSize = blockSize.alignTo(maxFieldAlign);
735 CharUnits padding = newBlockSize - blockSize;
736
737 // If we haven't yet added any fields, remember that there was an
738 // initial gap; this need to go into the block layout bit map.
739 if (blockSize == info.BlockHeaderForcedGapOffset) {
740 info.BlockHeaderForcedGapSize = padding;
741 }
742
743 elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty,
744 padding.getQuantity()));
745 blockSize = newBlockSize;
746 endAlign = getLowBit(blockSize); // might be > maxFieldAlign
747 }
748
749 assert(endAlign >= maxFieldAlign);
750 assert(endAlign == getLowBit(blockSize));
751 // Slam everything else on now. This works because they have
752 // strictly decreasing alignment and we expect that size is always a
753 // multiple of alignment.
754 for (SmallVectorImpl<BlockLayoutChunk>::iterator
755 li = layout.begin(), le = layout.end(); li != le; ++li) {
756 if (endAlign < li->Alignment) {
757 // size may not be multiple of alignment. This can only happen with
758 // an over-aligned variable. We will be adding a padding field to
759 // make the size be multiple of alignment.
760 CharUnits padding = li->Alignment - endAlign;
761 elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty,
762 padding.getQuantity()));
763 blockSize += padding;
764 endAlign = getLowBit(blockSize);
765 }
766 assert(endAlign >= li->Alignment);
767 li->setIndex(info, elementTypes.size(), blockSize);
768 elementTypes.push_back(li->Type);
769 blockSize += li->Size;
770 endAlign = getLowBit(blockSize);
771 }
772
773 info.StructureType =
774 llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
775}
776
777/// Emit a block literal expression in the current function.
778llvm::Value *CodeGenFunction::EmitBlockLiteral(const BlockExpr *blockExpr) {
779 // If the block has no captures, we won't have a pre-computed
780 // layout for it.
781 if (!blockExpr->getBlockDecl()->hasCaptures())
782 // The block literal is emitted as a global variable, and the block invoke
783 // function has to be extracted from its initializer.
784 if (llvm::Constant *Block = CGM.getAddrOfGlobalBlockIfEmitted(blockExpr))
785 return Block;
786
787 CGBlockInfo blockInfo(blockExpr->getBlockDecl(), CurFn->getName());
788 computeBlockInfo(CGM, this, blockInfo);
789 blockInfo.BlockExpression = blockExpr;
790 if (!blockInfo.CanBeGlobal)
791 blockInfo.LocalAddress = CreateTempAlloca(blockInfo.StructureType,
792 blockInfo.BlockAlign, "block");
793 return EmitBlockLiteral(blockInfo);
794}
795
796llvm::Value *CodeGenFunction::EmitBlockLiteral(const CGBlockInfo &blockInfo) {
797 bool IsOpenCL = CGM.getContext().getLangOpts().OpenCL;
798 auto GenVoidPtrTy =
799 IsOpenCL ? CGM.getOpenCLRuntime().getGenericVoidPointerType() : VoidPtrTy;
800 LangAS GenVoidPtrAddr = IsOpenCL ? LangAS::opencl_generic : LangAS::Default;
801 auto GenVoidPtrSize = CharUnits::fromQuantity(
802 CGM.getTarget().getPointerWidth(
803 CGM.getContext().getTargetAddressSpace(GenVoidPtrAddr)) /
804 8);
805 // Using the computed layout, generate the actual block function.
806 bool isLambdaConv = blockInfo.getBlockDecl()->isConversionFromLambda();
807 CodeGenFunction BlockCGF{CGM, true};
808 BlockCGF.SanOpts = SanOpts;
809 auto *InvokeFn = BlockCGF.GenerateBlockFunction(
810 CurGD, blockInfo, LocalDeclMap, isLambdaConv, blockInfo.CanBeGlobal);
811 auto *blockFn = llvm::ConstantExpr::getPointerCast(InvokeFn, GenVoidPtrTy);
812
813 // If there is nothing to capture, we can emit this as a global block.
814 if (blockInfo.CanBeGlobal)
815 return CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression);
816
817 // Otherwise, we have to emit this as a local block.
818
819 Address blockAddr = blockInfo.LocalAddress;
820 assert(blockAddr.isValid() && "block has no address!");
821
822 llvm::Constant *isa;
823 llvm::Constant *descriptor;
824 BlockFlags flags;
825 if (!IsOpenCL) {
826 // If the block is non-escaping, set field 'isa 'to NSConcreteGlobalBlock
827 // and set the BLOCK_IS_GLOBAL bit of field 'flags'. Copying a non-escaping
828 // block just returns the original block and releasing it is a no-op.
829 llvm::Constant *blockISA = blockInfo.getBlockDecl()->doesNotEscape()
830 ? CGM.getNSConcreteGlobalBlock()
831 : CGM.getNSConcreteStackBlock();
832 isa = llvm::ConstantExpr::getBitCast(blockISA, VoidPtrTy);
833
834 // Build the block descriptor.
835 descriptor = buildBlockDescriptor(CGM, blockInfo);
836
837 // Compute the initial on-stack block flags.
838 flags = BLOCK_HAS_SIGNATURE;
839 if (blockInfo.HasCapturedVariableLayout)
840 flags |= BLOCK_HAS_EXTENDED_LAYOUT;
841 if (blockInfo.needsCopyDisposeHelpers())
842 flags |= BLOCK_HAS_COPY_DISPOSE;
843 if (blockInfo.HasCXXObject)
844 flags |= BLOCK_HAS_CXX_OBJ;
845 if (blockInfo.UsesStret)
846 flags |= BLOCK_USE_STRET;
847 if (blockInfo.getBlockDecl()->doesNotEscape())
848 flags |= BLOCK_IS_NOESCAPE | BLOCK_IS_GLOBAL;
849 }
850
851 auto projectField = [&](unsigned index, const Twine &name) -> Address {
852 return Builder.CreateStructGEP(blockAddr, index, name);
853 };
854 auto storeField = [&](llvm::Value *value, unsigned index, const Twine &name) {
855 Builder.CreateStore(value, projectField(index, name));
856 };
857
858 // Initialize the block header.
859 {
860 // We assume all the header fields are densely packed.
861 unsigned index = 0;
862 CharUnits offset;
863 auto addHeaderField = [&](llvm::Value *value, CharUnits size,
864 const Twine &name) {
865 storeField(value, index, name);
866 offset += size;
867 index++;
868 };
869
870 if (!IsOpenCL) {
871 addHeaderField(isa, getPointerSize(), "block.isa");
872 addHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()),
873 getIntSize(), "block.flags");
874 addHeaderField(llvm::ConstantInt::get(IntTy, 0), getIntSize(),
875 "block.reserved");
876 } else {
877 addHeaderField(
878 llvm::ConstantInt::get(IntTy, blockInfo.BlockSize.getQuantity()),
879 getIntSize(), "block.size");
880 addHeaderField(
881 llvm::ConstantInt::get(IntTy, blockInfo.BlockAlign.getQuantity()),
882 getIntSize(), "block.align");
883 }
884 addHeaderField(blockFn, GenVoidPtrSize, "block.invoke");
885 if (!IsOpenCL)
886 addHeaderField(descriptor, getPointerSize(), "block.descriptor");
887 else if (auto *Helper =
888 CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) {
889 for (auto I : Helper->getCustomFieldValues(*this, blockInfo)) {
890 addHeaderField(
891 I.first,
892 CharUnits::fromQuantity(
893 CGM.getDataLayout().getTypeAllocSize(I.first->getType())),
894 I.second);
895 }
896 }
897 }
898
899 // Finally, capture all the values into the block.
900 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
901
902 // First, 'this'.
903 if (blockDecl->capturesCXXThis()) {
904 Address addr =
905 projectField(blockInfo.CXXThisIndex, "block.captured-this.addr");
906 Builder.CreateStore(LoadCXXThis(), addr);
907 }
908
909 // Next, captured variables.
910 for (const auto &CI : blockDecl->captures()) {
911 const VarDecl *variable = CI.getVariable();
912 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
913
914 // Ignore constant captures.
915 if (capture.isConstant()) continue;
916
917 QualType type = capture.fieldType();
918
919 // This will be a [[type]]*, except that a byref entry will just be
920 // an i8**.
921 Address blockField = projectField(capture.getIndex(), "block.captured");
922
923 // Compute the address of the thing we're going to move into the
924 // block literal.
925 Address src = Address::invalid();
926
927 if (blockDecl->isConversionFromLambda()) {
928 // The lambda capture in a lambda's conversion-to-block-pointer is
929 // special; we'll simply emit it directly.
930 src = Address::invalid();
931 } else if (CI.isEscapingByref()) {
932 if (BlockInfo && CI.isNested()) {
933 // We need to use the capture from the enclosing block.
934 const CGBlockInfo::Capture &enclosingCapture =
935 BlockInfo->getCapture(variable);
936
937 // This is a [[type]]*, except that a byref entry will just be an i8**.
938 src = Builder.CreateStructGEP(LoadBlockStruct(),
939 enclosingCapture.getIndex(),
940 "block.capture.addr");
941 } else {
942 auto I = LocalDeclMap.find(variable);
943 assert(I != LocalDeclMap.end());
944 src = I->second;
945 }
946 } else {
947 DeclRefExpr declRef(getContext(), const_cast<VarDecl *>(variable),
948 /*RefersToEnclosingVariableOrCapture*/ CI.isNested(),
949 type.getNonReferenceType(), VK_LValue,
950 SourceLocation());
951 src = EmitDeclRefLValue(&declRef).getAddress(*this);
952 };
953
954 // For byrefs, we just write the pointer to the byref struct into
955 // the block field. There's no need to chase the forwarding
956 // pointer at this point, since we're building something that will
957 // live a shorter life than the stack byref anyway.
958 if (CI.isEscapingByref()) {
959 // Get a void* that points to the byref struct.
960 llvm::Value *byrefPointer;
961 if (CI.isNested())
962 byrefPointer = Builder.CreateLoad(src, "byref.capture");
963 else
964 byrefPointer = Builder.CreateBitCast(src.getPointer(), VoidPtrTy);
965
966 // Write that void* into the capture field.
967 Builder.CreateStore(byrefPointer, blockField);
968
969 // If we have a copy constructor, evaluate that into the block field.
970 } else if (const Expr *copyExpr = CI.getCopyExpr()) {
971 if (blockDecl->isConversionFromLambda()) {
972 // If we have a lambda conversion, emit the expression
973 // directly into the block instead.
974 AggValueSlot Slot =
975 AggValueSlot::forAddr(blockField, Qualifiers(),
976 AggValueSlot::IsDestructed,
977 AggValueSlot::DoesNotNeedGCBarriers,
978 AggValueSlot::IsNotAliased,
979 AggValueSlot::DoesNotOverlap);
980 EmitAggExpr(copyExpr, Slot);
981 } else {
982 EmitSynthesizedCXXCopyCtor(blockField, src, copyExpr);
983 }
984
985 // If it's a reference variable, copy the reference into the block field.
986 } else if (type->isReferenceType()) {
987 Builder.CreateStore(src.getPointer(), blockField);
988
989 // If type is const-qualified, copy the value into the block field.
990 } else if (type.isConstQualified() &&
991 type.getObjCLifetime() == Qualifiers::OCL_Strong &&
992 CGM.getCodeGenOpts().OptimizationLevel != 0) {
993 llvm::Value *value = Builder.CreateLoad(src, "captured");
994 Builder.CreateStore(value, blockField);
995
996 // If this is an ARC __strong block-pointer variable, don't do a
997 // block copy.
998 //
999 // TODO: this can be generalized into the normal initialization logic:
1000 // we should never need to do a block-copy when initializing a local
1001 // variable, because the local variable's lifetime should be strictly
1002 // contained within the stack block's.
1003 } else if (type.getObjCLifetime() == Qualifiers::OCL_Strong &&
1004 type->isBlockPointerType()) {
1005 // Load the block and do a simple retain.
1006 llvm::Value *value = Builder.CreateLoad(src, "block.captured_block");
1007 value = EmitARCRetainNonBlock(value);
1008
1009 // Do a primitive store to the block field.
1010 Builder.CreateStore(value, blockField);
1011
1012 // Otherwise, fake up a POD copy into the block field.
1013 } else {
1014 // Fake up a new variable so that EmitScalarInit doesn't think
1015 // we're referring to the variable in its own initializer.
1016 ImplicitParamDecl BlockFieldPseudoVar(getContext(), type,
1017 ImplicitParamDecl::Other);
1018
1019 // We use one of these or the other depending on whether the
1020 // reference is nested.
1021 DeclRefExpr declRef(getContext(), const_cast<VarDecl *>(variable),
1022 /*RefersToEnclosingVariableOrCapture*/ CI.isNested(),
1023 type, VK_LValue, SourceLocation());
1024
1025 ImplicitCastExpr l2r(ImplicitCastExpr::OnStack, type, CK_LValueToRValue,
1026 &declRef, VK_RValue, FPOptionsOverride());
1027 // FIXME: Pass a specific location for the expr init so that the store is
1028 // attributed to a reasonable location - otherwise it may be attributed to
1029 // locations of subexpressions in the initialization.
1030 EmitExprAsInit(&l2r, &BlockFieldPseudoVar,
1031 MakeAddrLValue(blockField, type, AlignmentSource::Decl),
1032 /*captured by init*/ false);
1033 }
1034
1035 // Push a cleanup for the capture if necessary.
1036 if (!blockInfo.NeedsCopyDispose)
1037 continue;
1038
1039 // Ignore __block captures; there's nothing special in the on-stack block
1040 // that we need to do for them.
1041 if (CI.isByRef())
1042 continue;
1043
1044 // Ignore objects that aren't destructed.
1045 QualType::DestructionKind dtorKind = type.isDestructedType();
1046 if (dtorKind == QualType::DK_none)
1047 continue;
1048
1049 CodeGenFunction::Destroyer *destroyer;
1050
1051 // Block captures count as local values and have imprecise semantics.
1052 // They also can't be arrays, so need to worry about that.
1053 //
1054 // For const-qualified captures, emit clang.arc.use to ensure the captured
1055 // object doesn't get released while we are still depending on its validity
1056 // within the block.
1057 if (type.isConstQualified() &&
1058 type.getObjCLifetime() == Qualifiers::OCL_Strong &&
1059 CGM.getCodeGenOpts().OptimizationLevel != 0) {
1060 assert(CGM.getLangOpts().ObjCAutoRefCount &&
1061 "expected ObjC ARC to be enabled");
1062 destroyer = emitARCIntrinsicUse;
1063 } else if (dtorKind == QualType::DK_objc_strong_lifetime) {
1064 destroyer = destroyARCStrongImprecise;
1065 } else {
1066 destroyer = getDestroyer(dtorKind);
1067 }
1068
1069 CleanupKind cleanupKind = NormalCleanup;
1070 bool useArrayEHCleanup = needsEHCleanup(dtorKind);
1071 if (useArrayEHCleanup)
1072 cleanupKind = NormalAndEHCleanup;
1073
1074 // Extend the lifetime of the capture to the end of the scope enclosing the
1075 // block expression except when the block decl is in the list of RetExpr's
1076 // cleanup objects, in which case its lifetime ends after the full
1077 // expression.
1078 auto IsBlockDeclInRetExpr = [&]() {
1079 auto *EWC = llvm::dyn_cast_or_null<ExprWithCleanups>(RetExpr);
1080 if (EWC)
1081 for (auto &C : EWC->getObjects())
1082 if (auto *BD = C.dyn_cast<BlockDecl *>())
1083 if (BD == blockDecl)
1084 return true;
1085 return false;
1086 };
1087
1088 if (IsBlockDeclInRetExpr())
1089 pushDestroy(cleanupKind, blockField, type, destroyer, useArrayEHCleanup);
1090 else
1091 pushLifetimeExtendedDestroy(cleanupKind, blockField, type, destroyer,
1092 useArrayEHCleanup);
1093 }
1094
1095 // Cast to the converted block-pointer type, which happens (somewhat
1096 // unfortunately) to be a pointer to function type.
1097 llvm::Value *result = Builder.CreatePointerCast(
1098 blockAddr.getPointer(), ConvertType(blockInfo.getBlockExpr()->getType()));
1099
1100 if (IsOpenCL) {
1101 CGM.getOpenCLRuntime().recordBlockInfo(blockInfo.BlockExpression, InvokeFn,
1102 result);
1103 }
1104
1105 return result;
1106}
1107
1108
1109llvm::Type *CodeGenModule::getBlockDescriptorType() {
1110 if (BlockDescriptorType)
1111 return BlockDescriptorType;
1112
1113 llvm::Type *UnsignedLongTy =
1114 getTypes().ConvertType(getContext().UnsignedLongTy);
1115
1116 // struct __block_descriptor {
1117 // unsigned long reserved;
1118 // unsigned long block_size;
1119 //
1120 // // later, the following will be added
1121 //
1122 // struct {
1123 // void (*copyHelper)();
1124 // void (*copyHelper)();
1125 // } helpers; // !!! optional
1126 //
1127 // const char *signature; // the block signature
1128 // const char *layout; // reserved
1129 // };
1130 BlockDescriptorType = llvm::StructType::create(
1131 "struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy);
1132
1133 // Now form a pointer to that.
1134 unsigned AddrSpace = 0;
1135 if (getLangOpts().OpenCL)
1136 AddrSpace = getContext().getTargetAddressSpace(LangAS::opencl_constant);
1137 BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace);
1138 return BlockDescriptorType;
1139}
1140
1141llvm::Type *CodeGenModule::getGenericBlockLiteralType() {
1142 if (GenericBlockLiteralType)
1143 return GenericBlockLiteralType;
1144
1145 llvm::Type *BlockDescPtrTy = getBlockDescriptorType();
1146
1147 if (getLangOpts().OpenCL) {
1148 // struct __opencl_block_literal_generic {
1149 // int __size;
1150 // int __align;
1151 // __generic void *__invoke;
1152 // /* custom fields */
1153 // };
1154 SmallVector<llvm::Type *, 8> StructFields(
1155 {IntTy, IntTy, getOpenCLRuntime().getGenericVoidPointerType()});
1156 if (auto *Helper = getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) {
1157 for (auto I : Helper->getCustomFieldTypes())
1158 StructFields.push_back(I);
1159 }
1160 GenericBlockLiteralType = llvm::StructType::create(
1161 StructFields, "struct.__opencl_block_literal_generic");
1162 } else {
1163 // struct __block_literal_generic {
1164 // void *__isa;
1165 // int __flags;
1166 // int __reserved;
1167 // void (*__invoke)(void *);
1168 // struct __block_descriptor *__descriptor;
1169 // };
1170 GenericBlockLiteralType =
1171 llvm::StructType::create("struct.__block_literal_generic", VoidPtrTy,
1172 IntTy, IntTy, VoidPtrTy, BlockDescPtrTy);
1173 }
1174
1175 return GenericBlockLiteralType;
1176}
1177
1178RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E,
1179 ReturnValueSlot ReturnValue) {
1180 const auto *BPT = E->getCallee()->getType()->castAs<BlockPointerType>();
1181 llvm::Value *BlockPtr = EmitScalarExpr(E->getCallee());
1182 llvm::Type *GenBlockTy = CGM.getGenericBlockLiteralType();
1183 llvm::Value *Func = nullptr;
1184 QualType FnType = BPT->getPointeeType();
1185 ASTContext &Ctx = getContext();
1186 CallArgList Args;
1187
1188 if (getLangOpts().OpenCL) {
1189 // For OpenCL, BlockPtr is already casted to generic block literal.
1190
1191 // First argument of a block call is a generic block literal casted to
1192 // generic void pointer, i.e. i8 addrspace(4)*
1193 llvm::Type *GenericVoidPtrTy =
1194 CGM.getOpenCLRuntime().getGenericVoidPointerType();
1195 llvm::Value *BlockDescriptor = Builder.CreatePointerCast(
1196 BlockPtr, GenericVoidPtrTy);
1197 QualType VoidPtrQualTy = Ctx.getPointerType(
1198 Ctx.getAddrSpaceQualType(Ctx.VoidTy, LangAS::opencl_generic));
1199 Args.add(RValue::get(BlockDescriptor), VoidPtrQualTy);
1200 // And the rest of the arguments.
1201 EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments());
1202
1203 // We *can* call the block directly unless it is a function argument.
1204 if (!isa<ParmVarDecl>(E->getCalleeDecl()))
1205 Func = CGM.getOpenCLRuntime().getInvokeFunction(E->getCallee());
1206 else {
1207 llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 2);
1208 Func = Builder.CreateAlignedLoad(GenericVoidPtrTy, FuncPtr,
1209 getPointerAlign());
1210 }
1211 } else {
1212 // Bitcast the block literal to a generic block literal.
1213 BlockPtr = Builder.CreatePointerCast(
1214 BlockPtr, llvm::PointerType::get(GenBlockTy, 0), "block.literal");
1215 // Get pointer to the block invoke function
1216 llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 3);
1217
1218 // First argument is a block literal casted to a void pointer
1219 BlockPtr = Builder.CreatePointerCast(BlockPtr, VoidPtrTy);
1220 Args.add(RValue::get(BlockPtr), Ctx.VoidPtrTy);
1221 // And the rest of the arguments.
1222 EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments());
1223
1224 // Load the function.
1225 Func = Builder.CreateAlignedLoad(VoidPtrTy, FuncPtr, getPointerAlign());
1226 }
1227
1228 const FunctionType *FuncTy = FnType->castAs<FunctionType>();
1229 const CGFunctionInfo &FnInfo =
1230 CGM.getTypes().arrangeBlockFunctionCall(Args, FuncTy);
1231
1232 // Cast the function pointer to the right type.
1233 llvm::Type *BlockFTy = CGM.getTypes().GetFunctionType(FnInfo);
1234
1235 llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy);
1236 Func = Builder.CreatePointerCast(Func, BlockFTyPtr);
1237
1238 // Prepare the callee.
1239 CGCallee Callee(CGCalleeInfo(), Func);
1240
1241 // And call the block.
1242 return EmitCall(FnInfo, Callee, ReturnValue, Args);
1243}
1244
1245Address CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable) {
1246 assert(BlockInfo && "evaluating block ref without block information?");
1247 const CGBlockInfo::Capture &capture = BlockInfo->getCapture(variable);
1248
1249 // Handle constant captures.
1250 if (capture.isConstant()) return LocalDeclMap.find(variable)->second;
1251
1252 Address addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(),
1253 "block.capture.addr");
1254
1255 if (variable->isEscapingByref()) {
1256 // addr should be a void** right now. Load, then cast the result
1257 // to byref*.
1258
1259 auto &byrefInfo = getBlockByrefInfo(variable);
1260 addr = Address(Builder.CreateLoad(addr), byrefInfo.ByrefAlignment);
1261
1262 auto byrefPointerType = llvm::PointerType::get(byrefInfo.Type, 0);
1263 addr = Builder.CreateBitCast(addr, byrefPointerType, "byref.addr");
1264
1265 addr = emitBlockByrefAddress(addr, byrefInfo, /*follow*/ true,
1266 variable->getName());
1267 }
1268
1269 assert((!variable->isNonEscapingByref() ||
1270 capture.fieldType()->isReferenceType()) &&
1271 "the capture field of a non-escaping variable should have a "
1272 "reference type");
1273 if (capture.fieldType()->isReferenceType())
1274 addr = EmitLoadOfReference(MakeAddrLValue(addr, capture.fieldType()));
1275
1276 return addr;
1277}
1278
1279void CodeGenModule::setAddrOfGlobalBlock(const BlockExpr *BE,
1280 llvm::Constant *Addr) {
1281 bool Ok = EmittedGlobalBlocks.insert(std::make_pair(BE, Addr)).second;
1282 (void)Ok;
1283 assert(Ok && "Trying to replace an already-existing global block!");
1284}
1285
1286llvm::Constant *
1287CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *BE,
1288 StringRef Name) {
1289 if (llvm::Constant *Block = getAddrOfGlobalBlockIfEmitted(BE))
1290 return Block;
1291
1292 CGBlockInfo blockInfo(BE->getBlockDecl(), Name);
1293 blockInfo.BlockExpression = BE;
1294
1295 // Compute information about the layout, etc., of this block.
1296 computeBlockInfo(*this, nullptr, blockInfo);
1297
1298 // Using that metadata, generate the actual block function.
1299 {
1300 CodeGenFunction::DeclMapTy LocalDeclMap;
1301 CodeGenFunction(*this).GenerateBlockFunction(
1302 GlobalDecl(), blockInfo, LocalDeclMap,
1303 /*IsLambdaConversionToBlock*/ false, /*BuildGlobalBlock*/ true);
1304 }
1305
1306 return getAddrOfGlobalBlockIfEmitted(BE);
1307}
1308
1309static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM,
1310 const CGBlockInfo &blockInfo,
1311 llvm::Constant *blockFn) {
1312 assert(blockInfo.CanBeGlobal);
1313 // Callers should detect this case on their own: calling this function
1314 // generally requires computing layout information, which is a waste of time
1315 // if we've already emitted this block.
1316 assert(!CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression) &&
1317 "Refusing to re-emit a global block.");
1318
1319 // Generate the constants for the block literal initializer.
1320 ConstantInitBuilder builder(CGM);
1321 auto fields = builder.beginStruct();
1322
1323 bool IsOpenCL = CGM.getLangOpts().OpenCL;
1324 bool IsWindows = CGM.getTarget().getTriple().isOSWindows();
1325 if (!IsOpenCL) {
1326 // isa
1327 if (IsWindows)
1328 fields.addNullPointer(CGM.Int8PtrPtrTy);
1329 else
1330 fields.add(CGM.getNSConcreteGlobalBlock());
1331
1332 // __flags
1333 BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE;
1334 if (blockInfo.UsesStret)
1335 flags |= BLOCK_USE_STRET;
1336
1337 fields.addInt(CGM.IntTy, flags.getBitMask());
1338
1339 // Reserved
1340 fields.addInt(CGM.IntTy, 0);
1341 } else {
1342 fields.addInt(CGM.IntTy, blockInfo.BlockSize.getQuantity());
1343 fields.addInt(CGM.IntTy, blockInfo.BlockAlign.getQuantity());
1344 }
1345
1346 // Function
1347 fields.add(blockFn);
1348
1349 if (!IsOpenCL) {
1350 // Descriptor
1351 fields.add(buildBlockDescriptor(CGM, blockInfo));
1352 } else if (auto *Helper =
1353 CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) {
1354 for (auto I : Helper->getCustomFieldValues(CGM, blockInfo)) {
1355 fields.add(I);
1356 }
1357 }
1358
1359 unsigned AddrSpace = 0;
1360 if (CGM.getContext().getLangOpts().OpenCL)
1361 AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_global);
1362
1363 llvm::GlobalVariable *literal = fields.finishAndCreateGlobal(
1364 "__block_literal_global", blockInfo.BlockAlign,
1365 /*constant*/ !IsWindows, llvm::GlobalVariable::InternalLinkage, AddrSpace);
1366
1367 literal->addAttribute("objc_arc_inert");
1368
1369 // Windows does not allow globals to be initialised to point to globals in
1370 // different DLLs. Any such variables must run code to initialise them.
1371 if (IsWindows) {
1372 auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
1373 {}), llvm::GlobalValue::InternalLinkage, ".block_isa_init",
1374 &CGM.getModule());
1375 llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry",
1376 Init));
1377 b.CreateAlignedStore(CGM.getNSConcreteGlobalBlock(),
1378 b.CreateStructGEP(literal, 0),
1379 CGM.getPointerAlign().getAsAlign());
1380 b.CreateRetVoid();
1381 // We can't use the normal LLVM global initialisation array, because we
1382 // need to specify that this runs early in library initialisation.
1383 auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
1384 /*isConstant*/true, llvm::GlobalValue::InternalLinkage,
1385 Init, ".block_isa_init_ptr");
1386 InitVar->setSection(".CRT$XCLa");
1387 CGM.addUsedGlobal(InitVar);
1388 }
1389
1390 // Return a constant of the appropriately-casted type.
1391 llvm::Type *RequiredType =
1392 CGM.getTypes().ConvertType(blockInfo.getBlockExpr()->getType());
1393 llvm::Constant *Result =
1394 llvm::ConstantExpr::getPointerCast(literal, RequiredType);
1395 CGM.setAddrOfGlobalBlock(blockInfo.BlockExpression, Result);
1396 if (CGM.getContext().getLangOpts().OpenCL)
1397 CGM.getOpenCLRuntime().recordBlockInfo(
1398 blockInfo.BlockExpression,
1399 cast<llvm::Function>(blockFn->stripPointerCasts()), Result);
1400 return Result;
1401}
1402
1403void CodeGenFunction::setBlockContextParameter(const ImplicitParamDecl *D,
1404 unsigned argNum,
1405 llvm::Value *arg) {
1406 assert(BlockInfo && "not emitting prologue of block invocation function?!");
1407
1408 // Allocate a stack slot like for any local variable to guarantee optimal
1409 // debug info at -O0. The mem2reg pass will eliminate it when optimizing.
1410 Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr");
1411 Builder.CreateStore(arg, alloc);
1412 if (CGDebugInfo *DI = getDebugInfo()) {
1413 if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
1414 DI->setLocation(D->getLocation());
1415 DI->EmitDeclareOfBlockLiteralArgVariable(
1416 *BlockInfo, D->getName(), argNum,
1417 cast<llvm::AllocaInst>(alloc.getPointer()), Builder);
1418 }
1419 }
1420
1421 SourceLocation StartLoc = BlockInfo->getBlockExpr()->getBody()->getBeginLoc();
1422 ApplyDebugLocation Scope(*this, StartLoc);
1423
1424 // Instead of messing around with LocalDeclMap, just set the value
1425 // directly as BlockPointer.
1426 BlockPointer = Builder.CreatePointerCast(
1427 arg,
1428 BlockInfo->StructureType->getPointerTo(
1429 getContext().getLangOpts().OpenCL
1430 ? getContext().getTargetAddressSpace(LangAS::opencl_generic)
1431 : 0),
1432 "block");
1433}
1434
1435Address CodeGenFunction::LoadBlockStruct() {
1436 assert(BlockInfo && "not in a block invocation function!");
1437 assert(BlockPointer && "no block pointer set!");
1438 return Address(BlockPointer, BlockInfo->BlockAlign);
1439}
1440
1441llvm::Function *
1442CodeGenFunction::GenerateBlockFunction(GlobalDecl GD,
1443 const CGBlockInfo &blockInfo,
1444 const DeclMapTy &ldm,
1445 bool IsLambdaConversionToBlock,
1446 bool BuildGlobalBlock) {
1447 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
1448
1449 CurGD = GD;
1450
1451 CurEHLocation = blockInfo.getBlockExpr()->getEndLoc();
1452
1453 BlockInfo = &blockInfo;
1454
1455 // Arrange for local static and local extern declarations to appear
1456 // to be local to this function as well, in case they're directly
1457 // referenced in a block.
1458 for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) {
1459 const auto *var = dyn_cast<VarDecl>(i->first);
1460 if (var && !var->hasLocalStorage())
1461 setAddrOfLocalVar(var, i->second);
1462 }
1463
1464 // Begin building the function declaration.
1465
1466 // Build the argument list.
1467 FunctionArgList args;
1468
1469 // The first argument is the block pointer. Just take it as a void*
1470 // and cast it later.
1471 QualType selfTy = getContext().VoidPtrTy;
1472
1473 // For OpenCL passed block pointer can be private AS local variable or
1474 // global AS program scope variable (for the case with and without captures).
1475 // Generic AS is used therefore to be able to accommodate both private and
1476 // generic AS in one implementation.
1477 if (getLangOpts().OpenCL)
1478 selfTy = getContext().getPointerType(getContext().getAddrSpaceQualType(
1479 getContext().VoidTy, LangAS::opencl_generic));
1480
1481 IdentifierInfo *II = &CGM.getContext().Idents.get(".block_descriptor");
1482
1483 ImplicitParamDecl SelfDecl(getContext(), const_cast<BlockDecl *>(blockDecl),
1484 SourceLocation(), II, selfTy,
1485 ImplicitParamDecl::ObjCSelf);
1486 args.push_back(&SelfDecl);
1487
1488 // Now add the rest of the parameters.
1489 args.append(blockDecl->param_begin(), blockDecl->param_end());
1490
1491 // Create the function declaration.
1492 const FunctionProtoType *fnType = blockInfo.getBlockExpr()->getFunctionType();
1493 const CGFunctionInfo &fnInfo =
1494 CGM.getTypes().arrangeBlockFunctionDeclaration(fnType, args);
1495 if (CGM.ReturnSlotInterferesWithArgs(fnInfo))
1496 blockInfo.UsesStret = true;
1497
1498 llvm::FunctionType *fnLLVMType = CGM.getTypes().GetFunctionType(fnInfo);
1499
1500 StringRef name = CGM.getBlockMangledName(GD, blockDecl);
1501 llvm::Function *fn = llvm::Function::Create(
1502 fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &CGM.getModule());
1503 CGM.SetInternalFunctionAttributes(blockDecl, fn, fnInfo);
1504
1505 if (BuildGlobalBlock) {
1506 auto GenVoidPtrTy = getContext().getLangOpts().OpenCL
1507 ? CGM.getOpenCLRuntime().getGenericVoidPointerType()
1508 : VoidPtrTy;
1509 buildGlobalBlock(CGM, blockInfo,
1510 llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy));
1511 }
1512
1513 // Begin generating the function.
1514 StartFunction(blockDecl, fnType->getReturnType(), fn, fnInfo, args,
1515 blockDecl->getLocation(),
1516 blockInfo.getBlockExpr()->getBody()->getBeginLoc());
1517
1518 // Okay. Undo some of what StartFunction did.
1519
1520 // At -O0 we generate an explicit alloca for the BlockPointer, so the RA
1521 // won't delete the dbg.declare intrinsics for captured variables.
1522 llvm::Value *BlockPointerDbgLoc = BlockPointer;
1523 if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
1524 // Allocate a stack slot for it, so we can point the debugger to it
1525 Address Alloca = CreateTempAlloca(BlockPointer->getType(),
1526 getPointerAlign(),
1527 "block.addr");
1528 // Set the DebugLocation to empty, so the store is recognized as a
1529 // frame setup instruction by llvm::DwarfDebug::beginFunction().
1530 auto NL = ApplyDebugLocation::CreateEmpty(*this);
1531 Builder.CreateStore(BlockPointer, Alloca);
1532 BlockPointerDbgLoc = Alloca.getPointer();
1533 }
1534
1535 // If we have a C++ 'this' reference, go ahead and force it into
1536 // existence now.
1537 if (blockDecl->capturesCXXThis()) {
1538 Address addr = Builder.CreateStructGEP(
1539 LoadBlockStruct(), blockInfo.CXXThisIndex, "block.captured-this");
1540 CXXThisValue = Builder.CreateLoad(addr, "this");
1541 }
1542
1543 // Also force all the constant captures.
1544 for (const auto &CI : blockDecl->captures()) {
1545 const VarDecl *variable = CI.getVariable();
1546 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
1547 if (!capture.isConstant()) continue;
1548
1549 CharUnits align = getContext().getDeclAlign(variable);
1550 Address alloca =
1551 CreateMemTemp(variable->getType(), align, "block.captured-const");
1552
1553 Builder.CreateStore(capture.getConstant(), alloca);
1554
1555 setAddrOfLocalVar(variable, alloca);
1556 }
1557
1558 // Save a spot to insert the debug information for all the DeclRefExprs.
1559 llvm::BasicBlock *entry = Builder.GetInsertBlock();
1560 llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint();
1561 --entry_ptr;
1562
1563 if (IsLambdaConversionToBlock)
1564 EmitLambdaBlockInvokeBody();
1565 else {
1566 PGO.assignRegionCounters(GlobalDecl(blockDecl), fn);
1567 incrementProfileCounter(blockDecl->getBody());
1568 EmitStmt(blockDecl->getBody());
1569 }
1570
1571 // Remember where we were...
1572 llvm::BasicBlock *resume = Builder.GetInsertBlock();
1573
1574 // Go back to the entry.
1575 ++entry_ptr;
1576 Builder.SetInsertPoint(entry, entry_ptr);
1577
1578 // Emit debug information for all the DeclRefExprs.
1579 // FIXME: also for 'this'
1580 if (CGDebugInfo *DI = getDebugInfo()) {
1581 for (const auto &CI : blockDecl->captures()) {
1582 const VarDecl *variable = CI.getVariable();
1583 DI->EmitLocation(Builder, variable->getLocation());
1584
1585 if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
1586 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
1587 if (capture.isConstant()) {
1588 auto addr = LocalDeclMap.find(variable)->second;
1589 (void)DI->EmitDeclareOfAutoVariable(variable, addr.getPointer(),
1590 Builder);
1591 continue;
1592 }
1593
1594 DI->EmitDeclareOfBlockDeclRefVariable(
1595 variable, BlockPointerDbgLoc, Builder, blockInfo,
1596 entry_ptr == entry->end() ? nullptr : &*entry_ptr);
1597 }
1598 }
1599 // Recover location if it was changed in the above loop.
1600 DI->EmitLocation(Builder,
1601 cast<CompoundStmt>(blockDecl->getBody())->getRBracLoc());
1602 }
1603
1604 // And resume where we left off.
1605 if (resume == nullptr)
1606 Builder.ClearInsertionPoint();
1607 else
1608 Builder.SetInsertPoint(resume);
1609
1610 FinishFunction(cast<CompoundStmt>(blockDecl->getBody())->getRBracLoc());
1611
1612 return fn;
1613}
1614
1615static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
1616computeCopyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T,
1617 const LangOptions &LangOpts) {
1618 if (CI.getCopyExpr()) {
1619 assert(!CI.isByRef());
1620 // don't bother computing flags
1621 return std::make_pair(BlockCaptureEntityKind::CXXRecord, BlockFieldFlags());
1622 }
1623 BlockFieldFlags Flags;
1624 if (CI.isEscapingByref()) {
1625 Flags = BLOCK_FIELD_IS_BYREF;
1626 if (T.isObjCGCWeak())
1627 Flags |= BLOCK_FIELD_IS_WEAK;
1628 return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags);
1629 }
1630
1631 Flags = BLOCK_FIELD_IS_OBJECT;
1632 bool isBlockPointer = T->isBlockPointerType();
1633 if (isBlockPointer)
1634 Flags = BLOCK_FIELD_IS_BLOCK;
1635
1636 switch (T.isNonTrivialToPrimitiveCopy()) {
1637 case QualType::PCK_Struct:
1638 return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct,
1639 BlockFieldFlags());
1640 case QualType::PCK_ARCWeak:
1641 // We need to register __weak direct captures with the runtime.
1642 return std::make_pair(BlockCaptureEntityKind::ARCWeak, Flags);
1643 case QualType::PCK_ARCStrong:
1644 // We need to retain the copied value for __strong direct captures.
1645 // If it's a block pointer, we have to copy the block and assign that to
1646 // the destination pointer, so we might as well use _Block_object_assign.
1647 // Otherwise we can avoid that.
1648 return std::make_pair(!isBlockPointer ? BlockCaptureEntityKind::ARCStrong
1649 : BlockCaptureEntityKind::BlockObject,
1650 Flags);
1651 case QualType::PCK_Trivial:
1652 case QualType::PCK_VolatileTrivial: {
1653 if (!T->isObjCRetainableType())
1654 // For all other types, the memcpy is fine.
1655 return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags());
1656
1657 // Special rules for ARC captures:
1658 Qualifiers QS = T.getQualifiers();
1659
1660 // Non-ARC captures of retainable pointers are strong and
1661 // therefore require a call to _Block_object_assign.
1662 if (!QS.getObjCLifetime() && !LangOpts.ObjCAutoRefCount)
1663 return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags);
1664
1665 // Otherwise the memcpy is fine.
1666 return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags());
1667 }
1668 }
1669 llvm_unreachable("after exhaustive PrimitiveCopyKind switch");
1670}
1671
1672static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
1673computeDestroyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T,
1674 const LangOptions &LangOpts);
1675
1676/// Find the set of block captures that need to be explicitly copied or destroy.
1677static void findBlockCapturedManagedEntities(
1678 const CGBlockInfo &BlockInfo, const LangOptions &LangOpts,
1679 SmallVectorImpl<BlockCaptureManagedEntity> &ManagedCaptures) {
1680 for (const auto &CI : BlockInfo.getBlockDecl()->captures()) {
1681 const VarDecl *Variable = CI.getVariable();
1682 const CGBlockInfo::Capture &Capture = BlockInfo.getCapture(Variable);
1683 if (Capture.isConstant())
1684 continue;
1685
1686 QualType VT = Capture.fieldType();
1687 auto CopyInfo = computeCopyInfoForBlockCapture(CI, VT, LangOpts);
1688 auto DisposeInfo = computeDestroyInfoForBlockCapture(CI, VT, LangOpts);
1689 if (CopyInfo.first != BlockCaptureEntityKind::None ||
1690 DisposeInfo.first != BlockCaptureEntityKind::None)
1691 ManagedCaptures.emplace_back(CopyInfo.first, DisposeInfo.first,
1692 CopyInfo.second, DisposeInfo.second, CI,
1693 Capture);
1694 }
1695
1696 // Sort the captures by offset.
1697 llvm::sort(ManagedCaptures);
1698}
1699
1700namespace {
1701/// Release a __block variable.
1702struct CallBlockRelease final : EHScopeStack::Cleanup {
1703 Address Addr;
1704 BlockFieldFlags FieldFlags;
1705 bool LoadBlockVarAddr, CanThrow;
1706
1707 CallBlockRelease(Address Addr, BlockFieldFlags Flags, bool LoadValue,
1708 bool CT)
1709 : Addr(Addr), FieldFlags(Flags), LoadBlockVarAddr(LoadValue),
1710 CanThrow(CT) {}
1711
1712 void Emit(CodeGenFunction &CGF, Flags flags) override {
1713 llvm::Value *BlockVarAddr;
1714 if (LoadBlockVarAddr) {
1715 BlockVarAddr = CGF.Builder.CreateLoad(Addr);
1716 BlockVarAddr = CGF.Builder.CreateBitCast(BlockVarAddr, CGF.VoidPtrTy);
1717 } else {
1718 BlockVarAddr = Addr.getPointer();
1719 }
1720
1721 CGF.BuildBlockRelease(BlockVarAddr, FieldFlags, CanThrow);
1722 }
1723};
1724} // end anonymous namespace
1725
1726/// Check if \p T is a C++ class that has a destructor that can throw.
1727bool CodeGenFunction::cxxDestructorCanThrow(QualType T) {
1728 if (const auto *RD = T->getAsCXXRecordDecl())
1729 if (const CXXDestructorDecl *DD = RD->getDestructor())
1730 return DD->getType()->castAs<FunctionProtoType>()->canThrow();
1731 return false;
1732}
1733
1734// Return a string that has the information about a capture.
1735static std::string getBlockCaptureStr(const BlockCaptureManagedEntity &E,
1736 CaptureStrKind StrKind,
1737 CharUnits BlockAlignment,
1738 CodeGenModule &CGM) {
1739 std::string Str;
1740 ASTContext &Ctx = CGM.getContext();
1741 const BlockDecl::Capture &CI = *E.CI;
1742 QualType CaptureTy = CI.getVariable()->getType();
1743
1744 BlockCaptureEntityKind Kind;
1745 BlockFieldFlags Flags;
1746
1747 // CaptureStrKind::Merged should be passed only when the operations and the
1748 // flags are the same for copy and dispose.
1749 assert((StrKind != CaptureStrKind::Merged ||
1750 (E.CopyKind == E.DisposeKind && E.CopyFlags == E.DisposeFlags)) &&
1751 "different operations and flags");
1752
1753 if (StrKind == CaptureStrKind::DisposeHelper) {
1754 Kind = E.DisposeKind;
1755 Flags = E.DisposeFlags;
1756 } else {
1757 Kind = E.CopyKind;
1758 Flags = E.CopyFlags;
1759 }
1760
1761 switch (Kind) {
1762 case BlockCaptureEntityKind::CXXRecord: {
1763 Str += "c";
1764 SmallString<256> TyStr;
1765 llvm::raw_svector_ostream Out(TyStr);
1766 CGM.getCXXABI().getMangleContext().mangleTypeName(CaptureTy, Out);
1767 Str += llvm::to_string(TyStr.size()) + TyStr.c_str();
1768 break;
1769 }
1770 case BlockCaptureEntityKind::ARCWeak:
1771 Str += "w";
1772 break;
1773 case BlockCaptureEntityKind::ARCStrong:
1774 Str += "s";
1775 break;
1776 case BlockCaptureEntityKind::BlockObject: {
1777 const VarDecl *Var = CI.getVariable();
1778 unsigned F = Flags.getBitMask();
1779 if (F & BLOCK_FIELD_IS_BYREF) {
1780 Str += "r";
1781 if (F & BLOCK_FIELD_IS_WEAK)
1782 Str += "w";
1783 else {
1784 // If CaptureStrKind::Merged is passed, check both the copy expression
1785 // and the destructor.
1786 if (StrKind != CaptureStrKind::DisposeHelper) {
1787 if (Ctx.getBlockVarCopyInit(Var).canThrow())
1788 Str += "c";
1789 }
1790 if (StrKind != CaptureStrKind::CopyHelper) {
1791 if (CodeGenFunction::cxxDestructorCanThrow(CaptureTy))
1792 Str += "d";
1793 }
1794 }
1795 } else {
1796 assert((F & BLOCK_FIELD_IS_OBJECT) && "unexpected flag value");
1797 if (F == BLOCK_FIELD_IS_BLOCK)
1798 Str += "b";
1799 else
1800 Str += "o";
1801 }
1802 break;
1803 }
1804 case BlockCaptureEntityKind::NonTrivialCStruct: {
1805 bool IsVolatile = CaptureTy.isVolatileQualified();
1806 CharUnits Alignment =
1807 BlockAlignment.alignmentAtOffset(E.Capture->getOffset());
1808
1809 Str += "n";
1810 std::string FuncStr;
1811 if (StrKind == CaptureStrKind::DisposeHelper)
1812 FuncStr = CodeGenFunction::getNonTrivialDestructorStr(
1813 CaptureTy, Alignment, IsVolatile, Ctx);
1814 else
1815 // If CaptureStrKind::Merged is passed, use the copy constructor string.
1816 // It has all the information that the destructor string has.
1817 FuncStr = CodeGenFunction::getNonTrivialCopyConstructorStr(
1818 CaptureTy, Alignment, IsVolatile, Ctx);
1819 // The underscore is necessary here because non-trivial copy constructor
1820 // and destructor strings can start with a number.
1821 Str += llvm::to_string(FuncStr.size()) + "_" + FuncStr;
1822 break;
1823 }
1824 case BlockCaptureEntityKind::None:
1825 break;
1826 }
1827
1828 return Str;
1829}
1830
1831static std::string getCopyDestroyHelperFuncName(
1832 const SmallVectorImpl<BlockCaptureManagedEntity> &Captures,
1833 CharUnits BlockAlignment, CaptureStrKind StrKind, CodeGenModule &CGM) {
1834 assert((StrKind == CaptureStrKind::CopyHelper ||
1835 StrKind == CaptureStrKind::DisposeHelper) &&
1836 "unexpected CaptureStrKind");
1837 std::string Name = StrKind == CaptureStrKind::CopyHelper
1838 ? "__copy_helper_block_"
1839 : "__destroy_helper_block_";
1840 if (CGM.getLangOpts().Exceptions)
1841 Name += "e";
1842 if (CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
1843 Name += "a";
1844 Name += llvm::to_string(BlockAlignment.getQuantity()) + "_";
1845
1846 for (const BlockCaptureManagedEntity &E : Captures) {
1847 Name += llvm::to_string(E.Capture->getOffset().getQuantity());
1848 Name += getBlockCaptureStr(E, StrKind, BlockAlignment, CGM);
1849 }
1850
1851 return Name;
1852}
1853
1854static void pushCaptureCleanup(BlockCaptureEntityKind CaptureKind,
1855 Address Field, QualType CaptureType,
1856 BlockFieldFlags Flags, bool ForCopyHelper,
1857 VarDecl *Var, CodeGenFunction &CGF) {
1858 bool EHOnly = ForCopyHelper;
1859
1860 switch (CaptureKind) {
1861 case BlockCaptureEntityKind::CXXRecord:
1862 case BlockCaptureEntityKind::ARCWeak:
1863 case BlockCaptureEntityKind::NonTrivialCStruct:
1864 case BlockCaptureEntityKind::ARCStrong: {
1865 if (CaptureType.isDestructedType() &&
1866 (!EHOnly || CGF.needsEHCleanup(CaptureType.isDestructedType()))) {
1867 CodeGenFunction::Destroyer *Destroyer =
1868 CaptureKind == BlockCaptureEntityKind::ARCStrong
1869 ? CodeGenFunction::destroyARCStrongImprecise
1870 : CGF.getDestroyer(CaptureType.isDestructedType());
1871 CleanupKind Kind =
1872 EHOnly ? EHCleanup
1873 : CGF.getCleanupKind(CaptureType.isDestructedType());
1874 CGF.pushDestroy(Kind, Field, CaptureType, Destroyer, Kind & EHCleanup);
1875 }
1876 break;
1877 }
1878 case BlockCaptureEntityKind::BlockObject: {
1879 if (!EHOnly || CGF.getLangOpts().Exceptions) {
1880 CleanupKind Kind = EHOnly ? EHCleanup : NormalAndEHCleanup;
1881 // Calls to _Block_object_dispose along the EH path in the copy helper
1882 // function don't throw as newly-copied __block variables always have a
1883 // reference count of 2.
1884 bool CanThrow =
1885 !ForCopyHelper && CGF.cxxDestructorCanThrow(CaptureType);
1886 CGF.enterByrefCleanup(Kind, Field, Flags, /*LoadBlockVarAddr*/ true,
1887 CanThrow);
1888 }
1889 break;
1890 }
1891 case BlockCaptureEntityKind::None:
1892 break;
1893 }
1894}
1895
1896static void setBlockHelperAttributesVisibility(bool CapturesNonExternalType,
1897 llvm::Function *Fn,
1898 const CGFunctionInfo &FI,
1899 CodeGenModule &CGM) {
1900 if (CapturesNonExternalType) {
1901 CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
1902 } else {
1903 Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
1904 Fn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1905 CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, Fn);
1906 CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Fn);
1907 }
1908}
1909/// Generate the copy-helper function for a block closure object:
1910/// static void block_copy_helper(block_t *dst, block_t *src);
1911/// The runtime will have previously initialized 'dst' by doing a
1912/// bit-copy of 'src'.
1913///
1914/// Note that this copies an entire block closure object to the heap;
1915/// it should not be confused with a 'byref copy helper', which moves
1916/// the contents of an individual __block variable to the heap.
1917llvm::Constant *
1918CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) {
1919 SmallVector<BlockCaptureManagedEntity, 4> CopiedCaptures;
1920 findBlockCapturedManagedEntities(blockInfo, getLangOpts(), CopiedCaptures);
1921 std::string FuncName =
1922 getCopyDestroyHelperFuncName(CopiedCaptures, blockInfo.BlockAlign,
1923 CaptureStrKind::CopyHelper, CGM);
1924
1925 if (llvm::GlobalValue *Func = CGM.getModule().getNamedValue(FuncName))
1926 return llvm::ConstantExpr::getBitCast(Func, VoidPtrTy);
1927
1928 ASTContext &C = getContext();
1929
1930 QualType ReturnTy = C.VoidTy;
1931
1932 FunctionArgList args;
1933 ImplicitParamDecl DstDecl(C, C.VoidPtrTy, ImplicitParamDecl::Other);
1934 args.push_back(&DstDecl);
1935 ImplicitParamDecl SrcDecl(C, C.VoidPtrTy, ImplicitParamDecl::Other);
1936 args.push_back(&SrcDecl);
1937
1938 const CGFunctionInfo &FI =
1939 CGM.getTypes().arrangeBuiltinFunctionDeclaration(ReturnTy, args);
1940
1941 // FIXME: it would be nice if these were mergeable with things with
1942 // identical semantics.
1943 llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
1944
1945 llvm::Function *Fn =
1946 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
1947 FuncName, &CGM.getModule());
1948 if (CGM.supportsCOMDAT())
1949 Fn->setComdat(CGM.getModule().getOrInsertComdat(FuncName));
1950
1951 IdentifierInfo *II = &C.Idents.get(FuncName);
1952
1953 SmallVector<QualType, 2> ArgTys;
1954 ArgTys.push_back(C.VoidPtrTy);
1955 ArgTys.push_back(C.VoidPtrTy);
1956 QualType FunctionTy = C.getFunctionType(ReturnTy, ArgTys, {});
1957
1958 FunctionDecl *FD = FunctionDecl::Create(
1959 C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II,
1960 FunctionTy, nullptr, SC_Static, false, false);
1961 setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI,
1962 CGM);
1963 // This is necessary to avoid inheriting the previous line number.
1964 FD->setImplicit();
1965 StartFunction(FD, ReturnTy, Fn, FI, args);
1966 auto AL = ApplyDebugLocation::CreateArtificial(*this);
1967
1968 llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
1969
1970 Address src = GetAddrOfLocalVar(&SrcDecl);
1971 src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign);
1972 src = Builder.CreateBitCast(src, structPtrTy, "block.source");
1973
1974 Address dst = GetAddrOfLocalVar(&DstDecl);
1975 dst = Address(Builder.CreateLoad(dst), blockInfo.BlockAlign);
1976 dst = Builder.CreateBitCast(dst, structPtrTy, "block.dest");
1977
1978 for (const auto &CopiedCapture : CopiedCaptures) {
1979 const BlockDecl::Capture &CI = *CopiedCapture.CI;
1980 const CGBlockInfo::Capture &capture = *CopiedCapture.Capture;
1981 QualType captureType = CI.getVariable()->getType();
1982 BlockFieldFlags flags = CopiedCapture.CopyFlags;
1983
1984 unsigned index = capture.getIndex();
1985 Address srcField = Builder.CreateStructGEP(src, index);
1986 Address dstField = Builder.CreateStructGEP(dst, index);
1987
1988 switch (CopiedCapture.CopyKind) {
1989 case BlockCaptureEntityKind::CXXRecord:
1990 // If there's an explicit copy expression, we do that.
1991 assert(CI.getCopyExpr() && "copy expression for variable is missing");
1992 EmitSynthesizedCXXCopyCtor(dstField, srcField, CI.getCopyExpr());
1993 break;
1994 case BlockCaptureEntityKind::ARCWeak:
1995 EmitARCCopyWeak(dstField, srcField);
1996 break;
1997 case BlockCaptureEntityKind::NonTrivialCStruct: {
1998 // If this is a C struct that requires non-trivial copy construction,
1999 // emit a call to its copy constructor.
2000 QualType varType = CI.getVariable()->getType();
2001 callCStructCopyConstructor(MakeAddrLValue(dstField, varType),
2002 MakeAddrLValue(srcField, varType));
2003 break;
2004 }
2005 case BlockCaptureEntityKind::ARCStrong: {
2006 llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src");
2007 // At -O0, store null into the destination field (so that the
2008 // storeStrong doesn't over-release) and then call storeStrong.
2009 // This is a workaround to not having an initStrong call.
2010 if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
2011 auto *ty = cast<llvm::PointerType>(srcValue->getType());
2012 llvm::Value *null = llvm::ConstantPointerNull::get(ty);
2013 Builder.