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

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

clang: lib/CodeGen/CGDecl.cpp Source File

;

CodeGen;

);

CodeGenFunction::EmitDecl(

&

) {

Decl::BuiltinTemplate:

Decl::TranslationUnit:

Decl::ExternCContext:

Decl::UnresolvedUsingTypename:

Decl::ClassTemplateSpecialization:

Decl::ClassTemplatePartialSpecialization:

Decl::VarTemplateSpecialization:

Decl::VarTemplatePartialSpecialization:

Decl::TemplateTypeParm:

Decl::UnresolvedUsingValue:

Decl::NonTypeTemplateParm:

Decl::CXXDeductionGuide:

Decl::CXXConstructor:

Decl::CXXDestructor:

Decl::CXXConversion:

Decl::MSProperty:

Decl::IndirectField:

Decl::ObjCAtDefsField:

Decl::ImplicitParam:

Decl::ClassTemplate:

Decl::VarTemplate:

Decl::FunctionTemplate:

Decl::TypeAliasTemplate:

Decl::TemplateTemplateParm:

Decl::ObjCMethod:

Decl::ObjCCategory:

Decl::ObjCProtocol:

Decl::ObjCInterface:

Decl::ObjCCategoryImpl:

Decl::ObjCImplementation:

Decl::ObjCProperty:

Decl::ObjCCompatibleAlias:

Decl::PragmaComment:

Decl::PragmaDetectMismatch:

Decl::AccessSpec:

Decl::LinkageSpec:

Decl::ObjCPropertyImpl:

Decl::FileScopeAsm:

Decl::TopLevelStmt:

Decl::FriendTemplate:

Decl::OutlinedFunction:

Decl::UsingShadow:

Decl::ConstructorUsingShadow:

Decl::ObjCTypeParam:

Decl::UnresolvedUsingIfExists:

Decl::HLSLBuffer:

llvm_unreachable(

);

Decl::CXXRecord:

DI->EmitAndRetainType(

().getEnumType(cast<EnumDecl>(&

)));

Decl::EnumConstant:

Decl::StaticAssert:

Decl::UnnamedGlobalConstant:

Decl::TemplateParamObject:

Decl::OMPThreadPrivate:

Decl::OMPAllocate:

Decl::OMPCapturedExpr:

Decl::OMPRequires:

Decl::ImplicitConceptSpecialization:

Decl::LifetimeExtendedTemporary:

Decl::RequiresExprBody:

Decl::NamespaceAlias:

DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(

));

DI->EmitUsingDecl(cast<UsingDecl>(

));

Decl::UsingEnum:

DI->EmitUsingEnumDecl(cast<UsingEnumDecl>(

));

Decl::UsingPack:

(

*Using : cast<UsingPackDecl>(

).expansions())

Decl::UsingDirective:

DI->EmitUsingDirective(cast<UsingDirectiveDecl>(

));

Decl::Decomposition: {

&VD = cast<VarDecl>(

);

);

(

*DD = dyn_cast<DecompositionDecl>(&VD))

(

*B : DD->flat_bindings())

(

*HD = B->getHoldingVar())

Decl::OMPDeclareReduction:

Decl::OMPDeclareMapper:

Decl::TypeAlias: {

Ty = cast<TypedefNameDecl>(

).getUnderlyingType();

DI->EmitAndRetainType(Ty);

(

.hasExternalStorage())

(

.getType()->isSamplerT())

llvm::GlobalValue::LinkageTypes

=

assert(

.hasLocalStorage());

assert(!

.isExternallyVisible() &&

);

std::string ContextName;

(

*CD = dyn_cast<CapturedDecl>(DC))

DC = cast<DeclContext>(CD->getNonClosureContext());

(

*FD = dyn_cast<FunctionDecl>(DC))

(

*BD = dyn_cast<BlockDecl>(DC))

(

*OMD = dyn_cast<ObjCMethodDecl>(DC))

ContextName = OMD->getSelector().getAsString();

llvm_unreachable(

);

ContextName +=

+

.getNameAsString();

(llvm::Constant *ExistingGV = StaticLocalDeclMap[&

])

llvm::Constant *

=

;

= llvm::UndefValue::get(LTy);

llvm::GlobalVariable *GV =

llvm::GlobalVariable(

, llvm::GlobalVariable::NotThreadLocal, TargetAS);

GV->setAlignment(

().getDeclAlign(&

).getAsAlign());

GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));

(

.getTLSKind())

llvm::Constant *Addr = GV;

(AS != ExpectedAS) {

*

, GV, AS, ExpectedAS,

().getTargetAddressSpace(ExpectedAS)));

(isa<BlockDecl>(DC) || isa<CapturedDecl>(DC)) {

(

*CD = dyn_cast<CXXConstructorDecl>(DC))

(

*DD = dyn_cast<CXXDestructorDecl>(DC))

(

*FD = dyn_cast<FunctionDecl>(DC))

assert(isa<ObjCMethodDecl>(DC) &&

);

llvm::GlobalVariable *

llvm::GlobalVariable *GV) {

llvm::Constant *

= emitter.tryEmitForInitializer(

);

GV->setConstant(

);

assert(VarSize == CstSize &&

);

.getType().isConstantStorage(

(),

, !NeedsDtor));

GV->replaceInitializer(

);

emitter.finalize(GV);

llvm::GlobalValue::LinkageTypes

) {

setAddrOfLocalVar(&

,

(addr, elemTy, alignment));

(

.getType()->isVariablyModifiedType())

llvm::Type *expectedType = addr->getType();

llvm::GlobalVariable *

=

cast<llvm::GlobalVariable>(addr->stripPointerCasts());

(

.getInit() && !isCudaSharedVar)

(

*SA =

.

<PragmaClangBSSSectionAttr>())

->addAttribute(

, SA->getName());

(

*SA =

.

<PragmaClangDataSectionAttr>())

->addAttribute(

, SA->getName());

(

*SA =

.

<PragmaClangRodataSectionAttr>())

->addAttribute(

, SA->getName());

(

*SA =

.

<PragmaClangRelroSectionAttr>())

->addAttribute(

, SA->getName());

(

SectionAttr *SA =

.

<SectionAttr>())

->setSection(SA->getName());

llvm::Constant *castedAddr =

llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(var, expectedType);

LocalDeclMap.find(&

)->second =

(castedAddr, elemTy, alignment);

CodeGenFunction::Destroyer *destroyer,

useEHCleanupForArray)

: addr(addr),

(

), destroyer(destroyer),

useEHCleanupForArray(useEHCleanupForArray) {}

CodeGenFunction::Destroyer *destroyer;

useEHCleanupForArray;

useEHCleanupForArray =

flags.isForNormalCleanup() && this->useEHCleanupForArray;

<

Derived>

: NRVOFlag(NRVOFlag),

(addr), Ty(

) {}

llvm::Value *NRVOFlag;

NRVO = flags.isForNormalCleanup() && NRVOFlag;

llvm::BasicBlock *SkipDtorBB =

;

llvm::Value *DidNRVO =

CGF.

.CreateCondBr(DidNRVO, SkipDtorBB, RunDtorBB);

Derived *

(

)->emitDestructorCall(CGF);

~DestroyNRVOVariable() =

;

DestroyNRVOVariableCXX final

: DestroyNRVOVariable<DestroyNRVOVariableCXX> {

: DestroyNRVOVariable<DestroyNRVOVariableCXX>(addr,

, NRVOFlag),

DestroyNRVOVariableC final

: DestroyNRVOVariable<DestroyNRVOVariableC> {

DestroyNRVOVariableC(

addr, llvm::Value *NRVOFlag,

Ty)

: DestroyNRVOVariable<DestroyNRVOVariableC>(addr, Ty, NRVOFlag) {}

CallStackRestore(

Stack) : Stack(Stack) {}

isRedundantBeforeReturn()

{

; }

CGF.

.CreateStackRestore(

);

std::pair<llvm::Value *, llvm::Value *> AddrSizePair;

KmpcAllocFree(

std::pair<llvm::Value *, llvm::Value *> &AddrSizePair)

: AddrSizePair(AddrSizePair) {}

ExtendGCLifetime(

*var) : Var(*

) {}

llvm::Constant *CleanupFn;

CallCleanupFunction(llvm::Constant *CleanupFn,

*Info,

: CleanupFn(CleanupFn), FnInfo(*Info), Var(*Var) {}

llvm_unreachable(

);

(var.hasAttr<ObjCPreciseLifetimeAttr>()

CGF.

(cleanupKind, addr, var.getType(), destroyer,

(

*e = dyn_cast<Expr>(

)) {

= e = e->IgnoreParenCasts();

(

*ref = dyn_cast<DeclRefExpr>(e))

(ref->getDecl() == &var);

(

*be = dyn_cast<BlockExpr>(e)) {

*block = be->getBlockDecl();

(

&I : block->

()) {

(I.getVariable() == &var)

(

*SubStmt :

->children())

(!

)

;

(!isa<VarDecl>(

))

;

needsCast =

;

(

->getCastKind()) {

CK_BlockPointerToObjCPointerCast:

CK_LValueToRValue: {

(!

.

(SanitizerKind::NullabilityAssign))

SanitizerScope SanScope(

);

llvm::Constant *StaticData[] = {

llvm::ConstantInt::get(

, 0),

SanitizerHandler::TypeMismatch, StaticData, RHS);

lvalue,

capturedByInit) {

init = DIE->getExpr();

(

*EWC = dyn_cast<ExprWithCleanups>(init)) {

CodeGenFunction::RunCleanupsScope

(*

);

accessedByInit =

;

accessedByInit = (capturedByInit ||

(

, init));

(accessedByInit) {

(capturedByInit) {

llvm::Value *value =

;

llvm_unreachable(

);

(!

|| !isa<VarDecl>(

) || !cast<VarDecl>(

)->isARCPseudoStrong()) {

&NumStores) {

(isa<llvm::ConstantAggregateZero>(

) ||

isa<llvm::ConstantPointerNull>(

) ||

isa<llvm::UndefValue>(

))

(isa<llvm::ConstantInt>(

) || isa<llvm::ConstantFP>(

) ||

isa<llvm::ConstantVector>(

) || isa<llvm::BlockAddress>(

) ||

isa<llvm::ConstantExpr>(

))

->isNullValue() || NumStores--;

(isa<llvm::ConstantArray>(

) || isa<llvm::ConstantStruct>(

)) {

(

i = 0, e =

->getNumOperands(); i != e; ++i) {

llvm::Constant *Elt = cast<llvm::Constant>(

->getOperand(i));

(llvm::ConstantDataSequential *CDS =

dyn_cast<llvm::ConstantDataSequential>(

)) {

(

i = 0, e = CDS->getNumElements(); i != e; ++i) {

llvm::Constant *Elt = CDS->getElementAsConstant(i);

assert(!

->isNullValue() && !isa<llvm::UndefValue>(

) &&

);

(isa<llvm::ConstantInt>(

) || isa<llvm::ConstantFP>(

) ||

isa<llvm::ConstantVector>(

) || isa<llvm::BlockAddress>(

) ||

isa<llvm::ConstantExpr>(

)) {

*I = Builder.CreateStore(

,

, isVolatile);

I->addAnnotationMetadata(

);

(llvm::ConstantDataSequential *CDS =

dyn_cast<llvm::ConstantDataSequential>(

)) {

(

i = 0, e = CDS->getNumElements(); i != e; ++i) {

llvm::Constant *Elt = CDS->getElementAsConstant(i);

(!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))

CGM, Elt, Builder.CreateConstInBoundsGEP2_32(

, 0, i), isVolatile,

Builder, IsAutoInit);

assert((isa<llvm::ConstantStruct>(

) || isa<llvm::ConstantArray>(

)) &&

);

(

i = 0, e =

->getNumOperands(); i != e; ++i) {

llvm::Constant *Elt = cast<llvm::Constant>(

->getOperand(i));

(!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))

Builder.CreateConstInBoundsGEP2_32(

, 0, i),

isVolatile, Builder, IsAutoInit);

uint64_t GlobalSize) {

(isa<llvm::ConstantAggregateZero>(

))

;

StoreBudget = 6;

uint64_t SizeLimit = 32;

GlobalSize > SizeLimit &&

llvm::DataLayout &DL) {

uint64_t SizeLimit = 32;

(GlobalSize <= SizeLimit)

llvm::isBytewiseValue(

, DL);

uint64_t GlobalByteSize) {

uint64_t ByteSizeLimit = 64;

(GlobalByteSize <= ByteSizeLimit)

(isPattern == IsPattern::Yes)

llvm::Constant::getNullValue(Ty);

llvm::Constant *constant);

llvm::StructType *STy,

llvm::Constant *constant) {

llvm::StructLayout *Layout = DL.getStructLayout(STy);

llvm::Type *Int8Ty = llvm::IntegerType::getInt8Ty(CGM.

());

SizeSoFar = 0;

NestedIntact =

;

(

i = 0, e = STy->getNumElements(); i != e; i++) {

CurOff = Layout->getElementOffset(i);

(SizeSoFar < CurOff) {

assert(!STy->isPacked());

*PadTy = llvm::ArrayType::get(Int8Ty, CurOff - SizeSoFar);

llvm::Constant *CurOp;

(constant->isZeroValue())

CurOp = llvm::Constant::getNullValue(STy->getElementType(i));

CurOp = cast<llvm::Constant>(constant->getAggregateElement(i));

NestedIntact =

;

Values.push_back(NewOp);

SizeSoFar = CurOff + DL.getTypeAllocSize(CurOp->getType());

TotalSize = Layout->getSizeInBytes();

(SizeSoFar < TotalSize) {

*PadTy = llvm::ArrayType::get(Int8Ty, TotalSize - SizeSoFar);

(NestedIntact && Values.size() == STy->getNumElements())

llvm::ConstantStruct::getAnon(Values, STy->isPacked());

llvm::Constant *constant) {

llvm::Type *OrigTy = constant->getType();

(

STy = dyn_cast<llvm::StructType>(OrigTy))

(

*ArrayTy = dyn_cast<llvm::ArrayType>(OrigTy)) {

uint64_t Size = ArrayTy->getNumElements();

llvm::Type *ElemTy = ArrayTy->getElementType();

ZeroInitializer = constant->isNullValue();

llvm::Constant *OpValue, *PaddedOp;

(ZeroInitializer) {

OpValue = llvm::Constant::getNullValue(ElemTy);

(

Op = 0; Op != Size; ++Op) {

(!ZeroInitializer) {

OpValue = constant->getAggregateElement(Op);

Values.push_back(PaddedOp);

*NewElemTy = Values[0]->getType();

(NewElemTy == ElemTy)

*NewArrayTy = llvm::ArrayType::get(NewElemTy, Size);

llvm::ConstantArray::get(NewArrayTy, Values);

llvm::Constant *Constant,

FunctionName = [&](

*DC) -> std::string {

(

*FD = dyn_cast<FunctionDecl>(DC)) {

(

*CC = dyn_cast<CXXConstructorDecl>(FD))

CC->getNameAsString();

(

*CD = dyn_cast<CXXDestructorDecl>(FD))

CD->getNameAsString();

}

(

*OM = dyn_cast<ObjCMethodDecl>(DC)) {

OM->getNameAsString();

}

(isa<BlockDecl>(DC)) {

}

(isa<CapturedDecl>(DC)) {

;

llvm_unreachable(

);

llvm::GlobalVariable *&CacheEntry = InitializerConstants[&

];

(!CacheEntry || CacheEntry->getInitializer() != Constant) {

*Ty = Constant->getType();

isConstant =

;

llvm::GlobalVariable *InsertBefore =

;

(

.hasGlobalStorage())

Name = (

+ FunctionName(DC) +

+

.getName()).str();

llvm_unreachable(

);

llvm::GlobalVariable *GV =

llvm::GlobalVariable(

(), Ty, isConstant, llvm::GlobalValue::PrivateLinkage,

Constant, Name, InsertBefore, llvm::GlobalValue::NotThreadLocal, AS);

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

}

(CacheEntry->getAlignment() < uint64_t(Align.

())) {

CacheEntry->setAlignment(Align.

());

(CacheEntry, CacheEntry->getValueType(), Align);

llvm::Constant *Constant,

llvm::Constant *constant,

IsAutoInit) {

*Ty = constant->getType();

uint64_t ConstantSize = CGM.

().getTypeAllocSize(Ty);

canDoSingleStore = Ty->isIntOrIntVectorTy() ||

Ty->isPtrOrPtrVectorTy() || Ty->isFPOrFPVectorTy();

(canDoSingleStore) {

*I = Builder.CreateStore(constant,

, isVolatile);

I->addAnnotationMetadata(

);

*SizeVal = llvm::ConstantInt::get(CGM.

, ConstantSize);

*I = Builder.CreateMemSet(

, llvm::ConstantInt::get(CGM.

, 0),

SizeVal, isVolatile);

I->addAnnotationMetadata(

);

valueAlreadyCorrect =

constant->isNullValue() || isa<llvm::UndefValue>(constant);

(!valueAlreadyCorrect) {

=

.withElementType(Ty);

llvm::Value *Pattern =

uint64_t

= 0x00;

(!isa<llvm::UndefValue>(Pattern)) {

llvm::APInt &AP = cast<llvm::ConstantInt>(Pattern)->getValue();

assert(AP.getBitWidth() <= 8);

= AP.getLimitedValue();

*I = Builder.CreateMemSet(

, llvm::ConstantInt::get(CGM.

,

), SizeVal, isVolatile);

I->addAnnotationMetadata(

);

IsTrivialAutoVarInitPattern =

(

*STy = dyn_cast<llvm::StructType>(Ty)) {

(STy ==

.getElementType() ||

(STy !=

.getElementType() && IsTrivialAutoVarInitPattern)) {

llvm::StructLayout *Layout =

(

i = 0; i != constant->getNumOperands(); i++) {

EltPtr = Builder.CreateConstInBoundsByteGEP(

.withElementType(CGM.

), CurOff);

constant->getAggregateElement(i), IsAutoInit);

}

(

*ATy = dyn_cast<llvm::ArrayType>(Ty)) {

(ATy ==

.getElementType() ||

(ATy !=

.getElementType() && IsTrivialAutoVarInitPattern)) {

(

i = 0; i != ATy->getNumElements(); i++) {

EltPtr = Builder.CreateConstGEP(

.withElementType(ATy->getElementType()), i);

constant->getAggregateElement(i), IsAutoInit);

Builder.CreateMemCpy(

,

CGM,

, Builder, constant,

.getAlignment()),

SizeVal, isVolatile);

I->addAnnotationMetadata(

);

llvm::Type *ElTy =

.getElementType();

llvm::Constant *constant =

llvm::Type *ElTy =

.getElementType();

assert(!isa<llvm::UndefValue>(constant));

*Ty = constant->getType();

(isa<llvm::UndefValue>(constant))

(Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy())

(llvm::Use &Op : constant->operands())

llvm::Constant *constant) {

*Ty = constant->getType();

(isa<llvm::UndefValue>(constant))

(!(Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()))

(

Op = 0, NumOp = constant->getNumOperands(); Op != NumOp; ++Op) {

*OpValue = cast<llvm::Constant>(constant->getOperand(Op));

(Ty->isStructTy())

llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Values);

(Ty->isArrayTy())

llvm::ConstantArray::get(cast<llvm::ArrayType>(Ty), Values);

assert(Ty->isVectorTy());

llvm::ConstantVector::get(Values);

llvm::Value *Addr) {

(!ShouldEmitLifetimeMarkers)

assert(Addr->getType()->getPointerAddressSpace() ==

);

llvm::Value *SizeV = llvm::ConstantInt::get(

llvm::CallInst *

=

->setDoesNotThrow();

assert(Addr->getType()->getPointerAddressSpace() ==

);

llvm::CallInst *

=

->setDoesNotThrow();

->setDoesNotThrow();

->setTailCallKind(llvm::CallInst::TCK_NoTail);

(

().getAsVariableArrayType(Type1D)) {

(

*

= dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))

Twine Name = Twine(

) + Twine(VLAExprCounter++);

StringRef NameRef = Name.toStringRef(Buffer);

VLAExprNames.push_back(&Ident);

Dimensions.emplace_back(SizeExprAddr.getPointer(),

Type1D = VlaSize.Type;

NameIdx = 0;

(

&VlaSize : Dimensions) {

(

*

= dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))

MD = llvm::ConstantAsMetadata::get(

);

->getScalarSizeInBits(),

);

ArtificialDecl->setImplicit();

assert(MD &&

);

4 *

.getTypeSize(

.UnsignedIntTy);

(FuncDecl->

<NoDebugAttr>() || FuncDecl->

<OptimizeNoneAttr>())

CodeGenFunction::AutoVarEmission

AutoVarEmission emission(

);

isEscapingByRef =

.isEscapingByref();

emission.IsEscapingByRef = isEscapingByRef;

NRVO =

().ElideConstructors &&

.isNRVOVariable();

address = OpenMPLocalAddr;

AllocaAddr = OpenMPLocalAddr;

(

.isConstexpr() ||

().getBaseElementType(Ty)->isObjCObjectPointerType()) &&

.getInit()->isConstantInitializer(

(),

)))) {

assert(emission.wasEmittedAsGlobal());

emission.IsConstantAggregate =

;

*RD = RecordTy->getDecl();

*CXXRD = dyn_cast<CXXRecordDecl>(RD);

((CXXRD && !CXXRD->hasTrivialDestructor()) ||

RD->isNonTrivialToPrimitiveDestroy()) {

llvm::Type *allocaTy;

(isEscapingByRef) {

allocaTy = byrefInfo.Type;

allocaAlignment = byrefInfo.ByrefAlignment;

allocaAlignment = alignment;

, &AllocaAddr);

IsMSCatchParam =

emission.SizeForLifetimeMarkers =

assert(!emission.useLifetimeMarkers());

VarAllocated =

;

(RT.isDelayedVariableLengthDecl(*

, &

)) {

std::pair<llvm::Value *, llvm::Value *> AddrSizePair =

address =

.getAddress();

VarAllocated =

;

(!VarAllocated) {

(!DidCallStackSave) {

llvm::Value *

=

.CreateStackSave();

DidCallStackSave =

;

setAddrOfLocalVar(&

, address);

emission.Addr = address;

emission.AllocaAddr = AllocaAddr;

(UsePointerValue) {

(emission.useLifetimeMarkers())

emission.getOriginalAllocatedAddress(),

emission.getSizeForLifetimeMarkers());

emission.getAllocatedAddress());

(

*

= dyn_cast<Expr>(S))

(

*SubStmt : S->children())

(

*BE = dyn_cast<BlockExpr>(

)) {

(

&I :

->captures()) {

(I.getVariable() == &Var)

(

*SE = dyn_cast<StmtExpr>(

)) {

(

*BI : CS->

())

(

*BIE = dyn_cast<Expr>(BI)) {

(

*DS = dyn_cast<DeclStmt>(BI)) {

(

*I : DS->decls()) {

(

*VD = dyn_cast<VarDecl>((I))) {

!Construct->requiresZeroInitialization())

CodeGenFunction::emitZeroOrPatternForAutoVarInit(

,

trivialAutoVarInitMaxSize =

isVolatile =

.isVolatileQualified();

(!

.isZero()) {

(trivialAutoVarInit) {

llvm_unreachable(

);

(trivialAutoVarInitMaxSize > 0 &&

allocSize > trivialAutoVarInitMaxSize)

(trivialAutoVarInitMaxSize > 0 &&

allocSize > trivialAutoVarInitMaxSize)

SizeVal = VlaSize.NumElts;

(trivialAutoVarInit) {

llvm_unreachable(

);

(!EltSize.

())

SizeVal, isVolatile);

I->addAnnotationMetadata(

);

llvm::Type *ElTy =

.getElementType();

llvm::Value *IsZeroSizedVLA =

.CreateICmpEQ(

SizeVal, llvm::ConstantInt::get(SizeVal->getType(), 0),

);

.CreateCondBr(IsZeroSizedVLA, ContBB, SetupBB);

(!EltSize.

())

llvm::Value *BaseSizeInChars =

.emitRawPointer(*

),

SizeVal,

);

llvm::BasicBlock *OriginBB =

.GetInsertBlock();

llvm::PHINode *Cur =

.CreatePHI(

.getType(), 2,

);

Cur->addIncoming(

.emitRawPointer(*

), OriginBB);

CurAlign =

.getAlignment().alignmentOfArrayElement(EltSize);

BaseSizeInChars, isVolatile);

I->addAnnotationMetadata(

);

llvm::Value *Done =

.CreateICmpEQ(Next, End,

);

.CreateCondBr(Done, ContBB, LoopBB);

Cur->addIncoming(Next, LoopBB);

assert(emission.Variable &&

);

(emission.wasEmittedAsGlobal())

;

&

= *emission.Variable;

(emission.IsEscapingByRef)

.isNonTrivialToPrimitiveDefaultInitialize() ==

(emission.IsEscapingByRef)

capturedByInit =

locIsByrefHeader = !capturedByInit;

locIsByrefHeader ? emission.getObjectAddress(*

) : emission.Addr;

hasNoTrivialAutoVarInitAttr = [&](

*

) {

&&

->

<NoTrivialAutoVarInitAttr>();

((

.isConstexpr() ||

.

<UninitializedAttr>() ||

hasNoTrivialAutoVarInitAttr(

->getAsTagDecl()) ||

initializeWhatIsTechnicallyUninitialized = [&](

) {

(trivialAutoVarInit ==

(emission.IsEscapingByRef && !locIsByrefHeader)

emitZeroOrPatternForAutoVarInit(

,

,

);

initializeWhatIsTechnicallyUninitialized(

);

llvm::Constant *constant =

;

(emission.IsConstantAggregate ||

.mightBeUsableInConstantExpressions(

())) {

assert(!capturedByInit &&

);

(constant && !constant->isZeroValue() &&

(trivialAutoVarInit !=

(constant &&

->isBitIntType() &&

llvm::Type *LoadType =

constant = llvm::ConstantFoldLoadFromConst(

(trivialAutoVarInit !=

initializeWhatIsTechnicallyUninitialized(

);

(!emission.IsConstantAggregate) {

lvalue,

capturedByInit) {

(

->isReferenceType()) {

(

->isAtomicType()) {

(isa<VarDecl>(

))

(

*FD = dyn_cast<FieldDecl>(

))

llvm_unreachable(

);

CodeGenFunction::AutoVarEmission &emission,

addr = emission.getObjectAddress(*

);

llvm_unreachable(

);

(emission.NRVOFlag) {

assert(!

->isArrayType());

.pushCleanup<DestroyNRVOVariableCXX>(cleanupKind, addr,

, dtor,

(

->isARCPseudoStrong())

;

(!

->hasAttr<ObjCPreciseLifetimeAttr>())

(emission.NRVOFlag) {

assert(!

->isArrayType());

.pushCleanup<DestroyNRVOVariableC>(cleanupKind, addr,

emission.NRVOFlag,

);

useEHCleanup = (cleanupKind &

);

.pushCleanup<DestroyObject>(cleanupKind, addr,

, destroyer,

assert(emission.Variable &&

);

(emission.wasEmittedAsGlobal())

;

&

= *emission.Variable;

.

<ObjCPreciseLifetimeAttr>()) {

(

CleanupAttr *CA =

.

<CleanupAttr>()) {

assert(F &&

);

(emission.IsEscapingByRef &&

(emission.Variable->getType().isObjCGCWeak())

llvm_unreachable(

);

assert(dtorKind &&

);

assert(dtorKind &&

);

useEHCleanupForArray) {

pushFullExprCleanup<DestroyObject>(cleanupKind, addr,

,

destroyer, useEHCleanupForArray);

assert(dtorKind &&

);

useEHCleanupForArray) {

llvm::Instruction *DominatingIP =

(cleanupKind, addr,

, destroyer, useEHCleanupForArray);

.pushCleanup<CallStackRestore>(

, SPMem);

Kind, std::pair<llvm::Value *, llvm::Value *> AddrSizePair) {

.pushCleanup<KmpcAllocFree>(

, AddrSizePair);

Destroyer *destroyer,

useEHCleanupForArray) {

useEHCleanupForArray);

pushCleanupAfterFullExprWithActiveFlag<DestroyObject>(

useEHCleanupForArray);

ConditionalCleanupType =

AllocaTrackerRAII DeactivationAllocas(*

);

pushCleanupAndDeferDeactivation<ConditionalCleanupType>(

cleanupKind, SavedAddr,

, destroyer, useEHCleanupForArray);

.AddAuxAllocas(std::move(DeactivationAllocas).Take());

pushCleanupAfterFullExprWithActiveFlag<ConditionalCleanupType>(

cleanupKind, ActiveFlagForLifetimeExt, SavedAddr,

, destroyer,

useEHCleanupForArray);

Destroyer *destroyer,

useEHCleanupForArray) {

destroyer(*

, addr,

);

checkZeroLength =

;

(llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(

)) {

(constLength->isZero())

;

checkZeroLength =

;

checkZeroLength, useEHCleanupForArray);

Destroyer *destroyer,

checkZeroLength,

useEHCleanup) {

(checkZeroLength) {

llvm::Value *isEmpty =

.CreateICmpEQ(begin, end,

);

.CreateCondBr(isEmpty, doneBB, bodyBB);

llvm::BasicBlock *entryBB =

.GetInsertBlock();

llvm::PHINode *elementPast =

.CreatePHI(begin->getType(), 2,

);

elementPast->addIncoming(end, entryBB);

llvm::Value *negativeOne = llvm::ConstantInt::get(

, -1,

);

llvmElementType, elementPast, negativeOne,

);

destroyer(*

,

(element, llvmElementType, elementAlign),

llvm::Value *done =

.CreateICmpEQ(element, begin,

);

.CreateCondBr(done, doneBB, bodyBB);

elementPast->addIncoming(element,

.GetInsertBlock());

llvm::Value *begin, llvm::Value *end,

arrayDepth = 0;

(!isa<VariableArrayType>(

))

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

, 0);

elemTy, begin, gepIndices,

);

elemTy, end, gepIndices,

);

llvm::Value *ArrayBegin;

llvm::Value *ArrayEnd;

CodeGenFunction::Destroyer *Destroyer;

RegularPartialArrayDestroy(llvm::Value *arrayBegin, llvm::Value *arrayEnd,

CodeGenFunction::Destroyer *destroyer)

: ArrayBegin(arrayBegin), ArrayEnd(arrayEnd),

ElementType(elementType), Destroyer(destroyer),

ElementAlign(elementAlign) {}

ElementType, ElementAlign, Destroyer);

llvm::Value *ArrayBegin;

CodeGenFunction::Destroyer *Destroyer;

IrregularPartialArrayDestroy(llvm::Value *arrayBegin,

CodeGenFunction::Destroyer *destroyer)

: ArrayBegin(arrayBegin), ArrayEndPointer(arrayEndPointer),

ElementType(elementType), Destroyer(destroyer),

ElementAlign(elementAlign) {}

ElementType, ElementAlign, Destroyer);

Destroyer *destroyer) {

pushFullExprCleanup<IrregularPartialArrayDestroy>(

elementAlign, destroyer);

llvm::Value *arrayEnd,

Destroyer *destroyer) {

pushFullExprCleanup<RegularPartialArrayDestroy>(

,

arrayBegin, arrayEnd,

elementType, elementAlign,

(LifetimeStartFn)

LifetimeStartFn;

LifetimeStartFn = llvm::Intrinsic::getOrInsertDeclaration(

LifetimeStartFn;

LifetimeEndFn;

LifetimeEndFn = llvm::Intrinsic::getOrInsertDeclaration(

LifetimeEndFn;

FakeUseFn = llvm::Intrinsic::getOrInsertDeclaration(

&

(), llvm::Intrinsic::fake_use);

ConsumeARCParameter(llvm::Value *param,

: Param(param), Precise(precise) {}

NoDebugInfo =

;

assert((isa<ParmVarDecl>(

) || isa<ImplicitParamDecl>(

)) &&

);

(!isa<llvm::GlobalValue>(Arg.getAnyValue()))

Arg.getAnyValue()->setName(

.getName());

(

IPD = dyn_cast<ImplicitParamDecl>(&

)) {

llvm::Value *

= Arg.isIndirect()

: Arg.getDirectValue();

DoStore =

;

UseIndirectDebugAddress =

;

(Arg.isIndirect()) {

DeclPtr = Arg.getIndirectAddress();

(UseIndirectDebugAddress) {

.getName() +

);

(SrcLangAS != DestLangAS) {

assert(

().getTargetAddressSpace(SrcLangAS) ==

*

,

, SrcLangAS, DestLangAS,

,

),

);

CalleeDestructedParamCleanups[cast<ParmVarDecl>(&

)] =

DeclPtr = OpenMPLocalAddr;

AllocaPtr = DeclPtr;

.getName() +

, &AllocaPtr);

llvm::Value *ArgVal = (DoStore ? Arg.getDirectValue() :

);

isConsumed =

.

<NSConsumedAttr>();

(

.isARCPseudoStrong()) {

);

assert(qs.

() &&

);

(Arg.isIndirect() && !ArgVal)

setAddrOfLocalVar(&

, DeclPtr);

&

== CXXABIThisDecl)) {

(

*Var = dyn_cast_or_null<ParmVarDecl>(&

))

(requiresReturnValueNullabilityCheck()) {

SanitizerScope SanScope(

);

RetValNullabilityPrecondition =

.CreateAnd(RetValNullabilityPrecondition,

.CreateIsNotNull(Arg.getAnyValue()));

(!LangOpts.OpenMP || (!LangOpts.EmitAllDecls && !

->

()))

(!LangOpts.OpenMP || LangOpts.OpenMPSimd ||

(!LangOpts.EmitAllDecls && !

->

()))

(

*

:

->varlist()) {

*DE = cast<DeclRefExpr>(

);

*VD = cast<VarDecl>(DE->getDecl());

(Entry->getType()->getAddressSpace() == TargetAS)

llvm::PointerType *PTy = llvm::PointerType::get(Ty, TargetAS);

llvm::GlobalVariable *DummyGV =

llvm::GlobalVariable(

(), Entry->getValueType(),

,

llvm::GlobalValue::CommonLinkage,

,

,

,

llvm::GlobalVariable::NotThreadLocal, Entry->getAddressSpace());

Entry->replaceAllUsesWith(DummyGV);

Entry->mutateType(PTy);

llvm::Constant *NewPtrForOldDecl =

llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(

Entry, DummyGV->getType());

DummyGV->replaceAllUsesWith(NewPtrForOldDecl);

DummyGV->eraseFromParent();

std::optional<CharUnits>

(

*AA = VD->

<OMPAllocateDeclAttr>()) {

(

*Alignment = AA->getAlignment()) {

UserAlign =

Alignment->EvaluateKnownConstInt(

()).getExtValue();

std::max<unsigned>(UserAlign, NaturalAlign.

()));

std::nullopt;

Defines the clang::ASTContext interface.

static void emitStoresForInitAfterBZero(CodeGenModule &CGM, llvm::Constant *Init, Address Loc, bool isVolatile, CGBuilderTy &Builder, bool IsAutoInit)

For inits that canEmitInitWithFewStoresAfterBZero returned true for, emit the scalar stores that woul...

static bool isCapturedBy(const VarDecl &, const Expr *)

Determines whether the given __block variable is potentially captured by the given expression.

static void emitPartialArrayDestroy(CodeGenFunction &CGF, llvm::Value *begin, llvm::Value *end, QualType type, CharUnits elementAlign, CodeGenFunction::Destroyer *destroyer)

Perform partial array destruction as if in an EH cleanup.

static void emitStoresForPatternInit(CodeGenModule &CGM, const VarDecl &D, Address Loc, bool isVolatile, CGBuilderTy &Builder)

static bool canEmitInitWithFewStoresAfterBZero(llvm::Constant *Init, unsigned &NumStores)

Decide whether we can emit the non-zero parts of the specified initializer with equal or fewer than N...

static llvm::Constant * patternOrZeroFor(CodeGenModule &CGM, IsPattern isPattern, llvm::Type *Ty)

Generate a constant filled with either a pattern or zeroes.

static llvm::Constant * constWithPadding(CodeGenModule &CGM, IsPattern isPattern, llvm::Constant *constant)

Replace all padding bytes in a given constant with either a pattern byte or 0x00.

static llvm::Value * shouldUseMemSetToInitialize(llvm::Constant *Init, uint64_t GlobalSize, const llvm::DataLayout &DL)

Decide whether we should use memset to initialize a local variable instead of using a memcpy from a c...

static std::string getStaticDeclName(CodeGenModule &CGM, const VarDecl &D)

static void emitStoresForConstant(CodeGenModule &CGM, const VarDecl &D, Address Loc, bool isVolatile, CGBuilderTy &Builder, llvm::Constant *constant, bool IsAutoInit)

static bool shouldSplitConstantStore(CodeGenModule &CGM, uint64_t GlobalByteSize)

Decide whether we want to split a constant structure or array store into a sequence of its fields' st...

static llvm::Constant * replaceUndef(CodeGenModule &CGM, IsPattern isPattern, llvm::Constant *constant)

static bool shouldExtendLifetime(const ASTContext &Context, const Decl *FuncDecl, const VarDecl &D, ImplicitParamDecl *CXXABIThisDecl)

static bool tryEmitARCCopyWeakInit(CodeGenFunction &CGF, const LValue &destLV, const Expr *init)

static bool shouldUseBZeroPlusStoresToInitialize(llvm::Constant *Init, uint64_t GlobalSize)

Decide whether we should use bzero plus some stores to initialize a local variable instead of using a...

static llvm::Constant * constStructWithPadding(CodeGenModule &CGM, IsPattern isPattern, llvm::StructType *STy, llvm::Constant *constant)

Helper function for constWithPadding() to deal with padding in structures.

static bool containsUndef(llvm::Constant *constant)

static uint64_t maxFakeUseAggregateSize(const ASTContext &C)

Return the maximum size of an aggregate for which we generate a fake use intrinsic when -fextend-vari...

static bool isAccessedBy(const VarDecl &var, const Stmt *s)

static void EmitAutoVarWithLifetime(CodeGenFunction &CGF, const VarDecl &var, Address addr, Qualifiers::ObjCLifetime lifetime)

EmitAutoVarWithLifetime - Does the setup required for an automatic variable with lifetime.

static Address createUnnamedGlobalForMemcpyFrom(CodeGenModule &CGM, const VarDecl &D, CGBuilderTy &Builder, llvm::Constant *Constant, CharUnits Align)

static void emitStoresForZeroInit(CodeGenModule &CGM, const VarDecl &D, Address Loc, bool isVolatile, CGBuilderTy &Builder)

static void drillIntoBlockVariable(CodeGenFunction &CGF, LValue &lvalue, const VarDecl *var)

CodeGenFunction::ComplexPairTy ComplexPairTy

This file defines OpenMP nodes for declarative directives.

static const RecordType * getRecordType(QualType QT)

Checks that the passed in QualType either is of RecordType or points to RecordType.

static const NamedDecl * getDefinition(const Decl *D)

__device__ __2f16 float __ockl_bool s

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

CharUnits getTypeAlignInChars(QualType T) const

Return the ABI-specified alignment of a (complete) type T, in characters.

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

const LangOptions & getLangOpts() const

QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const

getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...

CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const

Return a conservative estimate of the alignment of the specified decl D.

const ArrayType * getAsArrayType(QualType T) const

Type Query functions.

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

CharUnits getTypeSizeInChars(QualType T) const

Return the size of the specified (complete) type T, in characters.

const VariableArrayType * getAsVariableArrayType(QualType T) const

unsigned getTargetAddressSpace(LangAS AS) const

Represents an array type, per C99 6.7.5.2 - Array Declarators.

Represents a block literal declaration, which is like an unnamed FunctionDecl.

ArrayRef< Capture > captures() const

BlockExpr - Adaptor class for mixing a BlockDecl with expressions.

Represents a call to a C++ constructor.

Represents a C++ constructor within a class.

A use of a default initializer in a constructor or in aggregate initialization.

Represents a C++ destructor within a class.

CharUnits - This is an opaque type for sizes expressed in character units.

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 One()

One - Construct a CharUnits quantity of one.

CharUnits alignmentOfArrayElement(CharUnits elementSize) const

Given that this is the alignment of the first element of an array, return the minimum alignment of an...

bool isOne() const

isOne - Test whether the quantity equals one.

static CharUnits fromQuantity(QuantityType Quantity)

fromQuantity - Construct a CharUnits quantity from a raw integer type.

bool hasReducedDebugInfo() const

Check if type and variable info should be emitted.

ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...

bool getIndirectByVal() const

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

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

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

CharUnits getAlignment() const

llvm::Type * getElementType() const

Return the type of the values stored in this address.

Address withPointer(llvm::Value *NewPointer, KnownNonNull_t IsKnownNonNull) const

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

Address withElementType(llvm::Type *ElemTy) const

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

KnownNonNull_t isKnownNonNull() const

Whether the pointer is known not to be null.

static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)

static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)

Apply TemporaryLocation if it is valid.

static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)

Set the IRBuilder to not attach debug locations.

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

llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)

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

llvm::LoadInst * CreateFlagLoad(llvm::Value *Addr, const llvm::Twine &Name="")

Emit a load from an i1 flag variable.

llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)

Address CreateInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *ElementType, CharUnits Align, const Twine &Name="")

static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())

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

void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl)

Emit information about a global variable.

Param2DILocTy & getParamDbgMappings()

llvm::DILocalVariable * EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI, unsigned ArgNo, CGBuilderTy &Builder, bool UsePointerValue=false)

Emit call to llvm.dbg.declare for an argument variable declaration.

llvm::DILocalVariable * EmitDeclareOfAutoVariable(const VarDecl *Decl, llvm::Value *AI, CGBuilderTy &Builder, const bool UsePointerValue=false)

Emit call to llvm.dbg.declare for an automatic variable declaration.

void setLocation(SourceLocation Loc)

Update the current source location.

void registerVLASizeExpression(QualType Ty, llvm::Metadata *SizeExpr)

Register VLA size expression debug node with the qualified type.

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

const_arg_iterator arg_begin() const

MutableArrayRef< ArgInfo > arguments()

virtual void EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF, const VarDecl &D)

Emit the IR required for a work-group-local variable declaration, and add an entry to CGF's LocalDecl...

Allows to disable automatic handling of functions used in target regions as those marked as omp decla...

virtual void getKmpcFreeShared(CodeGenFunction &CGF, const std::pair< llvm::Value *, llvm::Value * > &AddrSizePair)

Get call to __kmpc_free_shared.

void emitUserDefinedMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)

Emit the function for the user defined mapper construct.

virtual void processRequiresDirective(const OMPRequiresDecl *D)

Perform check on requires decl to ensure that target architecture supports unified addressing.

virtual std::pair< llvm::Value *, llvm::Value * > getKmpcAllocShared(CodeGenFunction &CGF, const VarDecl *VD)

Get call to __kmpc_alloc_shared.

virtual void emitUserDefinedReduction(CodeGenFunction *CGF, const OMPDeclareReductionDecl *D)

Emit code for the specified user defined reduction construct.

virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD)

Gets the OpenMP-specific address of the local variable.

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 emitAutoVarTypeCleanup(const AutoVarEmission &emission, QualType::DestructionKind dtorKind)

void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags, bool LoadBlockVarAddr, bool CanThrow)

Enter a cleanup to destroy a __block variable.

llvm::Value * EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr)

static TypeEvaluationKind getEvaluationKind(QualType T)

getEvaluationKind - Return the TypeEvaluationKind of QualType T.

static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)

ContainsLabel - Return true if the statement contains a label in it.

static Destroyer destroyNonTrivialCStruct

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.

RawAddress createCleanupActiveFlag()

llvm::DenseMap< const VarDecl *, llvm::Value * > NRVOFlags

A mapping from NRVO variables to the flags used to indicate when the NRVO has been applied to this va...

void EmitARCMoveWeak(Address dst, Address src)

void EmitAutoVarDecl(const VarDecl &D)

EmitAutoVarDecl - Emit an auto variable declaration.

void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr)

void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)

EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...

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

static bool hasScalarEvaluationKind(QualType T)

const BlockByrefInfo & getBlockByrefInfo(const VarDecl *var)

void EmitDecl(const Decl &D)

EmitDecl - Emit a declaration.

void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, Address arrayEndPointer, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)

RawAddress CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")

CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...

llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)

emitArrayLength - Compute the length of an array, even if it's a VLA, and drill down to the base elem...

VlaSizePair getVLASize(const VariableArrayType *vla)

Returns an LLVM value that corresponds to the size, in non-variably-sized elements,...

CleanupKind getARCCleanupKind()

Retrieves the default cleanup kind for an ARC cleanup.

bool CurFuncIsThunk

In C++, whether we are code generating a thunk.

void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This, QualType ThisTy)

LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)

EmitLValue - Emit code to compute a designator that specifies the location of the expression.

void EmitExtendGCLifetime(llvm::Value *object)

EmitExtendGCLifetime - Given a pointer to an Objective-C object, make sure it survives garbage collec...

llvm::SmallVector< DeferredDeactivateCleanup > DeferredDeactivationCleanupStack

llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)

void EmitVariablyModifiedType(QualType Ty)

EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...

llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)

createBasicBlock - Create an LLVM basic block.

const LangOptions & getLangOpts() const

llvm::Constant * EmitCheckTypeDescriptor(QualType T)

Emit a description of a type in a format suitable for passing to a runtime sanitizer handler.

void pushEHDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)

void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, QualType elementType, CharUnits elementAlign, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup)

void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)

EmitBlock - Emit the given block.

void pushDestroyAndDeferDeactivation(QualType::DestructionKind dtorKind, Address addr, QualType type)

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

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)

ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal=false, bool IgnoreImag=false)

EmitComplexExpr - Emit the computation of the specified expression of complex type,...

@ TCK_NonnullAssign

Checking the value assigned to a _Nonnull pointer. Must not be null.

llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)

llvm::Type * ConvertTypeForMem(QualType T)

llvm::Value * EmitARCUnsafeUnretainedScalarExpr(const Expr *expr)

const Decl * CurCodeDecl

CurCodeDecl - This is the inner-most code context, which includes blocks.

void EmitAutoVarInit(const AutoVarEmission &emission)

void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)

DominatingValue< T >::saved_type saveValueInCond(T value)

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 EmitStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)

static Destroyer destroyCXXObject

void EmitVarAnnotations(const VarDecl *D, llvm::Value *V)

Emit local annotations for the local variable V, declared by D.

Destroyer * getDestroyer(QualType::DestructionKind destructionKind)

void EmitAtomicInit(Expr *E, LValue lvalue)

const TargetInfo & getTarget() const

bool isInConditionalBranch() const

isInConditionalBranch - Return true if we're currently emitting one branch or the other of a conditio...

void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)

void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)

Emit code in this function to perform a guarded variable initialization.

void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)

void initFullExprCleanupWithFlag(RawAddress ActiveFlag)

void EmitARCCopyWeak(Address dst, Address src)

void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerKind::SanitizerOrdinal > > Checked, SanitizerHandler Check, ArrayRef< llvm::Constant * > StaticArgs, ArrayRef< llvm::Value * > DynamicArgs)

Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...

void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, llvm::Value *ptr)

void defaultInitNonTrivialCStructVar(LValue Dst)

bool HaveInsertPoint() const

HaveInsertPoint - True if an insertion point is defined.

llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)

Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...

bool isTrivialInitializer(const Expr *Init)

Determine whether the given initializer is trivial in the sense that it requires no code to be genera...

CGDebugInfo * getDebugInfo()

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)

AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *FD)

Determine whether a field initialization may overlap some other object.

llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)

const TargetCodeGenInfo & getTargetHooks() const

RValue EmitReferenceBindingToExpr(const Expr *E)

Emits a reference binding to the passed in expression.

void EmitAggExpr(const Expr *E, AggValueSlot AS)

EmitAggExpr - Emit the computation of the specified expression of aggregate type.

void EmitFakeUse(Address Addr)

VlaSizePair getVLAElements1D(const VariableArrayType *vla)

Return the number of elements for a single dimension for the given array type.

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,...

void EmitVarDecl(const VarDecl &D)

EmitVarDecl - Emit a local variable declaration.

ASTContext & getContext() const

llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)

EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...

void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc)

Given an assignment *LHS = RHS, emit a test that checks if RHS is nonnull, if LHS is marked _Nonnull.

void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)

const Decl * CurFuncDecl

CurFuncDecl - Holds the Decl for the current outermost non-closure context.

AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)

void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)

Address ReturnValuePointer

ReturnValuePointer - The temporary alloca to hold a pointer to sret.

void EmitAutoVarCleanups(const AutoVarEmission &emission)

llvm::GlobalVariable * AddInitializerToStaticVarDecl(const VarDecl &D, llvm::GlobalVariable *GV)

AddInitializerToStaticVarDecl - Add the initializer for 'D' to the global variable that has already b...

void PopCleanupBlock(bool FallThroughIsBranchThrough=false, bool ForDeactivation=false)

PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.

static Destroyer destroyARCWeak

bool needsEHCleanup(QualType::DestructionKind kind)

Determines whether an EH cleanup is required to destroy a type with the given destruction kind.

CleanupKind getCleanupKind(QualType::DestructionKind kind)

llvm::Type * ConvertType(QualType T)

void EmitARCInitWeak(Address addr, llvm::Value *value)

static Destroyer destroyARCStrongPrecise

VarBypassDetector Bypasses

llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)

void pushStackRestore(CleanupKind kind, Address SPMem)

LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)

void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)

EmitStoreOfComplex - Store a complex number into the specified l-value.

const CGFunctionInfo * CurFnInfo

void pushKmpcAllocFree(CleanupKind Kind, std::pair< llvm::Value *, llvm::Value * > AddrSizePair)

void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo)

EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

static Destroyer destroyARCStrongImprecise

void EnsureInsertPoint()

EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.

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 EmitAndRegisterVariableArrayDimensions(CGDebugInfo *DI, const VarDecl &D, bool EmitDebugInfo)

Emits the alloca and debug information for the size expressions for each dimension of an array.

llvm::Value * EmitARCRetainScalarExpr(const Expr *expr)

void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)

void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)

EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...

bool hasLabelBeenSeenInCurrentScope() const

Return true if a label was seen in the current scope.

This class organizes the cross-function state that is used while generating LLVM code.

StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD)

void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const

Set visibility, dllimport/dllexport and dso_local.

llvm::Module & getModule() const

void setStaticLocalDeclAddress(const VarDecl *D, llvm::Constant *C)

llvm::Function * getLLVMLifetimeStartFn()

Lazily declare the @llvm.lifetime.start intrinsic.

llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)

Return the address of the given function.

Address createUnnamedGlobalFrom(const VarDecl &D, llvm::Constant *Constant, CharUnits Align)

llvm::Constant * getNullPointer(llvm::PointerType *T, QualType QT)

Get target specific null pointer.

void ErrorUnsupported(const Stmt *S, const char *Type)

Print out an error that codegen doesn't support the specified stmt yet.

const LangOptions & getLangOpts() const

CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)

CodeGenTypes & getTypes()

CGOpenCLRuntime & getOpenCLRuntime()

Return a reference to the configured OpenCL runtime.

llvm::Function * getLLVMFakeUseFn()

Lazily declare the @llvm.fake.use intrinsic.

void addUsedGlobal(llvm::GlobalValue *GV)

Add a global to a list to be added to the llvm.used metadata.

void EmitOMPAllocateDecl(const OMPAllocateDecl *D)

Emit a code for the allocate directive.

llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD)

Returns LLVM linkage for a declarator.

const llvm::DataLayout & getDataLayout() const

void addUsedOrCompilerUsedGlobal(llvm::GlobalValue *GV)

Add a global to a list to be added to the llvm.compiler.used metadata.

CGOpenMPRuntime & getOpenMPRuntime()

Return a reference to the configured OpenMP runtime.

SanitizerMetadata * getSanitizerMetadata()

llvm::Constant * getOrCreateStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)

llvm::Constant * GetAddrOfGlobal(GlobalDecl GD, ForDefinition_t IsForDefinition=NotForDefinition)

void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV)

Add global annotations that are set on D, for the global GV.

void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const

Set the TLS mode for the given LLVM GlobalValue for the thread-local variable declaration D.

ASTContext & getContext() const

void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)

Emit a code for declare mapper construct.

llvm::Function * getLLVMLifetimeEndFn()

Lazily declare the @llvm.lifetime.end intrinsic.

bool supportsCOMDAT() const

void EmitOMPRequiresDecl(const OMPRequiresDecl *D)

Emit a code for requires directive.

const TargetCodeGenInfo & getTargetCodeGenInfo()

const CodeGenOptions & getCodeGenOpts() const

StringRef getMangledName(GlobalDecl GD)

std::optional< CharUnits > getOMPAllocateAlignment(const VarDecl *VD)

Return the alignment specified in an allocate directive, if present.

llvm::LLVMContext & getLLVMContext()

llvm::GlobalValue * GetGlobalValue(StringRef Ref)

void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF=nullptr)

Emit a code for declare reduction construct.

llvm::Constant * EmitNullConstant(QualType T)

Return the result of value-initializing the given type, i.e.

LangAS GetGlobalConstantAddressSpace() const

Return the AST address space of constant literal, which is used to emit the constant literal as globa...

LangAS GetGlobalVarAddressSpace(const VarDecl *D)

Return the AST address space of the underlying global variable for D, as determined by its declaratio...

llvm::ConstantInt * getSize(CharUnits numChars)

Emit the given number of characters as a value of type size_t.

void markStmtMaybeUsed(const Stmt *S)

llvm::Type * convertTypeForLoadStore(QualType T, llvm::Type *LLVMTy=nullptr)

Given that T is a scalar type, return the IR type that should be used for load and store operations.

llvm::Type * ConvertTypeForMem(QualType T)

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

bool typeRequiresSplitIntoByteArray(QualType ASTTy, llvm::Type *LLVMTy=nullptr)

Check whether the given type needs to be laid out in memory using an opaque byte-array type because i...

const CGFunctionInfo & arrangeFunctionDeclaration(const FunctionDecl *FD)

Free functions are functions that are compatible with an ordinary C function pointer type.

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

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

A cleanup scope which generates the cleanup blocks lazily.

Information for lazily generating a cleanup.

ConditionalCleanup stores the saved form of its parameters, then restores them and performs the clean...

stable_iterator stable_begin() const

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

iterator begin() const

Returns an iterator pointing to the innermost EH scope.

LValue - This represents an lvalue references.

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

Address getAddress() const

void setNonGC(bool Value)

void setAddress(Address address)

Qualifiers::ObjCLifetime getObjCLifetime() 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

static RawAddress invalid()

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

Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const

virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const

setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...

bool IsBypassed(const VarDecl *D) const

Returns true if the variable declaration was by bypassed by any goto or switch statement.

CompoundStmt - This represents a group of statements like { stmt stmt }.

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

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

Decl - This represents one declaration (or definition), e.g.

const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const

If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...

bool isImplicit() const

isImplicit - Indicates whether the declaration was implicitly generated by the implementation.

Decl * getNonClosureContext()

Find the innermost non-closure ancestor of this declaration, walking up through blocks,...

SourceLocation getLocation() const

bool isUsed(bool CheckUsedAttr=true) const

Whether any (re-)declaration of the entity was used, meaning that a definition is required.

DeclContext * getDeclContext()

This represents one expression.

Expr * IgnoreParenCasts() LLVM_READONLY

Skip past any parentheses and casts which might surround this expression until reaching a fixed point...

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

bool isLValue() const

isLValue - True if this expression is an "l-value" according to the rules of the current language.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

Represents a function declaration or definition.

GlobalDecl - represents a global declaration.

const Decl * getDecl() const

One of these records is kept for each identifier that is lexed.

IdentifierInfo & getOwn(StringRef Name)

Gets an IdentifierInfo for the given name without consulting external sources.

This represents '#pragma omp allocate ...' directive.

This represents '#pragma omp declare mapper ...' directive.

This represents '#pragma omp declare reduction ...' directive.

This represents '#pragma omp requires...' directive.

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

@ DK_objc_strong_lifetime

@ PDIK_Struct

The type is a struct containing a field whose type is not PCK_Trivial.

LangAS getAddressSpace() const

Return the address space of this type.

bool isConstant(const ASTContext &Ctx) const

Qualifiers getQualifiers() const

Retrieve the set of qualifiers applied to this type.

Qualifiers::ObjCLifetime getObjCLifetime() const

Returns lifetime attribute of this type.

QualType getNonReferenceType() const

If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...

QualType getUnqualifiedType() const

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)

bool isPODType(const ASTContext &Context) const

Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).

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

bool isParamDestroyedInCallee() const

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

RecordDecl * getDecl() const

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

static const uint64_t MaximumAlignment

Encodes a location in the source.

StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).

Stmt - This represents one statement.

bool isMicrosoft() const

Is this ABI an MSVC-compatible ABI?

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

bool isConstantSizeType() const

Return true if this is not a variable sized type, according to the rules of C99 6....

const T * castAs() const

Member-template castAs<specific type>.

bool isVariablyModifiedType() const

Whether this type is a variably-modified type (C99 6.7.5).

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

std::optional< NullabilityKind > getNullability() const

Determine the nullability of the given type.

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)

bool hasGlobalStorage() const

Returns true for all variables that do not have local storage.

const Expr * getInit() const

bool isLocalVarDecl() const

Returns true for local variable declarations other than parameters.

Defines the clang::TargetInfo interface.

@ Decl

The l-value was an access to a declared entity or something equivalently strong, like the address of ...

llvm::Constant * initializationPatternFor(CodeGenModule &, llvm::Type *)

@ 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...

ARCPreciseLifetime_t

Does an ARC strong l-value have precise lifetime?

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

const AstTypeMatcher< ArrayType > arrayType

Matches all kinds of arrays.

const internal::VariadicAllOfMatcher< Decl > decl

Matches declarations.

const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr

Matches any cast nodes of Clang's AST.

constexpr Variable var(Literal L)

Returns the variable of L.

tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")

Clean up any erroneous/redundant code in the given Ranges in Code.

bool Null(InterpState &S, CodePtr OpPC, uint64_t Value, const Descriptor *Desc)

bool Zero(InterpState &S, CodePtr OpPC)

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

@ Ctor_Base

Base object ctor.

@ NonNull

Values of this type can never be null.

Linkage

Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.

@ SD_Automatic

Automatic storage duration (most local variables).

@ Dtor_Base

Base object dtor.

@ Dtor_Complete

Complete object dtor.

LangAS

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

@ VK_LValue

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

const FunctionProtoType * T

@ ThreadPrivateVar

Parameter for Thread private variable.

float __ovld __cnfn length(float)

Return the length of vector p, i.e., sqrt(p.x2 + p.y 2 + ...)

static Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD)

Gets the OpenMP-specific address of the local variable /p VD.

llvm::IntegerType * Int64Ty

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * SizeTy

llvm::IntegerType * IntPtrTy

llvm::PointerType * Int8PtrTy

llvm::PointerType * AllocaInt8PtrTy

LangAS getASTAllocaAddressSpace() const

A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function.

bool has(SanitizerMask K) const

Check if a certain (single) sanitizer is enabled.

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