25#include "llvm/ADT/SmallSet.h"
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(
Address::invalid()), StructureType(nullptr),
Block(block) {
43 if (!name.empty() && name[0] ==
'\01')
44 name = name.substr(1);
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 =
127 std::replace(TypeAtEncoding.begin(), TypeAtEncoding.end(),
'@',
'\1');
128 Name +=
"e" + llvm::to_string(TypeAtEncoding.size()) +
"_" + TypeAtEncoding;
151 llvm::IntegerType *
ulong =
153 llvm::PointerType *i8p =
nullptr;
155 i8p = llvm::PointerType::get(
160 std::string descName;
163 if (
C.getLangOpts().ObjC &&
166 if (llvm::GlobalValue *desc = CGM.
getModule().getNamedValue(descName))
176 elements.addInt(
ulong, 0);
185 bool hasInternalHelper =
false;
189 elements.add(copyHelper);
193 elements.add(disposeHelper);
195 if (cast<llvm::Function>(copyHelper->stripPointerCasts())
196 ->hasInternalLinkage() ||
197 cast<llvm::Function>(disposeHelper->stripPointerCasts())
198 ->hasInternalLinkage())
199 hasInternalHelper =
true;
203 std::string typeAtEncoding =
208 if (
C.getLangOpts().ObjC) {
215 elements.addNullPointer(i8p);
217 unsigned AddrSpace = 0;
218 if (
C.getLangOpts().OpenCL)
221 llvm::GlobalValue::LinkageTypes linkage;
222 if (descName.empty()) {
223 linkage = llvm::GlobalValue::InternalLinkage;
224 descName =
"__block_descriptor_tmp";
225 }
else if (hasInternalHelper) {
228 linkage = llvm::GlobalValue::InternalLinkage;
230 linkage = llvm::GlobalValue::LinkOnceODRLinkage;
233 llvm::GlobalVariable *global =
235 true, linkage, AddrSpace);
237 if (linkage == llvm::GlobalValue::LinkOnceODRLinkage) {
239 global->setComdat(CGM.
getModule().getOrInsertComdat(descName));
240 global->setVisibility(llvm::GlobalValue::HiddenVisibility);
241 global->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
260 struct objc_class *isa;
288 _ResultType (*invoke)(Block_literal *, _ParamTypes...);
291 struct Block_descriptor *block_descriptor;
294 _CapturesTypes captures...;
300 struct BlockLayoutChunk {
316 FieldType(fieldType), CopyKind(CopyKind), DisposeKind(DisposeKind),
317 CopyFlags(CopyFlags), DisposeFlags(DisposeFlags) {}
326 index, offset, FieldType, CopyKind, CopyFlags, DisposeKind,
332 return CopyKind == BlockCaptureEntityKind::None &&
333 DisposeKind == BlockCaptureEntityKind::None;
340 bool operator<(
const BlockLayoutChunk &left,
const BlockLayoutChunk &right) {
341 if (left.Alignment != right.Alignment)
342 return left.Alignment > right.Alignment;
344 auto getPrefOrder = [](
const BlockLayoutChunk &chunk) {
345 switch (chunk.CopyKind) {
349 switch (chunk.CopyFlags.getBitMask()) {
368 return getPrefOrder(left) < getPrefOrder(right);
372static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
376static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
387 Layout.push_back(BlockLayoutChunk(
397 std::tie(CopyKind, CopyFlags) =
399 std::tie(DisposeKind, DisposeFlags) =
401 Layout.push_back(BlockLayoutChunk(align, size, capture,
type, fieldType,
402 CopyKind, CopyFlags, DisposeKind,
408 if (!Layout.back().isTrivial())
420 const auto *record = cast<CXXRecordDecl>(
recordType->getDecl());
423 if (!record->hasTrivialDestructor())
return false;
424 if (record->hasNonTrivialCopyConstructor())
return false;
428 return !record->hasMutableFields();
442 if (isa<ParmVarDecl>(var))
448 if (!
type.isConstQualified())
return nullptr;
462 if (!init)
return nullptr;
476 assert(elementTypes.empty());
486 assert((2 * CGM.
getIntSize()).isMultipleOf(GenPtrAlign));
487 elementTypes.push_back(CGM.
IntTy);
488 elementTypes.push_back(CGM.
IntTy);
489 elementTypes.push_back(
494 unsigned BlockAlign = GenPtrAlign.getQuantity();
497 for (
auto *I : Helper->getCustomFieldTypes()) {
500 unsigned Align = CGM.
getDataLayout().getABITypeAlign(I).value();
501 if (BlockAlign < Align)
503 assert(Offset % Align == 0);
505 elementTypes.push_back(I);
519 elementTypes.push_back(CGM.
IntTy);
520 elementTypes.push_back(CGM.
IntTy);
535 return FD->getType();
552 bool hasNonConstantCustomFields =
false;
553 if (
auto *OpenCLHelper =
555 hasNonConstantCustomFields =
556 !OpenCLHelper->areAllCustomFieldValuesConstant(info);
557 if (!block->
hasCaptures() && !hasNonConstantCustomFields) {
563 else if (
C.getLangOpts().ObjC &&
580 "Can't capture 'this' outside a method");
587 maxFieldAlign = std::max(maxFieldAlign, TInfo.Align);
589 addBlockLayout(TInfo.Align, TInfo.Width,
nullptr, llvmType, thisType,
594 for (
const auto &CI : block->
captures()) {
595 const VarDecl *variable = CI.getVariable();
597 if (CI.isEscapingByref()) {
600 maxFieldAlign = std::max(maxFieldAlign, align);
605 "capture type differs from the variable type");
607 variable->
getType(), layout, info, CGM);
623 if (CI.hasCopyExpr() || !record->hasTrivialDestructor()) {
625 if (!record->isExternallyVisible())
632 maxFieldAlign = std::max(maxFieldAlign, align);
634 llvm::Type *llvmType =
637 addBlockLayout(align, size, &CI, llvmType, VT, layout, info, CGM);
641 if (layout.empty()) {
652 llvm::stable_sort(layout);
676 if (endAlign < maxFieldAlign) {
678 li = layout.begin() + 1, le = layout.end();
682 for (; li != le && endAlign < li->Alignment; ++li)
689 for (; li != le; ++li) {
690 assert(endAlign >= li->Alignment);
692 li->setIndex(info, elementTypes.size(), blockSize);
693 elementTypes.push_back(li->Type);
694 blockSize += li->Size;
698 if (endAlign >= maxFieldAlign) {
704 layout.erase(first, li);
708 assert(endAlign ==
getLowBit(blockSize));
712 if (endAlign < maxFieldAlign) {
714 CharUnits padding = newBlockSize - blockSize;
722 elementTypes.push_back(llvm::ArrayType::get(CGM.
Int8Ty,
724 blockSize = newBlockSize;
728 assert(endAlign >= maxFieldAlign);
729 assert(endAlign ==
getLowBit(blockSize));
734 li = layout.begin(), le = layout.end(); li != le; ++li) {
735 if (endAlign < li->Alignment) {
739 CharUnits padding = li->Alignment - endAlign;
740 elementTypes.push_back(llvm::ArrayType::get(CGM.
Int8Ty,
742 blockSize += padding;
745 assert(endAlign >= li->Alignment);
746 li->setIndex(info, elementTypes.size(), blockSize);
747 elementTypes.push_back(li->Type);
748 blockSize += li->Size;
761 if (!
blockExpr->getBlockDecl()->hasCaptures())
770 if (!blockInfo.CanBeGlobal)
772 blockInfo.BlockAlign,
"block");
787 auto *InvokeFn = BlockCGF.GenerateBlockFunction(
789 auto *blockFn = llvm::ConstantExpr::getPointerCast(InvokeFn, GenVoidPtrTy);
798 assert(blockAddr.
isValid() &&
"block has no address!");
801 llvm::Constant *descriptor;
807 llvm::Constant *blockISA = blockInfo.
NoEscape
829 auto projectField = [&](
unsigned index,
const Twine &
name) ->
Address {
832 auto storeField = [&](llvm::Value *value,
unsigned index,
const Twine &
name) {
841 auto addHeaderField = [&](llvm::Value *value,
CharUnits size,
843 storeField(value, index, name);
862 addHeaderField(blockFn, GenVoidPtrSize,
"block.invoke");
865 else if (
auto *Helper =
867 for (
auto I : Helper->getCustomFieldValues(*
this, blockInfo)) {
883 projectField(blockInfo.
CXXThisIndex,
"block.captured-this.addr");
888 for (
const auto &CI :
blockDecl->captures()) {
889 const VarDecl *variable = CI.getVariable();
899 Address blockField = projectField(capture.
getIndex(),
"block.captured");
905 if (
blockDecl->isConversionFromLambda()) {
909 }
else if (CI.isEscapingByref()) {
918 "block.capture.addr");
920 auto I = LocalDeclMap.find(variable);
921 assert(I != LocalDeclMap.end());
936 if (CI.isEscapingByref()) {
938 llvm::Value *byrefPointer;
948 }
else if (
const Expr *copyExpr = CI.getCopyExpr()) {
949 if (
blockDecl->isConversionFromLambda()) {
964 }
else if (
type->isReferenceType()) {
968 }
else if (
type.isConstQualified() &&
982 type->isBlockPointerType()) {
1035 if (
type.isConstQualified() &&
1039 "expected ObjC ARC to be enabled");
1049 if (useArrayEHCleanup)
1056 auto IsBlockDeclInRetExpr = [&]() {
1057 auto *EWC = llvm::dyn_cast_or_null<ExprWithCleanups>(
RetExpr);
1059 for (
auto &
C : EWC->getObjects())
1066 if (IsBlockDeclInRetExpr())
1067 pushDestroy(cleanupKind, blockField,
type, destroyer, useArrayEHCleanup);
1075 llvm::Value *result =
Builder.CreatePointerCast(
1088 if (BlockDescriptorType)
1089 return BlockDescriptorType;
1091 llvm::Type *UnsignedLongTy =
1108 BlockDescriptorType = llvm::StructType::create(
1109 "struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy);
1112 unsigned AddrSpace = 0;
1115 BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace);
1116 return BlockDescriptorType;
1120 if (GenericBlockLiteralType)
1121 return GenericBlockLiteralType;
1135 llvm::append_range(StructFields, Helper->getCustomFieldTypes());
1137 GenericBlockLiteralType = llvm::StructType::create(
1138 StructFields,
"struct.__opencl_block_literal_generic");
1147 GenericBlockLiteralType =
1148 llvm::StructType::create(
"struct.__block_literal_generic",
VoidPtrTy,
1152 return GenericBlockLiteralType;
1160 llvm::Value *
Func =
nullptr;
1170 llvm::Type *GenericVoidPtrTy =
1172 llvm::Value *BlockDescriptor =
Builder.CreatePointerCast(
1173 BlockPtr, GenericVoidPtrTy);
1217 assert(
BlockInfo &&
"evaluating block ref without block information?");
1221 if (capture.
isConstant())
return LocalDeclMap.find(variable)->second;
1224 "block.capture.addr");
1232 byrefInfo.ByrefAlignment);
1240 "the capture field of a non-escaping variable should have a "
1249 llvm::Constant *Addr) {
1250 bool Ok = EmittedGlobalBlocks.insert(std::make_pair(BE, Addr)).second;
1252 assert(Ok &&
"Trying to replace an already-existing global block!");
1280 llvm::Constant *blockFn) {
1286 "Refusing to re-emit a global block.");
1309 fields.addInt(CGM.
IntTy, 0);
1316 fields.add(blockFn);
1321 }
else if (
auto *Helper =
1323 for (
auto *I : Helper->getCustomFieldValues(CGM, blockInfo)) {
1328 unsigned AddrSpace = 0;
1332 llvm::GlobalVariable *literal = fields.finishAndCreateGlobal(
1333 "__block_literal_global", blockInfo.
BlockAlign,
1334 !IsWindows, llvm::GlobalVariable::InternalLinkage, AddrSpace);
1336 literal->addAttribute(
"objc_arc_inert");
1341 auto *
Init = llvm::Function::Create(llvm::FunctionType::get(CGM.
VoidTy,
1342 {}), llvm::GlobalValue::InternalLinkage,
".block_isa_init",
1344 llvm::IRBuilder<>
b(llvm::BasicBlock::Create(CGM.
getLLVMContext(),
"entry",
1347 b.CreateStructGEP(literal->getValueType(), literal, 0),
1352 auto *InitVar =
new llvm::GlobalVariable(CGM.
getModule(),
Init->getType(),
1353 true, llvm::GlobalValue::InternalLinkage,
1354 Init,
".block_isa_init_ptr");
1355 InitVar->setSection(
".CRT$XCLa");
1360 llvm::Type *RequiredType =
1363 llvm::ConstantExpr::getPointerCast(literal, RequiredType);
1368 cast<llvm::Function>(blockFn->stripPointerCasts()),
Result,
1369 literal->getValueType());
1376 assert(
BlockInfo &&
"not emitting prologue of block invocation function?!");
1385 DI->EmitDeclareOfBlockLiteralArgVariable(
1398 llvm::PointerType::get(
1407 assert(
BlockInfo &&
"not in a block invocation function!");
1414 bool IsLambdaConversionToBlock,
bool BuildGlobalBlock) {
1426 for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) {
1427 const auto *var = dyn_cast<VarDecl>(i->first);
1428 if (var && !var->hasLocalStorage())
1429 setAddrOfLocalVar(var, i->second);
1454 args.push_back(&SelfDecl);
1469 llvm::Function *fn = llvm::Function::Create(
1470 fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &
CGM.
getModule());
1473 if (BuildGlobalBlock) {
1478 llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy));
1512 for (
const auto &CI :
blockDecl->captures()) {
1513 const VarDecl *variable = CI.getVariable();
1523 setAddrOfLocalVar(variable, alloca);
1527 llvm::BasicBlock *entry =
Builder.GetInsertBlock();
1528 llvm::BasicBlock::iterator entry_ptr =
Builder.GetInsertPoint();
1531 if (IsLambdaConversionToBlock)
1540 llvm::BasicBlock *resume =
Builder.GetInsertBlock();
1544 Builder.SetInsertPoint(entry, entry_ptr);
1549 for (
const auto &CI :
blockDecl->captures()) {
1550 const VarDecl *variable = CI.getVariable();
1556 auto addr = LocalDeclMap.find(variable)->second;
1557 (void)DI->EmitDeclareOfAutoVariable(variable, addr.
getPointer(),
1562 DI->EmitDeclareOfBlockDeclRefVariable(
1563 variable, BlockPointerDbgLoc,
Builder, blockInfo,
1564 entry_ptr == entry->end() ? nullptr : &*entry_ptr);
1569 cast<CompoundStmt>(
blockDecl->getBody())->getRBracLoc());
1573 if (resume ==
nullptr)
1574 Builder.ClearInsertionPoint();
1576 Builder.SetInsertPoint(resume);
1583static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
1642 llvm_unreachable(
"after exhaustive PrimitiveCopyKind switch");
1654 : Addr(Addr), FieldFlags(Flags), LoadBlockVarAddr(LoadValue),
1658 llvm::Value *BlockVarAddr;
1659 if (LoadBlockVarAddr) {
1662 BlockVarAddr = Addr.getPointer();
1680 CaptureStrKind StrKind,
1693 assert((StrKind != CaptureStrKind::Merged ||
1696 "different operations and flags");
1698 if (StrKind == CaptureStrKind::DisposeHelper) {
1710 llvm::raw_svector_ostream Out(TyStr);
1712 Str += llvm::to_string(TyStr.size()) + TyStr.c_str();
1731 if (StrKind != CaptureStrKind::DisposeHelper) {
1735 if (StrKind != CaptureStrKind::CopyHelper) {
1754 std::string FuncStr;
1755 if (StrKind == CaptureStrKind::DisposeHelper)
1757 CaptureTy, Alignment, IsVolatile, Ctx);
1762 CaptureTy, Alignment, IsVolatile, Ctx);
1765 Str += llvm::to_string(FuncStr.size()) +
"_" + FuncStr;
1778 assert((StrKind == CaptureStrKind::CopyHelper ||
1779 StrKind == CaptureStrKind::DisposeHelper) &&
1780 "unexpected CaptureStrKind");
1781 std::string Name = StrKind == CaptureStrKind::CopyHelper
1782 ?
"__copy_helper_block_"
1783 :
"__destroy_helper_block_";
1788 Name += llvm::to_string(BlockAlignment.
getQuantity()) +
"_";
1790 for (
auto &Cap : Captures) {
1791 if (Cap.isConstantOrTrivial())
1793 Name += llvm::to_string(Cap.getOffset().getQuantity());
1804 bool EHOnly = ForCopyHelper;
1806 switch (CaptureKind) {
1846 if (CapturesNonExternalType) {
1849 Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
1850 Fn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1867 CaptureStrKind::CopyHelper,
CGM);
1878 args.push_back(&DstDecl);
1880 args.push_back(&SrcDecl);
1889 llvm::Function *Fn =
1890 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
1893 Fn->setComdat(
CGM.
getModule().getOrInsertComdat(FuncName));
1896 ArgTys.push_back(
C.VoidPtrTy);
1897 ArgTys.push_back(
C.VoidPtrTy);
1920 unsigned index = capture.
getIndex();
1927 assert(CI.
getCopyExpr() &&
"copy expression for variable is missing");
1947 auto *ty = cast<llvm::PointerType>(srcValue->getType());
1948 llvm::Value *null = llvm::ConstantPointerNull::get(ty);
1962 cast<llvm::Instruction>(dstField.
getPointer())->eraseFromParent();
1968 llvm::Value *dstAddr = dstField.
getPointer();
1969 llvm::Value *args[] = {
2003static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
2040 llvm_unreachable(
"after exhaustive DestructionKind switch");
2054 CaptureStrKind::DisposeHelper,
CGM);
2065 args.push_back(&SrcDecl);
2074 llvm::Function *Fn =
2075 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
2078 Fn->setComdat(
CGM.
getModule().getOrInsertComdat(FuncName));
2081 ArgTys.push_back(
C.VoidPtrTy);
2094 CodeGenFunction::RunCleanupsScope cleanups(*
this);
2110 cleanups.ForceCleanup();
2136 llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.
Int32Ty, flags);
2139 llvm::Value *args[] = { destField.
getPointer(), srcValue, flagsVal };
2150 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2151 id.AddInteger(Flags.getBitMask());
2169 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2189 llvm::ConstantPointerNull::get(cast<llvm::PointerType>(value->getType()));
2205 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2215 ARCStrongBlockByrefHelpers(
CharUnits alignment)
2232 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2242 const Expr *CopyExpr;
2246 const Expr *copyExpr)
2249 bool needsCopy()
const override {
return CopyExpr !=
nullptr; }
2252 if (!CopyExpr)
return;
2262 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2263 id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
2282 bool needsDispose()
const override {
2283 return VarType.isDestructedType();
2288 CGF.
pushDestroy(VarType.isDestructedType(), field, VarType);
2292 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2293 id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
2298static llvm::Constant *
2307 args.push_back(&Dst);
2310 args.push_back(&Src);
2319 llvm::Function *Fn =
2320 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
2348 generator.
emitCopy(CGF, destField, srcField);
2365static llvm::Constant *
2375 args.push_back(&Src);
2384 llvm::Function *Fn =
2385 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
2386 "__Block_byref_object_dispose_",
2425 llvm::FoldingSetNodeID id;
2426 generator.Profile(
id);
2431 if (node)
return static_cast<T*
>(node);
2436 T *copy =
new (CGM.
getContext()) T(std::forward<T>(generator));
2445CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType,
2446 const AutoVarEmission &emission) {
2447 const VarDecl &var = *emission.Variable;
2449 "only escaping __block variables need byref helpers");
2461 const Expr *copyExpr =
2463 if (!copyExpr && record->hasTrivialDestructor())
return nullptr;
2465 return ::buildByrefHelpers(
2466 CGM, byrefInfo, CXXByrefHelpers(valueAlignment,
type, copyExpr));
2473 return ::buildByrefHelpers(
2474 CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment,
type));
2478 if (!
type->isObjCRetainableType())
return nullptr;
2495 return ::buildByrefHelpers(
CGM, byrefInfo,
2496 ARCWeakByrefHelpers(valueAlignment));
2502 if (
type->isBlockPointerType()) {
2503 return ::buildByrefHelpers(
CGM, byrefInfo,
2504 ARCStrongBlockByrefHelpers(valueAlignment));
2509 return ::buildByrefHelpers(
CGM, byrefInfo,
2510 ARCStrongByrefHelpers(valueAlignment));
2513 llvm_unreachable(
"fell out of lifetime switch!");
2517 if (
type->isBlockPointerType()) {
2520 type->isObjCObjectPointerType()) {
2526 if (
type.isObjCGCWeak())
2529 return ::buildByrefHelpers(
CGM, byrefInfo,
2530 ObjectByrefHelpers(valueAlignment, flags));
2535 bool followForward) {
2543 const llvm::Twine &name) {
2545 if (followForward) {
2570 auto it = BlockByrefInfos.find(D);
2571 if (it != BlockByrefInfos.end())
2574 llvm::StructType *byrefType =
2601 if (hasCopyAndDispose) {
2611 bool HasByrefExtendedLayout =
false;
2613 if (
getContext().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) &&
2614 HasByrefExtendedLayout) {
2623 bool packed =
false;
2628 if (varOffset != size) {
2629 llvm::Type *paddingTy =
2630 llvm::ArrayType::get(
Int8Ty, (varOffset - size).getQuantity());
2632 types.push_back(paddingTy);
2640 types.push_back(varTy);
2642 byrefType->setBody(
types, packed);
2645 info.
Type = byrefType;
2650 auto pair = BlockByrefInfos.insert({D, info});
2651 assert(pair.second &&
"info was inserted recursively?");
2652 return pair.first->second;
2662 llvm::StructType *byrefType = cast<llvm::StructType>(addr.
getElementType());
2664 unsigned nextHeaderIndex = 0;
2666 auto storeHeaderField = [&](llvm::Value *value,
CharUnits fieldSize,
2667 const Twine &
name) {
2672 nextHeaderOffset += fieldSize;
2678 const VarDecl &D = *emission.Variable;
2681 bool HasByrefExtendedLayout =
false;
2683 bool ByRefHasLifetime =
2690 if (
type.isObjCGCWeak())
2703 if (ByRefHasLifetime) {
2705 else switch (ByrefLifetime) {
2716 if (!
type->isObjCObjectPointerType() && !
type->isBlockPointerType())
2723 printf(
"\n Inline flag for BYREF variable layout (%d):", flags.
getBitMask());
2725 printf(
" BLOCK_BYREF_HAS_COPY_DISPOSE");
2729 printf(
" BLOCK_BYREF_LAYOUT_EXTENDED");
2731 printf(
" BLOCK_BYREF_LAYOUT_STRONG");
2733 printf(
" BLOCK_BYREF_LAYOUT_WEAK");
2735 printf(
" BLOCK_BYREF_LAYOUT_UNRETAINED");
2737 printf(
" BLOCK_BYREF_LAYOUT_NON_OBJECT");
2751 "byref.copyHelper");
2753 "byref.disposeHelper");
2756 if (ByRefHasLifetime && HasByrefExtendedLayout) {
2765 llvm::Value *args[] = {
V,
2776 bool LoadBlockVarAddr,
bool CanThrow) {
2777 EHStack.pushCleanup<CallBlockRelease>(
Kind, Addr, Flags, LoadBlockVarAddr,
2783 llvm::Constant *
C) {
2784 auto *GV = cast<llvm::GlobalValue>(
C->stripPointerCasts());
2791 assert((isa<llvm::Function>(
C->stripPointerCasts()) ||
2792 isa<llvm::GlobalVariable>(
C->stripPointerCasts())) &&
2793 "expected Function or GlobalVariable");
2797 if ((ND = dyn_cast<FunctionDecl>(
Result)) ||
2798 (ND = dyn_cast<VarDecl>(
Result)))
2802 if (GV->isDeclaration() && (!ND || !ND->
hasAttr<DLLExportAttr>())) {
2803 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
2804 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
2806 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
2807 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
2811 if (CGM.
getLangOpts().BlocksRuntimeOptional && GV->isDeclaration() &&
2812 GV->hasExternalLinkage())
2813 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2819 if (BlockObjectDispose)
2820 return BlockObjectDispose;
2823 llvm::FunctionType *fty
2824 = llvm::FunctionType::get(
VoidTy, args,
false);
2827 *
this, cast<llvm::Constant>(BlockObjectDispose.getCallee()));
2828 return BlockObjectDispose;
2832 if (BlockObjectAssign)
2833 return BlockObjectAssign;
2836 llvm::FunctionType *fty
2837 = llvm::FunctionType::get(
VoidTy, args,
false);
2840 *
this, cast<llvm::Constant>(BlockObjectAssign.getCallee()));
2841 return BlockObjectAssign;
2845 if (NSConcreteGlobalBlock)
2846 return NSConcreteGlobalBlock;
2851 return NSConcreteGlobalBlock;
2855 if (NSConcreteStackBlock)
2856 return NSConcreteStackBlock;
2861 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 bool isBlockPointer(Expr *Arg)
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.
bool hasReducedDebugInfo() const
Check if type and variable info should be emitted.
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.
llvm::Value * getPointer() const
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)
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void EmitARCDestroyWeak(Address addr)
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags, bool LoadBlockVarAddr, bool CanThrow)
Enter a cleanup to destroy a __block variable.
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
static bool cxxDestructorCanThrow(QualType T)
Check if T is a C++ class that has a destructor that can throw.
SanitizerSet SanOpts
Sanitizers enabled for this function.
void EmitARCMoveWeak(Address dst, Address src)
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue)
const BlockByrefInfo & getBlockByrefInfo(const VarDecl *var)
void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp)
void callCStructMoveConstructor(LValue Dst, LValue Src)
void callCStructCopyConstructor(LValue Dst, LValue Src)
const LangOptions & getLangOpts() const
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...
const CodeGen::CGBlockInfo * BlockInfo
Address EmitLoadOfReference(LValue RefLVal, LValueBaseInfo *PointeeBaseInfo=nullptr, TBAAAccessInfo *PointeeTBAAInfo=nullptr)
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...
void emitByrefStructureInit(const AutoVarEmission &emission)
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, bool IsMustTail, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type,...
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.
llvm::Type * ConvertTypeForMem(QualType T)
llvm::Value * EmitARCRetainBlock(llvm::Value *value, bool mandatory)
void EmitLambdaBlockInvokeBody()
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
static std::string getNonTrivialDestructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
llvm::DenseMap< const Decl *, Address > DeclMapTy
llvm::Constant * GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo)
const Expr * RetExpr
If a return statement is being visited, this holds the return statment's result expression.
void EmitARCCopyWeak(Address dst, Address src)
void PushDestructorCleanup(QualType T, Address Addr)
PushDestructorCleanup - Push a cleanup to call the complete-object destructor of an object of the giv...
llvm::Value * BlockPointer
void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, llvm::Value *ptr)
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.
void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn)
Annotate the function with an attribute that disables TSan checking at runtime.
CGDebugInfo * getDebugInfo()
Address LoadBlockStruct()
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...
LValue EmitDeclRefLValue(const DeclRefExpr *E)
llvm::Constant * GenerateCopyHelperFunction(const CGBlockInfo &blockInfo)
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
llvm::Function * GenerateBlockFunction(GlobalDecl GD, const CGBlockInfo &Info, const DeclMapTy &ldm, bool IsLambdaConversionToBlock, bool BuildGlobalBlock)
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
ASTContext & getContext() const
llvm::Value * EmitBlockLiteral(const BlockExpr *)
Emit block literal.
Address CreateMemTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
CleanupKind getCleanupKind(QualType::DestructionKind kind)
llvm::Type * ConvertType(QualType T)
Address GetAddrOfBlockDecl(const VarDecl *var)
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
llvm::Value * LoadCXXThis()
LoadCXXThis - Load the value of 'this'.
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
static Destroyer destroyARCStrongImprecise
void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs=std::nullopt)
EmitStmt - Emit the code for the statement.
llvm::LLVMContext & getLLVMContext()
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
static std::string getNonTrivialCopyConstructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
static Destroyer emitARCIntrinsicUse
void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags, bool CanThrow)
void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)
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.
void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)
Assign counters to regions and configure them for PGO of a given function.
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.
const CGFunctionInfo & arrangeBlockFunctionDeclaration(const FunctionProtoType *type, const FunctionArgList &args)
Block invocation functions are C functions with an implicit parameter.
llvm::Type * ConvertTypeForMem(QualType T, bool ForBitField=false)
ConvertTypeForMem - Convert type T into a llvm::Type.
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(CodeGenFunction &CGF) const
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
static RValue get(llvm::Value *V)
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.
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.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
@ DK_objc_strong_lifetime
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isObjCGCWeak() const
true when Type is objc's weak.
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_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.
bool hasObjCLifetime() const
ObjCLifetime getObjCLifetime() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
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.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
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.
const Expr * getInit() const
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
@ 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...
@ 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 AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicDynCastAllOfMatcher< Decl, BlockDecl > blockDecl
Matches block declarations.
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.
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.
@ Other
Other implicit parameter.
@ ObjCSelf
Parameter for Objective-C 'self' argument.
int printf(__constant const char *st,...) __attribute__((format(printf
unsigned long ulong
An unsigned 64-bit integer.
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