Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CGBlocks_8cpp_source.html below:

clang: lib/CodeGen/CGBlocks.cpp Source File

;

CodeGen;

: Name(name), CXXThisIndex(0), CanBeGlobal(

), NeedsCopyDispose(

),

HasCapturedVariableLayout(

), CapturesNonExternalType(

),

LocalAddress(

::invalid()), StructureType(nullptr),

(!name.empty() && name[0] ==

)

name = name.substr(1);

llvm::Constant *blockFn);

CaptureStrKind {

CaptureStrKind StrKind,

std::string Name =

;

(Cap.isConstantOrTrivial())

Name += llvm::to_string(Cap.getOffset().getQuantity());

(Cap.CopyKind == Cap.DisposeKind) {

);

std::string TypeAtEncoding;

std::replace(TypeAtEncoding.begin(), TypeAtEncoding.end(),

,

);

Name +=

+ llvm::to_string(TypeAtEncoding.size()) +

+ TypeAtEncoding;

llvm::IntegerType *

=

llvm::PointerType *i8p =

;

i8p = llvm::PointerType::get(

std::string descName;

(

.getLangOpts().ObjC &&

(llvm::GlobalValue *desc = CGM.

().getNamedValue(descName))

elements.addInt(

, 0);

hasInternalHelper =

;

elements.add(copyHelper);

elements.add(disposeHelper);

(cast<llvm::Function>(copyHelper->stripPointerCasts())

->hasInternalLinkage() ||

cast<llvm::Function>(disposeHelper->stripPointerCasts())

->hasInternalLinkage())

hasInternalHelper =

;

elements.addNullPointer(i8p);

std::string typeAtEncoding =

(

.getLangOpts().ObjC) {

elements.addNullPointer(i8p);

AddrSpace = 0;

(

.getLangOpts().OpenCL)

llvm::GlobalValue::LinkageTypes linkage;

(descName.empty()) {

linkage = llvm::GlobalValue::InternalLinkage;

descName =

;

}

(hasInternalHelper) {

linkage = llvm::GlobalValue::InternalLinkage;

linkage = llvm::GlobalValue::LinkOnceODRLinkage;

llvm::GlobalVariable *global =

, linkage, AddrSpace);

(linkage == llvm::GlobalValue::LinkOnceODRLinkage) {

global->setComdat(CGM.

().getOrInsertComdat(descName));

global->setVisibility(llvm::GlobalValue::HiddenVisibility);

global->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

struct objc_class *isa;

_ResultType (*invoke)(Block_literal *, _ParamTypes...);

struct Block_descriptor *block_descriptor;

_CapturesTypes captures...;

BlockLayoutChunk {

FieldType(fieldType), CopyKind(CopyKind), DisposeKind(DisposeKind),

CopyFlags(CopyFlags), DisposeFlags(DisposeFlags) {}

index, offset, FieldType, CopyKind, CopyFlags, DisposeKind,

CopyKind == BlockCaptureEntityKind::None &&

DisposeKind == BlockCaptureEntityKind::None;

(

BlockLayoutChunk &left,

BlockLayoutChunk &right) {

(left.Alignment != right.Alignment)

left.Alignment > right.Alignment;

getPrefOrder = [](

BlockLayoutChunk &chunk) {

(chunk.CopyKind) {

(chunk.CopyFlags.getBitMask()) {

getPrefOrder(left) < getPrefOrder(right);

std::pair<BlockCaptureEntityKind, BlockFieldFlags>

std::pair<BlockCaptureEntityKind, BlockFieldFlags>

Layout.push_back(BlockLayoutChunk(

std::tie(CopyKind, CopyFlags) =

std::tie(DisposeKind, DisposeFlags) =

Layout.push_back(BlockLayoutChunk(align, size, capture,

, fieldType,

CopyKind, CopyFlags, DisposeKind,

(!Layout.back().isTrivial())

*record = cast<CXXRecordDecl>(

->getDecl());

(!record->hasTrivialDestructor())

;

(record->hasNonTrivialCopyConstructor())

;

!record->hasMutableFields();

(isa<ParmVarDecl>(var))

(!

.isConstQualified())

;

*init = var->getInit();

(!init)

;

assert(elementTypes.empty());

assert((2 * CGM.

()).isMultipleOf(GenPtrAlign));

elementTypes.push_back(CGM.

);

elementTypes.push_back(CGM.

);

elementTypes.push_back(

BlockAlign = GenPtrAlign.getQuantity();

(

*I : Helper->getCustomFieldTypes())

{

Align = CGM.

().getABITypeAlign(I).value();

(BlockAlign < Align)

assert(Offset % Align == 0);

elementTypes.push_back(I);

elementTypes.push_back(CGM.

);

elementTypes.push_back(CGM.

);

FD->getType();

hasNonConstantCustomFields =

;

(

*OpenCLHelper =

hasNonConstantCustomFields =

!OpenCLHelper->areAllCustomFieldValuesConstant(info);

(!block->

() && !hasNonConstantCustomFields) {

llvm::StructType::get(CGM.

(), elementTypes,

);

(

.getLangOpts().ObjC &&

assert(CGF && isa_and_nonnull<CXXMethodDecl>(CGF->

) &&

);

maxFieldAlign = std::max(maxFieldAlign, TInfo.Align);

(TInfo.Align, TInfo.Width,

, llvmType, thisType,

(

&CI : block->

()) {

*variable = CI.getVariable();

(CI.isEscapingByref()) {

maxFieldAlign = std::max(maxFieldAlign, align);

);

variable->

(), layout, info, CGM);

(CI.hasCopyExpr() || !record->hasTrivialDestructor()) {

(!record->isExternallyVisible())

maxFieldAlign = std::max(maxFieldAlign, align);

llvm::Type *llvmType =

(align, size, &CI, llvmType, VT, layout, info, CGM);

(layout.empty()) {

llvm::StructType::get(CGM.

(), elementTypes,

);

llvm::stable_sort(layout);

(endAlign < maxFieldAlign) {

li = layout.begin() + 1, le = layout.end();

(; li != le && endAlign < li->Alignment; ++li)

(; li != le; ++li) {

assert(endAlign >= li->Alignment);

li->setIndex(info, elementTypes.size(), blockSize);

elementTypes.push_back(li->Type);

blockSize += li->Size;

(endAlign >= maxFieldAlign) {

layout.erase(first, li);

assert(endAlign ==

(blockSize));

(endAlign < maxFieldAlign) {

padding = newBlockSize - blockSize;

elementTypes.push_back(llvm::ArrayType::get(CGM.

,

blockSize = newBlockSize;

assert(endAlign >= maxFieldAlign);

assert(endAlign ==

(blockSize));

li = layout.begin(), le = layout.end(); li != le; ++li) {

(endAlign < li->Alignment) {

padding = li->Alignment - endAlign;

elementTypes.push_back(llvm::ArrayType::get(CGM.

,

blockSize += padding;

assert(endAlign >= li->Alignment);

li->setIndex(info, elementTypes.size(), blockSize);

elementTypes.push_back(li->Type);

blockSize += li->Size;

llvm::StructType::get(CGM.

(), elementTypes,

);

(!

->getBlockDecl()->hasCaptures())

(!blockInfo.CanBeGlobal)

blockInfo.BlockAlign,

);

*InvokeFn = BlockCGF.GenerateBlockFunction(

*blockFn = llvm::ConstantExpr::getPointerCast(InvokeFn, GenVoidPtrTy);

assert(blockAddr.

() &&

);

llvm::Constant *

;

llvm::Constant *descriptor;

llvm::Constant *blockISA = blockInfo.

projectField = [&](

index,

Twine &

) ->

{

storeField = [&](llvm::Value *value,

index,

Twine &

) {

addHeaderField = [&](llvm::Value *value,

size,

Twine &

) {

storeField(value, index, name);

addHeaderField(blockFn, GenVoidPtrSize,

);

addHeaderField(descriptor,

(),

);

(

*Helper =

(

I : Helper->getCustomFieldValues(*

, blockInfo)) {

projectField(blockInfo.

,

);

(

&CI :

->captures()) {

*variable = CI.getVariable();

blockField = projectField(capture.

(),

);

(

->isConversionFromLambda()) {

}

(CI.isEscapingByref()) {

);

I = LocalDeclMap.find(variable);

assert(I != LocalDeclMap.end());

(CI.isEscapingByref()) {

llvm::Value *byrefPointer;

}

(

*copyExpr = CI.getCopyExpr()) {

(

->isConversionFromLambda()) {

}

(

.isConstQualified() &&

->isBlockPointerType()) {

(

.isConstQualified() &&

);

(useArrayEHCleanup)

IsBlockDeclInRetExpr = [&]() {

*EWC = llvm::dyn_cast_or_null<ExprWithCleanups>(

);

(

&

: EWC->getObjects())

(IsBlockDeclInRetExpr())

(cleanupKind, blockField,

, destroyer, useArrayEHCleanup);

llvm::Value *result =

.CreatePointerCast(

(BlockDescriptorType)

BlockDescriptorType;

llvm::Type *UnsignedLongTy =

BlockDescriptorType = llvm::StructType::create(

, UnsignedLongTy, UnsignedLongTy);

AddrSpace = 0;

BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace);

BlockDescriptorType;

(GenericBlockLiteralType)

GenericBlockLiteralType;

llvm::append_range(StructFields, Helper->getCustomFieldTypes());

GenericBlockLiteralType = llvm::StructType::create(

StructFields,

);

GenericBlockLiteralType =

llvm::StructType::create(

,

,

GenericBlockLiteralType;

llvm::CallBase **CallOrInvoke) {

llvm::Value *

=

;

llvm::Type *GenericVoidPtrTy =

llvm::Value *BlockDescriptor =

.CreatePointerCast(

BlockPtr, GenericVoidPtrTy);

(!isa<ParmVarDecl>(

->getCalleeDecl()))

assert(

&&

);

(capture.

())

LocalDeclMap.find(variable)->second;

);

byrefInfo.ByrefAlignment);

llvm::Constant *Addr) {

= EmittedGlobalBlocks.insert(std::make_pair(BE, Addr)).second;

assert(

&&

);

llvm::Constant *blockFn) {

);

fields.addInt(CGM.

, 0);

fields.add(blockFn);

}

(

*Helper =

(

*I : Helper->getCustomFieldValues(CGM, blockInfo)) {

AddrSpace = 0;

llvm::GlobalVariable *literal = fields.finishAndCreateGlobal(

, blockInfo.

,

!IsWindows, llvm::GlobalVariable::InternalLinkage, AddrSpace);

literal->addAttribute(

);

*

= llvm::Function::Create(llvm::FunctionType::get(CGM.

,

{}), llvm::GlobalValue::InternalLinkage,

,

llvm::IRBuilder<>

(llvm::BasicBlock::Create(CGM.

(),

,

.CreateStructGEP(literal->getValueType(), literal, 0),

*InitVar =

llvm::GlobalVariable(CGM.

(),

->getType(),

, llvm::GlobalValue::InternalLinkage,

,

);

InitVar->setSection(

);

llvm::Type *RequiredType =

llvm::Constant *

=

llvm::ConstantExpr::getPointerCast(literal, RequiredType);

cast<llvm::Function>(blockFn->stripPointerCasts()),

,

literal->getValueType());

assert(

&&

);

DI->EmitDeclareOfBlockLiteralArgVariable(

cast<llvm::AllocaInst>(alloc.

()->stripPointerCasts()),

llvm::PointerType::get(

assert(

&&

);

IsLambdaConversionToBlock,

BuildGlobalBlock) {

(DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) {

*

= dyn_cast<VarDecl>(i->first);

(var && !

->hasLocalStorage())

setAddrOfLocalVar(var, i->second);

args.push_back(&SelfDecl);

llvm::Function *fn = llvm::Function::Create(

fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &

.

());

(BuildGlobalBlock) {

llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy));

(

&CI :

->captures()) {

*variable = CI.getVariable();

setAddrOfLocalVar(variable, alloca);

llvm::BasicBlock *entry =

.GetInsertBlock();

llvm::BasicBlock::iterator entry_ptr =

.GetInsertPoint();

(IsLambdaConversionToBlock)

llvm::BasicBlock *resume =

.GetInsertBlock();

(entry_ptr->getNextNonDebugInstruction())

entry_ptr = entry_ptr->getNextNonDebugInstruction()->getIterator();

entry_ptr = entry->end();

.SetInsertPoint(entry, entry_ptr);

(

&CI :

->captures()) {

*variable = CI.getVariable();

addr = LocalDeclMap.find(variable)->second;

(void)DI->EmitDeclareOfAutoVariable(

DI->EmitDeclareOfBlockDeclRefVariable(

variable, BlockPointerDbgLoc,

, blockInfo,

entry_ptr == entry->end() ? nullptr : &*entry_ptr);

cast<CompoundStmt>(

->getBody())->getRBracLoc());

(resume ==

)

.ClearInsertionPoint();

.SetInsertPoint(resume);

std::pair<BlockCaptureEntityKind, BlockFieldFlags>

(

.isObjCGCWeak())

(

.isNonTrivialToPrimitiveCopy()) {

llvm_unreachable(

);

: Addr(Addr), FieldFlags(Flags), LoadBlockVarAddr(LoadValue),

llvm::Value *BlockVarAddr;

(LoadBlockVarAddr) {

BlockVarAddr = Addr.emitRawPointer(CGF);

CaptureStrKind StrKind,

assert((StrKind != CaptureStrKind::Merged ||

);

(StrKind == CaptureStrKind::DisposeHelper) {

llvm::raw_svector_ostream Out(TyStr);

Str += llvm::to_string(TyStr.size()) + TyStr.c_str();

(StrKind != CaptureStrKind::DisposeHelper) {

(StrKind != CaptureStrKind::CopyHelper) {

std::string FuncStr;

(StrKind == CaptureStrKind::DisposeHelper)

CaptureTy, Alignment, IsVolatile, Ctx);

CaptureTy, Alignment, IsVolatile, Ctx);

Str += llvm::to_string(FuncStr.size()) +

+ FuncStr;

assert((StrKind == CaptureStrKind::CopyHelper ||

StrKind == CaptureStrKind::DisposeHelper) &&

);

std::string Name = StrKind == CaptureStrKind::CopyHelper

?

:

;

Name += llvm::to_string(BlockAlignment.

()) +

;

(

&Cap : Captures) {

(Cap.isConstantOrTrivial())

Name += llvm::to_string(Cap.getOffset().getQuantity());

EHOnly = ForCopyHelper;

(CaptureKind) {

(CapturesNonExternalType) {

Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);

Fn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

CaptureStrKind::CopyHelper,

);

args.push_back(&DstDecl);

args.push_back(&SrcDecl);

llvm::Function *

=

llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,

ArgTys.push_back(

.VoidPtrTy);

ArgTys.push_back(

.VoidPtrTy);

index = capture.

();

assert(CI.

() &&

);

*ty = cast<llvm::PointerType>(srcValue->getType());

llvm::Value *null = llvm::ConstantPointerNull::get(ty);

I->eraseFromParent();

llvm::Value *args[] = {

std::pair<BlockCaptureEntityKind, BlockFieldFlags>

(

.isObjCGCWeak())

(

.isDestructedType()) {

llvm_unreachable(

);

CaptureStrKind::DisposeHelper,

);

args.push_back(&SrcDecl);

llvm::Function *

=

llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,

ArgTys.push_back(

.VoidPtrTy);

CodeGenFunction::RunCleanupsScope cleanups(*

);

cleanups.ForceCleanup();

llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.

, flags);

llvm::Value *args[] = {destField.

(CGF), srcValue, flagsVal};

profileImpl(llvm::FoldingSetNodeID &

)

{

.AddInteger(Flags.getBitMask());

profileImpl(llvm::FoldingSetNodeID &

)

{

llvm::ConstantPointerNull::get(cast<llvm::PointerType>(value->getType()));

profileImpl(llvm::FoldingSetNodeID &

)

{

ARCStrongBlockByrefHelpers(

alignment)

profileImpl(llvm::FoldingSetNodeID &

)

{

*CopyExpr;

*copyExpr)

needsCopy()

{

CopyExpr !=

; }

(!CopyExpr)

;

profileImpl(llvm::FoldingSetNodeID &

)

{

.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());

needsDispose()

{

VarType.isDestructedType();

CGF.

(VarType.isDestructedType(), field, VarType);

profileImpl(llvm::FoldingSetNodeID &

)

{

.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());

llvm::Constant *

args.push_back(&Dst);

args.push_back(&Src);

llvm::Function *Fn =

llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,

, &CGF.

.

());

generator.

(CGF, destField, srcField);

llvm::Constant *

args.push_back(&Src);

llvm::Function *Fn =

llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,

,

llvm::FoldingSetNodeID id;

generator.Profile(

);

(node)

*

(node);

*copy =

(CGM.

())

(std::forward<T>(generator));

CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType,

AutoVarEmission &emission) {

assert(

.isEscapingByref() &&

);

*copyExpr =

(!copyExpr && record->hasTrivialDestructor())

;

return ::buildByrefHelpers(

, byrefInfo, CXXByrefHelpers(valueAlignment,

, copyExpr));

return ::buildByrefHelpers(

, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment,

));

(!

->isObjCRetainableType())

;

return ::buildByrefHelpers(

, byrefInfo,

ARCWeakByrefHelpers(valueAlignment));

(

->isBlockPointerType()) {

return ::buildByrefHelpers(

, byrefInfo,

ARCStrongBlockByrefHelpers(valueAlignment));

return ::buildByrefHelpers(

, byrefInfo,

ARCStrongByrefHelpers(valueAlignment));

llvm_unreachable(

);

(

->isBlockPointerType()) {

->isObjCObjectPointerType()) {

(

.isObjCGCWeak())

return ::buildByrefHelpers(

, byrefInfo,

ObjectByrefHelpers(valueAlignment, flags));

followForward) {

llvm::Twine &name) {

(followForward) {

it = BlockByrefInfos.find(

);

(it != BlockByrefInfos.end())

(hasCopyAndDispose) {

HasByrefExtendedLayout =

;

(

().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) &&

HasByrefExtendedLayout) {

packed =

;

(varOffset != size) {

llvm::Type *paddingTy =

llvm::ArrayType::get(

, (varOffset - size).getQuantity());

.push_back(paddingTy);

.push_back(varTy);

llvm::StructType *byrefType = llvm::StructType::create(

info.

= byrefType;

pair = BlockByrefInfos.insert({

, info});

assert(pair.second &&

);

pair.first->second;

llvm::StructType *byrefType = cast<llvm::StructType>(addr.

());

nextHeaderIndex = 0;

storeHeaderField = [&](llvm::Value *value,

fieldSize,

Twine &

) {

nextHeaderOffset += fieldSize;

&

= *emission.Variable;

HasByrefExtendedLayout =

;

ByRefHasLifetime =

(

.isObjCGCWeak())

);

(ByRefHasLifetime) {

(ByrefLifetime) {

(!

->isObjCObjectPointerType() && !

->isBlockPointerType())

(

, flags.

());

(

);

(

);

(

);

(

);

(

);

(

);

storeHeaderField(llvm::ConstantInt::get(

, flags.

()),

storeHeaderField(

,

(),

);

);

);

(ByRefHasLifetime && HasByrefExtendedLayout) {

storeHeaderField(layoutInfo,

(),

);

llvm::Value *args[] = {

,

LoadBlockVarAddr,

) {

.pushCleanup<CallBlockRelease>(

, Addr, Flags, LoadBlockVarAddr,

llvm::Constant *

) {

*GV = cast<llvm::GlobalValue>(

->stripPointerCasts());

assert((isa<llvm::Function>(

->stripPointerCasts()) ||

isa<llvm::GlobalVariable>(

->stripPointerCasts())) &&

);

((ND = dyn_cast<FunctionDecl>(

)) ||

(ND = dyn_cast<VarDecl>(

)))

(GV->isDeclaration() && (!ND || !ND->

<DLLExportAttr>())) {

GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);

GV->setLinkage(llvm::GlobalValue::ExternalLinkage);

GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);

GV->setLinkage(llvm::GlobalValue::ExternalLinkage);

(CGM.

().BlocksRuntimeOptional && GV->isDeclaration() &&

GV->hasExternalLinkage())

GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);

(BlockObjectDispose)

BlockObjectDispose;

BlockObjectDispose =

*

, cast<llvm::Constant>(BlockObjectDispose.getCallee()));

BlockObjectDispose;

(BlockObjectAssign)

BlockObjectAssign;

*

, cast<llvm::Constant>(BlockObjectAssign.getCallee()));

BlockObjectAssign;

(NSConcreteGlobalBlock)

NSConcreteGlobalBlock;

NSConcreteGlobalBlock;

(NSConcreteStackBlock)

NSConcreteStackBlock;

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.

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.

Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...

llvm::Value * getBasePointer() const

llvm::Value * emitRawPointer(CodeGenFunction &CGF) const

Return the pointer contained in this class after authenticating it and adding offset to it if necessa...

llvm::Type * getElementType() const

Return the type of the values stored in this address.

Address withElementType(llvm::Type *ElemTy) const

Return address with different element type, but same pointer and alignment.

static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)

forAddr - Make a slot for an aggregate value.

A scoped helper to set the current debug location to the specified location or preferred location of ...

static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)

Apply TemporaryLocation if it is valid.

static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)

Set the IRBuilder to not attach debug locations.

A pair of helper functions for a __block variable.

virtual ~BlockByrefHelpers()

virtual void emitCopy(CodeGenFunction &CGF, Address dest, Address src)=0

virtual bool needsCopy() const

llvm::Constant * CopyHelper

virtual void emitDispose(CodeGenFunction &CGF, Address field)=0

virtual bool needsDispose() const

llvm::Constant * DisposeHelper

Information about the layout of a __block variable.

uint32_t getBitMask() const

uint32_t getBitMask() const

const BlockDecl::Capture * Cap

BlockFieldFlags DisposeFlags

static Capture makeIndex(unsigned index, CharUnits offset, QualType FieldType, BlockCaptureEntityKind CopyKind, BlockFieldFlags CopyFlags, BlockCaptureEntityKind DisposeKind, BlockFieldFlags DisposeFlags, const BlockDecl::Capture *Cap)

BlockCaptureEntityKind CopyKind

bool isConstantOrTrivial() const

QualType fieldType() const

BlockFieldFlags CopyFlags

BlockCaptureEntityKind DisposeKind

llvm::Value * getConstant() const

unsigned getIndex() const

static Capture makeConstant(llvm::Value *value, const BlockDecl::Capture *Cap)

CharUnits getOffset() const

CGBlockInfo - Information to generate a block literal.

CGBlockInfo(const BlockDecl *blockDecl, StringRef Name)

unsigned CXXThisIndex

The field index of 'this' within the block, if there is one.

const BlockDecl * getBlockDecl() const

llvm::StructType * StructureType

CharUnits BlockHeaderForcedGapOffset

bool UsesStret

UsesStret : True if the block uses an stret return.

const BlockExpr * BlockExpression

const BlockExpr * getBlockExpr() const

bool HasCapturedVariableLayout

HasCapturedVariableLayout : True if block has captured variables and their layout meta-data has been ...

bool CapturesNonExternalType

Indicates whether an object of a non-external C++ class is captured.

bool NeedsCopyDispose

True if the block has captures that would necessitate custom copy or dispose helper functions if the ...

bool CanBeGlobal

CanBeGlobal - True if the block can be global, i.e.

bool HasCXXObject

HasCXXObject - True if the block's custom copy/dispose functions need to be run even in GC mode.

CharUnits BlockHeaderForcedGapSize

const Capture & getCapture(const VarDecl *var) const

llvm::SmallVector< Capture, 4 > SortedCaptures

The block's captures. Non-constant captures are sorted by their offsets.

bool NoEscape

Indicates whether the block is non-escaping.

llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)

Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")

llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")

llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")

MangleContext & getMangleContext()

Gets the mangle context.

Abstract information about a function or function prototype.

All available information about a concrete callee.

This class gathers all debug information during compilation and is responsible for emitting to llvm g...

CGFunctionInfo - Class to encapsulate the information about a function definition.

virtual llvm::Constant * BuildByrefLayout(CodeGen::CodeGenModule &CGM, QualType T)=0

Returns an i8* which points to the byref layout information.

virtual std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM, const CGBlockInfo &blockInfo)

virtual llvm::Constant * BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, const CodeGen::CGBlockInfo &blockInfo)=0

virtual llvm::Constant * BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, const CodeGen::CGBlockInfo &blockInfo)=0

llvm::Function * getInvokeFunction(const Expr *E)

void recordBlockInfo(const BlockExpr *E, llvm::Function *InvokeF, llvm::Value *Block, llvm::Type *BlockTy)

Record invoke function and block literal emitted during normal codegen for a block expression.

llvm::PointerType * getGenericVoidPointerType()

CallArgList - Type for representing both the value and type of arguments in a call.

void add(RValue rvalue, QualType type)

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)

RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)

void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)

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)

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)

RawAddress CreateMemTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)

CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...

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)

RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)

EmitCall - Generate a call of the given function, expecting the given result type,...

llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

ASTContext & getContext() const

llvm::Value * EmitBlockLiteral(const BlockExpr *)

Emit block literal.

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)

void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs={})

EmitStmt - Emit the code for the statement.

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

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.

llvm::Type * ConvertTypeForMem(QualType T)

ConvertTypeForMem - Convert type T into a llvm::Type.

const CGFunctionInfo & arrangeBlockFunctionDeclaration(const FunctionProtoType *type, const FunctionArgList &args)

Block invocation functions are C functions with an implicit parameter.

llvm::Constant * getPointer() const

llvm::Constant * tryEmitAbstractForInitializer(const VarDecl &D)

Try to emit the initializer of the given declaration as an abstract constant.

StructBuilder beginStruct(llvm::StructType *structTy=nullptr)

The standard implementation of ConstantInitBuilder used in Clang.

Information for lazily generating a cleanup.

A saved depth on the scope stack.

stable_iterator stable_begin() const

Create a stable reference to the top of the EH stack.

FunctionArgList - Type for representing both the decl and type of parameters to a function.

Address getAddress() const

RValue - This trivial value class is used to represent the result of an expression that is evaluated.

static RValue get(llvm::Value *V)

An abstract representation of an aligned address.

llvm::Value * getPointer() const

ReturnValueSlot - Contains the address where the return value of a function can be stored,...

virtual TargetOpenCLBlockHelper * getTargetOpenCLBlockHelper() const

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

lookup_result lookup(DeclarationName Name) const

lookup - Find the declarations (if any) with the given Name in this context.

A reference to a declared variable, function, enum, etc.

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.

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

@ DK_objc_strong_lifetime

DestructionKind isDestructedType() const

Returns a nonzero value if objects of this type require non-trivial work to clean up after.

@ PCK_Struct

The type is a struct containing a field whose type is neither PCK_Trivial nor PCK_VolatileTrivial.

@ PCK_Trivial

The type does not fall into any of the following categories.

@ PCK_ARCStrong

The type is an Objective-C retainable pointer type that is qualified with the ARC __strong qualifier.

@ PCK_VolatileTrivial

The type would be trivial except that it is volatile-qualified.

@ PCK_ARCWeak

The type is an Objective-C retainable pointer type that is qualified with the ARC __weak qualifier.

The collection of all-type qualifiers we support.

@ OCL_Strong

Assigning into this object requires the old value to be released and the new value to be retained.

@ OCL_ExplicitNone

This object can be modified without requiring retains or releases.

@ OCL_None

There is no lifetime qualification on this type.

@ OCL_Weak

Reading or writing from this object requires a barrier call.

@ OCL_Autoreleasing

Assigning into this object requires a lifetime extension.

ObjCLifetime getObjCLifetime() const

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

Base for LValueReferenceType and RValueReferenceType.

Scope - A scope is a transient data structure that is used while parsing the program.

Encodes a location in the source.

SourceLocation getBeginLoc() const LLVM_READONLY

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

uint64_t getPointerWidth(LangAS AddrSpace) const

Return the width of pointers on this target, for the specified address space.

uint64_t getPointerAlign(LangAS AddrSpace) const

The top declaration context.

static DeclContext * castToDeclContext(const TranslationUnitDecl *D)

The base class of the type hierarchy.

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.

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 Variable var(Literal L)

Returns the variable of L.

constexpr size_t align(size_t Size)

Aligns a size to the pointer alignment.

RangeSelector name(std::string ID)

Given a node with a "name", (like NamedDecl, DeclRefExpr, CxxCtorInitializer, and TypeLoc) selects th...

The JSON file list parser is used to communicate input to InstallAPI.

bool isa(CodeGen::Address addr)

bool operator<(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

@ Result

The result type of a method or function.

static bool isBlockPointer(Expr *Arg)

LangAS

Defines the address space values used by the address space qualifier of QualType.

@ VK_PRValue

A pr-value expression (in the C++11 taxonomy) produces a temporary value.

@ VK_LValue

An l-value expression is a reference to an object with independent storage.

const FunctionProtoType * T

@ Other

Other implicit parameter.

@ ObjCSelf

Parameter for Objective-C 'self' argument.

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4