26#include "llvm/IR/DataLayout.h"
27#include "llvm/IR/Module.h"
28#include "llvm/Support/ScopedPrinter.h"
33using namespace CodeGen;
36 : Name(name), CXXThisIndex(0), CanBeGlobal(
false), NeedsCopyDispose(
false),
38 HasCapturedVariableLayout(
false), CapturesNonExternalType(
false),
39 LocalAddress(
RawAddress::invalid()), StructureType(nullptr),
44 name.consume_front(
"\01");
53 llvm::Constant *blockFn);
69enum class CaptureStrKind {
81 CaptureStrKind StrKind,
87 std::string Name =
"__block_descriptor_";
98 if (Cap.isConstantOrTrivial())
101 Name += llvm::to_string(Cap.getOffset().getQuantity());
103 if (Cap.CopyKind == Cap.DisposeKind) {
107 "shouldn't see BlockCaptureManagedEntity that is None");
123 std::string TypeAtEncoding;
130 llvm::replace(TypeAtEncoding,
'@',
'\1');
132 Name +=
"e" + llvm::to_string(TypeAtEncoding.size()) +
"_" + TypeAtEncoding;
155 llvm::IntegerType *
ulong =
157 llvm::PointerType *i8p =
nullptr;
159 i8p = llvm::PointerType::get(
164 std::string descName;
167 if (
C.getLangOpts().ObjC &&
170 if (llvm::GlobalValue *desc = CGM.
getModule().getNamedValue(descName))
180 elements.addInt(
ulong, 0);
189 bool hasInternalHelper =
false;
200 if (cast<llvm::Function>(copyHelper->stripPointerCasts())
201 ->hasInternalLinkage() ||
202 cast<llvm::Function>(disposeHelper->stripPointerCasts())
203 ->hasInternalLinkage())
204 hasInternalHelper =
true;
209 elements.addNullPointer(i8p);
211 std::string typeAtEncoding =
217 if (
C.getLangOpts().ObjC) {
224 elements.addNullPointer(i8p);
226 unsigned AddrSpace = 0;
227 if (
C.getLangOpts().OpenCL)
230 llvm::GlobalValue::LinkageTypes linkage;
231 if (descName.empty()) {
232 linkage = llvm::GlobalValue::InternalLinkage;
233 descName =
"__block_descriptor_tmp";
234 }
else if (hasInternalHelper) {
237 linkage = llvm::GlobalValue::InternalLinkage;
239 linkage = llvm::GlobalValue::LinkOnceODRLinkage;
242 llvm::GlobalVariable *global =
244 true, linkage, AddrSpace);
246 if (linkage == llvm::GlobalValue::LinkOnceODRLinkage) {
248 global->setComdat(CGM.
getModule().getOrInsertComdat(descName));
249 global->setVisibility(llvm::GlobalValue::HiddenVisibility);
250 global->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
269 struct objc_class *isa;
297 _ResultType (*invoke)(Block_literal *, _ParamTypes...);
300 struct Block_descriptor *block_descriptor;
303 _CapturesTypes captures...;
309 struct BlockLayoutChunk {
325 FieldType(fieldType), CopyKind(CopyKind), DisposeKind(DisposeKind),
326 CopyFlags(CopyFlags), DisposeFlags(DisposeFlags) {}
335 index, offset, FieldType, CopyKind, CopyFlags, DisposeKind,
341 return CopyKind == BlockCaptureEntityKind::None &&
342 DisposeKind == BlockCaptureEntityKind::None;
349 bool operator<(
const BlockLayoutChunk &left,
const BlockLayoutChunk &right) {
350 if (left.Alignment != right.Alignment)
351 return left.Alignment > right.Alignment;
353 auto getPrefOrder = [](
const BlockLayoutChunk &chunk) {
354 switch (chunk.CopyKind) {
358 switch (chunk.CopyFlags.getBitMask()) {
377 return getPrefOrder(left) < getPrefOrder(right);
381static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
385static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
396 Layout.push_back(BlockLayoutChunk(
406 std::tie(CopyKind, CopyFlags) =
408 std::tie(DisposeKind, DisposeFlags) =
410 Layout.push_back(BlockLayoutChunk(align, size, capture,
type, fieldType,
411 CopyKind, CopyFlags, DisposeKind,
417 if (!Layout.back().isTrivial())
423 const auto *record =
type->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
430 if (!record->hasTrivialDestructor())
return false;
431 if (record->hasNonTrivialCopyConstructor())
return false;
435 return !record->hasMutableFields();
449 if (isa<ParmVarDecl>(var))
455 if (!
type.isConstQualified())
return nullptr;
468 const Expr *init = var->getInit();
469 if (!init)
return nullptr;
483 assert(elementTypes.empty());
493 assert((2 * CGM.
getIntSize()).isMultipleOf(GenPtrAlign));
494 elementTypes.push_back(CGM.
IntTy);
495 elementTypes.push_back(CGM.
IntTy);
496 elementTypes.push_back(
501 unsigned BlockAlign = GenPtrAlign.getQuantity();
504 for (
auto *I : Helper->getCustomFieldTypes()) {
507 unsigned Align = CGM.
getDataLayout().getABITypeAlign(I).value();
508 if (BlockAlign < Align)
510 assert(Offset % Align == 0);
512 elementTypes.push_back(I);
526 elementTypes.push_back(CGM.
IntTy);
527 elementTypes.push_back(CGM.
IntTy);
542 return FD->getType();
559 bool hasNonConstantCustomFields =
false;
560 if (
auto *OpenCLHelper =
562 hasNonConstantCustomFields =
563 !OpenCLHelper->areAllCustomFieldValuesConstant(info);
564 if (!block->
hasCaptures() && !hasNonConstantCustomFields) {
569 }
else if (
C.getLangOpts().ObjC &&
585 assert(CGF && isa_and_nonnull<CXXMethodDecl>(CGF->
CurFuncDecl) &&
586 "Can't capture 'this' outside a method");
593 maxFieldAlign = std::max(maxFieldAlign, TInfo.Align);
595 addBlockLayout(TInfo.Align, TInfo.Width,
nullptr, llvmType, thisType,
600 for (
const auto &CI : block->
captures()) {
601 const VarDecl *variable = CI.getVariable();
603 if (CI.isEscapingByref()) {
606 maxFieldAlign = std::max(maxFieldAlign, align);
611 "capture type differs from the variable type");
613 variable->
getType(), layout, info, CGM);
629 if (CI.hasCopyExpr() || !record->hasTrivialDestructor()) {
631 if (!record->isExternallyVisible())
638 maxFieldAlign = std::max(maxFieldAlign, align);
640 llvm::Type *llvmType =
643 addBlockLayout(align, size, &CI, llvmType, VT, layout, info, CGM);
647 if (layout.empty()) {
658 llvm::stable_sort(layout);
682 if (endAlign < maxFieldAlign) {
684 li = layout.begin() + 1, le = layout.end();
688 for (; li != le && endAlign < li->Alignment; ++li)
695 for (; li != le; ++li) {
696 assert(endAlign >= li->Alignment);
698 li->setIndex(info, elementTypes.size(), blockSize);
699 elementTypes.push_back(li->Type);
700 blockSize += li->Size;
704 if (endAlign >= maxFieldAlign) {
710 layout.erase(first, li);
714 assert(endAlign ==
getLowBit(blockSize));
718 if (endAlign < maxFieldAlign) {
720 CharUnits padding = newBlockSize - blockSize;
728 elementTypes.push_back(llvm::ArrayType::get(CGM.
Int8Ty,
730 blockSize = newBlockSize;
734 assert(endAlign >= maxFieldAlign);
735 assert(endAlign ==
getLowBit(blockSize));
740 li = layout.begin(), le = layout.end(); li != le; ++li) {
741 if (endAlign < li->Alignment) {
745 CharUnits padding = li->Alignment - endAlign;
746 elementTypes.push_back(llvm::ArrayType::get(CGM.
Int8Ty,
748 blockSize += padding;
751 assert(endAlign >= li->Alignment);
752 li->setIndex(info, elementTypes.size(), blockSize);
753 elementTypes.push_back(li->Type);
754 blockSize += li->Size;
767 if (!
blockExpr->getBlockDecl()->hasCaptures())
784 llvm::PointerType *GenVoidPtrTy =
793 auto *InvokeFn = BlockCGF.GenerateBlockFunction(
795 auto *blockFn = llvm::ConstantExpr::getPointerCast(InvokeFn, GenVoidPtrTy);
804 assert(blockAddr.
isValid() &&
"block has no address!");
807 llvm::Constant *descriptor;
813 llvm::Constant *blockISA = blockInfo.
NoEscape
836 auto projectField = [&](
unsigned index,
const Twine &name) ->
Address {
839 auto storeField = [&](llvm::Value *value,
unsigned index,
const Twine &
name) {
848 auto addHeaderField = [&](llvm::Value *value,
CharUnits size,
850 storeField(value, index, name);
854 auto addSignedHeaderField =
857 auto StorageAddress = projectField(index, Name);
860 Schema, StorageAddress.emitRawPointer(*
this),
Decl,
Type);
869 addSignedHeaderField(
886 llvm::Value *blockFnPtr =
887 llvm::ConstantExpr::getBitCast(InvokeFn,
VoidPtrTy);
892 addSignedHeaderField(
897 addSignedHeaderField(
900 }
else if (
auto *Helper =
902 addHeaderField(blockFn, GenVoidPtrSize,
"block.invoke");
903 for (
auto I : Helper->getCustomFieldValues(*
this, blockInfo)) {
911 addHeaderField(blockFn, GenVoidPtrSize,
"block.invoke");
920 projectField(blockInfo.
CXXThisIndex,
"block.captured-this.addr");
925 for (
const auto &CI :
blockDecl->captures()) {
926 const VarDecl *variable = CI.getVariable();
936 Address blockField = projectField(capture.
getIndex(),
"block.captured");
942 if (
blockDecl->isConversionFromLambda()) {
946 }
else if (CI.isEscapingByref()) {
955 "block.capture.addr");
957 auto I = LocalDeclMap.find(variable);
958 assert(I != LocalDeclMap.end());
973 if (CI.isEscapingByref()) {
975 llvm::Value *byrefPointer;
985 }
else if (
const Expr *copyExpr = CI.getCopyExpr()) {
986 if (
blockDecl->isConversionFromLambda()) {
1005 }
else if (
type.isConstQualified() &&
1019 type->isBlockPointerType()) {
1072 if (
type.isConstQualified() &&
1076 "expected ObjC ARC to be enabled");
1086 if (useArrayEHCleanup)
1093 auto IsBlockDeclInRetExpr = [&]() {
1094 auto *EWC = llvm::dyn_cast_or_null<ExprWithCleanups>(
RetExpr);
1096 for (
auto &
C : EWC->getObjects())
1103 if (IsBlockDeclInRetExpr())
1104 pushDestroy(cleanupKind, blockField,
type, destroyer, useArrayEHCleanup);
1112 llvm::Value *result =
Builder.CreatePointerCast(
1125 if (BlockDescriptorType)
1126 return BlockDescriptorType;
1128 unsigned AddrSpace = 0;
1131 BlockDescriptorType = llvm::PointerType::get(
getLLVMContext(), AddrSpace);
1132 return BlockDescriptorType;
1136 if (GenericBlockLiteralType)
1137 return GenericBlockLiteralType;
1151 llvm::append_range(StructFields, Helper->getCustomFieldTypes());
1153 GenericBlockLiteralType = llvm::StructType::create(
1154 StructFields,
"struct.__opencl_block_literal_generic");
1163 GenericBlockLiteralType =
1164 llvm::StructType::create(
"struct.__block_literal_generic",
VoidPtrTy,
1168 return GenericBlockLiteralType;
1173 llvm::CallBase **CallOrInvoke) {
1177 llvm::Value *
Func =
nullptr;
1182 llvm::Value *FuncPtr =
nullptr;
1189 llvm::Type *GenericVoidPtrTy =
1191 llvm::Value *BlockDescriptor =
Builder.CreatePointerCast(
1192 BlockPtr, GenericVoidPtrTy);
1200 if (!isa<ParmVarDecl>(
E->getCalleeDecl()))
1230 if (
auto &AuthSchema =
1232 assert(FuncPtr !=
nullptr &&
"Missing function pointer for AuthInfo");
1244 assert(
BlockInfo &&
"evaluating block ref without block information?");
1248 if (capture.
isConstant())
return LocalDeclMap.find(variable)->second;
1251 "block.capture.addr");
1259 byrefInfo.ByrefAlignment);
1267 "the capture field of a non-escaping variable should have a "
1276 llvm::Constant *
Addr) {
1277 bool Ok = EmittedGlobalBlocks.insert(std::make_pair(BE,
Addr)).second;
1279 assert(
Ok &&
"Trying to replace an already-existing global block!");
1307 llvm::Constant *blockFn) {
1313 "Refusing to re-emit a global block.");
1328 CGOPointerAuth.ObjCIsaPointers,
GlobalDecl(),
1341 fields.addInt(CGM.
IntTy, 0);
1348 if (
auto &Schema = CGOPointerAuth.BlockInvocationFunctionPointers) {
1353 fields.addSignedPointer(blockFn, Schema,
GlobalDecl(), FnType);
1355 fields.add(blockFn);
1360 fields.addSignedPointer(Descriptor, CGOPointerAuth.BlockDescriptorPointers,
1362 }
else if (
auto *Helper =
1364 for (
auto *I : Helper->getCustomFieldValues(CGM, blockInfo)) {
1369 unsigned AddrSpace = 0;
1373 llvm::GlobalVariable *literal = fields.finishAndCreateGlobal(
1374 "__block_literal_global", blockInfo.
BlockAlign,
1375 !IsWindows, llvm::GlobalVariable::InternalLinkage, AddrSpace);
1377 literal->addAttribute(
"objc_arc_inert");
1382 auto *
Init = llvm::Function::Create(llvm::FunctionType::get(CGM.
VoidTy,
1383 {}), llvm::GlobalValue::InternalLinkage,
".block_isa_init",
1385 llvm::IRBuilder<>
b(llvm::BasicBlock::Create(CGM.
getLLVMContext(),
"entry",
1388 b.CreateStructGEP(literal->getValueType(), literal, 0),
1393 auto *InitVar =
new llvm::GlobalVariable(CGM.
getModule(),
Init->getType(),
1394 true, llvm::GlobalValue::InternalLinkage,
1395 Init,
".block_isa_init_ptr");
1396 InitVar->setSection(
".CRT$XCLa");
1401 llvm::Type *RequiredType =
1404 llvm::ConstantExpr::getPointerCast(literal, RequiredType);
1409 cast<llvm::Function>(blockFn->stripPointerCasts()),
Result,
1410 literal->getValueType());
1417 assert(
BlockInfo &&
"not emitting prologue of block invocation function?!");
1426 DI->EmitDeclareOfBlockLiteralArgVariable(
1428 cast<llvm::AllocaInst>(alloc.
getPointer()->stripPointerCasts()),
1440 llvm::PointerType::get(
1449 assert(
BlockInfo &&
"not in a block invocation function!");
1456 bool IsLambdaConversionToBlock,
bool BuildGlobalBlock) {
1468 for (
const auto &KV : ldm) {
1469 const auto *var = dyn_cast<VarDecl>(KV.first);
1470 if (var && !var->hasLocalStorage())
1471 setAddrOfLocalVar(var, KV.second);
1496 args.push_back(&SelfDecl);
1511 llvm::Function *fn = llvm::Function::Create(
1512 fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &
CGM.
getModule());
1515 if (BuildGlobalBlock) {
1520 llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy));
1554 for (
const auto &CI :
blockDecl->captures()) {
1555 const VarDecl *variable = CI.getVariable();
1565 setAddrOfLocalVar(variable, alloca);
1569 llvm::BasicBlock *entry =
Builder.GetInsertBlock();
1570 llvm::BasicBlock::iterator entry_ptr =
Builder.GetInsertPoint();
1573 if (IsLambdaConversionToBlock)
1582 llvm::BasicBlock *resume =
Builder.GetInsertBlock();
1585 if (entry_ptr->getNextNode())
1586 entry_ptr = entry_ptr->getNextNode()->getIterator();
1588 entry_ptr = entry->end();
1589 Builder.SetInsertPoint(entry, entry_ptr);
1594 for (
const auto &CI :
blockDecl->captures()) {
1595 const VarDecl *variable = CI.getVariable();
1601 auto addr = LocalDeclMap.find(variable)->second;
1602 (void)DI->EmitDeclareOfAutoVariable(
1607 DI->EmitDeclareOfBlockDeclRefVariable(
1608 variable, BlockPointerDbgLoc,
Builder, blockInfo,
1609 entry_ptr == entry->end() ? nullptr : &*entry_ptr);
1614 cast<CompoundStmt>(
blockDecl->getBody())->getRBracLoc());
1618 if (resume ==
nullptr)
1619 Builder.ClearInsertionPoint();
1621 Builder.SetInsertPoint(resume);
1628static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
1639 if (
T.isObjCGCWeak())
1644 if (
T.hasAddressDiscriminatedPointerAuth())
1645 return std::make_pair(
1653 switch (
T.isNonTrivialToPrimitiveCopy()) {
1669 return std::make_pair(
1695 llvm_unreachable(
"after exhaustive PrimitiveCopyKind switch");
1707 :
Addr(
Addr), FieldFlags(Flags), LoadBlockVarAddr(LoadValue),
1711 llvm::Value *BlockVarAddr;
1712 if (LoadBlockVarAddr) {
1715 BlockVarAddr =
Addr.emitRawPointer(CGF);
1733 CaptureStrKind StrKind,
1746 assert((StrKind != CaptureStrKind::Merged ||
1749 "different operations and flags");
1751 if (StrKind == CaptureStrKind::DisposeHelper) {
1763 llvm::raw_svector_ostream Out(TyStr);
1765 Str += llvm::to_string(TyStr.size()) + TyStr.c_str();
1776 assert(PtrAuth && PtrAuth.isAddressDiscriminated());
1777 Str +=
"p" + llvm::to_string(PtrAuth.getKey()) +
"d" +
1778 llvm::to_string(PtrAuth.getExtraDiscriminator());
1791 if (StrKind != CaptureStrKind::DisposeHelper) {
1795 if (StrKind != CaptureStrKind::CopyHelper) {
1814 std::string FuncStr;
1815 if (StrKind == CaptureStrKind::DisposeHelper)
1817 CaptureTy, Alignment, IsVolatile, Ctx);
1822 CaptureTy, Alignment, IsVolatile, Ctx);
1825 Str += llvm::to_string(FuncStr.size()) +
"_" + FuncStr;
1838 assert((StrKind == CaptureStrKind::CopyHelper ||
1839 StrKind == CaptureStrKind::DisposeHelper) &&
1840 "unexpected CaptureStrKind");
1841 std::string Name = StrKind == CaptureStrKind::CopyHelper
1842 ?
"__copy_helper_block_"
1843 :
"__destroy_helper_block_";
1848 Name += llvm::to_string(BlockAlignment.
getQuantity()) +
"_";
1850 for (
auto &Cap : Captures) {
1851 if (Cap.isConstantOrTrivial())
1853 Name += llvm::to_string(Cap.getOffset().getQuantity());
1864 bool EHOnly = ForCopyHelper;
1866 switch (CaptureKind) {
1907 if (CapturesNonExternalType) {
1910 Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
1911 Fn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1928 CaptureStrKind::CopyHelper,
CGM);
1939 args.push_back(&DstDecl);
1941 args.push_back(&SrcDecl);
1950 llvm::Function *Fn =
1951 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
1954 Fn->setComdat(
CGM.
getModule().getOrInsertComdat(FuncName));
1957 ArgTys.push_back(
C.VoidPtrTy);
1958 ArgTys.push_back(
C.VoidPtrTy);
1981 unsigned index = capture.
getIndex();
1988 assert(CI.
getCopyExpr() &&
"copy expression for variable is missing");
2016 auto *ty = cast<llvm::PointerType>(srcValue->getType());
2017 llvm::Value *null = llvm::ConstantPointerNull::get(ty);
2031 if (
auto *I = cast_or_null<llvm::Instruction>(
2033 I->eraseFromParent();
2040 llvm::Value *args[] = {
2074static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
2079 if (
T.isObjCGCWeak())
2084 switch (
T.isDestructedType()) {
2111 llvm_unreachable(
"after exhaustive DestructionKind switch");
2125 CaptureStrKind::DisposeHelper,
CGM);
2136 args.push_back(&SrcDecl);
2145 llvm::Function *Fn =
2146 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
2149 Fn->setComdat(
CGM.
getModule().getOrInsertComdat(FuncName));
2152 ArgTys.push_back(
C.VoidPtrTy);
2207 llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.
Int32Ty, flags);
2210 llvm::Value *args[] = {destField.
emitRawPointer(CGF), srcValue, flagsVal};
2221 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2222 id.AddInteger(Flags.getBitMask());
2240 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2260 llvm::ConstantPointerNull::get(cast<llvm::PointerType>(value->getType()));
2276 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2286 ARCStrongBlockByrefHelpers(
CharUnits alignment)
2303 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2313 const Expr *CopyExpr;
2317 const Expr *copyExpr)
2320 bool needsCopy()
const override {
return CopyExpr !=
nullptr; }
2323 if (!CopyExpr)
return;
2333 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2334 id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
2346 assert(
Type.hasAddressDiscriminatedPointerAuth());
2355 bool needsDispose()
const override {
return false; }
2357 llvm_unreachable(
"should never be called");
2360 void profileImpl(llvm::FoldingSetNodeID &
ID)
const override {
2361 ID.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
2380 bool needsDispose()
const override {
2381 return VarType.isDestructedType();
2386 CGF.
pushDestroy(VarType.isDestructedType(), field, VarType);
2390 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2391 id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
2396static llvm::Constant *
2405 args.push_back(&Dst);
2408 args.push_back(&Src);
2417 llvm::Function *Fn =
2418 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
2446 generator.
emitCopy(CGF, destField, srcField);
2463static llvm::Constant *
2473 args.push_back(&Src);
2482 llvm::Function *Fn =
2483 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
2484 "__Block_byref_object_dispose_",
2523 llvm::FoldingSetNodeID id;
2524 generator.Profile(
id);
2529 if (node)
return static_cast<T*
>(node);
2534 T *copy =
new (CGM.
getContext())
T(std::forward<T>(generator));
2543CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType,
2544 const AutoVarEmission &emission) {
2546 assert(
var.isEscapingByref() &&
2547 "only escaping __block variables need byref helpers");
2559 const Expr *copyExpr =
2561 if (!copyExpr && record->hasTrivialDestructor())
return nullptr;
2563 return ::buildByrefHelpers(
2564 CGM, byrefInfo, CXXByrefHelpers(valueAlignment,
type, copyExpr));
2566 if (
type.hasAddressDiscriminatedPointerAuth()) {
2567 return ::buildByrefHelpers(
2568 CGM, byrefInfo, AddressDiscriminatedByrefHelpers(valueAlignment,
type));
2574 return ::buildByrefHelpers(
2575 CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment,
type));
2579 if (!
type->isObjCRetainableType())
return nullptr;
2596 return ::buildByrefHelpers(
CGM, byrefInfo,
2597 ARCWeakByrefHelpers(valueAlignment));
2603 if (
type->isBlockPointerType()) {
2604 return ::buildByrefHelpers(
CGM, byrefInfo,
2605 ARCStrongBlockByrefHelpers(valueAlignment));
2610 return ::buildByrefHelpers(
CGM, byrefInfo,
2611 ARCStrongByrefHelpers(valueAlignment));
2614 llvm_unreachable(
"fell out of lifetime switch!");
2618 if (
type->isBlockPointerType()) {
2621 type->isObjCObjectPointerType()) {
2627 if (
type.isObjCGCWeak())
2630 return ::buildByrefHelpers(
CGM, byrefInfo,
2631 ObjectByrefHelpers(valueAlignment, flags));
2636 bool followForward) {
2644 const llvm::Twine &name) {
2646 if (followForward) {
2671 auto it = BlockByrefInfos.find(
D);
2672 if (it != BlockByrefInfos.end())
2698 if (hasCopyAndDispose) {
2708 bool HasByrefExtendedLayout =
false;
2710 if (
getContext().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) &&
2711 HasByrefExtendedLayout) {
2720 bool packed =
false;
2725 if (varOffset != size) {
2726 llvm::Type *paddingTy =
2727 llvm::ArrayType::get(
Int8Ty, (varOffset - size).getQuantity());
2729 types.push_back(paddingTy);
2737 types.push_back(varTy);
2739 llvm::StructType *byrefType = llvm::StructType::create(
2744 info.
Type = byrefType;
2749 auto pair = BlockByrefInfos.insert({
D, info});
2750 assert(pair.second &&
"info was inserted recursively?");
2751 return pair.first->second;
2761 llvm::StructType *byrefType = cast<llvm::StructType>(addr.
getElementType());
2763 unsigned nextHeaderIndex = 0;
2765 auto storeHeaderField = [&](llvm::Value *value,
CharUnits fieldSize,
2766 const Twine &name,
bool isFunction =
false) {
2779 nextHeaderOffset += fieldSize;
2785 const VarDecl &
D = *emission.Variable;
2788 bool HasByrefExtendedLayout =
false;
2790 bool ByRefHasLifetime =
2797 if (
type.isObjCGCWeak())
2804 "byref.forwarding");
2811 if (ByRefHasLifetime) {
2813 else switch (ByrefLifetime) {
2824 if (!
type->isObjCObjectPointerType() && !
type->isBlockPointerType())
2831 printf(
"\n Inline flag for BYREF variable layout (%d):", flags.
getBitMask());
2833 printf(
" BLOCK_BYREF_HAS_COPY_DISPOSE");
2837 printf(
" BLOCK_BYREF_LAYOUT_EXTENDED");
2839 printf(
" BLOCK_BYREF_LAYOUT_STRONG");
2841 printf(
" BLOCK_BYREF_LAYOUT_WEAK");
2843 printf(
" BLOCK_BYREF_LAYOUT_UNRETAINED");
2845 printf(
" BLOCK_BYREF_LAYOUT_NON_OBJECT");
2861 "byref.disposeHelper",
true);
2864 if (ByRefHasLifetime && HasByrefExtendedLayout) {
2873 llvm::Value *args[] = {
V,
2884 bool LoadBlockVarAddr,
bool CanThrow) {
2885 EHStack.pushCleanup<CallBlockRelease>(Kind,
Addr, Flags, LoadBlockVarAddr,
2891 llvm::Constant *
C) {
2892 auto *GV = cast<llvm::GlobalValue>(
C->stripPointerCasts());
2900 assert((isa<llvm::Function>(
C->stripPointerCasts()) ||
2901 isa<llvm::GlobalVariable>(
C->stripPointerCasts())) &&
2902 "expected Function or GlobalVariable");
2906 if ((ND = dyn_cast<FunctionDecl>(
Result)) ||
2907 (ND = dyn_cast<VarDecl>(
Result)))
2910 if (GV->isDeclaration() && (!ND || !ND->
hasAttr<DLLExportAttr>())) {
2911 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
2912 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
2914 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
2915 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
2919 if (CGM.
getLangOpts().BlocksRuntimeOptional && GV->isDeclaration() &&
2920 GV->hasExternalLinkage())
2921 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2927 if (BlockObjectDispose)
2928 return BlockObjectDispose;
2931 BlockObjectDispose =
2934 *
this, cast<llvm::Constant>(BlockObjectDispose.getCallee()));
2935 return BlockObjectDispose;
2939 if (BlockObjectAssign)
2940 return BlockObjectAssign;
2946 *
this, cast<llvm::Constant>(BlockObjectAssign.getCallee()));
2947 return BlockObjectAssign;
2951 if (NSConcreteGlobalBlock)
2952 return NSConcreteGlobalBlock;
2957 return NSConcreteGlobalBlock;
2961 if (NSConcreteStackBlock)
2962 return NSConcreteStackBlock;
2967 return NSConcreteStackBlock;
static bool CanThrow(Expr *E, ASTContext &Ctx)
static llvm::Constant * buildByrefDisposeHelper(CodeGenModule &CGM, const BlockByrefInfo &byrefInfo, BlockByrefHelpers &generator)
Build the dispose helper for a __block variable.
static llvm::Constant * buildBlockDescriptor(CodeGenModule &CGM, const CGBlockInfo &blockInfo)
buildBlockDescriptor - Build the block descriptor meta-data for a block.
static void addBlockLayout(CharUnits align, CharUnits size, const BlockDecl::Capture *capture, llvm::Type *type, QualType fieldType, SmallVectorImpl< BlockLayoutChunk > &Layout, CGBlockInfo &Info, CodeGenModule &CGM)
static llvm::Constant * generateByrefDisposeHelper(CodeGenFunction &CGF, const BlockByrefInfo &byrefInfo, BlockByrefHelpers &generator)
Generate code for a __block variable's dispose helper.
static QualType getCaptureFieldType(const CodeGenFunction &CGF, const BlockDecl::Capture &CI)
static std::string getCopyDestroyHelperFuncName(const SmallVectorImpl< CGBlockInfo::Capture > &Captures, CharUnits BlockAlignment, CaptureStrKind StrKind, CodeGenModule &CGM)
static std::string getBlockDescriptorName(const CGBlockInfo &BlockInfo, CodeGenModule &CGM)
static llvm::Constant * buildCopyHelper(CodeGenModule &CGM, const CGBlockInfo &blockInfo)
Build the helper function to copy a block.
static std::string getBlockCaptureStr(const CGBlockInfo::Capture &Cap, CaptureStrKind StrKind, CharUnits BlockAlignment, CodeGenModule &CGM)
static llvm::Constant * tryCaptureAsConstant(CodeGenModule &CGM, CodeGenFunction *CGF, const VarDecl *var)
It is illegal to modify a const object after initialization.
static llvm::Constant * generateByrefCopyHelper(CodeGenFunction &CGF, const BlockByrefInfo &byrefInfo, BlockByrefHelpers &generator)
static std::pair< BlockCaptureEntityKind, BlockFieldFlags > computeDestroyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T, const LangOptions &LangOpts)
static llvm::Constant * buildByrefCopyHelper(CodeGenModule &CGM, const BlockByrefInfo &byrefInfo, BlockByrefHelpers &generator)
Build the copy helper for a __block variable.
static BlockFieldFlags getBlockFieldFlagsForObjCObjectPointer(const BlockDecl::Capture &CI, QualType T)
static void computeBlockInfo(CodeGenModule &CGM, CodeGenFunction *CGF, CGBlockInfo &info)
Compute the layout of the given block.
static T * buildByrefHelpers(CodeGenModule &CGM, const BlockByrefInfo &byrefInfo, T &&generator)
Lazily build the copy and dispose helpers for a __block variable with the given information.
static llvm::Constant * buildGlobalBlock(CodeGenModule &CGM, const CGBlockInfo &blockInfo, llvm::Constant *blockFn)
Build the given block as a global block.
static llvm::Constant * buildDisposeHelper(CodeGenModule &CGM, const CGBlockInfo &blockInfo)
Build the helper function to dispose of a block.
static void configureBlocksRuntimeObject(CodeGenModule &CGM, llvm::Constant *C)
Adjust the declaration of something from the blocks API.
static bool isSafeForCXXConstantCapture(QualType type)
Determines if the given type is safe for constant capture in C++.
static void pushCaptureCleanup(BlockCaptureEntityKind CaptureKind, Address Field, QualType CaptureType, BlockFieldFlags Flags, bool ForCopyHelper, VarDecl *Var, CodeGenFunction &CGF)
static std::pair< BlockCaptureEntityKind, BlockFieldFlags > computeCopyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T, const LangOptions &LangOpts)
static void setBlockHelperAttributesVisibility(bool CapturesNonExternalType, llvm::Function *Fn, const CGFunctionInfo &FI, CodeGenModule &CGM)
static void initializeForBlockHeader(CodeGenModule &CGM, CGBlockInfo &info, SmallVectorImpl< llvm::Type * > &elementTypes)
static CharUnits getLowBit(CharUnits v)
Get the low bit of a nonzero character count.
static bool isTrivial(ASTContext &Ctx, const Expr *E)
Checks if the expression is constant or does not have non-trivial function calls.
static QualType getPointeeType(const MemRegion *R)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
bool getByrefLifetime(QualType Ty, Qualifiers::ObjCLifetime &Lifetime, bool &HasByrefExtendedLayout) const
Returns true, if given type has a known lifetime.
TranslationUnitDecl * getTranslationUnitDecl() const
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
bool BlockRequiresCopying(QualType Ty, const VarDecl *D)
Returns true iff we need copy/dispose helpers for the given type.
const LangOptions & getLangOpts() const
BlockVarCopyInit getBlockVarCopyInit(const VarDecl *VD) const
Get the copy initialization expression of the VarDecl VD, or nullptr if none exists.
TypeInfoChars getTypeInfoInChars(const Type *T) const
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
std::string getObjCEncodingForBlock(const BlockExpr *blockExpr) const
Return the encoded type for this block declaration.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
unsigned getTargetAddressSpace(LangAS AS) const
A class which contains all the information about a particular captured value.
bool isNested() const
Whether this is a nested capture, i.e.
Expr * getCopyExpr() const
bool isByRef() const
Whether this is a "by ref" capture, i.e.
VarDecl * getVariable() const
The variable being captured.
bool isEscapingByref() const
Represents a block literal declaration, which is like an unnamed FunctionDecl.
capture_const_iterator capture_begin() const
capture_const_iterator capture_end() const
ArrayRef< Capture > captures() const
bool capturesCXXThis() const
bool doesNotEscape() const
bool hasCaptures() const
True if this block (or its nested blocks) captures anything of local storage from its enclosing scope...
bool isConversionFromLambda() const
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
const Stmt * getBody() const
SourceLocation getEndLoc() const LLVM_READONLY
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
const BlockDecl * getBlockDecl() const
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
CharUnits - This is an opaque type for sizes expressed in character units.
CharUnits alignmentAtOffset(CharUnits offset) const
Given that this is a non-zero alignment value, what is the alignment at the given offset?
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
CharUnits alignTo(const CharUnits &Align) const
alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
PointerAuthOptions PointerAuth
Configuration for pointer-signing.
bool hasReducedDebugInfo() const
Check if type and variable info should be emitted.
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
llvm::Value * getPointerIfNotSigned() const
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Address withElementType(llvm::Type *ElemTy) const
Return address with different element type, but same pointer and alignment.
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
A scoped helper to set the current debug location to the specified location or preferred location of ...
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
A pair of helper functions for a __block variable.
virtual ~BlockByrefHelpers()
virtual void emitCopy(CodeGenFunction &CGF, Address dest, Address src)=0
virtual bool needsCopy() const
llvm::Constant * CopyHelper
virtual void emitDispose(CodeGenFunction &CGF, Address field)=0
virtual bool needsDispose() const
llvm::Constant * DisposeHelper
Information about the layout of a __block variable.
uint32_t getBitMask() const
uint32_t getBitMask() const
const BlockDecl::Capture * Cap
BlockFieldFlags DisposeFlags
static Capture makeIndex(unsigned index, CharUnits offset, QualType FieldType, BlockCaptureEntityKind CopyKind, BlockFieldFlags CopyFlags, BlockCaptureEntityKind DisposeKind, BlockFieldFlags DisposeFlags, const BlockDecl::Capture *Cap)
BlockCaptureEntityKind CopyKind
bool isConstantOrTrivial() const
QualType fieldType() const
BlockFieldFlags CopyFlags
BlockCaptureEntityKind DisposeKind
llvm::Value * getConstant() const
unsigned getIndex() const
static Capture makeConstant(llvm::Value *value, const BlockDecl::Capture *Cap)
CharUnits getOffset() const
CGBlockInfo - Information to generate a block literal.
CGBlockInfo(const BlockDecl *blockDecl, StringRef Name)
unsigned CXXThisIndex
The field index of 'this' within the block, if there is one.
const BlockDecl * getBlockDecl() const
llvm::StructType * StructureType
CharUnits BlockHeaderForcedGapOffset
bool UsesStret
UsesStret : True if the block uses an stret return.
const BlockExpr * BlockExpression
const BlockExpr * getBlockExpr() const
bool HasCapturedVariableLayout
HasCapturedVariableLayout : True if block has captured variables and their layout meta-data has been ...
bool CapturesNonExternalType
Indicates whether an object of a non-external C++ class is captured.
bool NeedsCopyDispose
True if the block has captures that would necessitate custom copy or dispose helper functions if the ...
bool CanBeGlobal
CanBeGlobal - True if the block can be global, i.e.
bool HasCXXObject
HasCXXObject - True if the block's custom copy/dispose functions need to be run even in GC mode.
CharUnits BlockHeaderForcedGapSize
const Capture & getCapture(const VarDecl *var) const
llvm::SmallVector< Capture, 4 > SortedCaptures
The block's captures. Non-constant captures are sorted by their offsets.
bool NoEscape
Indicates whether the block is non-escaping.
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
MangleContext & getMangleContext()
Gets the mangle context.
Abstract information about a function or function prototype.
All available information about a concrete callee.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
CGFunctionInfo - Class to encapsulate the information about a function definition.
virtual llvm::Constant * BuildByrefLayout(CodeGen::CodeGenModule &CGM, QualType T)=0
Returns an i8* which points to the byref layout information.
virtual std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM, const CGBlockInfo &blockInfo)
virtual llvm::Constant * BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, const CodeGen::CGBlockInfo &blockInfo)=0
virtual llvm::Constant * BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, const CodeGen::CGBlockInfo &blockInfo)=0
llvm::Function * getInvokeFunction(const Expr *E)
void recordBlockInfo(const BlockExpr *E, llvm::Function *InvokeF, llvm::Value *Block, llvm::Type *BlockTy)
Record invoke function and block literal emitted during normal codegen for a block expression.
llvm::PointerType * getGenericVoidPointerType()
CallArgList - Type for representing both the value and type of arguments in a call.
void add(RValue rvalue, QualType type)
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited.
void ForceCleanup(std::initializer_list< llvm::Value ** > ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
void EmitARCMoveWeak(Address dst, Address src)
void @objc_moveWeak(i8** dest, i8** src) Disregards the current value in dest.
void emitByrefStructureInit(const AutoVarEmission &emission)
Initialize the structural components of a __block variable, i.e.
void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags, bool CanThrow)
SanitizerSet SanOpts
Sanitizers enabled for this function.
void callCStructMoveConstructor(LValue Dst, LValue Src)
Address LoadBlockStruct()
llvm::Type * ConvertType(QualType T)
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
void EmitARCDestroyWeak(Address addr)
void @objc_destroyWeak(i8** addr) Essentially objc_storeWeak(addr, nil).
RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)
void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp)
void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags, bool LoadBlockVarAddr, bool CanThrow)
Enter a cleanup to destroy a __block variable.
const LangOptions & getLangOpts() const
llvm::Function * GenerateBlockFunction(GlobalDecl GD, const CGBlockInfo &Info, const DeclMapTy &ldm, bool IsLambdaConversionToBlock, bool BuildGlobalBlock)
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
pushDestroy - Push the standard destructor for the given type as at least a normal cleanup.
const CodeGen::CGBlockInfo * BlockInfo
llvm::Constant * GenerateCopyHelperFunction(const CGBlockInfo &blockInfo)
Generate the copy-helper function for a block closure object: static void block_copy_helper(block_t *...
static std::string getNonTrivialDestructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
const BlockByrefInfo & getBlockByrefInfo(const VarDecl *var)
BuildByrefInfo - This routine changes a __block variable declared as T x into:
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
void PushDestructorCleanup(QualType T, Address Addr)
PushDestructorCleanup - Push a cleanup to call the complete-object destructor of an object of the giv...
static bool cxxDestructorCanThrow(QualType T)
Check if T is a C++ class that has a destructor that can throw.
llvm::DenseMap< const Decl *, Address > DeclMapTy
void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, std::initializer_list< llvm::Value ** > ValuesToReload={})
Takes the old cleanup stack size and emits the cleanup blocks that have been added.
const Expr * RetExpr
If a return statement is being visited, this holds the return statment's result expression.
Address GetAddrOfBlockDecl(const VarDecl *var)
void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)
Destroy a __strong variable.
static Destroyer destroyARCStrongImprecise
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
llvm::Value * EmitPointerAuthSign(const CGPointerAuthInfo &Info, llvm::Value *Pointer)
void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn)
Annotate the function with an attribute that disables TSan checking at runtime.
llvm::Value * BlockPointer
LValue EmitDeclRefLValue(const DeclRefExpr *E)
void callCStructCopyConstructor(LValue Dst, LValue Src)
llvm::Value * EmitARCRetainBlock(llvm::Value *value, bool mandatory)
Retain the given block, with _Block_copy semantics.
CGDebugInfo * getDebugInfo()
llvm::Value * EmitBlockLiteral(const BlockExpr *)
Emit block literal.
Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V, bool followForward=true)
BuildBlockByrefAddress - Computes the location of the data in a variable which is declared as __block...
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)
EmitCall - Generate a call of the given function, expecting the given result type,...
CGPointerAuthInfo EmitPointerAuthInfo(const PointerAuthSchema &Schema, llvm::Value *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)
Emit the concrete pointer authentication informaton for the given authentication schema.
void EmitPointerAuthCopy(PointerAuthQualifier Qualifier, QualType Type, Address DestField, Address SrcField)
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
ASTContext & getContext() const
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs={})
EmitStmt - Emit the code for the statement.
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
CleanupKind getCleanupKind(QualType::DestructionKind kind)
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
llvm::Type * ConvertTypeForMem(QualType T)
static std::string getNonTrivialCopyConstructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
void EmitLambdaBlockInvokeBody()
RawAddress CreateMemTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
Address EmitLoadOfReference(LValue RefLVal, LValueBaseInfo *PointeeBaseInfo=nullptr, TBAAAccessInfo *PointeeTBAAInfo=nullptr)
void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, llvm::Value *ptr)
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
EmitCallArgs - Emit call arguments for a function.
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
llvm::Value * LoadCXXThis()
LoadCXXThis - Load the value of 'this'.
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
llvm::Constant * GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo)
Generate the destroy-helper function for a block closure object: static void block_destroy_helper(blo...
llvm::LLVMContext & getLLVMContext()
void EmitARCCopyWeak(Address dst, Address src)
void @objc_copyWeak(i8** dest, i8** src) Disregards the current value in dest.
static Destroyer emitARCIntrinsicUse
void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
EmitExprAsInit - Emits the code necessary to initialize a location in memory with the given initializ...
This class organizes the cross-function state that is used while generating LLVM code.
StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD)
llvm::FunctionCallee getBlockObjectAssign()
llvm::FoldingSet< BlockByrefHelpers > ByrefHelpersCache
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
void setDSOLocal(llvm::GlobalValue *GV) const
llvm::Module & getModule() const
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name.
CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const
Return the store size, in character units, of the given LLVM type.
void setAddrOfGlobalBlock(const BlockExpr *BE, llvm::Constant *Addr)
Notes that BE's global block is available via Addr.
llvm::Type * getBlockDescriptorType()
Fetches the type of a generic block descriptor.
llvm::Constant * GetAddrOfGlobalBlock(const BlockExpr *BE, StringRef Name)
Gets the address of a block which requires no captures.
const LangOptions & getLangOpts() const
CodeGenTypes & getTypes()
CGOpenCLRuntime & getOpenCLRuntime()
Return a reference to the configured OpenCL runtime.
const TargetInfo & getTarget() const
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
const llvm::DataLayout & getDataLayout() const
llvm::Constant * getNSConcreteGlobalBlock()
CGCXXABI & getCXXABI() const
llvm::Constant * getAddrOfGlobalBlockIfEmitted(const BlockExpr *BE)
Returns the address of a block which requires no caputres, or null if we've yet to emit the block for...
bool ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI)
Return true iff the given type uses an argument slot when 'sret' is used as a return type.
llvm::Constant * GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty, LangAS AddrSpace, const VarDecl *D, ForDefinition_t IsForDefinition=NotForDefinition)
GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, create and return an llvm...
ASTContext & getContext() const
llvm::Constant * getNSConcreteStackBlock()
bool supportsCOMDAT() const
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
llvm::FunctionCallee getBlockObjectDispose()
llvm::LLVMContext & getLLVMContext()
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)
Set the LLVM function attributes (sext, zext, etc).
llvm::Type * getGenericBlockLiteralType()
The type of a generic block literal.
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating '\0' character.
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
const CGFunctionInfo & arrangeBlockFunctionCall(const CallArgList &args, const FunctionType *type)
A block function is essentially a free function with an extra implicit argument.
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
const CGFunctionInfo & arrangeBlockFunctionDeclaration(const FunctionProtoType *type, const FunctionArgList &args)
Block invocation functions are C functions with an implicit parameter.
llvm::Constant * getPointer() const
llvm::Constant * tryEmitAbstractForInitializer(const VarDecl &D)
Try to emit the initializer of the given declaration as an abstract constant.
StructBuilder beginStruct(llvm::StructType *structTy=nullptr)
The standard implementation of ConstantInitBuilder used in Clang.
Information for lazily generating a cleanup.
A saved depth on the scope stack.
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
FunctionArgList - Type for representing both the decl and type of parameters to a function.
Address getAddress() const
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
static RValue get(llvm::Value *V)
An abstract representation of an aligned address.
llvm::Value * getPointer() const
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
virtual TargetOpenCLBlockHelper * getTargetOpenCLBlockHelper() const
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
SourceLocation getLocation() const
This represents one expression.
Represents difference between two FPOptions values.
Represents a prototype with parameter type info, e.g.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getReturnType() const
GlobalDecl - represents a global declaration.
One of these records is kept for each identifier that is lexed.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0
Generates a unique string for an externally visible type for use with TBAA or type uniquing.
This represents a decl that may have a name.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Pointer-authentication qualifiers.
bool isAddressDiscriminated() const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
PointerAuthQualifier getPointerAuth() const
@ DK_objc_strong_lifetime
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
@ PCK_Struct
The type is a struct containing a field whose type is neither PCK_Trivial nor PCK_VolatileTrivial.
@ PCK_Trivial
The type does not fall into any of the following categories.
@ PCK_ARCStrong
The type is an Objective-C retainable pointer type that is qualified with the ARC __strong qualifier.
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
@ PCK_PtrAuth
The type is an address-discriminated signed pointer type.
@ PCK_ARCWeak
The type is an Objective-C retainable pointer type that is qualified with the ARC __weak qualifier.
The collection of all-type qualifiers we support.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
ObjCLifetime getObjCLifetime() const
Base for LValueReferenceType and RValueReferenceType.
Scope - A scope is a transient data structure that is used while parsing the program.
Encodes a location in the source.
SourceLocation getBeginLoc() const LLVM_READONLY
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
uint64_t getPointerAlign(LangAS AddrSpace) const
The top declaration context.
static DeclContext * castToDeclContext(const TranslationUnitDecl *D)
The base class of the type hierarchy.
bool isBlockPointerType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isObjCInertUnsafeUnretainedType() const
Was this type written with the special inert-in-ARC __unsafe_unretained qualifier?
const T * getAs() const
Member-template getAs<specific type>'.
bool isObjCRetainableType() const
Represents a variable declaration or definition.
bool isNonEscapingByref() const
Indicates the capture is a __block variable that is never captured by an escaping block.
bool isEscapingByref() const
Indicates the capture is a __block variable that is captured by a block that can potentially escape (...
@ BLOCK_HAS_EXTENDED_LAYOUT
@ BLOCK_BYREF_LAYOUT_MASK
@ BLOCK_BYREF_LAYOUT_WEAK
@ BLOCK_BYREF_LAYOUT_STRONG
@ BLOCK_BYREF_LAYOUT_EXTENDED
@ BLOCK_BYREF_LAYOUT_NON_OBJECT
@ BLOCK_BYREF_HAS_COPY_DISPOSE
@ BLOCK_BYREF_LAYOUT_UNRETAINED
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
BlockCaptureEntityKind
Represents a type of copy/destroy operation that should be performed for an entity that's captured by...
@ AddressDiscriminatedPointerAuth
@ NormalCleanup
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
@ EHCleanup
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Stmt, BlockExpr > blockExpr
Matches a reference to a block.
const internal::VariadicDynCastAllOfMatcher< Decl, BlockDecl > blockDecl
Matches block declarations.
constexpr Variable var(Literal L)
Returns the variable of L.
constexpr size_t align(size_t Size)
Aligns a size to the pointer alignment.
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
@ Result
The result type of a method or function.
static bool isBlockPointer(Expr *Arg)
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
@ Other
Other implicit parameter.
@ ObjCSelf
Parameter for Objective-C 'self' argument.
unsigned long ulong
An unsigned 64-bit integer.
CLINKAGE int printf(__constant const char *st,...) __attribute__((format(printf
Expr * getCopyExpr() const
llvm::PointerType * VoidPtrTy
llvm::PointerType * Int8PtrPtrTy
CharUnits getIntAlign() const
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
CharUnits getPointerSize() const
unsigned char PointerSizeInBytes
CharUnits getIntSize() const
llvm::IntegerType * Int32Ty
llvm::IntegerType * IntTy
int
llvm::PointerType * Int8PtrTy
llvm::PointerType * UnqualPtrTy
CharUnits getPointerAlign() const
PointerAuthSchema BlockDescriptorPointers
The ABI for pointers to block descriptors.
PointerAuthSchema BlockHelperFunctionPointers
The ABI for block object copy/destroy function pointers.
PointerAuthSchema BlockInvocationFunctionPointers
The ABI for block invocation function pointers.
PointerAuthSchema BlockByrefHelperFunctionPointers
The ABI for __block variable copy/destroy function pointers.
PointerAuthSchema ObjCIsaPointers
The ABI for Objective-C isa pointers.