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 32 using namespace clang; 33 using namespace CodeGen; 34 35 CGBlockInfo::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. 48 BlockByrefHelpers::~BlockByrefHelpers() {} 49 50 /// Build the given block as a global block. 51 static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM, 52 const CGBlockInfo &blockInfo, 53 llvm::Constant *blockFn); 54 55 /// Build the helper function to copy a block. 56 static 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. 62 static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM, 63 const CGBlockInfo &blockInfo) { 64 return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo); 65 } 66 67 namespace { 68 69 /// Represents a type of copy/destroy operation that should be performed for an 70 /// entity that's captured by a block. 71 enum 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. 82 struct 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 102 enum 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 113 static void findBlockCapturedManagedEntities( 114 const CGBlockInfo &BlockInfo, const LangOptions &LangOpts, 115 SmallVectorImpl<BlockCaptureManagedEntity> &ManagedCaptures); 116 117 static std::string getBlockCaptureStr(const BlockCaptureManagedEntity &E, 118 CaptureStrKind StrKind, 119 CharUnits BlockAlignment, 120 CodeGenModule &CGM); 121 122 static 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 185 static 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 338 namespace { 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++. 388 static 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. 412 static 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. 444 static CharUnits getLowBit(CharUnits v) { 445 return CharUnits::fromQuantity(v.getQuantity() & (~v.getQuantity() + 1)); 446 } 447 448 static 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 503 static 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. 522 static 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 std::pair<CharUnits,CharUnits> tinfo 561 = CGM.getContext().getTypeInfoInChars(thisType); 562 maxFieldAlign = std::max(maxFieldAlign, tinfo.second); 563 564 layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, 565 Qualifiers::OCL_None, 566 nullptr, llvmType, thisType)); 567 } 568 569 // Next, all the block captures. 570 for (const auto &CI : block->captures()) { 571 const VarDecl *variable = CI.getVariable(); 572 573 if (CI.isEscapingByref()) { 574 // We have to copy/dispose of the __block reference. 575 info.NeedsCopyDispose = true; 576 577 // Just use void* instead of a pointer to the byref type. 578 CharUnits align = CGM.getPointerAlign(); 579 maxFieldAlign = std::max(maxFieldAlign, align); 580 581 // Since a __block variable cannot be captured by lambdas, its type and 582 // the capture field type should always match. 583 assert(getCaptureFieldType(*CGF, CI) == variable->getType() && 584 "capture type differs from the variable type"); 585 layout.push_back(BlockLayoutChunk(align, CGM.getPointerSize(), 586 Qualifiers::OCL_None, &CI, 587 CGM.VoidPtrTy, variable->getType())); 588 continue; 589 } 590 591 // Otherwise, build a layout chunk with the size and alignment of 592 // the declaration. 593 if (llvm::Constant *constant = tryCaptureAsConstant(CGM, CGF, variable)) { 594 info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant); 595 continue; 596 } 597 598 QualType VT = getCaptureFieldType(*CGF, CI); 599 600 // If we have a lifetime qualifier, honor it for capture purposes. 601 // That includes *not* copying it if it's __unsafe_unretained. 602 Qualifiers::ObjCLifetime lifetime = VT.getObjCLifetime(); 603 if (lifetime) { 604 switch (lifetime) { 605 case Qualifiers::OCL_None: llvm_unreachable("impossible"); 606 case Qualifiers::OCL_ExplicitNone: 607 case Qualifiers::OCL_Autoreleasing: 608 break; 609 610 case Qualifiers::OCL_Strong: 611 case Qualifiers::OCL_Weak: 612 info.NeedsCopyDispose = true; 613 } 614 615 // Block pointers require copy/dispose. So do Objective-C pointers. 616 } else if (VT->isObjCRetainableType()) { 617 // But honor the inert __unsafe_unretained qualifier, which doesn't 618 // actually make it into the type system. 619 if (VT->isObjCInertUnsafeUnretainedType()) { 620 lifetime = Qualifiers::OCL_ExplicitNone; 621 } else { 622 info.NeedsCopyDispose = true; 623 // used for mrr below. 624 lifetime = Qualifiers::OCL_Strong; 625 } 626 627 // So do types that require non-trivial copy construction. 628 } else if (CI.hasCopyExpr()) { 629 info.NeedsCopyDispose = true; 630 info.HasCXXObject = true; 631 if (!VT->getAsCXXRecordDecl()->isExternallyVisible()) 632 info.CapturesNonExternalType = true; 633 634 // So do C structs that require non-trivial copy construction or 635 // destruction. 636 } else if (VT.isNonTrivialToPrimitiveCopy() == QualType::PCK_Struct || 637 VT.isDestructedType() == QualType::DK_nontrivial_c_struct) { 638 info.NeedsCopyDispose = true; 639 640 // And so do types with destructors. 641 } else if (CGM.getLangOpts().CPlusPlus) { 642 if (const CXXRecordDecl *record = VT->getAsCXXRecordDecl()) { 643 if (!record->hasTrivialDestructor()) { 644 info.HasCXXObject = true; 645 info.NeedsCopyDispose = true; 646 if (!record->isExternallyVisible()) 647 info.CapturesNonExternalType = true; 648 } 649 } 650 } 651 652 CharUnits size = C.getTypeSizeInChars(VT); 653 CharUnits align = C.getDeclAlign(variable); 654 655 maxFieldAlign = std::max(maxFieldAlign, align); 656 657 llvm::Type *llvmType = 658 CGM.getTypes().ConvertTypeForMem(VT); 659 660 layout.push_back( 661 BlockLayoutChunk(align, size, lifetime, &CI, llvmType, VT)); 662 } 663 664 // If that was everything, we're done here. 665 if (layout.empty()) { 666 info.StructureType = 667 llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); 668 info.CanBeGlobal = true; 669 return; 670 } 671 672 // Sort the layout by alignment. We have to use a stable sort here 673 // to get reproducible results. There should probably be an 674 // llvm::array_pod_stable_sort. 675 llvm::stable_sort(layout); 676 677 // Needed for blocks layout info. 678 info.BlockHeaderForcedGapOffset = info.BlockSize; 679 info.BlockHeaderForcedGapSize = CharUnits::Zero(); 680 681 CharUnits &blockSize = info.BlockSize; 682 info.BlockAlign = std::max(maxFieldAlign, info.BlockAlign); 683 684 // Assuming that the first byte in the header is maximally aligned, 685 // get the alignment of the first byte following the header. 686 CharUnits endAlign = getLowBit(blockSize); 687 688 // If the end of the header isn't satisfactorily aligned for the 689 // maximum thing, look for things that are okay with the header-end 690 // alignment, and keep appending them until we get something that's 691 // aligned right. This algorithm is only guaranteed optimal if 692 // that condition is satisfied at some point; otherwise we can get 693 // things like: 694 // header // next byte has alignment 4 695 // something_with_size_5; // next byte has alignment 1 696 // something_with_alignment_8; 697 // which has 7 bytes of padding, as opposed to the naive solution 698 // which might have less (?). 699 if (endAlign < maxFieldAlign) { 700 SmallVectorImpl<BlockLayoutChunk>::iterator 701 li = layout.begin() + 1, le = layout.end(); 702 703 // Look for something that the header end is already 704 // satisfactorily aligned for. 705 for (; li != le && endAlign < li->Alignment; ++li) 706 ; 707 708 // If we found something that's naturally aligned for the end of 709 // the header, keep adding things... 710 if (li != le) { 711 SmallVectorImpl<BlockLayoutChunk>::iterator first = li; 712 for (; li != le; ++li) { 713 assert(endAlign >= li->Alignment); 714 715 li->setIndex(info, elementTypes.size(), blockSize); 716 elementTypes.push_back(li->Type); 717 blockSize += li->Size; 718 endAlign = getLowBit(blockSize); 719 720 // ...until we get to the alignment of the maximum field. 721 if (endAlign >= maxFieldAlign) { 722 break; 723 } 724 } 725 // Don't re-append everything we just appended. 726 layout.erase(first, li); 727 } 728 } 729 730 assert(endAlign == getLowBit(blockSize)); 731 732 // At this point, we just have to add padding if the end align still 733 // isn't aligned right. 734 if (endAlign < maxFieldAlign) { 735 CharUnits newBlockSize = blockSize.alignTo(maxFieldAlign); 736 CharUnits padding = newBlockSize - blockSize; 737 738 // If we haven't yet added any fields, remember that there was an 739 // initial gap; this need to go into the block layout bit map. 740 if (blockSize == info.BlockHeaderForcedGapOffset) { 741 info.BlockHeaderForcedGapSize = padding; 742 } 743 744 elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty, 745 padding.getQuantity())); 746 blockSize = newBlockSize; 747 endAlign = getLowBit(blockSize); // might be > maxFieldAlign 748 } 749 750 assert(endAlign >= maxFieldAlign); 751 assert(endAlign == getLowBit(blockSize)); 752 // Slam everything else on now. This works because they have 753 // strictly decreasing alignment and we expect that size is always a 754 // multiple of alignment. 755 for (SmallVectorImpl<BlockLayoutChunk>::iterator 756 li = layout.begin(), le = layout.end(); li != le; ++li) { 757 if (endAlign < li->Alignment) { 758 // size may not be multiple of alignment. This can only happen with 759 // an over-aligned variable. We will be adding a padding field to 760 // make the size be multiple of alignment. 761 CharUnits padding = li->Alignment - endAlign; 762 elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty, 763 padding.getQuantity())); 764 blockSize += padding; 765 endAlign = getLowBit(blockSize); 766 } 767 assert(endAlign >= li->Alignment); 768 li->setIndex(info, elementTypes.size(), blockSize); 769 elementTypes.push_back(li->Type); 770 blockSize += li->Size; 771 endAlign = getLowBit(blockSize); 772 } 773 774 info.StructureType = 775 llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); 776 } 777 778 /// Emit a block literal expression in the current function. 779 llvm::Value *CodeGenFunction::EmitBlockLiteral(const BlockExpr *blockExpr) { 780 // If the block has no captures, we won't have a pre-computed 781 // layout for it. 782 if (!blockExpr->getBlockDecl()->hasCaptures()) 783 // The block literal is emitted as a global variable, and the block invoke 784 // function has to be extracted from its initializer. 785 if (llvm::Constant *Block = CGM.getAddrOfGlobalBlockIfEmitted(blockExpr)) 786 return Block; 787 788 CGBlockInfo blockInfo(blockExpr->getBlockDecl(), CurFn->getName()); 789 computeBlockInfo(CGM, this, blockInfo); 790 blockInfo.BlockExpression = blockExpr; 791 if (!blockInfo.CanBeGlobal) 792 blockInfo.LocalAddress = CreateTempAlloca(blockInfo.StructureType, 793 blockInfo.BlockAlign, "block"); 794 return EmitBlockLiteral(blockInfo); 795 } 796 797 llvm::Value *CodeGenFunction::EmitBlockLiteral(const CGBlockInfo &blockInfo) { 798 bool IsOpenCL = CGM.getContext().getLangOpts().OpenCL; 799 auto GenVoidPtrTy = 800 IsOpenCL ? CGM.getOpenCLRuntime().getGenericVoidPointerType() : VoidPtrTy; 801 LangAS GenVoidPtrAddr = IsOpenCL ? LangAS::opencl_generic : LangAS::Default; 802 auto GenVoidPtrSize = CharUnits::fromQuantity( 803 CGM.getTarget().getPointerWidth( 804 CGM.getContext().getTargetAddressSpace(GenVoidPtrAddr)) / 805 8); 806 // Using the computed layout, generate the actual block function. 807 bool isLambdaConv = blockInfo.getBlockDecl()->isConversionFromLambda(); 808 CodeGenFunction BlockCGF{CGM, true}; 809 BlockCGF.SanOpts = SanOpts; 810 auto *InvokeFn = BlockCGF.GenerateBlockFunction( 811 CurGD, blockInfo, LocalDeclMap, isLambdaConv, blockInfo.CanBeGlobal); 812 auto *blockFn = llvm::ConstantExpr::getPointerCast(InvokeFn, GenVoidPtrTy); 813 814 // If there is nothing to capture, we can emit this as a global block. 815 if (blockInfo.CanBeGlobal) 816 return CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression); 817 818 // Otherwise, we have to emit this as a local block. 819 820 Address blockAddr = blockInfo.LocalAddress; 821 assert(blockAddr.isValid() && "block has no address!"); 822 823 llvm::Constant *isa; 824 llvm::Constant *descriptor; 825 BlockFlags flags; 826 if (!IsOpenCL) { 827 // If the block is non-escaping, set field 'isa 'to NSConcreteGlobalBlock 828 // and set the BLOCK_IS_GLOBAL bit of field 'flags'. Copying a non-escaping 829 // block just returns the original block and releasing it is a no-op. 830 llvm::Constant *blockISA = blockInfo.getBlockDecl()->doesNotEscape() 831 ? CGM.getNSConcreteGlobalBlock() 832 : CGM.getNSConcreteStackBlock(); 833 isa = llvm::ConstantExpr::getBitCast(blockISA, VoidPtrTy); 834 835 // Build the block descriptor. 836 descriptor = buildBlockDescriptor(CGM, blockInfo); 837 838 // Compute the initial on-stack block flags. 839 flags = BLOCK_HAS_SIGNATURE; 840 if (blockInfo.HasCapturedVariableLayout) 841 flags |= BLOCK_HAS_EXTENDED_LAYOUT; 842 if (blockInfo.needsCopyDisposeHelpers()) 843 flags |= BLOCK_HAS_COPY_DISPOSE; 844 if (blockInfo.HasCXXObject) 845 flags |= BLOCK_HAS_CXX_OBJ; 846 if (blockInfo.UsesStret) 847 flags |= BLOCK_USE_STRET; 848 if (blockInfo.getBlockDecl()->doesNotEscape()) 849 flags |= BLOCK_IS_NOESCAPE | BLOCK_IS_GLOBAL; 850 } 851 852 auto projectField = [&](unsigned index, const Twine &name) -> Address { 853 return Builder.CreateStructGEP(blockAddr, index, name); 854 }; 855 auto storeField = [&](llvm::Value *value, unsigned index, const Twine &name) { 856 Builder.CreateStore(value, projectField(index, name)); 857 }; 858 859 // Initialize the block header. 860 { 861 // We assume all the header fields are densely packed. 862 unsigned index = 0; 863 CharUnits offset; 864 auto addHeaderField = [&](llvm::Value *value, CharUnits size, 865 const Twine &name) { 866 storeField(value, index, name); 867 offset += size; 868 index++; 869 }; 870 871 if (!IsOpenCL) { 872 addHeaderField(isa, getPointerSize(), "block.isa"); 873 addHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()), 874 getIntSize(), "block.flags"); 875 addHeaderField(llvm::ConstantInt::get(IntTy, 0), getIntSize(), 876 "block.reserved"); 877 } else { 878 addHeaderField( 879 llvm::ConstantInt::get(IntTy, blockInfo.BlockSize.getQuantity()), 880 getIntSize(), "block.size"); 881 addHeaderField( 882 llvm::ConstantInt::get(IntTy, blockInfo.BlockAlign.getQuantity()), 883 getIntSize(), "block.align"); 884 } 885 addHeaderField(blockFn, GenVoidPtrSize, "block.invoke"); 886 if (!IsOpenCL) 887 addHeaderField(descriptor, getPointerSize(), "block.descriptor"); 888 else if (auto *Helper = 889 CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { 890 for (auto I : Helper->getCustomFieldValues(*this, blockInfo)) { 891 addHeaderField( 892 I.first, 893 CharUnits::fromQuantity( 894 CGM.getDataLayout().getTypeAllocSize(I.first->getType())), 895 I.second); 896 } 897 } 898 } 899 900 // Finally, capture all the values into the block. 901 const BlockDecl *blockDecl = blockInfo.getBlockDecl(); 902 903 // First, 'this'. 904 if (blockDecl->capturesCXXThis()) { 905 Address addr = 906 projectField(blockInfo.CXXThisIndex, "block.captured-this.addr"); 907 Builder.CreateStore(LoadCXXThis(), addr); 908 } 909 910 // Next, captured variables. 911 for (const auto &CI : blockDecl->captures()) { 912 const VarDecl *variable = CI.getVariable(); 913 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); 914 915 // Ignore constant captures. 916 if (capture.isConstant()) continue; 917 918 QualType type = capture.fieldType(); 919 920 // This will be a [[type]]*, except that a byref entry will just be 921 // an i8**. 922 Address blockField = projectField(capture.getIndex(), "block.captured"); 923 924 // Compute the address of the thing we're going to move into the 925 // block literal. 926 Address src = Address::invalid(); 927 928 if (blockDecl->isConversionFromLambda()) { 929 // The lambda capture in a lambda's conversion-to-block-pointer is 930 // special; we'll simply emit it directly. 931 src = Address::invalid(); 932 } else if (CI.isEscapingByref()) { 933 if (BlockInfo && CI.isNested()) { 934 // We need to use the capture from the enclosing block. 935 const CGBlockInfo::Capture &enclosingCapture = 936 BlockInfo->getCapture(variable); 937 938 // This is a [[type]]*, except that a byref entry will just be an i8**. 939 src = Builder.CreateStructGEP(LoadBlockStruct(), 940 enclosingCapture.getIndex(), 941 "block.capture.addr"); 942 } else { 943 auto I = LocalDeclMap.find(variable); 944 assert(I != LocalDeclMap.end()); 945 src = I->second; 946 } 947 } else { 948 DeclRefExpr declRef(getContext(), const_cast<VarDecl *>(variable), 949 /*RefersToEnclosingVariableOrCapture*/ CI.isNested(), 950 type.getNonReferenceType(), VK_LValue, 951 SourceLocation()); 952 src = EmitDeclRefLValue(&declRef).getAddress(*this); 953 }; 954 955 // For byrefs, we just write the pointer to the byref struct into 956 // the block field. There's no need to chase the forwarding 957 // pointer at this point, since we're building something that will 958 // live a shorter life than the stack byref anyway. 959 if (CI.isEscapingByref()) { 960 // Get a void* that points to the byref struct. 961 llvm::Value *byrefPointer; 962 if (CI.isNested()) 963 byrefPointer = Builder.CreateLoad(src, "byref.capture"); 964 else 965 byrefPointer = Builder.CreateBitCast(src.getPointer(), VoidPtrTy); 966 967 // Write that void* into the capture field. 968 Builder.CreateStore(byrefPointer, blockField); 969 970 // If we have a copy constructor, evaluate that into the block field. 971 } else if (const Expr *copyExpr = CI.getCopyExpr()) { 972 if (blockDecl->isConversionFromLambda()) { 973 // If we have a lambda conversion, emit the expression 974 // directly into the block instead. 975 AggValueSlot Slot = 976 AggValueSlot::forAddr(blockField, Qualifiers(), 977 AggValueSlot::IsDestructed, 978 AggValueSlot::DoesNotNeedGCBarriers, 979 AggValueSlot::IsNotAliased, 980 AggValueSlot::DoesNotOverlap); 981 EmitAggExpr(copyExpr, Slot); 982 } else { 983 EmitSynthesizedCXXCopyCtor(blockField, src, copyExpr); 984 } 985 986 // If it's a reference variable, copy the reference into the block field. 987 } else if (type->isReferenceType()) { 988 Builder.CreateStore(src.getPointer(), blockField); 989 990 // If type is const-qualified, copy the value into the block field. 991 } else if (type.isConstQualified() && 992 type.getObjCLifetime() == Qualifiers::OCL_Strong && 993 CGM.getCodeGenOpts().OptimizationLevel != 0) { 994 llvm::Value *value = Builder.CreateLoad(src, "captured"); 995 Builder.CreateStore(value, blockField); 996 997 // If this is an ARC __strong block-pointer variable, don't do a 998 // block copy. 999 // 1000 // TODO: this can be generalized into the normal initialization logic: 1001 // we should never need to do a block-copy when initializing a local 1002 // variable, because the local variable's lifetime should be strictly 1003 // contained within the stack block's. 1004 } else if (type.getObjCLifetime() == Qualifiers::OCL_Strong && 1005 type->isBlockPointerType()) { 1006 // Load the block and do a simple retain. 1007 llvm::Value *value = Builder.CreateLoad(src, "block.captured_block"); 1008 value = EmitARCRetainNonBlock(value); 1009 1010 // Do a primitive store to the block field. 1011 Builder.CreateStore(value, blockField); 1012 1013 // Otherwise, fake up a POD copy into the block field. 1014 } else { 1015 // Fake up a new variable so that EmitScalarInit doesn't think 1016 // we're referring to the variable in its own initializer. 1017 ImplicitParamDecl BlockFieldPseudoVar(getContext(), type, 1018 ImplicitParamDecl::Other); 1019 1020 // We use one of these or the other depending on whether the 1021 // reference is nested. 1022 DeclRefExpr declRef(getContext(), const_cast<VarDecl *>(variable), 1023 /*RefersToEnclosingVariableOrCapture*/ CI.isNested(), 1024 type, VK_LValue, SourceLocation()); 1025 1026 ImplicitCastExpr l2r(ImplicitCastExpr::OnStack, type, CK_LValueToRValue, 1027 &declRef, VK_RValue); 1028 // FIXME: Pass a specific location for the expr init so that the store is 1029 // attributed to a reasonable location - otherwise it may be attributed to 1030 // locations of subexpressions in the initialization. 1031 EmitExprAsInit(&l2r, &BlockFieldPseudoVar, 1032 MakeAddrLValue(blockField, type, AlignmentSource::Decl), 1033 /*captured by init*/ false); 1034 } 1035 1036 // Push a cleanup for the capture if necessary. 1037 if (!blockInfo.NeedsCopyDispose) 1038 continue; 1039 1040 // Ignore __block captures; there's nothing special in the on-stack block 1041 // that we need to do for them. 1042 if (CI.isByRef()) 1043 continue; 1044 1045 // Ignore objects that aren't destructed. 1046 QualType::DestructionKind dtorKind = type.isDestructedType(); 1047 if (dtorKind == QualType::DK_none) 1048 continue; 1049 1050 CodeGenFunction::Destroyer *destroyer; 1051 1052 // Block captures count as local values and have imprecise semantics. 1053 // They also can't be arrays, so need to worry about that. 1054 // 1055 // For const-qualified captures, emit clang.arc.use to ensure the captured 1056 // object doesn't get released while we are still depending on its validity 1057 // within the block. 1058 if (type.isConstQualified() && 1059 type.getObjCLifetime() == Qualifiers::OCL_Strong && 1060 CGM.getCodeGenOpts().OptimizationLevel != 0) { 1061 assert(CGM.getLangOpts().ObjCAutoRefCount && 1062 "expected ObjC ARC to be enabled"); 1063 destroyer = emitARCIntrinsicUse; 1064 } else if (dtorKind == QualType::DK_objc_strong_lifetime) { 1065 destroyer = destroyARCStrongImprecise; 1066 } else { 1067 destroyer = getDestroyer(dtorKind); 1068 } 1069 1070 CleanupKind cleanupKind = NormalCleanup; 1071 bool useArrayEHCleanup = needsEHCleanup(dtorKind); 1072 if (useArrayEHCleanup) 1073 cleanupKind = NormalAndEHCleanup; 1074 1075 // Extend the lifetime of the capture to the end of the scope enclosing the 1076 // block expression except when the block decl is in the list of RetExpr's 1077 // cleanup objects, in which case its lifetime ends after the full 1078 // expression. 1079 auto IsBlockDeclInRetExpr = [&]() { 1080 auto *EWC = llvm::dyn_cast_or_null<ExprWithCleanups>(RetExpr); 1081 if (EWC) 1082 for (auto &C : EWC->getObjects()) 1083 if (auto *BD = C.dyn_cast<BlockDecl *>()) 1084 if (BD == blockDecl) 1085 return true; 1086 return false; 1087 }; 1088 1089 if (IsBlockDeclInRetExpr()) 1090 pushDestroy(cleanupKind, blockField, type, destroyer, useArrayEHCleanup); 1091 else 1092 pushLifetimeExtendedDestroy(cleanupKind, blockField, type, destroyer, 1093 useArrayEHCleanup); 1094 } 1095 1096 // Cast to the converted block-pointer type, which happens (somewhat 1097 // unfortunately) to be a pointer to function type. 1098 llvm::Value *result = Builder.CreatePointerCast( 1099 blockAddr.getPointer(), ConvertType(blockInfo.getBlockExpr()->getType())); 1100 1101 if (IsOpenCL) { 1102 CGM.getOpenCLRuntime().recordBlockInfo(blockInfo.BlockExpression, InvokeFn, 1103 result); 1104 } 1105 1106 return result; 1107 } 1108 1109 1110 llvm::Type *CodeGenModule::getBlockDescriptorType() { 1111 if (BlockDescriptorType) 1112 return BlockDescriptorType; 1113 1114 llvm::Type *UnsignedLongTy = 1115 getTypes().ConvertType(getContext().UnsignedLongTy); 1116 1117 // struct __block_descriptor { 1118 // unsigned long reserved; 1119 // unsigned long block_size; 1120 // 1121 // // later, the following will be added 1122 // 1123 // struct { 1124 // void (*copyHelper)(); 1125 // void (*copyHelper)(); 1126 // } helpers; // !!! optional 1127 // 1128 // const char *signature; // the block signature 1129 // const char *layout; // reserved 1130 // }; 1131 BlockDescriptorType = llvm::StructType::create( 1132 "struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy); 1133 1134 // Now form a pointer to that. 1135 unsigned AddrSpace = 0; 1136 if (getLangOpts().OpenCL) 1137 AddrSpace = getContext().getTargetAddressSpace(LangAS::opencl_constant); 1138 BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace); 1139 return BlockDescriptorType; 1140 } 1141 1142 llvm::Type *CodeGenModule::getGenericBlockLiteralType() { 1143 if (GenericBlockLiteralType) 1144 return GenericBlockLiteralType; 1145 1146 llvm::Type *BlockDescPtrTy = getBlockDescriptorType(); 1147 1148 if (getLangOpts().OpenCL) { 1149 // struct __opencl_block_literal_generic { 1150 // int __size; 1151 // int __align; 1152 // __generic void *__invoke; 1153 // /* custom fields */ 1154 // }; 1155 SmallVector<llvm::Type *, 8> StructFields( 1156 {IntTy, IntTy, getOpenCLRuntime().getGenericVoidPointerType()}); 1157 if (auto *Helper = getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { 1158 for (auto I : Helper->getCustomFieldTypes()) 1159 StructFields.push_back(I); 1160 } 1161 GenericBlockLiteralType = llvm::StructType::create( 1162 StructFields, "struct.__opencl_block_literal_generic"); 1163 } else { 1164 // struct __block_literal_generic { 1165 // void *__isa; 1166 // int __flags; 1167 // int __reserved; 1168 // void (*__invoke)(void *); 1169 // struct __block_descriptor *__descriptor; 1170 // }; 1171 GenericBlockLiteralType = 1172 llvm::StructType::create("struct.__block_literal_generic", VoidPtrTy, 1173 IntTy, IntTy, VoidPtrTy, BlockDescPtrTy); 1174 } 1175 1176 return GenericBlockLiteralType; 1177 } 1178 1179 RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E, 1180 ReturnValueSlot ReturnValue) { 1181 const auto *BPT = E->getCallee()->getType()->castAs<BlockPointerType>(); 1182 llvm::Value *BlockPtr = EmitScalarExpr(E->getCallee()); 1183 llvm::Type *GenBlockTy = CGM.getGenericBlockLiteralType(); 1184 llvm::Value *Func = nullptr; 1185 QualType FnType = BPT->getPointeeType(); 1186 ASTContext &Ctx = getContext(); 1187 CallArgList Args; 1188 1189 if (getLangOpts().OpenCL) { 1190 // For OpenCL, BlockPtr is already casted to generic block literal. 1191 1192 // First argument of a block call is a generic block literal casted to 1193 // generic void pointer, i.e. i8 addrspace(4)* 1194 llvm::Value *BlockDescriptor = Builder.CreatePointerCast( 1195 BlockPtr, CGM.getOpenCLRuntime().getGenericVoidPointerType()); 1196 QualType VoidPtrQualTy = Ctx.getPointerType( 1197 Ctx.getAddrSpaceQualType(Ctx.VoidTy, LangAS::opencl_generic)); 1198 Args.add(RValue::get(BlockDescriptor), VoidPtrQualTy); 1199 // And the rest of the arguments. 1200 EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments()); 1201 1202 // We *can* call the block directly unless it is a function argument. 1203 if (!isa<ParmVarDecl>(E->getCalleeDecl())) 1204 Func = CGM.getOpenCLRuntime().getInvokeFunction(E->getCallee()); 1205 else { 1206 llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 2); 1207 Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign()); 1208 } 1209 } else { 1210 // Bitcast the block literal to a generic block literal. 1211 BlockPtr = Builder.CreatePointerCast( 1212 BlockPtr, llvm::PointerType::get(GenBlockTy, 0), "block.literal"); 1213 // Get pointer to the block invoke function 1214 llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 3); 1215 1216 // First argument is a block literal casted to a void pointer 1217 BlockPtr = Builder.CreatePointerCast(BlockPtr, VoidPtrTy); 1218 Args.add(RValue::get(BlockPtr), Ctx.VoidPtrTy); 1219 // And the rest of the arguments. 1220 EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments()); 1221 1222 // Load the function. 1223 Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign()); 1224 } 1225 1226 const FunctionType *FuncTy = FnType->castAs<FunctionType>(); 1227 const CGFunctionInfo &FnInfo = 1228 CGM.getTypes().arrangeBlockFunctionCall(Args, FuncTy); 1229 1230 // Cast the function pointer to the right type. 1231 llvm::Type *BlockFTy = CGM.getTypes().GetFunctionType(FnInfo); 1232 1233 llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy); 1234 Func = Builder.CreatePointerCast(Func, BlockFTyPtr); 1235 1236 // Prepare the callee. 1237 CGCallee Callee(CGCalleeInfo(), Func); 1238 1239 // And call the block. 1240 return EmitCall(FnInfo, Callee, ReturnValue, Args); 1241 } 1242 1243 Address CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable) { 1244 assert(BlockInfo && "evaluating block ref without block information?"); 1245 const CGBlockInfo::Capture &capture = BlockInfo->getCapture(variable); 1246 1247 // Handle constant captures. 1248 if (capture.isConstant()) return LocalDeclMap.find(variable)->second; 1249 1250 Address addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(), 1251 "block.capture.addr"); 1252 1253 if (variable->isEscapingByref()) { 1254 // addr should be a void** right now. Load, then cast the result 1255 // to byref*. 1256 1257 auto &byrefInfo = getBlockByrefInfo(variable); 1258 addr = Address(Builder.CreateLoad(addr), byrefInfo.ByrefAlignment); 1259 1260 auto byrefPointerType = llvm::PointerType::get(byrefInfo.Type, 0); 1261 addr = Builder.CreateBitCast(addr, byrefPointerType, "byref.addr"); 1262 1263 addr = emitBlockByrefAddress(addr, byrefInfo, /*follow*/ true, 1264 variable->getName()); 1265 } 1266 1267 assert((!variable->isNonEscapingByref() || 1268 capture.fieldType()->isReferenceType()) && 1269 "the capture field of a non-escaping variable should have a " 1270 "reference type"); 1271 if (capture.fieldType()->isReferenceType()) 1272 addr = EmitLoadOfReference(MakeAddrLValue(addr, capture.fieldType())); 1273 1274 return addr; 1275 } 1276 1277 void CodeGenModule::setAddrOfGlobalBlock(const BlockExpr *BE, 1278 llvm::Constant *Addr) { 1279 bool Ok = EmittedGlobalBlocks.insert(std::make_pair(BE, Addr)).second; 1280 (void)Ok; 1281 assert(Ok && "Trying to replace an already-existing global block!"); 1282 } 1283 1284 llvm::Constant * 1285 CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *BE, 1286 StringRef Name) { 1287 if (llvm::Constant *Block = getAddrOfGlobalBlockIfEmitted(BE)) 1288 return Block; 1289 1290 CGBlockInfo blockInfo(BE->getBlockDecl(), Name); 1291 blockInfo.BlockExpression = BE; 1292 1293 // Compute information about the layout, etc., of this block. 1294 computeBlockInfo(*this, nullptr, blockInfo); 1295 1296 // Using that metadata, generate the actual block function. 1297 { 1298 CodeGenFunction::DeclMapTy LocalDeclMap; 1299 CodeGenFunction(*this).GenerateBlockFunction( 1300 GlobalDecl(), blockInfo, LocalDeclMap, 1301 /*IsLambdaConversionToBlock*/ false, /*BuildGlobalBlock*/ true); 1302 } 1303 1304 return getAddrOfGlobalBlockIfEmitted(BE); 1305 } 1306 1307 static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM, 1308 const CGBlockInfo &blockInfo, 1309 llvm::Constant *blockFn) { 1310 assert(blockInfo.CanBeGlobal); 1311 // Callers should detect this case on their own: calling this function 1312 // generally requires computing layout information, which is a waste of time 1313 // if we've already emitted this block. 1314 assert(!CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression) && 1315 "Refusing to re-emit a global block."); 1316 1317 // Generate the constants for the block literal initializer. 1318 ConstantInitBuilder builder(CGM); 1319 auto fields = builder.beginStruct(); 1320 1321 bool IsOpenCL = CGM.getLangOpts().OpenCL; 1322 bool IsWindows = CGM.getTarget().getTriple().isOSWindows(); 1323 if (!IsOpenCL) { 1324 // isa 1325 if (IsWindows) 1326 fields.addNullPointer(CGM.Int8PtrPtrTy); 1327 else 1328 fields.add(CGM.getNSConcreteGlobalBlock()); 1329 1330 // __flags 1331 BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE; 1332 if (blockInfo.UsesStret) 1333 flags |= BLOCK_USE_STRET; 1334 1335 fields.addInt(CGM.IntTy, flags.getBitMask()); 1336 1337 // Reserved 1338 fields.addInt(CGM.IntTy, 0); 1339 } else { 1340 fields.addInt(CGM.IntTy, blockInfo.BlockSize.getQuantity()); 1341 fields.addInt(CGM.IntTy, blockInfo.BlockAlign.getQuantity()); 1342 } 1343 1344 // Function 1345 fields.add(blockFn); 1346 1347 if (!IsOpenCL) { 1348 // Descriptor 1349 fields.add(buildBlockDescriptor(CGM, blockInfo)); 1350 } else if (auto *Helper = 1351 CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { 1352 for (auto I : Helper->getCustomFieldValues(CGM, blockInfo)) { 1353 fields.add(I); 1354 } 1355 } 1356 1357 unsigned AddrSpace = 0; 1358 if (CGM.getContext().getLangOpts().OpenCL) 1359 AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_global); 1360 1361 llvm::GlobalVariable *literal = fields.finishAndCreateGlobal( 1362 "__block_literal_global", blockInfo.BlockAlign, 1363 /*constant*/ !IsWindows, llvm::GlobalVariable::InternalLinkage, AddrSpace); 1364 1365 literal->addAttribute("objc_arc_inert"); 1366 1367 // Windows does not allow globals to be initialised to point to globals in 1368 // different DLLs. Any such variables must run code to initialise them. 1369 if (IsWindows) { 1370 auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy, 1371 {}), llvm::GlobalValue::InternalLinkage, ".block_isa_init", 1372 &CGM.getModule()); 1373 llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry", 1374 Init)); 1375 b.CreateAlignedStore(CGM.getNSConcreteGlobalBlock(), 1376 b.CreateStructGEP(literal, 0), 1377 CGM.getPointerAlign().getAsAlign()); 1378 b.CreateRetVoid(); 1379 // We can't use the normal LLVM global initialisation array, because we 1380 // need to specify that this runs early in library initialisation. 1381 auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), 1382 /*isConstant*/true, llvm::GlobalValue::InternalLinkage, 1383 Init, ".block_isa_init_ptr"); 1384 InitVar->setSection(".CRT$XCLa"); 1385 CGM.addUsedGlobal(InitVar); 1386 } 1387 1388 // Return a constant of the appropriately-casted type. 1389 llvm::Type *RequiredType = 1390 CGM.getTypes().ConvertType(blockInfo.getBlockExpr()->getType()); 1391 llvm::Constant *Result = 1392 llvm::ConstantExpr::getPointerCast(literal, RequiredType); 1393 CGM.setAddrOfGlobalBlock(blockInfo.BlockExpression, Result); 1394 if (CGM.getContext().getLangOpts().OpenCL) 1395 CGM.getOpenCLRuntime().recordBlockInfo( 1396 blockInfo.BlockExpression, 1397 cast<llvm::Function>(blockFn->stripPointerCasts()), Result); 1398 return Result; 1399 } 1400 1401 void CodeGenFunction::setBlockContextParameter(const ImplicitParamDecl *D, 1402 unsigned argNum, 1403 llvm::Value *arg) { 1404 assert(BlockInfo && "not emitting prologue of block invocation function?!"); 1405 1406 // Allocate a stack slot like for any local variable to guarantee optimal 1407 // debug info at -O0. The mem2reg pass will eliminate it when optimizing. 1408 Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr"); 1409 Builder.CreateStore(arg, alloc); 1410 if (CGDebugInfo *DI = getDebugInfo()) { 1411 if (CGM.getCodeGenOpts().hasReducedDebugInfo()) { 1412 DI->setLocation(D->getLocation()); 1413 DI->EmitDeclareOfBlockLiteralArgVariable( 1414 *BlockInfo, D->getName(), argNum, 1415 cast<llvm::AllocaInst>(alloc.getPointer()), Builder); 1416 } 1417 } 1418 1419 SourceLocation StartLoc = BlockInfo->getBlockExpr()->getBody()->getBeginLoc(); 1420 ApplyDebugLocation Scope(*this, StartLoc); 1421 1422 // Instead of messing around with LocalDeclMap, just set the value 1423 // directly as BlockPointer. 1424 BlockPointer = Builder.CreatePointerCast( 1425 arg, 1426 BlockInfo->StructureType->getPointerTo( 1427 getContext().getLangOpts().OpenCL 1428 ? getContext().getTargetAddressSpace(LangAS::opencl_generic) 1429 : 0), 1430 "block"); 1431 } 1432 1433 Address CodeGenFunction::LoadBlockStruct() { 1434 assert(BlockInfo && "not in a block invocation function!"); 1435 assert(BlockPointer && "no block pointer set!"); 1436 return Address(BlockPointer, BlockInfo->BlockAlign); 1437 } 1438 1439 llvm::Function * 1440 CodeGenFunction::GenerateBlockFunction(GlobalDecl GD, 1441 const CGBlockInfo &blockInfo, 1442 const DeclMapTy &ldm, 1443 bool IsLambdaConversionToBlock, 1444 bool BuildGlobalBlock) { 1445 const BlockDecl *blockDecl = blockInfo.getBlockDecl(); 1446 1447 CurGD = GD; 1448 1449 CurEHLocation = blockInfo.getBlockExpr()->getEndLoc(); 1450 1451 BlockInfo = &blockInfo; 1452 1453 // Arrange for local static and local extern declarations to appear 1454 // to be local to this function as well, in case they're directly 1455 // referenced in a block. 1456 for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) { 1457 const auto *var = dyn_cast<VarDecl>(i->first); 1458 if (var && !var->hasLocalStorage()) 1459 setAddrOfLocalVar(var, i->second); 1460 } 1461 1462 // Begin building the function declaration. 1463 1464 // Build the argument list. 1465 FunctionArgList args; 1466 1467 // The first argument is the block pointer. Just take it as a void* 1468 // and cast it later. 1469 QualType selfTy = getContext().VoidPtrTy; 1470 1471 // For OpenCL passed block pointer can be private AS local variable or 1472 // global AS program scope variable (for the case with and without captures). 1473 // Generic AS is used therefore to be able to accommodate both private and 1474 // generic AS in one implementation. 1475 if (getLangOpts().OpenCL) 1476 selfTy = getContext().getPointerType(getContext().getAddrSpaceQualType( 1477 getContext().VoidTy, LangAS::opencl_generic)); 1478 1479 IdentifierInfo *II = &CGM.getContext().Idents.get(".block_descriptor"); 1480 1481 ImplicitParamDecl SelfDecl(getContext(), const_cast<BlockDecl *>(blockDecl), 1482 SourceLocation(), II, selfTy, 1483 ImplicitParamDecl::ObjCSelf); 1484 args.push_back(&SelfDecl); 1485 1486 // Now add the rest of the parameters. 1487 args.append(blockDecl->param_begin(), blockDecl->param_end()); 1488 1489 // Create the function declaration. 1490 const FunctionProtoType *fnType = blockInfo.getBlockExpr()->getFunctionType(); 1491 const CGFunctionInfo &fnInfo = 1492 CGM.getTypes().arrangeBlockFunctionDeclaration(fnType, args); 1493 if (CGM.ReturnSlotInterferesWithArgs(fnInfo)) 1494 blockInfo.UsesStret = true; 1495 1496 llvm::FunctionType *fnLLVMType = CGM.getTypes().GetFunctionType(fnInfo); 1497 1498 StringRef name = CGM.getBlockMangledName(GD, blockDecl); 1499 llvm::Function *fn = llvm::Function::Create( 1500 fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &CGM.getModule()); 1501 CGM.SetInternalFunctionAttributes(blockDecl, fn, fnInfo); 1502 1503 if (BuildGlobalBlock) { 1504 auto GenVoidPtrTy = getContext().getLangOpts().OpenCL 1505 ? CGM.getOpenCLRuntime().getGenericVoidPointerType() 1506 : VoidPtrTy; 1507 buildGlobalBlock(CGM, blockInfo, 1508 llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy)); 1509 } 1510 1511 // Begin generating the function. 1512 StartFunction(blockDecl, fnType->getReturnType(), fn, fnInfo, args, 1513 blockDecl->getLocation(), 1514 blockInfo.getBlockExpr()->getBody()->getBeginLoc()); 1515 1516 // Okay. Undo some of what StartFunction did. 1517 1518 // At -O0 we generate an explicit alloca for the BlockPointer, so the RA 1519 // won't delete the dbg.declare intrinsics for captured variables. 1520 llvm::Value *BlockPointerDbgLoc = BlockPointer; 1521 if (CGM.getCodeGenOpts().OptimizationLevel == 0) { 1522 // Allocate a stack slot for it, so we can point the debugger to it 1523 Address Alloca = CreateTempAlloca(BlockPointer->getType(), 1524 getPointerAlign(), 1525 "block.addr"); 1526 // Set the DebugLocation to empty, so the store is recognized as a 1527 // frame setup instruction by llvm::DwarfDebug::beginFunction(). 1528 auto NL = ApplyDebugLocation::CreateEmpty(*this); 1529 Builder.CreateStore(BlockPointer, Alloca); 1530 BlockPointerDbgLoc = Alloca.getPointer(); 1531 } 1532 1533 // If we have a C++ 'this' reference, go ahead and force it into 1534 // existence now. 1535 if (blockDecl->capturesCXXThis()) { 1536 Address addr = Builder.CreateStructGEP( 1537 LoadBlockStruct(), blockInfo.CXXThisIndex, "block.captured-this"); 1538 CXXThisValue = Builder.CreateLoad(addr, "this"); 1539 } 1540 1541 // Also force all the constant captures. 1542 for (const auto &CI : blockDecl->captures()) { 1543 const VarDecl *variable = CI.getVariable(); 1544 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); 1545 if (!capture.isConstant()) continue; 1546 1547 CharUnits align = getContext().getDeclAlign(variable); 1548 Address alloca = 1549 CreateMemTemp(variable->getType(), align, "block.captured-const"); 1550 1551 Builder.CreateStore(capture.getConstant(), alloca); 1552 1553 setAddrOfLocalVar(variable, alloca); 1554 } 1555 1556 // Save a spot to insert the debug information for all the DeclRefExprs. 1557 llvm::BasicBlock *entry = Builder.GetInsertBlock(); 1558 llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint(); 1559 --entry_ptr; 1560 1561 if (IsLambdaConversionToBlock) 1562 EmitLambdaBlockInvokeBody(); 1563 else { 1564 PGO.assignRegionCounters(GlobalDecl(blockDecl), fn); 1565 incrementProfileCounter(blockDecl->getBody()); 1566 EmitStmt(blockDecl->getBody()); 1567 } 1568 1569 // Remember where we were... 1570 llvm::BasicBlock *resume = Builder.GetInsertBlock(); 1571 1572 // Go back to the entry. 1573 ++entry_ptr; 1574 Builder.SetInsertPoint(entry, entry_ptr); 1575 1576 // Emit debug information for all the DeclRefExprs. 1577 // FIXME: also for 'this' 1578 if (CGDebugInfo *DI = getDebugInfo()) { 1579 for (const auto &CI : blockDecl->captures()) { 1580 const VarDecl *variable = CI.getVariable(); 1581 DI->EmitLocation(Builder, variable->getLocation()); 1582 1583 if (CGM.getCodeGenOpts().hasReducedDebugInfo()) { 1584 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); 1585 if (capture.isConstant()) { 1586 auto addr = LocalDeclMap.find(variable)->second; 1587 (void)DI->EmitDeclareOfAutoVariable(variable, addr.getPointer(), 1588 Builder); 1589 continue; 1590 } 1591 1592 DI->EmitDeclareOfBlockDeclRefVariable( 1593 variable, BlockPointerDbgLoc, Builder, blockInfo, 1594 entry_ptr == entry->end() ? nullptr : &*entry_ptr); 1595 } 1596 } 1597 // Recover location if it was changed in the above loop. 1598 DI->EmitLocation(Builder, 1599 cast<CompoundStmt>(blockDecl->getBody())->getRBracLoc()); 1600 } 1601 1602 // And resume where we left off. 1603 if (resume == nullptr) 1604 Builder.ClearInsertionPoint(); 1605 else 1606 Builder.SetInsertPoint(resume); 1607 1608 FinishFunction(cast<CompoundStmt>(blockDecl->getBody())->getRBracLoc()); 1609 1610 return fn; 1611 } 1612 1613 static std::pair<BlockCaptureEntityKind, BlockFieldFlags> 1614 computeCopyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T, 1615 const LangOptions &LangOpts) { 1616 if (CI.getCopyExpr()) { 1617 assert(!CI.isByRef()); 1618 // don't bother computing flags 1619 return std::make_pair(BlockCaptureEntityKind::CXXRecord, BlockFieldFlags()); 1620 } 1621 BlockFieldFlags Flags; 1622 if (CI.isEscapingByref()) { 1623 Flags = BLOCK_FIELD_IS_BYREF; 1624 if (T.isObjCGCWeak()) 1625 Flags |= BLOCK_FIELD_IS_WEAK; 1626 return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); 1627 } 1628 1629 Flags = BLOCK_FIELD_IS_OBJECT; 1630 bool isBlockPointer = T->isBlockPointerType(); 1631 if (isBlockPointer) 1632 Flags = BLOCK_FIELD_IS_BLOCK; 1633 1634 switch (T.isNonTrivialToPrimitiveCopy()) { 1635 case QualType::PCK_Struct: 1636 return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct, 1637 BlockFieldFlags()); 1638 case QualType::PCK_ARCWeak: 1639 // We need to register __weak direct captures with the runtime. 1640 return std::make_pair(BlockCaptureEntityKind::ARCWeak, Flags); 1641 case QualType::PCK_ARCStrong: 1642 // We need to retain the copied value for __strong direct captures. 1643 // If it's a block pointer, we have to copy the block and assign that to 1644 // the destination pointer, so we might as well use _Block_object_assign. 1645 // Otherwise we can avoid that. 1646 return std::make_pair(!isBlockPointer ? BlockCaptureEntityKind::ARCStrong 1647 : BlockCaptureEntityKind::BlockObject, 1648 Flags); 1649 case QualType::PCK_Trivial: 1650 case QualType::PCK_VolatileTrivial: { 1651 if (!T->isObjCRetainableType()) 1652 // For all other types, the memcpy is fine. 1653 return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); 1654 1655 // Special rules for ARC captures: 1656 Qualifiers QS = T.getQualifiers(); 1657 1658 // Non-ARC captures of retainable pointers are strong and 1659 // therefore require a call to _Block_object_assign. 1660 if (!QS.getObjCLifetime() && !LangOpts.ObjCAutoRefCount) 1661 return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); 1662 1663 // Otherwise the memcpy is fine. 1664 return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); 1665 } 1666 } 1667 llvm_unreachable("after exhaustive PrimitiveCopyKind switch"); 1668 } 1669 1670 static std::pair<BlockCaptureEntityKind, BlockFieldFlags> 1671 computeDestroyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T, 1672 const LangOptions &LangOpts); 1673 1674 /// Find the set of block captures that need to be explicitly copied or destroy. 1675 static void findBlockCapturedManagedEntities( 1676 const CGBlockInfo &BlockInfo, const LangOptions &LangOpts, 1677 SmallVectorImpl<BlockCaptureManagedEntity> &ManagedCaptures) { 1678 for (const auto &CI : BlockInfo.getBlockDecl()->captures()) { 1679 const VarDecl *Variable = CI.getVariable(); 1680 const CGBlockInfo::Capture &Capture = BlockInfo.getCapture(Variable); 1681 if (Capture.isConstant()) 1682 continue; 1683 1684 QualType VT = Capture.fieldType(); 1685 auto CopyInfo = computeCopyInfoForBlockCapture(CI, VT, LangOpts); 1686 auto DisposeInfo = computeDestroyInfoForBlockCapture(CI, VT, LangOpts); 1687 if (CopyInfo.first != BlockCaptureEntityKind::None || 1688 DisposeInfo.first != BlockCaptureEntityKind::None) 1689 ManagedCaptures.emplace_back(CopyInfo.first, DisposeInfo.first, 1690 CopyInfo.second, DisposeInfo.second, CI, 1691 Capture); 1692 } 1693 1694 // Sort the captures by offset. 1695 llvm::sort(ManagedCaptures); 1696 } 1697 1698 namespace { 1699 /// Release a __block variable. 1700 struct CallBlockRelease final : EHScopeStack::Cleanup { 1701 Address Addr; 1702 BlockFieldFlags FieldFlags; 1703 bool LoadBlockVarAddr, CanThrow; 1704 1705 CallBlockRelease(Address Addr, BlockFieldFlags Flags, bool LoadValue, 1706 bool CT) 1707 : Addr(Addr), FieldFlags(Flags), LoadBlockVarAddr(LoadValue), 1708 CanThrow(CT) {} 1709 1710 void Emit(CodeGenFunction &CGF, Flags flags) override { 1711 llvm::Value *BlockVarAddr; 1712 if (LoadBlockVarAddr) { 1713 BlockVarAddr = CGF.Builder.CreateLoad(Addr); 1714 BlockVarAddr = CGF.Builder.CreateBitCast(BlockVarAddr, CGF.VoidPtrTy); 1715 } else { 1716 BlockVarAddr = Addr.getPointer(); 1717 } 1718 1719 CGF.BuildBlockRelease(BlockVarAddr, FieldFlags, CanThrow); 1720 } 1721 }; 1722 } // end anonymous namespace 1723 1724 /// Check if \p T is a C++ class that has a destructor that can throw. 1725 bool CodeGenFunction::cxxDestructorCanThrow(QualType T) { 1726 if (const auto *RD = T->getAsCXXRecordDecl()) 1727 if (const CXXDestructorDecl *DD = RD->getDestructor()) 1728 return DD->getType()->castAs<FunctionProtoType>()->canThrow(); 1729 return false; 1730 } 1731 1732 // Return a string that has the information about a capture. 1733 static std::string getBlockCaptureStr(const BlockCaptureManagedEntity &E, 1734 CaptureStrKind StrKind, 1735 CharUnits BlockAlignment, 1736 CodeGenModule &CGM) { 1737 std::string Str; 1738 ASTContext &Ctx = CGM.getContext(); 1739 const BlockDecl::Capture &CI = *E.CI; 1740 QualType CaptureTy = CI.getVariable()->getType(); 1741 1742 BlockCaptureEntityKind Kind; 1743 BlockFieldFlags Flags; 1744 1745 // CaptureStrKind::Merged should be passed only when the operations and the 1746 // flags are the same for copy and dispose. 1747 assert((StrKind != CaptureStrKind::Merged || 1748 (E.CopyKind == E.DisposeKind && E.CopyFlags == E.DisposeFlags)) && 1749 "different operations and flags"); 1750 1751 if (StrKind == CaptureStrKind::DisposeHelper) { 1752 Kind = E.DisposeKind; 1753 Flags = E.DisposeFlags; 1754 } else { 1755 Kind = E.CopyKind; 1756 Flags = E.CopyFlags; 1757 } 1758 1759 switch (Kind) { 1760 case BlockCaptureEntityKind::CXXRecord: { 1761 Str += "c"; 1762 SmallString<256> TyStr; 1763 llvm::raw_svector_ostream Out(TyStr); 1764 CGM.getCXXABI().getMangleContext().mangleTypeName(CaptureTy, Out); 1765 Str += llvm::to_string(TyStr.size()) + TyStr.c_str(); 1766 break; 1767 } 1768 case BlockCaptureEntityKind::ARCWeak: 1769 Str += "w"; 1770 break; 1771 case BlockCaptureEntityKind::ARCStrong: 1772 Str += "s"; 1773 break; 1774 case BlockCaptureEntityKind::BlockObject: { 1775 const VarDecl *Var = CI.getVariable(); 1776 unsigned F = Flags.getBitMask(); 1777 if (F & BLOCK_FIELD_IS_BYREF) { 1778 Str += "r"; 1779 if (F & BLOCK_FIELD_IS_WEAK) 1780 Str += "w"; 1781 else { 1782 // If CaptureStrKind::Merged is passed, check both the copy expression 1783 // and the destructor. 1784 if (StrKind != CaptureStrKind::DisposeHelper) { 1785 if (Ctx.getBlockVarCopyInit(Var).canThrow()) 1786 Str += "c"; 1787 } 1788 if (StrKind != CaptureStrKind::CopyHelper) { 1789 if (CodeGenFunction::cxxDestructorCanThrow(CaptureTy)) 1790 Str += "d"; 1791 } 1792 } 1793 } else { 1794 assert((F & BLOCK_FIELD_IS_OBJECT) && "unexpected flag value"); 1795 if (F == BLOCK_FIELD_IS_BLOCK) 1796 Str += "b"; 1797 else 1798 Str += "o"; 1799 } 1800 break; 1801 } 1802 case BlockCaptureEntityKind::NonTrivialCStruct: { 1803 bool IsVolatile = CaptureTy.isVolatileQualified(); 1804 CharUnits Alignment = 1805 BlockAlignment.alignmentAtOffset(E.Capture->getOffset()); 1806 1807 Str += "n"; 1808 std::string FuncStr; 1809 if (StrKind == CaptureStrKind::DisposeHelper) 1810 FuncStr = CodeGenFunction::getNonTrivialDestructorStr( 1811 CaptureTy, Alignment, IsVolatile, Ctx); 1812 else 1813 // If CaptureStrKind::Merged is passed, use the copy constructor string. 1814 // It has all the information that the destructor string has. 1815 FuncStr = CodeGenFunction::getNonTrivialCopyConstructorStr( 1816 CaptureTy, Alignment, IsVolatile, Ctx); 1817 // The underscore is necessary here because non-trivial copy constructor 1818 // and destructor strings can start with a number. 1819 Str += llvm::to_string(FuncStr.size()) + "_" + FuncStr; 1820 break; 1821 } 1822 case BlockCaptureEntityKind::None: 1823 break; 1824 } 1825 1826 return Str; 1827 } 1828 1829 static std::string getCopyDestroyHelperFuncName( 1830 const SmallVectorImpl<BlockCaptureManagedEntity> &Captures, 1831 CharUnits BlockAlignment, CaptureStrKind StrKind, CodeGenModule &CGM) { 1832 assert((StrKind == CaptureStrKind::CopyHelper || 1833 StrKind == CaptureStrKind::DisposeHelper) && 1834 "unexpected CaptureStrKind"); 1835 std::string Name = StrKind == CaptureStrKind::CopyHelper 1836 ? "__copy_helper_block_" 1837 : "__destroy_helper_block_"; 1838 if (CGM.getLangOpts().Exceptions) 1839 Name += "e"; 1840 if (CGM.getCodeGenOpts().ObjCAutoRefCountExceptions) 1841 Name += "a"; 1842 Name += llvm::to_string(BlockAlignment.getQuantity()) + "_"; 1843 1844 for (const BlockCaptureManagedEntity &E : Captures) { 1845 Name += llvm::to_string(E.Capture->getOffset().getQuantity()); 1846 Name += getBlockCaptureStr(E, StrKind, BlockAlignment, CGM); 1847 } 1848 1849 return Name; 1850 } 1851 1852 static void pushCaptureCleanup(BlockCaptureEntityKind CaptureKind, 1853 Address Field, QualType CaptureType, 1854 BlockFieldFlags Flags, bool ForCopyHelper, 1855 VarDecl *Var, CodeGenFunction &CGF) { 1856 bool EHOnly = ForCopyHelper; 1857 1858 switch (CaptureKind) { 1859 case BlockCaptureEntityKind::CXXRecord: 1860 case BlockCaptureEntityKind::ARCWeak: 1861 case BlockCaptureEntityKind::NonTrivialCStruct: 1862 case BlockCaptureEntityKind::ARCStrong: { 1863 if (CaptureType.isDestructedType() && 1864 (!EHOnly || CGF.needsEHCleanup(CaptureType.isDestructedType()))) { 1865 CodeGenFunction::Destroyer *Destroyer = 1866 CaptureKind == BlockCaptureEntityKind::ARCStrong 1867 ? CodeGenFunction::destroyARCStrongImprecise 1868 : CGF.getDestroyer(CaptureType.isDestructedType()); 1869 CleanupKind Kind = 1870 EHOnly ? EHCleanup 1871 : CGF.getCleanupKind(CaptureType.isDestructedType()); 1872 CGF.pushDestroy(Kind, Field, CaptureType, Destroyer, Kind & EHCleanup); 1873 } 1874 break; 1875 } 1876 case BlockCaptureEntityKind::BlockObject: { 1877 if (!EHOnly || CGF.getLangOpts().Exceptions) { 1878 CleanupKind Kind = EHOnly ? EHCleanup : NormalAndEHCleanup; 1879 // Calls to _Block_object_dispose along the EH path in the copy helper 1880 // function don't throw as newly-copied __block variables always have a 1881 // reference count of 2. 1882 bool CanThrow = 1883 !ForCopyHelper && CGF.cxxDestructorCanThrow(CaptureType); 1884 CGF.enterByrefCleanup(Kind, Field, Flags, /*LoadBlockVarAddr*/ true, 1885 CanThrow); 1886 } 1887 break; 1888 } 1889 case BlockCaptureEntityKind::None: 1890 break; 1891 } 1892 } 1893 1894 static void setBlockHelperAttributesVisibility(bool CapturesNonExternalType, 1895 llvm::Function *Fn, 1896 const CGFunctionInfo &FI, 1897 CodeGenModule &CGM) { 1898 if (CapturesNonExternalType) { 1899 CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); 1900 } else { 1901 Fn->setVisibility(llvm::GlobalValue::HiddenVisibility); 1902 Fn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 1903 CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, Fn); 1904 CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Fn); 1905 } 1906 } 1907 /// Generate the copy-helper function for a block closure object: 1908 /// static void block_copy_helper(block_t *dst, block_t *src); 1909 /// The runtime will have previously initialized 'dst' by doing a 1910 /// bit-copy of 'src'. 1911 /// 1912 /// Note that this copies an entire block closure object to the heap; 1913 /// it should not be confused with a 'byref copy helper', which moves 1914 /// the contents of an individual __block variable to the heap. 1915 llvm::Constant * 1916 CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) { 1917 SmallVector<BlockCaptureManagedEntity, 4> CopiedCaptures; 1918 findBlockCapturedManagedEntities(blockInfo, getLangOpts(), CopiedCaptures); 1919 std::string FuncName = 1920 getCopyDestroyHelperFuncName(CopiedCaptures, blockInfo.BlockAlign, 1921 CaptureStrKind::CopyHelper, CGM); 1922 1923 if (llvm::GlobalValue *Func = CGM.getModule().getNamedValue(FuncName)) 1924 return llvm::ConstantExpr::getBitCast(Func, VoidPtrTy); 1925 1926 ASTContext &C = getContext(); 1927 1928 QualType ReturnTy = C.VoidTy; 1929 1930 FunctionArgList args; 1931 ImplicitParamDecl DstDecl(C, C.VoidPtrTy, ImplicitParamDecl::Other); 1932 args.push_back(&DstDecl); 1933 ImplicitParamDecl SrcDecl(C, C.VoidPtrTy, ImplicitParamDecl::Other); 1934 args.push_back(&SrcDecl); 1935 1936 const CGFunctionInfo &FI = 1937 CGM.getTypes().arrangeBuiltinFunctionDeclaration(ReturnTy, args); 1938 1939 // FIXME: it would be nice if these were mergeable with things with 1940 // identical semantics. 1941 llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI); 1942 1943 llvm::Function *Fn = 1944 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage, 1945 FuncName, &CGM.getModule()); 1946 if (CGM.supportsCOMDAT()) 1947 Fn->setComdat(CGM.getModule().getOrInsertComdat(FuncName)); 1948 1949 IdentifierInfo *II = &C.Idents.get(FuncName); 1950 1951 SmallVector<QualType, 2> ArgTys; 1952 ArgTys.push_back(C.VoidPtrTy); 1953 ArgTys.push_back(C.VoidPtrTy); 1954 QualType FunctionTy = C.getFunctionType(ReturnTy, ArgTys, {}); 1955 1956 FunctionDecl *FD = FunctionDecl::Create( 1957 C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, 1958 FunctionTy, nullptr, SC_Static, false, false); 1959 setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI, 1960 CGM); 1961 // This is necessary to avoid inheriting the previous line number. 1962 FD->setImplicit(); 1963 StartFunction(FD, ReturnTy, Fn, FI, args); 1964 auto AL = ApplyDebugLocation::CreateArtificial(*this); 1965 1966 llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo(); 1967 1968 Address src = GetAddrOfLocalVar(&SrcDecl); 1969 src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign); 1970 src = Builder.CreateBitCast(src, structPtrTy, "block.source"); 1971 1972 Address dst = GetAddrOfLocalVar(&DstDecl); 1973 dst = Address(Builder.CreateLoad(dst), blockInfo.BlockAlign); 1974 dst = Builder.CreateBitCast(dst, structPtrTy, "block.dest"); 1975 1976 for (const auto &CopiedCapture : CopiedCaptures) { 1977 const BlockDecl::Capture &CI = *CopiedCapture.CI; 1978 const CGBlockInfo::Capture &capture = *CopiedCapture.Capture; 1979 QualType captureType = CI.getVariable()->getType(); 1980 BlockFieldFlags flags = CopiedCapture.CopyFlags; 1981 1982 unsigned index = capture.getIndex(); 1983 Address srcField = Builder.CreateStructGEP(src, index); 1984 Address dstField = Builder.CreateStructGEP(dst, index); 1985 1986 switch (CopiedCapture.CopyKind) { 1987 case BlockCaptureEntityKind::CXXRecord: 1988 // If there's an explicit copy expression, we do that. 1989 assert(CI.getCopyExpr() && "copy expression for variable is missing"); 1990 EmitSynthesizedCXXCopyCtor(dstField, srcField, CI.getCopyExpr()); 1991 break; 1992 case BlockCaptureEntityKind::ARCWeak: 1993 EmitARCCopyWeak(dstField, srcField); 1994 break; 1995 case BlockCaptureEntityKind::NonTrivialCStruct: { 1996 // If this is a C struct that requires non-trivial copy construction, 1997 // emit a call to its copy constructor. 1998 QualType varType = CI.getVariable()->getType(); 1999 callCStructCopyConstructor(MakeAddrLValue(dstField, varType), 2000 MakeAddrLValue(srcField, varType)); 2001 break; 2002 } 2003 case BlockCaptureEntityKind::ARCStrong: { 2004 llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src"); 2005 // At -O0, store null into the destination field (so that the 2006 // storeStrong doesn't over-release) and then call storeStrong. 2007 // This is a workaround to not having an initStrong call. 2008 if (CGM.getCodeGenOpts().OptimizationLevel == 0) { 2009 auto *ty = cast<llvm::PointerType>(srcValue->getType()); 2010 llvm::Value *null = llvm::ConstantPointerNull::get(ty); 2011 Builder.CreateStore(null, dstField); 2012 EmitARCStoreStrongCall(dstField, srcValue, true); 2013 2014 // With optimization enabled, take advantage of the fact that 2015 // the blocks runtime guarantees a memcpy of the block data, and 2016 // just emit a retain of the src field. 2017 } else { 2018 EmitARCRetainNonBlock(srcValue); 2019 2020 // Unless EH cleanup is required, we don't need this anymore, so kill 2021 // it. It's not quite worth the annoyance to avoid creating it in the 2022 // first place. 2023 if (!needsEHCleanup(captureType.isDestructedType())) 2024 cast<llvm::Instruction>(dstField.getPointer())->eraseFromParent(); 2025 } 2026 break; 2027 } 2028 case BlockCaptureEntityKind::BlockObject: { 2029 llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src"); 2030 srcValue = Builder.CreateBitCast(srcValue, VoidPtrTy); 2031 llvm::Value *dstAddr = 2032 Builder.CreateBitCast(dstField.getPointer(), VoidPtrTy); 2033 llvm::Value *args[] = { 2034 dstAddr, srcValue, llvm::ConstantInt::get(Int32Ty, flags.getBitMask()) 2035 }; 2036 2037 if (CI.isByRef() && C.getBlockVarCopyInit(CI.getVariable()).canThrow()) 2038 EmitRuntimeCallOrInvoke(CGM.getBlockObjectAssign(), args); 2039 else 2040 EmitNounwindRuntimeCall(CGM.getBlockObjectAssign(), args); 2041 break; 2042 } 2043 case BlockCaptureEntityKind::None: 2044 continue; 2045 } 2046 2047 // Ensure that we destroy the copied object if an exception is thrown later 2048 // in the helper function. 2049 pushCaptureCleanup(CopiedCapture.CopyKind, dstField, captureType, flags, 2050 /*ForCopyHelper*/ true, CI.getVariable(), *this); 2051 } 2052 2053 FinishFunction(); 2054 2055 return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy); 2056 } 2057 2058 static BlockFieldFlags 2059 getBlockFieldFlagsForObjCObjectPointer(const BlockDecl::Capture &CI, 2060 QualType T) { 2061 BlockFieldFlags Flags = BLOCK_FIELD_IS_OBJECT; 2062 if (T->isBlockPointerType()) 2063 Flags = BLOCK_FIELD_IS_BLOCK; 2064 return Flags; 2065 } 2066 2067 static std::pair<BlockCaptureEntityKind, BlockFieldFlags> 2068 computeDestroyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T, 2069 const LangOptions &LangOpts) { 2070 if (CI.isEscapingByref()) { 2071 BlockFieldFlags Flags = BLOCK_FIELD_IS_BYREF; 2072 if (T.isObjCGCWeak()) 2073 Flags |= BLOCK_FIELD_IS_WEAK; 2074 return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); 2075 } 2076 2077 switch (T.isDestructedType()) { 2078 case QualType::DK_cxx_destructor: 2079 return std::make_pair(BlockCaptureEntityKind::CXXRecord, BlockFieldFlags()); 2080 case QualType::DK_objc_strong_lifetime: 2081 // Use objc_storeStrong for __strong direct captures; the 2082 // dynamic tools really like it when we do this. 2083 return std::make_pair(BlockCaptureEntityKind::ARCStrong, 2084 getBlockFieldFlagsForObjCObjectPointer(CI, T)); 2085 case QualType::DK_objc_weak_lifetime: 2086 // Support __weak direct captures. 2087 return std::make_pair(BlockCaptureEntityKind::ARCWeak, 2088 getBlockFieldFlagsForObjCObjectPointer(CI, T)); 2089 case QualType::DK_nontrivial_c_struct: 2090 return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct, 2091 BlockFieldFlags()); 2092 case QualType::DK_none: { 2093 // Non-ARC captures are strong, and we need to use _Block_object_dispose. 2094 if (T->isObjCRetainableType() && !T.getQualifiers().hasObjCLifetime() && 2095 !LangOpts.ObjCAutoRefCount) 2096 return std::make_pair(BlockCaptureEntityKind::BlockObject, 2097 getBlockFieldFlagsForObjCObjectPointer(CI, T)); 2098 // Otherwise, we have nothing to do. 2099 return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); 2100 } 2101 } 2102 llvm_unreachable("after exhaustive DestructionKind switch"); 2103 } 2104 2105 /// Generate the destroy-helper function for a block closure object: 2106 /// static void block_destroy_helper(block_t *theBlock); 2107 /// 2108 /// Note that this destroys a heap-allocated block closure object; 2109 /// it should not be confused with a 'byref destroy helper', which 2110 /// destroys the heap-allocated contents of an individual __block 2111 /// variable. 2112 llvm::Constant * 2113 CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) { 2114 SmallVector<BlockCaptureManagedEntity, 4> DestroyedCaptures; 2115 findBlockCapturedManagedEntities(blockInfo, getLangOpts(), DestroyedCaptures); 2116 std::string FuncName = 2117 getCopyDestroyHelperFuncName(DestroyedCaptures, blockInfo.BlockAlign, 2118 CaptureStrKind::DisposeHelper, CGM); 2119 2120 if (llvm::GlobalValue *Func = CGM.getModule().getNamedValue(FuncName)) 2121 return llvm::ConstantExpr::getBitCast(Func, VoidPtrTy); 2122 2123 ASTContext &C = getContext(); 2124 2125 QualType ReturnTy = C.VoidTy; 2126 2127 FunctionArgList args; 2128 ImplicitParamDecl SrcDecl(C, C.VoidPtrTy, ImplicitParamDecl::Other); 2129 args.push_back(&SrcDecl); 2130 2131 const CGFunctionInfo &FI = 2132 CGM.getTypes().arrangeBuiltinFunctionDeclaration(ReturnTy, args); 2133 2134 // FIXME: We'd like to put these into a mergable by content, with 2135 // internal linkage. 2136 llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI); 2137 2138 llvm::Function *Fn = 2139 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage, 2140 FuncName, &CGM.getModule()); 2141 if (CGM.supportsCOMDAT()) 2142 Fn->setComdat(CGM.getModule().getOrInsertComdat(FuncName)); 2143 2144 IdentifierInfo *II = &C.Idents.get(FuncName); 2145 2146 SmallVector<QualType, 1> ArgTys; 2147 ArgTys.push_back(C.VoidPtrTy); 2148 QualType FunctionTy = C.getFunctionType(ReturnTy, ArgTys, {}); 2149 2150 FunctionDecl *FD = FunctionDecl::Create( 2151 C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, 2152 FunctionTy, nullptr, SC_Static, false, false); 2153 2154 setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI, 2155 CGM); 2156 // This is necessary to avoid inheriting the previous line number. 2157 FD->setImplicit(); 2158 StartFunction(FD, ReturnTy, Fn, FI, args); 2159 markAsIgnoreThreadCheckingAtRuntime(Fn); 2160 2161 auto AL = ApplyDebugLocation::CreateArtificial(*this); 2162 2163 llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo(); 2164 2165 Address src = GetAddrOfLocalVar(&SrcDecl); 2166 src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign); 2167 src = Builder.CreateBitCast(src, structPtrTy, "block"); 2168 2169 CodeGenFunction::RunCleanupsScope cleanups(*this); 2170 2171 for (const auto &DestroyedCapture : DestroyedCaptures) { 2172 const BlockDecl::Capture &CI = *DestroyedCapture.CI; 2173 const CGBlockInfo::Capture &capture = *DestroyedCapture.Capture; 2174 BlockFieldFlags flags = DestroyedCapture.DisposeFlags; 2175 2176 Address srcField = Builder.CreateStructGEP(src, capture.getIndex()); 2177 2178 pushCaptureCleanup(DestroyedCapture.DisposeKind, srcField, 2179 CI.getVariable()->getType(), flags, 2180 /*ForCopyHelper*/ false, CI.getVariable(), *this); 2181 } 2182 2183 cleanups.ForceCleanup(); 2184 2185 FinishFunction(); 2186 2187 return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy); 2188 } 2189 2190 namespace { 2191 2192 /// Emits the copy/dispose helper functions for a __block object of id type. 2193 class ObjectByrefHelpers final : public BlockByrefHelpers { 2194 BlockFieldFlags Flags; 2195 2196 public: 2197 ObjectByrefHelpers(CharUnits alignment, BlockFieldFlags flags) 2198 : BlockByrefHelpers(alignment), Flags(flags) {} 2199 2200 void emitCopy(CodeGenFunction &CGF, Address destField, 2201 Address srcField) override { 2202 destField = CGF.Builder.CreateBitCast(destField, CGF.VoidPtrTy); 2203 2204 srcField = CGF.Builder.CreateBitCast(srcField, CGF.VoidPtrPtrTy); 2205 llvm::Value *srcValue = CGF.Builder.CreateLoad(srcField); 2206 2207 unsigned flags = (Flags | BLOCK_BYREF_CALLER).getBitMask(); 2208 2209 llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.Int32Ty, flags); 2210 llvm::FunctionCallee fn = CGF.CGM.getBlockObjectAssign(); 2211 2212 llvm::Value *args[] = { destField.getPointer(), srcValue, flagsVal }; 2213 CGF.EmitNounwindRuntimeCall(fn, args); 2214 } 2215 2216 void emitDispose(CodeGenFunction &CGF, Address field) override { 2217 field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0)); 2218 llvm::Value *value = CGF.Builder.CreateLoad(field); 2219 2220 CGF.BuildBlockRelease(value, Flags | BLOCK_BYREF_CALLER, false); 2221 } 2222 2223 void profileImpl(llvm::FoldingSetNodeID &id) const override { 2224 id.AddInteger(Flags.getBitMask()); 2225 } 2226 }; 2227 2228 /// Emits the copy/dispose helpers for an ARC __block __weak variable. 2229 class ARCWeakByrefHelpers final : public BlockByrefHelpers { 2230 public: 2231 ARCWeakByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {} 2232 2233 void emitCopy(CodeGenFunction &CGF, Address destField, 2234 Address srcField) override { 2235 CGF.EmitARCMoveWeak(destField, srcField); 2236 } 2237 2238 void emitDispose(CodeGenFunction &CGF, Address field) override { 2239 CGF.EmitARCDestroyWeak(field); 2240 } 2241 2242 void profileImpl(llvm::FoldingSetNodeID &id) const override { 2243 // 0 is distinguishable from all pointers and byref flags 2244 id.AddInteger(0); 2245 } 2246 }; 2247 2248 /// Emits the copy/dispose helpers for an ARC __block __strong variable 2249 /// that's not of block-pointer type. 2250 class ARCStrongByrefHelpers final : public BlockByrefHelpers { 2251 public: 2252 ARCStrongByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {} 2253 2254 void emitCopy(CodeGenFunction &CGF, Address destField, 2255 Address srcField) override { 2256 // Do a "move" by copying the value and then zeroing out the old 2257 // variable. 2258 2259 llvm::Value *value = CGF.Builder.CreateLoad(srcField); 2260 2261 llvm::Value *null = 2262 llvm::ConstantPointerNull::get(cast<llvm::PointerType>(value->getType())); 2263 2264 if (CGF.CGM.getCodeGenOpts().OptimizationLevel == 0) { 2265 CGF.Builder.CreateStore(null, destField); 2266 CGF.EmitARCStoreStrongCall(destField, value, /*ignored*/ true); 2267 CGF.EmitARCStoreStrongCall(srcField, null, /*ignored*/ true); 2268 return; 2269 } 2270 CGF.Builder.CreateStore(value, destField); 2271 CGF.Builder.CreateStore(null, srcField); 2272 } 2273 2274 void emitDispose(CodeGenFunction &CGF, Address field) override { 2275 CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); 2276 } 2277 2278 void profileImpl(llvm::FoldingSetNodeID &id) const override { 2279 // 1 is distinguishable from all pointers and byref flags 2280 id.AddInteger(1); 2281 } 2282 }; 2283 2284 /// Emits the copy/dispose helpers for an ARC __block __strong 2285 /// variable that's of block-pointer type. 2286 class ARCStrongBlockByrefHelpers final : public BlockByrefHelpers { 2287 public: 2288 ARCStrongBlockByrefHelpers(CharUnits alignment) 2289 : BlockByrefHelpers(alignment) {} 2290 2291 void emitCopy(CodeGenFunction &CGF, Address destField, 2292 Address srcField) override { 2293 // Do the copy with objc_retainBlock; that's all that 2294 // _Block_object_assign would do anyway, and we'd have to pass the 2295 // right arguments to make sure it doesn't get no-op'ed. 2296 llvm::Value *oldValue = CGF.Builder.CreateLoad(srcField); 2297 llvm::Value *copy = CGF.EmitARCRetainBlock(oldValue, /*mandatory*/ true); 2298 CGF.Builder.CreateStore(copy, destField); 2299 } 2300 2301 void emitDispose(CodeGenFunction &CGF, Address field) override { 2302 CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); 2303 } 2304 2305 void profileImpl(llvm::FoldingSetNodeID &id) const override { 2306 // 2 is distinguishable from all pointers and byref flags 2307 id.AddInteger(2); 2308 } 2309 }; 2310 2311 /// Emits the copy/dispose helpers for a __block variable with a 2312 /// nontrivial copy constructor or destructor. 2313 class CXXByrefHelpers final : public BlockByrefHelpers { 2314 QualType VarType; 2315 const Expr *CopyExpr; 2316 2317 public: 2318 CXXByrefHelpers(CharUnits alignment, QualType type, 2319 const Expr *copyExpr) 2320 : BlockByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {} 2321 2322 bool needsCopy() const override { return CopyExpr != nullptr; } 2323 void emitCopy(CodeGenFunction &CGF, Address destField, 2324 Address srcField) override { 2325 if (!CopyExpr) return; 2326 CGF.EmitSynthesizedCXXCopyCtor(destField, srcField, CopyExpr); 2327 } 2328 2329 void emitDispose(CodeGenFunction &CGF, Address field) override { 2330 EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); 2331 CGF.PushDestructorCleanup(VarType, field); 2332 CGF.PopCleanupBlocks(cleanupDepth); 2333 } 2334 2335 void profileImpl(llvm::FoldingSetNodeID &id) const override { 2336 id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); 2337 } 2338 }; 2339 2340 /// Emits the copy/dispose helpers for a __block variable that is a non-trivial 2341 /// C struct. 2342 class NonTrivialCStructByrefHelpers final : public BlockByrefHelpers { 2343 QualType VarType; 2344 2345 public: 2346 NonTrivialCStructByrefHelpers(CharUnits alignment, QualType type) 2347 : BlockByrefHelpers(alignment), VarType(type) {} 2348 2349 void emitCopy(CodeGenFunction &CGF, Address destField, 2350 Address srcField) override { 2351 CGF.callCStructMoveConstructor(CGF.MakeAddrLValue(destField, VarType), 2352 CGF.MakeAddrLValue(srcField, VarType)); 2353 } 2354 2355 bool needsDispose() const override { 2356 return VarType.isDestructedType(); 2357 } 2358 2359 void emitDispose(CodeGenFunction &CGF, Address field) override { 2360 EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); 2361 CGF.pushDestroy(VarType.isDestructedType(), field, VarType); 2362 CGF.PopCleanupBlocks(cleanupDepth); 2363 } 2364 2365 void profileImpl(llvm::FoldingSetNodeID &id) const override { 2366 id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); 2367 } 2368 }; 2369 } // end anonymous namespace 2370 2371 static llvm::Constant * 2372 generateByrefCopyHelper(CodeGenFunction &CGF, const BlockByrefInfo &byrefInfo, 2373 BlockByrefHelpers &generator) { 2374 ASTContext &Context = CGF.getContext(); 2375 2376 QualType ReturnTy = Context.VoidTy; 2377 2378 FunctionArgList args; 2379 ImplicitParamDecl Dst(Context, Context.VoidPtrTy, ImplicitParamDecl::Other); 2380 args.push_back(&Dst); 2381 2382 ImplicitParamDecl Src(Context, Context.VoidPtrTy, ImplicitParamDecl::Other); 2383 args.push_back(&Src); 2384 2385 const CGFunctionInfo &FI = 2386 CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(ReturnTy, args); 2387 2388 llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI); 2389 2390 // FIXME: We'd like to put these into a mergable by content, with 2391 // internal linkage. 2392 llvm::Function *Fn = 2393 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, 2394 "__Block_byref_object_copy_", &CGF.CGM.getModule()); 2395 2396 IdentifierInfo *II 2397 = &Context.Idents.get("__Block_byref_object_copy_"); 2398 2399 SmallVector<QualType, 2> ArgTys; 2400 ArgTys.push_back(Context.VoidPtrTy); 2401 ArgTys.push_back(Context.VoidPtrTy); 2402 QualType FunctionTy = Context.getFunctionType(ReturnTy, ArgTys, {}); 2403 2404 FunctionDecl *FD = FunctionDecl::Create( 2405 Context, Context.getTranslationUnitDecl(), SourceLocation(), 2406 SourceLocation(), II, FunctionTy, nullptr, SC_Static, false, false); 2407 2408 CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); 2409 2410 CGF.StartFunction(FD, ReturnTy, Fn, FI, args); 2411 2412 if (generator.needsCopy()) { 2413 llvm::Type *byrefPtrType = byrefInfo.Type->getPointerTo(0); 2414 2415 // dst->x 2416 Address destField = CGF.GetAddrOfLocalVar(&Dst); 2417 destField = Address(CGF.Builder.CreateLoad(destField), 2418 byrefInfo.ByrefAlignment); 2419 destField = CGF.Builder.CreateBitCast(destField, byrefPtrType); 2420 destField = CGF.emitBlockByrefAddress(destField, byrefInfo, false, 2421 "dest-object"); 2422 2423 // src->x 2424 Address srcField = CGF.GetAddrOfLocalVar(&Src); 2425 srcField = Address(CGF.Builder.CreateLoad(srcField), 2426 byrefInfo.ByrefAlignment); 2427 srcField = CGF.Builder.CreateBitCast(srcField, byrefPtrType); 2428 srcField = CGF.emitBlockByrefAddress(srcField, byrefInfo, false, 2429 "src-object"); 2430 2431 generator.emitCopy(CGF, destField, srcField); 2432 } 2433 2434 CGF.FinishFunction(); 2435 2436 return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy); 2437 } 2438 2439 /// Build the copy helper for a __block variable. 2440 static llvm::Constant *buildByrefCopyHelper(CodeGenModule &CGM, 2441 const BlockByrefInfo &byrefInfo, 2442 BlockByrefHelpers &generator) { 2443 CodeGenFunction CGF(CGM); 2444 return generateByrefCopyHelper(CGF, byrefInfo, generator); 2445 } 2446 2447 /// Generate code for a __block variable's dispose helper. 2448 static llvm::Constant * 2449 generateByrefDisposeHelper(CodeGenFunction &CGF, 2450 const BlockByrefInfo &byrefInfo, 2451 BlockByrefHelpers &generator) { 2452 ASTContext &Context = CGF.getContext(); 2453 QualType R = Context.VoidTy; 2454 2455 FunctionArgList args; 2456 ImplicitParamDecl Src(CGF.getContext(), Context.VoidPtrTy, 2457 ImplicitParamDecl::Other); 2458 args.push_back(&Src); 2459 2460 const CGFunctionInfo &FI = 2461 CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(R, args); 2462 2463 llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI); 2464 2465 // FIXME: We'd like to put these into a mergable by content, with 2466 // internal linkage. 2467 llvm::Function *Fn = 2468 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, 2469 "__Block_byref_object_dispose_", 2470 &CGF.CGM.getModule()); 2471 2472 IdentifierInfo *II 2473 = &Context.Idents.get("__Block_byref_object_dispose_"); 2474 2475 SmallVector<QualType, 1> ArgTys; 2476 ArgTys.push_back(Context.VoidPtrTy); 2477 QualType FunctionTy = Context.getFunctionType(R, ArgTys, {}); 2478 2479 FunctionDecl *FD = FunctionDecl::Create( 2480 Context, Context.getTranslationUnitDecl(), SourceLocation(), 2481 SourceLocation(), II, FunctionTy, nullptr, SC_Static, false, false); 2482 2483 CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); 2484 2485 CGF.StartFunction(FD, R, Fn, FI, args); 2486 2487 if (generator.needsDispose()) { 2488 Address addr = CGF.GetAddrOfLocalVar(&Src); 2489 addr = Address(CGF.Builder.CreateLoad(addr), byrefInfo.ByrefAlignment); 2490 auto byrefPtrType = byrefInfo.Type->getPointerTo(0); 2491 addr = CGF.Builder.CreateBitCast(addr, byrefPtrType); 2492 addr = CGF.emitBlockByrefAddress(addr, byrefInfo, false, "object"); 2493 2494 generator.emitDispose(CGF, addr); 2495 } 2496 2497 CGF.FinishFunction(); 2498 2499 return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy); 2500 } 2501 2502 /// Build the dispose helper for a __block variable. 2503 static llvm::Constant *buildByrefDisposeHelper(CodeGenModule &CGM, 2504 const BlockByrefInfo &byrefInfo, 2505 BlockByrefHelpers &generator) { 2506 CodeGenFunction CGF(CGM); 2507 return generateByrefDisposeHelper(CGF, byrefInfo, generator); 2508 } 2509 2510 /// Lazily build the copy and dispose helpers for a __block variable 2511 /// with the given information. 2512 template <class T> 2513 static T *buildByrefHelpers(CodeGenModule &CGM, const BlockByrefInfo &byrefInfo, 2514 T &&generator) { 2515 llvm::FoldingSetNodeID id; 2516 generator.Profile(id); 2517 2518 void *insertPos; 2519 BlockByrefHelpers *node 2520 = CGM.ByrefHelpersCache.FindNodeOrInsertPos(id, insertPos); 2521 if (node) return static_cast<T*>(node); 2522 2523 generator.CopyHelper = buildByrefCopyHelper(CGM, byrefInfo, generator); 2524 generator.DisposeHelper = buildByrefDisposeHelper(CGM, byrefInfo, generator); 2525 2526 T *copy = new (CGM.getContext()) T(std::forward<T>(generator)); 2527 CGM.ByrefHelpersCache.InsertNode(copy, insertPos); 2528 return copy; 2529 } 2530 2531 /// Build the copy and dispose helpers for the given __block variable 2532 /// emission. Places the helpers in the global cache. Returns null 2533 /// if no helpers are required. 2534 BlockByrefHelpers * 2535 CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType, 2536 const AutoVarEmission &emission) { 2537 const VarDecl &var = *emission.Variable; 2538 assert(var.isEscapingByref() && 2539 "only escaping __block variables need byref helpers"); 2540 2541 QualType type = var.getType(); 2542 2543 auto &byrefInfo = getBlockByrefInfo(&var); 2544 2545 // The alignment we care about for the purposes of uniquing byref 2546 // helpers is the alignment of the actual byref value field. 2547 CharUnits valueAlignment = 2548 byrefInfo.ByrefAlignment.alignmentAtOffset(byrefInfo.FieldOffset); 2549 2550 if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) { 2551 const Expr *copyExpr = 2552 CGM.getContext().getBlockVarCopyInit(&var).getCopyExpr(); 2553 if (!copyExpr && record->hasTrivialDestructor()) return nullptr; 2554 2555 return ::buildByrefHelpers( 2556 CGM, byrefInfo, CXXByrefHelpers(valueAlignment, type, copyExpr)); 2557 } 2558 2559 // If type is a non-trivial C struct type that is non-trivial to 2560 // destructly move or destroy, build the copy and dispose helpers. 2561 if (type.isNonTrivialToPrimitiveDestructiveMove() == QualType::PCK_Struct || 2562 type.isDestructedType() == QualType::DK_nontrivial_c_struct) 2563 return ::buildByrefHelpers( 2564 CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment, type)); 2565 2566 // Otherwise, if we don't have a retainable type, there's nothing to do. 2567 // that the runtime does extra copies. 2568 if (!type->isObjCRetainableType()) return nullptr; 2569 2570 Qualifiers qs = type.getQualifiers(); 2571 2572 // If we have lifetime, that dominates. 2573 if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) { 2574 switch (lifetime) { 2575 case Qualifiers::OCL_None: llvm_unreachable("impossible"); 2576 2577 // These are just bits as far as the runtime is concerned. 2578 case Qualifiers::OCL_ExplicitNone: 2579 case Qualifiers::OCL_Autoreleasing: 2580 return nullptr; 2581 2582 // Tell the runtime that this is ARC __weak, called by the 2583 // byref routines. 2584 case Qualifiers::OCL_Weak: 2585 return ::buildByrefHelpers(CGM, byrefInfo, 2586 ARCWeakByrefHelpers(valueAlignment)); 2587 2588 // ARC __strong __block variables need to be retained. 2589 case Qualifiers::OCL_Strong: 2590 // Block pointers need to be copied, and there's no direct 2591 // transfer possible. 2592 if (type->isBlockPointerType()) { 2593 return ::buildByrefHelpers(CGM, byrefInfo, 2594 ARCStrongBlockByrefHelpers(valueAlignment)); 2595 2596 // Otherwise, we transfer ownership of the retain from the stack 2597 // to the heap. 2598 } else { 2599 return ::buildByrefHelpers(CGM, byrefInfo, 2600 ARCStrongByrefHelpers(valueAlignment)); 2601 } 2602 } 2603 llvm_unreachable("fell out of lifetime switch!"); 2604 } 2605 2606 BlockFieldFlags flags; 2607 if (type->isBlockPointerType()) { 2608 flags |= BLOCK_FIELD_IS_BLOCK; 2609 } else if (CGM.getContext().isObjCNSObjectType(type) || 2610 type->isObjCObjectPointerType()) { 2611 flags |= BLOCK_FIELD_IS_OBJECT; 2612 } else { 2613 return nullptr; 2614 } 2615 2616 if (type.isObjCGCWeak()) 2617 flags |= BLOCK_FIELD_IS_WEAK; 2618 2619 return ::buildByrefHelpers(CGM, byrefInfo, 2620 ObjectByrefHelpers(valueAlignment, flags)); 2621 } 2622 2623 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr, 2624 const VarDecl *var, 2625 bool followForward) { 2626 auto &info = getBlockByrefInfo(var); 2627 return emitBlockByrefAddress(baseAddr, info, followForward, var->getName()); 2628 } 2629 2630 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr, 2631 const BlockByrefInfo &info, 2632 bool followForward, 2633 const llvm::Twine &name) { 2634 // Chase the forwarding address if requested. 2635 if (followForward) { 2636 Address forwardingAddr = Builder.CreateStructGEP(baseAddr, 1, "forwarding"); 2637 baseAddr = Address(Builder.CreateLoad(forwardingAddr), info.ByrefAlignment); 2638 } 2639 2640 return Builder.CreateStructGEP(baseAddr, info.FieldIndex, name); 2641 } 2642 2643 /// BuildByrefInfo - This routine changes a __block variable declared as T x 2644 /// into: 2645 /// 2646 /// struct { 2647 /// void *__isa; 2648 /// void *__forwarding; 2649 /// int32_t __flags; 2650 /// int32_t __size; 2651 /// void *__copy_helper; // only if needed 2652 /// void *__destroy_helper; // only if needed 2653 /// void *__byref_variable_layout;// only if needed 2654 /// char padding[X]; // only if needed 2655 /// T x; 2656 /// } x 2657 /// 2658 const BlockByrefInfo &CodeGenFunction::getBlockByrefInfo(const VarDecl *D) { 2659 auto it = BlockByrefInfos.find(D); 2660 if (it != BlockByrefInfos.end()) 2661 return it->second; 2662 2663 llvm::StructType *byrefType = 2664 llvm::StructType::create(getLLVMContext(), 2665 "struct.__block_byref_" + D->getNameAsString()); 2666 2667 QualType Ty = D->getType(); 2668 2669 CharUnits size; 2670 SmallVector<llvm::Type *, 8> types; 2671 2672 // void *__isa; 2673 types.push_back(Int8PtrTy); 2674 size += getPointerSize(); 2675 2676 // void *__forwarding; 2677 types.push_back(llvm::PointerType::getUnqual(byrefType)); 2678 size += getPointerSize(); 2679 2680 // int32_t __flags; 2681 types.push_back(Int32Ty); 2682 size += CharUnits::fromQuantity(4); 2683 2684 // int32_t __size; 2685 types.push_back(Int32Ty); 2686 size += CharUnits::fromQuantity(4); 2687 2688 // Note that this must match *exactly* the logic in buildByrefHelpers. 2689 bool hasCopyAndDispose = getContext().BlockRequiresCopying(Ty, D); 2690 if (hasCopyAndDispose) { 2691 /// void *__copy_helper; 2692 types.push_back(Int8PtrTy); 2693 size += getPointerSize(); 2694 2695 /// void *__destroy_helper; 2696 types.push_back(Int8PtrTy); 2697 size += getPointerSize(); 2698 } 2699 2700 bool HasByrefExtendedLayout = false; 2701 Qualifiers::ObjCLifetime Lifetime; 2702 if (getContext().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) && 2703 HasByrefExtendedLayout) { 2704 /// void *__byref_variable_layout; 2705 types.push_back(Int8PtrTy); 2706 size += CharUnits::fromQuantity(PointerSizeInBytes); 2707 } 2708 2709 // T x; 2710 llvm::Type *varTy = ConvertTypeForMem(Ty); 2711 2712 bool packed = false; 2713 CharUnits varAlign = getContext().getDeclAlign(D); 2714 CharUnits varOffset = size.alignTo(varAlign); 2715 2716 // We may have to insert padding. 2717 if (varOffset != size) { 2718 llvm::Type *paddingTy = 2719 llvm::ArrayType::get(Int8Ty, (varOffset - size).getQuantity()); 2720 2721 types.push_back(paddingTy); 2722 size = varOffset; 2723 2724 // Conversely, we might have to prevent LLVM from inserting padding. 2725 } else if (CGM.getDataLayout().getABITypeAlignment(varTy) 2726 > varAlign.getQuantity()) { 2727 packed = true; 2728 } 2729 types.push_back(varTy); 2730 2731 byrefType->setBody(types, packed); 2732 2733 BlockByrefInfo info; 2734 info.Type = byrefType; 2735 info.FieldIndex = types.size() - 1; 2736 info.FieldOffset = varOffset; 2737 info.ByrefAlignment = std::max(varAlign, getPointerAlign()); 2738 2739 auto pair = BlockByrefInfos.insert({D, info}); 2740 assert(pair.second && "info was inserted recursively?"); 2741 return pair.first->second; 2742 } 2743 2744 /// Initialize the structural components of a __block variable, i.e. 2745 /// everything but the actual object. 2746 void CodeGenFunction::emitByrefStructureInit(const AutoVarEmission &emission) { 2747 // Find the address of the local. 2748 Address addr = emission.Addr; 2749 2750 // That's an alloca of the byref structure type. 2751 llvm::StructType *byrefType = cast<llvm::StructType>( 2752 cast<llvm::PointerType>(addr.getPointer()->getType())->getElementType()); 2753 2754 unsigned nextHeaderIndex = 0; 2755 CharUnits nextHeaderOffset; 2756 auto storeHeaderField = [&](llvm::Value *value, CharUnits fieldSize, 2757 const Twine &name) { 2758 auto fieldAddr = Builder.CreateStructGEP(addr, nextHeaderIndex, name); 2759 Builder.CreateStore(value, fieldAddr); 2760 2761 nextHeaderIndex++; 2762 nextHeaderOffset += fieldSize; 2763 }; 2764 2765 // Build the byref helpers if necessary. This is null if we don't need any. 2766 BlockByrefHelpers *helpers = buildByrefHelpers(*byrefType, emission); 2767 2768 const VarDecl &D = *emission.Variable; 2769 QualType type = D.getType(); 2770 2771 bool HasByrefExtendedLayout; 2772 Qualifiers::ObjCLifetime ByrefLifetime; 2773 bool ByRefHasLifetime = 2774 getContext().getByrefLifetime(type, ByrefLifetime, HasByrefExtendedLayout); 2775 2776 llvm::Value *V; 2777 2778 // Initialize the 'isa', which is just 0 or 1. 2779 int isa = 0; 2780 if (type.isObjCGCWeak()) 2781 isa = 1; 2782 V = Builder.CreateIntToPtr(Builder.getInt32(isa), Int8PtrTy, "isa"); 2783 storeHeaderField(V, getPointerSize(), "byref.isa"); 2784 2785 // Store the address of the variable into its own forwarding pointer. 2786 storeHeaderField(addr.getPointer(), getPointerSize(), "byref.forwarding"); 2787 2788 // Blocks ABI: 2789 // c) the flags field is set to either 0 if no helper functions are 2790 // needed or BLOCK_BYREF_HAS_COPY_DISPOSE if they are, 2791 BlockFlags flags; 2792 if (helpers) flags |= BLOCK_BYREF_HAS_COPY_DISPOSE; 2793 if (ByRefHasLifetime) { 2794 if (HasByrefExtendedLayout) flags |= BLOCK_BYREF_LAYOUT_EXTENDED; 2795 else switch (ByrefLifetime) { 2796 case Qualifiers::OCL_Strong: 2797 flags |= BLOCK_BYREF_LAYOUT_STRONG; 2798 break; 2799 case Qualifiers::OCL_Weak: 2800 flags |= BLOCK_BYREF_LAYOUT_WEAK; 2801 break; 2802 case Qualifiers::OCL_ExplicitNone: 2803 flags |= BLOCK_BYREF_LAYOUT_UNRETAINED; 2804 break; 2805 case Qualifiers::OCL_None: 2806 if (!type->isObjCObjectPointerType() && !type->isBlockPointerType()) 2807 flags |= BLOCK_BYREF_LAYOUT_NON_OBJECT; 2808 break; 2809 default: 2810 break; 2811 } 2812 if (CGM.getLangOpts().ObjCGCBitmapPrint) { 2813 printf("\n Inline flag for BYREF variable layout (%d):", flags.getBitMask()); 2814 if (flags & BLOCK_BYREF_HAS_COPY_DISPOSE) 2815 printf(" BLOCK_BYREF_HAS_COPY_DISPOSE"); 2816 if (flags & BLOCK_BYREF_LAYOUT_MASK) { 2817 BlockFlags ThisFlag(flags.getBitMask() & BLOCK_BYREF_LAYOUT_MASK); 2818 if (ThisFlag == BLOCK_BYREF_LAYOUT_EXTENDED) 2819 printf(" BLOCK_BYREF_LAYOUT_EXTENDED"); 2820 if (ThisFlag == BLOCK_BYREF_LAYOUT_STRONG) 2821 printf(" BLOCK_BYREF_LAYOUT_STRONG"); 2822 if (ThisFlag == BLOCK_BYREF_LAYOUT_WEAK) 2823 printf(" BLOCK_BYREF_LAYOUT_WEAK"); 2824 if (ThisFlag == BLOCK_BYREF_LAYOUT_UNRETAINED) 2825 printf(" BLOCK_BYREF_LAYOUT_UNRETAINED"); 2826 if (ThisFlag == BLOCK_BYREF_LAYOUT_NON_OBJECT) 2827 printf(" BLOCK_BYREF_LAYOUT_NON_OBJECT"); 2828 } 2829 printf("\n"); 2830 } 2831 } 2832 storeHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()), 2833 getIntSize(), "byref.flags"); 2834 2835 CharUnits byrefSize = CGM.GetTargetTypeStoreSize(byrefType); 2836 V = llvm::ConstantInt::get(IntTy, byrefSize.getQuantity()); 2837 storeHeaderField(V, getIntSize(), "byref.size"); 2838 2839 if (helpers) { 2840 storeHeaderField(helpers->CopyHelper, getPointerSize(), 2841 "byref.copyHelper"); 2842 storeHeaderField(helpers->DisposeHelper, getPointerSize(), 2843 "byref.disposeHelper"); 2844 } 2845 2846 if (ByRefHasLifetime && HasByrefExtendedLayout) { 2847 auto layoutInfo = CGM.getObjCRuntime().BuildByrefLayout(CGM, type); 2848 storeHeaderField(layoutInfo, getPointerSize(), "byref.layout"); 2849 } 2850 } 2851 2852 void CodeGenFunction::BuildBlockRelease(llvm::Value *V, BlockFieldFlags flags, 2853 bool CanThrow) { 2854 llvm::FunctionCallee F = CGM.getBlockObjectDispose(); 2855 llvm::Value *args[] = { 2856 Builder.CreateBitCast(V, Int8PtrTy), 2857 llvm::ConstantInt::get(Int32Ty, flags.getBitMask()) 2858 }; 2859 2860 if (CanThrow) 2861 EmitRuntimeCallOrInvoke(F, args); 2862 else 2863 EmitNounwindRuntimeCall(F, args); 2864 } 2865 2866 void CodeGenFunction::enterByrefCleanup(CleanupKind Kind, Address Addr, 2867 BlockFieldFlags Flags, 2868 bool LoadBlockVarAddr, bool CanThrow) { 2869 EHStack.pushCleanup<CallBlockRelease>(Kind, Addr, Flags, LoadBlockVarAddr, 2870 CanThrow); 2871 } 2872 2873 /// Adjust the declaration of something from the blocks API. 2874 static void configureBlocksRuntimeObject(CodeGenModule &CGM, 2875 llvm::Constant *C) { 2876 auto *GV = cast<llvm::GlobalValue>(C->stripPointerCasts()); 2877 2878 if (CGM.getTarget().getTriple().isOSBinFormatCOFF()) { 2879 IdentifierInfo &II = CGM.getContext().Idents.get(C->getName()); 2880 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); 2881 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); 2882 2883 assert((isa<llvm::Function>(C->stripPointerCasts()) || 2884 isa<llvm::GlobalVariable>(C->stripPointerCasts())) && 2885 "expected Function or GlobalVariable"); 2886 2887 const NamedDecl *ND = nullptr; 2888 for (const auto &Result : DC->lookup(&II)) 2889 if ((ND = dyn_cast<FunctionDecl>(Result)) || 2890 (ND = dyn_cast<VarDecl>(Result))) 2891 break; 2892 2893 // TODO: support static blocks runtime 2894 if (GV->isDeclaration() && (!ND || !ND->hasAttr<DLLExportAttr>())) { 2895 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 2896 GV->setLinkage(llvm::GlobalValue::ExternalLinkage); 2897 } else { 2898 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 2899 GV->setLinkage(llvm::GlobalValue::ExternalLinkage); 2900 } 2901 } 2902 2903 if (CGM.getLangOpts().BlocksRuntimeOptional && GV->isDeclaration() && 2904 GV->hasExternalLinkage()) 2905 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 2906 2907 CGM.setDSOLocal(GV); 2908 } 2909 2910 llvm::FunctionCallee CodeGenModule::getBlockObjectDispose() { 2911 if (BlockObjectDispose) 2912 return BlockObjectDispose; 2913 2914 llvm::Type *args[] = { Int8PtrTy, Int32Ty }; 2915 llvm::FunctionType *fty 2916 = llvm::FunctionType::get(VoidTy, args, false); 2917 BlockObjectDispose = CreateRuntimeFunction(fty, "_Block_object_dispose"); 2918 configureBlocksRuntimeObject( 2919 *this, cast<llvm::Constant>(BlockObjectDispose.getCallee())); 2920 return BlockObjectDispose; 2921 } 2922 2923 llvm::FunctionCallee CodeGenModule::getBlockObjectAssign() { 2924 if (BlockObjectAssign) 2925 return BlockObjectAssign; 2926 2927 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, Int32Ty }; 2928 llvm::FunctionType *fty 2929 = llvm::FunctionType::get(VoidTy, args, false); 2930 BlockObjectAssign = CreateRuntimeFunction(fty, "_Block_object_assign"); 2931 configureBlocksRuntimeObject( 2932 *this, cast<llvm::Constant>(BlockObjectAssign.getCallee())); 2933 return BlockObjectAssign; 2934 } 2935 2936 llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() { 2937 if (NSConcreteGlobalBlock) 2938 return NSConcreteGlobalBlock; 2939 2940 NSConcreteGlobalBlock = GetOrCreateLLVMGlobal("_NSConcreteGlobalBlock", 2941 Int8PtrTy->getPointerTo(), 2942 nullptr); 2943 configureBlocksRuntimeObject(*this, NSConcreteGlobalBlock); 2944 return NSConcreteGlobalBlock; 2945 } 2946 2947 llvm::Constant *CodeGenModule::getNSConcreteStackBlock() { 2948 if (NSConcreteStackBlock) 2949 return NSConcreteStackBlock; 2950 2951 NSConcreteStackBlock = GetOrCreateLLVMGlobal("_NSConcreteStackBlock", 2952 Int8PtrTy->getPointerTo(), 2953 nullptr); 2954 configureBlocksRuntimeObject(*this, NSConcreteStackBlock); 2955 return NSConcreteStackBlock; 2956 } 2957