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);
71struct BlockCaptureManagedEntity {
83 : CopyKind(CopyType), DisposeKind(DisposeType), CopyFlags(CopyFlags),
86 bool operator<(
const BlockCaptureManagedEntity &Other)
const {
87 return Capture->getOffset() <
Other.Capture->getOffset();
91enum class CaptureStrKind {
103 CaptureStrKind StrKind,
109 std::string Name =
"__block_descriptor_";
120 if (Cap.isConstantOrTrivial())
123 Name += llvm::to_string(Cap.getOffset().getQuantity());
125 if (Cap.CopyKind == Cap.DisposeKind) {
129 "shouldn't see BlockCaptureManagedEntity that is None");
145 std::string TypeAtEncoding =
149 std::replace(TypeAtEncoding.begin(), TypeAtEncoding.end(),
'@',
'\1');
150 Name +=
"e" + llvm::to_string(TypeAtEncoding.size()) +
"_" + TypeAtEncoding;
173 llvm::IntegerType *
ulong =
175 llvm::PointerType *i8p =
nullptr;
178 llvm::Type::getInt8PtrTy(
183 std::string descName;
186 if (
C.getLangOpts().ObjC &&
189 if (llvm::GlobalValue *desc = CGM.
getModule().getNamedValue(descName))
190 return llvm::ConstantExpr::getBitCast(desc,
200 elements.addInt(
ulong, 0);
209 bool hasInternalHelper =
false;
213 elements.add(copyHelper);
217 elements.add(disposeHelper);
219 if (cast<llvm::Function>(copyHelper->stripPointerCasts())
220 ->hasInternalLinkage() ||
221 cast<llvm::Function>(disposeHelper->stripPointerCasts())
222 ->hasInternalLinkage())
223 hasInternalHelper =
true;
227 std::string typeAtEncoding =
229 elements.add(llvm::ConstantExpr::getBitCast(
233 if (
C.getLangOpts().ObjC) {
240 elements.addNullPointer(i8p);
242 unsigned AddrSpace = 0;
243 if (
C.getLangOpts().OpenCL)
246 llvm::GlobalValue::LinkageTypes linkage;
247 if (descName.empty()) {
248 linkage = llvm::GlobalValue::InternalLinkage;
249 descName =
"__block_descriptor_tmp";
250 }
else if (hasInternalHelper) {
253 linkage = llvm::GlobalValue::InternalLinkage;
255 linkage = llvm::GlobalValue::LinkOnceODRLinkage;
258 llvm::GlobalVariable *global =
260 true, linkage, AddrSpace);
262 if (linkage == llvm::GlobalValue::LinkOnceODRLinkage) {
264 global->setComdat(CGM.
getModule().getOrInsertComdat(descName));
265 global->setVisibility(llvm::GlobalValue::HiddenVisibility);
266 global->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
285 struct objc_class *isa;
313 _ResultType (*invoke)(Block_literal *, _ParamTypes...);
316 struct Block_descriptor *block_descriptor;
319 _CapturesTypes captures...;
325 struct BlockLayoutChunk {
341 FieldType(fieldType), CopyKind(CopyKind), DisposeKind(DisposeKind),
342 CopyFlags(CopyFlags), DisposeFlags(DisposeFlags) {}
351 index, offset, FieldType, CopyKind, CopyFlags, DisposeKind,
357 return CopyKind == BlockCaptureEntityKind::None &&
358 DisposeKind == BlockCaptureEntityKind::None;
365 bool operator<(
const BlockLayoutChunk &left,
const BlockLayoutChunk &right) {
366 if (left.Alignment != right.Alignment)
367 return left.Alignment > right.Alignment;
369 auto getPrefOrder = [](
const BlockLayoutChunk &chunk) {
370 switch (chunk.CopyKind) {
374 switch (chunk.CopyFlags.getBitMask()) {
393 return getPrefOrder(left) < getPrefOrder(right);
397static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
401static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
412 Layout.push_back(BlockLayoutChunk(
422 std::tie(CopyKind, CopyFlags) =
424 std::tie(DisposeKind, DisposeFlags) =
426 Layout.push_back(BlockLayoutChunk(align, size, capture,
type, fieldType,
427 CopyKind, CopyFlags, DisposeKind,
433 if (!Layout.back().isTrivial())
445 const auto *record = cast<CXXRecordDecl>(
recordType->getDecl());
448 if (!record->hasTrivialDestructor())
return false;
449 if (record->hasNonTrivialCopyConstructor())
return false;
453 return !record->hasMutableFields();
467 if (isa<ParmVarDecl>(var))
473 if (!
type.isConstQualified())
return nullptr;
487 if (!init)
return nullptr;
501 assert(elementTypes.empty());
511 assert((2 * CGM.
getIntSize()).isMultipleOf(GenPtrAlign));
512 elementTypes.push_back(CGM.
IntTy);
513 elementTypes.push_back(CGM.
IntTy);
514 elementTypes.push_back(
519 unsigned BlockAlign = GenPtrAlign.getQuantity();
522 for (
auto *I : Helper->getCustomFieldTypes()) {
525 unsigned Align = CGM.
getDataLayout().getABITypeAlign(I).value();
526 if (BlockAlign < Align)
528 assert(
Offset % Align == 0);
530 elementTypes.push_back(I);
544 elementTypes.push_back(CGM.
IntTy);
545 elementTypes.push_back(CGM.
IntTy);
560 return FD->getType();
577 bool hasNonConstantCustomFields =
false;
578 if (
auto *OpenCLHelper =
580 hasNonConstantCustomFields =
581 !OpenCLHelper->areAllCustomFieldValuesConstant(info);
582 if (!block->
hasCaptures() && !hasNonConstantCustomFields) {
588 else if (
C.getLangOpts().ObjC &&
605 "Can't capture 'this' outside a method");
612 maxFieldAlign = std::max(maxFieldAlign, TInfo.Align);
614 addBlockLayout(TInfo.Align, TInfo.Width,
nullptr, llvmType, thisType,
619 for (
const auto &CI : block->
captures()) {
625 maxFieldAlign = std::max(maxFieldAlign, align);
630 "capture type differs from the variable type");
632 variable->
getType(), layout, info, CGM);
648 if (CI.
hasCopyExpr() || !record->hasTrivialDestructor()) {
650 if (!record->isExternallyVisible())
657 maxFieldAlign = std::max(maxFieldAlign, align);
659 llvm::Type *llvmType =
662 addBlockLayout(align, size, &CI, llvmType, VT, layout, info, CGM);
666 if (layout.empty()) {
677 llvm::stable_sort(layout);
701 if (endAlign < maxFieldAlign) {
703 li = layout.begin() + 1, le = layout.end();
707 for (; li != le && endAlign < li->Alignment; ++li)
714 for (; li != le; ++li) {
715 assert(endAlign >= li->Alignment);
717 li->setIndex(info, elementTypes.size(), blockSize);
718 elementTypes.push_back(li->Type);
719 blockSize += li->Size;
723 if (endAlign >= maxFieldAlign) {
729 layout.erase(first, li);
733 assert(endAlign ==
getLowBit(blockSize));
737 if (endAlign < maxFieldAlign) {
739 CharUnits padding = newBlockSize - blockSize;
747 elementTypes.push_back(llvm::ArrayType::get(CGM.
Int8Ty,
749 blockSize = newBlockSize;
753 assert(endAlign >= maxFieldAlign);
754 assert(endAlign ==
getLowBit(blockSize));
759 li = layout.begin(), le = layout.end(); li != le; ++li) {
760 if (endAlign < li->Alignment) {
764 CharUnits padding = li->Alignment - endAlign;
765 elementTypes.push_back(llvm::ArrayType::get(CGM.
Int8Ty,
767 blockSize += padding;
770 assert(endAlign >= li->Alignment);
771 li->setIndex(info, elementTypes.size(), blockSize);
772 elementTypes.push_back(li->Type);
773 blockSize += li->Size;
786 if (!
blockExpr->getBlockDecl()->hasCaptures())
795 if (!blockInfo.CanBeGlobal)
797 blockInfo.BlockAlign,
"block");
812 auto *InvokeFn = BlockCGF.GenerateBlockFunction(
814 auto *blockFn = llvm::ConstantExpr::getPointerCast(InvokeFn, GenVoidPtrTy);
823 assert(blockAddr.
isValid() &&
"block has no address!");
826 llvm::Constant *descriptor;
832 llvm::Constant *blockISA = blockInfo.
NoEscape
835 isa = llvm::ConstantExpr::getBitCast(blockISA,
VoidPtrTy);
854 auto projectField = [&](
unsigned index,
const Twine &
name) ->
Address {
857 auto storeField = [&](llvm::Value *value,
unsigned index,
const Twine &
name) {
866 auto addHeaderField = [&](llvm::Value *value,
CharUnits size,
868 storeField(value, index, name);
887 addHeaderField(blockFn, GenVoidPtrSize,
"block.invoke");
890 else if (
auto *Helper =
892 for (
auto I : Helper->getCustomFieldValues(*
this, blockInfo)) {
908 projectField(blockInfo.
CXXThisIndex,
"block.captured-this.addr");
913 for (
const auto &CI :
blockDecl->captures()) {
924 Address blockField = projectField(capture.
getIndex(),
"block.captured");
930 if (
blockDecl->isConversionFromLambda()) {
943 "block.capture.addr");
945 auto I = LocalDeclMap.find(variable);
946 assert(I != LocalDeclMap.end());
963 llvm::Value *byrefPointer;
974 if (
blockDecl->isConversionFromLambda()) {
989 }
else if (
type->isReferenceType()) {
993 }
else if (
type.isConstQualified() &&
1007 type->isBlockPointerType()) {
1060 if (
type.isConstQualified() &&
1064 "expected ObjC ARC to be enabled");
1074 if (useArrayEHCleanup)
1081 auto IsBlockDeclInRetExpr = [&]() {
1082 auto *EWC = llvm::dyn_cast_or_null<ExprWithCleanups>(
RetExpr);
1084 for (
auto &
C : EWC->getObjects())
1091 if (IsBlockDeclInRetExpr())
1092 pushDestroy(cleanupKind, blockField,
type, destroyer, useArrayEHCleanup);
1100 llvm::Value *result =
Builder.CreatePointerCast(
1113 if (BlockDescriptorType)
1114 return BlockDescriptorType;
1116 llvm::Type *UnsignedLongTy =
1133 BlockDescriptorType = llvm::StructType::create(
1134 "struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy);
1137 unsigned AddrSpace = 0;
1140 BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace);
1141 return BlockDescriptorType;
1145 if (GenericBlockLiteralType)
1146 return GenericBlockLiteralType;
1160 llvm::append_range(StructFields, Helper->getCustomFieldTypes());
1162 GenericBlockLiteralType = llvm::StructType::create(
1163 StructFields,
"struct.__opencl_block_literal_generic");
1172 GenericBlockLiteralType =
1173 llvm::StructType::create(
"struct.__block_literal_generic",
VoidPtrTy,
1177 return GenericBlockLiteralType;
1185 llvm::Value *Func =
nullptr;
1195 llvm::Type *GenericVoidPtrTy =
1197 llvm::Value *BlockDescriptor =
Builder.CreatePointerCast(
1198 BlockPtr, GenericVoidPtrTy);
1215 BlockPtr =
Builder.CreatePointerCast(
1216 BlockPtr, llvm::PointerType::get(GenBlockTy, 0),
"block.literal");
1237 llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy);
1238 Func =
Builder.CreatePointerCast(Func, BlockFTyPtr);
1248 assert(
BlockInfo &&
"evaluating block ref without block information?");
1252 if (capture.
isConstant())
return LocalDeclMap.find(variable)->second;
1255 "block.capture.addr");
1272 "the capture field of a non-escaping variable should have a "
1281 llvm::Constant *Addr) {
1282 bool Ok = EmittedGlobalBlocks.insert(std::make_pair(BE, Addr)).second;
1284 assert(Ok &&
"Trying to replace an already-existing global block!");
1312 llvm::Constant *blockFn) {
1318 "Refusing to re-emit a global block.");
1341 fields.addInt(CGM.
IntTy, 0);
1348 fields.add(blockFn);
1353 }
else if (
auto *Helper =
1355 for (
auto *I : Helper->getCustomFieldValues(CGM, blockInfo)) {
1360 unsigned AddrSpace = 0;
1364 llvm::GlobalVariable *literal = fields.finishAndCreateGlobal(
1365 "__block_literal_global", blockInfo.
BlockAlign,
1366 !IsWindows, llvm::GlobalVariable::InternalLinkage, AddrSpace);
1368 literal->addAttribute(
"objc_arc_inert");
1373 auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.
VoidTy,
1374 {}), llvm::GlobalValue::InternalLinkage,
".block_isa_init",
1376 llvm::IRBuilder<>
b(llvm::BasicBlock::Create(CGM.
getLLVMContext(),
"entry",
1379 b.CreateStructGEP(literal->getValueType(), literal, 0),
1384 auto *InitVar =
new llvm::GlobalVariable(CGM.
getModule(), Init->getType(),
1385 true, llvm::GlobalValue::InternalLinkage,
1386 Init,
".block_isa_init_ptr");
1387 InitVar->setSection(
".CRT$XCLa");
1392 llvm::Type *RequiredType =
1395 llvm::ConstantExpr::getPointerCast(literal, RequiredType);
1400 cast<llvm::Function>(blockFn->stripPointerCasts()),
Result,
1401 literal->getValueType());
1408 assert(
BlockInfo &&
"not emitting prologue of block invocation function?!");
1417 DI->EmitDeclareOfBlockLiteralArgVariable(
1438 assert(
BlockInfo &&
"not in a block invocation function!");
1445 bool IsLambdaConversionToBlock,
bool BuildGlobalBlock) {
1457 for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) {
1458 const auto *var = dyn_cast<VarDecl>(i->first);
1459 if (var && !var->hasLocalStorage())
1460 setAddrOfLocalVar(var, i->second);
1485 args.push_back(&SelfDecl);
1500 llvm::Function *fn = llvm::Function::Create(
1501 fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &
CGM.
getModule());
1504 if (BuildGlobalBlock) {
1509 llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy));
1543 for (
const auto &CI :
blockDecl->captures()) {
1554 setAddrOfLocalVar(variable, alloca);
1558 llvm::BasicBlock *entry =
Builder.GetInsertBlock();
1559 llvm::BasicBlock::iterator entry_ptr =
Builder.GetInsertPoint();
1562 if (IsLambdaConversionToBlock)
1571 llvm::BasicBlock *resume =
Builder.GetInsertBlock();
1575 Builder.SetInsertPoint(entry, entry_ptr);
1580 for (
const auto &CI :
blockDecl->captures()) {
1587 auto addr = LocalDeclMap.find(variable)->second;
1588 (void)DI->EmitDeclareOfAutoVariable(variable, addr.
getPointer(),
1593 DI->EmitDeclareOfBlockDeclRefVariable(
1594 variable, BlockPointerDbgLoc,
Builder, blockInfo,
1595 entry_ptr == entry->end() ? nullptr : &*entry_ptr);
1600 cast<CompoundStmt>(
blockDecl->getBody())->getRBracLoc());
1604 if (resume ==
nullptr)
1605 Builder.ClearInsertionPoint();
1607 Builder.SetInsertPoint(resume);
1614static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
1673 llvm_unreachable(
"after exhaustive PrimitiveCopyKind switch");
1685 : Addr(Addr), FieldFlags(Flags), LoadBlockVarAddr(LoadValue),
1689 llvm::Value *BlockVarAddr;
1690 if (LoadBlockVarAddr) {
1694 BlockVarAddr = Addr.getPointer();
1712 CaptureStrKind StrKind,
1725 assert((StrKind != CaptureStrKind::Merged ||
1728 "different operations and flags");
1730 if (StrKind == CaptureStrKind::DisposeHelper) {
1742 llvm::raw_svector_ostream Out(TyStr);
1744 Str += llvm::to_string(TyStr.size()) + TyStr.c_str();
1763 if (StrKind != CaptureStrKind::DisposeHelper) {
1767 if (StrKind != CaptureStrKind::CopyHelper) {
1786 std::string FuncStr;
1787 if (StrKind == CaptureStrKind::DisposeHelper)
1789 CaptureTy, Alignment, IsVolatile, Ctx);
1794 CaptureTy, Alignment, IsVolatile, Ctx);
1797 Str += llvm::to_string(FuncStr.size()) +
"_" + FuncStr;
1810 assert((StrKind == CaptureStrKind::CopyHelper ||
1811 StrKind == CaptureStrKind::DisposeHelper) &&
1812 "unexpected CaptureStrKind");
1813 std::string Name = StrKind == CaptureStrKind::CopyHelper
1814 ?
"__copy_helper_block_"
1815 :
"__destroy_helper_block_";
1820 Name += llvm::to_string(BlockAlignment.
getQuantity()) +
"_";
1822 for (
auto &Cap : Captures) {
1823 if (Cap.isConstantOrTrivial())
1825 Name += llvm::to_string(Cap.getOffset().getQuantity());
1836 bool EHOnly = ForCopyHelper;
1838 switch (CaptureKind) {
1878 if (CapturesNonExternalType) {
1881 Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
1882 Fn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1899 CaptureStrKind::CopyHelper,
CGM);
1901 if (llvm::GlobalValue *Func =
CGM.
getModule().getNamedValue(FuncName))
1902 return llvm::ConstantExpr::getBitCast(Func,
VoidPtrTy);
1910 args.push_back(&DstDecl);
1912 args.push_back(&SrcDecl);
1921 llvm::Function *Fn =
1922 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
1925 Fn->setComdat(
CGM.
getModule().getOrInsertComdat(FuncName));
1928 ArgTys.push_back(
C.VoidPtrTy);
1929 ArgTys.push_back(
C.VoidPtrTy);
1954 unsigned index = capture.
getIndex();
1961 assert(CI.
getCopyExpr() &&
"copy expression for variable is missing");
1981 auto *ty = cast<llvm::PointerType>(srcValue->getType());
1982 llvm::Value *null = llvm::ConstantPointerNull::get(ty);
1996 cast<llvm::Instruction>(dstField.
getPointer())->eraseFromParent();
2003 llvm::Value *dstAddr =
2005 llvm::Value *args[] = {
2027 return llvm::ConstantExpr::getBitCast(Fn,
VoidPtrTy);
2039static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
2076 llvm_unreachable(
"after exhaustive DestructionKind switch");
2090 CaptureStrKind::DisposeHelper,
CGM);
2092 if (llvm::GlobalValue *Func =
CGM.
getModule().getNamedValue(FuncName))
2093 return llvm::ConstantExpr::getBitCast(Func,
VoidPtrTy);
2101 args.push_back(&SrcDecl);
2110 llvm::Function *Fn =
2111 llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
2114 Fn->setComdat(
CGM.
getModule().getOrInsertComdat(FuncName));
2117 ArgTys.push_back(
C.VoidPtrTy);
2130 CodeGenFunction::RunCleanupsScope cleanups(*
this);
2146 cleanups.ForceCleanup();
2150 return llvm::ConstantExpr::getBitCast(Fn,
VoidPtrTy);
2172 llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.
Int32Ty, flags);
2175 llvm::Value *args[] = { destField.
getPointer(), srcValue, flagsVal };
2186 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2187 id.AddInteger(Flags.getBitMask());
2205 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2225 llvm::ConstantPointerNull::get(cast<llvm::PointerType>(value->getType()));
2241 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2251 ARCStrongBlockByrefHelpers(
CharUnits alignment)
2268 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2278 const Expr *CopyExpr;
2282 const Expr *copyExpr)
2285 bool needsCopy()
const override {
return CopyExpr !=
nullptr; }
2288 if (!CopyExpr)
return;
2298 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2299 id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
2318 bool needsDispose()
const override {
2319 return VarType.isDestructedType();
2324 CGF.
pushDestroy(VarType.isDestructedType(), field, VarType);
2328 void profileImpl(llvm::FoldingSetNodeID &
id)
const override {
2329 id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
2334static llvm::Constant *
2343 args.push_back(&Dst);
2346 args.push_back(&Src);
2355 llvm::Function *Fn =
2356 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
2386 generator.
emitCopy(CGF, destField, srcField);
2391 return llvm::ConstantExpr::getBitCast(Fn, CGF.
Int8PtrTy);
2403static llvm::Constant *
2413 args.push_back(&Src);
2422 llvm::Function *Fn =
2423 llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
2424 "__Block_byref_object_dispose_",
2448 return llvm::ConstantExpr::getBitCast(Fn, CGF.
Int8PtrTy);
2464 llvm::FoldingSetNodeID id;
2465 generator.Profile(
id);
2470 if (node)
return static_cast<T*
>(node);
2475 T *copy =
new (CGM.
getContext()) T(std::forward<T>(generator));
2484CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType,
2485 const AutoVarEmission &emission) {
2486 const VarDecl &var = *emission.Variable;
2488 "only escaping __block variables need byref helpers");
2500 const Expr *copyExpr =
2502 if (!copyExpr && record->hasTrivialDestructor())
return nullptr;
2504 return ::buildByrefHelpers(
2505 CGM, byrefInfo, CXXByrefHelpers(valueAlignment,
type, copyExpr));
2512 return ::buildByrefHelpers(
2513 CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment,
type));
2517 if (!
type->isObjCRetainableType())
return nullptr;
2534 return ::buildByrefHelpers(
CGM, byrefInfo,
2535 ARCWeakByrefHelpers(valueAlignment));
2541 if (
type->isBlockPointerType()) {
2542 return ::buildByrefHelpers(
CGM, byrefInfo,
2543 ARCStrongBlockByrefHelpers(valueAlignment));
2548 return ::buildByrefHelpers(
CGM, byrefInfo,
2549 ARCStrongByrefHelpers(valueAlignment));
2552 llvm_unreachable(
"fell out of lifetime switch!");
2556 if (
type->isBlockPointerType()) {
2559 type->isObjCObjectPointerType()) {
2565 if (
type.isObjCGCWeak())
2568 return ::buildByrefHelpers(
CGM, byrefInfo,
2569 ObjectByrefHelpers(valueAlignment, flags));
2574 bool followForward) {
2582 const llvm::Twine &name) {
2584 if (followForward) {
2609 auto it = BlockByrefInfos.find(D);
2610 if (it != BlockByrefInfos.end())
2613 llvm::StructType *byrefType =
2627 types.push_back(llvm::PointerType::getUnqual(byrefType));
2640 if (hasCopyAndDispose) {
2650 bool HasByrefExtendedLayout =
false;
2652 if (
getContext().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) &&
2653 HasByrefExtendedLayout) {
2662 bool packed =
false;
2667 if (varOffset != size) {
2668 llvm::Type *paddingTy =
2669 llvm::ArrayType::get(
Int8Ty, (varOffset - size).getQuantity());
2671 types.push_back(paddingTy);
2679 types.push_back(varTy);
2681 byrefType->setBody(
types, packed);
2684 info.
Type = byrefType;
2689 auto pair = BlockByrefInfos.insert({D, info});
2690 assert(pair.second &&
"info was inserted recursively?");
2691 return pair.first->second;
2701 llvm::StructType *byrefType = cast<llvm::StructType>(addr.
getElementType());
2703 unsigned nextHeaderIndex = 0;
2705 auto storeHeaderField = [&](llvm::Value *value,
CharUnits fieldSize,
2706 const Twine &
name) {
2711 nextHeaderOffset += fieldSize;
2717 const VarDecl &D = *emission.Variable;
2720 bool HasByrefExtendedLayout =
false;
2722 bool ByRefHasLifetime =
2729 if (
type.isObjCGCWeak())
2742 if (ByRefHasLifetime) {
2744 else switch (ByrefLifetime) {
2755 if (!
type->isObjCObjectPointerType() && !
type->isBlockPointerType())
2762 printf(
"\n Inline flag for BYREF variable layout (%d):", flags.
getBitMask());
2764 printf(
" BLOCK_BYREF_HAS_COPY_DISPOSE");
2768 printf(
" BLOCK_BYREF_LAYOUT_EXTENDED");
2770 printf(
" BLOCK_BYREF_LAYOUT_STRONG");
2772 printf(
" BLOCK_BYREF_LAYOUT_WEAK");
2774 printf(
" BLOCK_BYREF_LAYOUT_UNRETAINED");
2776 printf(
" BLOCK_BYREF_LAYOUT_NON_OBJECT");
2790 "byref.copyHelper");
2792 "byref.disposeHelper");
2795 if (ByRefHasLifetime && HasByrefExtendedLayout) {
2804 llvm::Value *args[] = {
2817 bool LoadBlockVarAddr,
bool CanThrow) {
2818 EHStack.pushCleanup<CallBlockRelease>(
Kind, Addr, Flags, LoadBlockVarAddr,
2824 llvm::Constant *
C) {
2825 auto *GV = cast<llvm::GlobalValue>(
C->stripPointerCasts());
2832 assert((isa<llvm::Function>(
C->stripPointerCasts()) ||
2833 isa<llvm::GlobalVariable>(
C->stripPointerCasts())) &&
2834 "expected Function or GlobalVariable");
2838 if ((ND = dyn_cast<FunctionDecl>(
Result)) ||
2839 (ND = dyn_cast<VarDecl>(
Result)))
2843 if (GV->isDeclaration() && (!ND || !ND->
hasAttr<DLLExportAttr>())) {
2844 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
2845 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
2847 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
2848 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
2852 if (CGM.
getLangOpts().BlocksRuntimeOptional && GV->isDeclaration() &&
2853 GV->hasExternalLinkage())
2854 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2860 if (BlockObjectDispose)
2861 return BlockObjectDispose;
2864 llvm::FunctionType *fty
2865 = llvm::FunctionType::get(
VoidTy, args,
false);
2868 *
this, cast<llvm::Constant>(BlockObjectDispose.getCallee()));
2869 return BlockObjectDispose;
2873 if (BlockObjectAssign)
2874 return BlockObjectAssign;
2877 llvm::FunctionType *fty
2878 = llvm::FunctionType::get(
VoidTy, args,
false);
2881 *
this, cast<llvm::Constant>(BlockObjectAssign.getCallee()));
2882 return BlockObjectAssign;
2886 if (NSConcreteGlobalBlock)
2887 return NSConcreteGlobalBlock;
2889 NSConcreteGlobalBlock = GetOrCreateLLVMGlobal(
2892 return NSConcreteGlobalBlock;
2896 if (NSConcreteStackBlock)
2897 return NSConcreteStackBlock;
2899 NSConcreteStackBlock = GetOrCreateLLVMGlobal(
2902 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.
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 CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
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.
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 ...
@ ObjCSelf
Parameter for Objective-C 'self' argument.
@ Other
Other implicit parameter.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
virtual void mangleTypeName(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.
bool isa(CodeGen::Address addr)
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
@ C
Languages that the frontend can parse and compile.
@ 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.
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
CharUnits getPointerAlign() const