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

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

clang: lib/CodeGen/CGExpr.cpp Source File

;

CodeGen;

, llvm::cl::Optional,

llvm::cl::desc(

));

CodeGenFunction::CreateTempAllocaWithoutCast(llvm::Type *Ty,

Align,

llvm::Value *ArraySize) {

llvm::Value *ArraySize,

*AllocaAddr = Alloca;

llvm::Value *

= Alloca.getPointer();

llvm::IRBuilderBase::InsertPointGuard IPG(

);

.getPtrTy(DestAddrSpace),

);

llvm::Value *ArraySize) {

llvm::AllocaInst *Alloca;

Alloca =

.CreateAlloca(Ty, ArraySize, Name);

Allocas->Add(Alloca);

*ArrayTy = cast<llvm::ArrayType>(

.getElementType());

*VectorTy = llvm::FixedVectorType::get(ArrayTy->getElementType(),

ArrayTy->getNumElements());

CGFPOptionsRAII FPOptsRAII(*

,

);

(

*CondOp = dyn_cast<AbstractConditionalOperator>(

(!ignoreResult && aggSlot.

())

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

Precise = isa_and_nonnull<VarDecl>(VD) &&

VD->

<ObjCPreciseLifetimeAttr>();

llvm_unreachable(

);

llvm_unreachable(

);

*ClassDecl = cast<CXXRecordDecl>(RT->getDecl());

(!ClassDecl->hasTrivialDestructor())

ReferenceTemporaryDtor = ClassDecl->getDestructor();

(!ReferenceTemporaryDtor)

llvm::FunctionCallee CleanupFn;

llvm::Constant *CleanupArg;

ReferenceTemporary,

->

(),

CleanupArg = llvm::Constant::getNullValue(CGF.

);

CleanupArg = cast<llvm::Constant>(ReferenceTemporary.

(CGF));

ReferenceTemporary,

->

(),

llvm_unreachable(

);

*GV =

llvm::GlobalVariable(

llvm::GlobalValue::PrivateLinkage,

,

,

,

llvm::GlobalValue::NotThreadLocal,

llvm::Constant *

= GV;

= TCG.performAddrSpaceCast(

llvm::PointerType::get(

(

, GV->getValueType(), alignment);

llvm_unreachable(

);

llvm_unreachable(

);

);

(

*Var = dyn_cast<llvm::GlobalVariable>(

.getPointer())) {

(Var->hasInitializer())

: llvm_unreachable(

);

(

&Ignored : CommaLHSs)

(

*opaque = dyn_cast<OpaqueValueExpr>(

)) {

(opaque->getType()->isRecordType()) {

assert(Adjustments.empty());

(

*Var = dyn_cast<llvm::GlobalVariable>(

.getPointer()->stripPointerCasts())) {

(!Var->hasInitializer()) {

(!ShouldEmitLifetimeMarkers)

ConditionalEvaluation *OldConditional =

;

CGBuilderTy::InsertPoint OldIP;

((!

.

(SanitizerKind::HWAddress) &&

OldConditional = OutermostConditional;

OutermostConditional =

;

llvm::BasicBlock *

= OldConditional->getStartingBlock();

.restoreIP(CGBuilderTy::InsertPoint(

, llvm::BasicBlock::iterator(

->back())));

(OldConditional) {

OutermostConditional = OldConditional;

(Adjustment.Kind) {

Adjustment.DerivedToBase.BasePath->path_begin(),

Adjustment.DerivedToBase.BasePath->path_end(),

);

llvm::Constant *Elts) {

cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx))

Builder.CreateMul(Ptr, Builder.getInt64(0xbf58476d1ce4e5b9u));

Builder.CreateXor(A0, Builder.CreateLShr(A0, Builder.getInt64(31)));

Builder.CreateXor(Acc, A1);

llvm::Value *ArraySize) {

(Ptr->getType()->getPointerAddressSpace())

SanitizerScope SanScope(

);

llvm::BasicBlock *Done =

;

PtrToAlloca = dyn_cast<llvm::AllocaInst>(Ptr->stripPointerCasts());

IsGuaranteedNonNull =

SkippedChecks.

(SanitizerKind::Null) || PtrToAlloca;

((

.

(SanitizerKind::Null) || AllowNullPointers) &&

!IsGuaranteedNonNull) {

(!IsGuaranteedNonNull) {

(AllowNullPointers) {

.CreateCondBr(IsNonNull, Rest, Done);

Checks.push_back(std::make_pair(IsNonNull, SanitizerKind::SO_Null));

(

.

(SanitizerKind::ObjectSize) &&

!SkippedChecks.

(SanitizerKind::ObjectSize) &&

llvm::Value *

= llvm::ConstantInt::get(

, TySize);

llvm::Constant *ConstantSize = dyn_cast<llvm::Constant>(Size);

(!ConstantSize || !ConstantSize->isNullValue()) {

llvm::Function *F =

.

(llvm::Intrinsic::objectsize, Tys);

llvm::Value *NullIsUnknown =

.getFalse();

llvm::Value *LargeEnough =

.CreateICmpUGE(

.CreateCall(F, {Ptr, Min, NullIsUnknown, Dynamic}), Size);

std::make_pair(LargeEnough, SanitizerKind::SO_ObjectSize));

llvm::MaybeAlign AlignVal;

llvm::Value *PtrAsInt =

;

(

.

(SanitizerKind::Alignment) &&

!SkippedChecks.

(SanitizerKind::Alignment)) {

(AlignVal && *AlignVal > llvm::Align(1) &&

(!PtrToAlloca || PtrToAlloca->getAlign() < *AlignVal)) {

llvm::Value *Align =

.CreateAnd(

PtrAsInt, llvm::ConstantInt::get(

, AlignVal->value() - 1));

llvm::Value *Aligned =

(Aligned !=

)

Checks.push_back(std::make_pair(Aligned, SanitizerKind::SO_Alignment));

(Checks.size() > 0) {

llvm::Constant *StaticData[] = {

llvm::ConstantInt::get(

, AlignVal ? llvm::Log2(*AlignVal) : 1),

llvm::ConstantInt::get(

, TCK)};

(Checks, SanitizerHandler::TypeMismatch, StaticData,

PtrAsInt ? PtrAsInt : Ptr);

(!IsGuaranteedNonNull) {

.CreateCondBr(IsNonNull, VptrNotNull, Done);

llvm::raw_svector_ostream Out(MangledName);

llvm::Value *TypeHash =

llvm::ConstantInt::get(

, xxh3_64bits(Out.str()));

llvm::Type *VPtrTy = llvm::PointerType::get(

, 0);

CacheSize = 128;

llvm::Type *HashTable = llvm::ArrayType::get(

, CacheSize);

);

llvm::Value *Slot =

.CreateAnd(Hash,

llvm::Value *Indices[] = {

.getInt32(0), Slot };

llvm::Value *EqualHash =

.CreateICmpEQ(CacheVal, Hash);

llvm::Constant *StaticData[] = {

llvm::ConstantInt::get(

, TCK)

llvm::Value *DynamicData[] = { Ptr, Hash };

(std::make_pair(EqualHash, SanitizerKind::SO_Vptr),

SanitizerHandler::DynamicTypeCacheMiss, StaticData,

EltSize =

.getTypeSizeInChars(EltTy).getQuantity();

*ParamDecl = dyn_cast<ParmVarDecl>(ArrayDeclRef->getDecl());

*POSAttr = ParamDecl->getAttr<PassObjectSizeAttr>();

POSType = POSAttr->getType();

(POSType != 0 && POSType != 1)

PassedSizeIt = SizeArguments.find(ParamDecl);

(PassedSizeIt == SizeArguments.end())

assert(LocalDeclMap.count(PassedSizeDecl) &&

);

AddrOfSize = LocalDeclMap.find(PassedSizeDecl)->second;

llvm::Value *SizeOfElement =

llvm::ConstantInt::get(SizeInBytes->getType(), EltSize);

.CreateUDiv(SizeInBytes, SizeOfElement);

StrictFlexArraysLevel) {

IndexedType =

->getType();

CGF.

.getInt32(VT->getNumElements());

(

*CE = dyn_cast<CastExpr>(

)) {

(CE->getCastKind() == CK_ArrayToPointerDecay &&

!CE->getSubExpr()->isFlexibleArrayMemberLike(CGF.

(),

StrictFlexArraysLevel)) {

CodeGenFunction::SanitizerScope SanScope(&CGF);

IndexedType = CE->getSubExpr()->getType();

(

*CAT = dyn_cast<ConstantArrayType>(AT))

CGF.

.getInt(CAT->getSize());

(

*VAT = dyn_cast<VariableArrayType>(AT))

CodeGenFunction::SanitizerScope SanScope(&CGF);

EltTy{

->getType()->getPointeeOrArrayElementType(), 0};

IndexedType =

->getType();

StructAccessBase

IsExpectedRecordDecl(

*

)

{

StructAccessBase(

*ExpectedRD) : ExpectedRD(ExpectedRD) {}

*VisitStmt(

*S) {

; }

IsExpectedRecordDecl(

) ?

:

;

(IsExpectedRecordDecl(

) &&

->isArrow())

*Res = Visit(

->getBase());

!Res && IsExpectedRecordDecl(

) ?

: Res;

IsExpectedRecordDecl(

) ?

:

;

IsExpectedRecordDecl(

) ?

:

;

(IsExpectedRecordDecl(

))

Visit(

->getBase());

(

->getCastKind() == CK_LValueToRValue)

IsExpectedRecordDecl(

) ?

:

;

Visit(

->getSubExpr());

Visit(

->getSubExpr());

Visit(

->getSubExpr());

Visit(

->getSubExpr());

int64_t FieldNo = -1;

Indices.emplace_back(CGF.

.getInt32(FieldNo));

Indices.emplace_back(CGF.

.getInt32(FieldNo));

*StructBase = StructAccessBase(RD).Visit(

);

llvm::Value *Res =

;

}

(StructBase->

()) {

(Indices.empty())

Indices.push_back(

.getInt32(0));

(llvm::reverse(Indices)),

);

llvm::Value *Index,

IndexType,

assert(

.

(SanitizerKind::ArrayBounds) &&

);

llvm::Value *Bound =

IndexedType,

Accessed) {

SanitizerScope SanScope(

);

llvm::Value *IndexVal =

.CreateIntCast(Index,

, IndexSigned);

llvm::Value *BoundVal =

.CreateIntCast(Bound,

,

);

llvm::Constant *StaticData[] = {

llvm::Value *Check = Accessed ?

.CreateICmpULT(IndexVal, BoundVal)

:

.CreateICmpULE(IndexVal, BoundVal);

(std::make_pair(Check, SanitizerKind::SO_ArrayBounds),

SanitizerHandler::OutOfBounds, StaticData, Index);

isInc,

isPre) {

llvm::Value *NextVal;

(isa<llvm::IntegerType>(InVal.first->getType())) {

AmountVal = isInc ? 1 : -1;

NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal,

);

NextVal =

.CreateAdd(InVal.first, NextVal, isInc ?

:

);

llvm::APFloat FVal(

().getFloatTypeSemantics(ElemTy), 1);

NextVal =

.CreateFAdd(InVal.first, NextVal, isInc ?

:

);

isPre ? IncVal : InVal;

DI->EmitExplicitCastType(

->

());

(

*CE = dyn_cast<CastExpr>(

)) {

(

*ECE = dyn_cast<ExplicitCastExpr>(CE))

(CE->getCastKind()) {

CK_AddressSpaceConversion:

(

PtrTy = CE->getSubExpr()->getType()->getAs<

>()) {

(PtrTy->getPointeeType()->isVoidType())

CE->getSubExpr(), &InnerBaseInfo, &InnerTBAAInfo, IsKnownNonNull);

(BaseInfo) *BaseInfo = InnerBaseInfo;

(TBAAInfo) *TBAAInfo = InnerTBAAInfo;

(isa<ExplicitCastExpr>(CE)) {

->

(), &TargetTypeBaseInfo, &TargetTypeTBAAInfo);

(CGF.

.

(SanitizerKind::CFIUnrelatedCast) &&

CE->getCastKind() == CK_BitCast) {

llvm::Type *ElemTy =

(CE->getCastKind() == CK_AddressSpaceConversion)

CK_ArrayToPointerDecay:

CK_UncheckedDerivedToBase:

CK_DerivedToBase: {

CE->getSubExpr(), BaseInfo,

,

CE->getCastKind() == CK_UncheckedDerivedToBase));

Derived = CE->getSubExpr()->

()->getPointeeCXXRecordDecl();

Addr, Derived, CE->path_begin(), CE->path_end(),

(UO->getOpcode() == UO_AddrOf) {

(

*

= dyn_cast<CallExpr>(

)) {

(

->getBuiltinCallee()) {

Builtin::BIaddressof:

Builtin::BI__addressof:

Builtin::BI__builtin_addressof: {

, BaseInfo, TBAAInfo, IsKnownNonNull);

.CreateICmpNE(

, llvm::Constant::getNullValue(

->getType()));

llvm::Value *

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

llvm_unreachable(

);

(!isa<CXXThisExpr>(

)) {

(isa<CXXDynamicCastExpr>(

))

(

*CE = dyn_cast<CastExpr>(

)) {

= CE->getSubExpr();

}

(

*PE = dyn_cast<ParenExpr>(

)) {

= PE->getSubExpr();

}

(

*UO = dyn_cast<UnaryOperator>(

)) {

(UO->getOpcode() == UO_Extension)

= UO->getSubExpr();

(

.

(SanitizerKind::ArrayBounds) && isa<ArraySubscriptExpr>(

))

(

*ME = dyn_cast<MemberExpr>(

)) {

SkippedChecks.

(SanitizerKind::Alignment,

);

(IsBaseCXXThis || isa<DeclRefExpr>(ME->getBase()))

SkippedChecks.

(SanitizerKind::Null,

);

->

(), [&] { LV = EmitLValueHelper(E, IsKnownNonNull); });

(isa<OpaqueValueExpr>(SE))

cast<CallExpr>(SE)->getCallReturnType(Ctx)->

();

CodeGenFunction::EmitLValueHelper(

*

,

Expr::ObjCPropertyRefExprClass:

llvm_unreachable(

);

Expr::ObjCSelectorExprClass:

Expr::ObjCIsaExprClass:

Expr::BinaryOperatorClass:

Expr::CompoundAssignOperatorClass: {

Ty = AT->getValueType();

Expr::CallExprClass:

Expr::CXXMemberCallExprClass:

Expr::CXXOperatorCallExprClass:

Expr::UserDefinedLiteralClass:

Expr::CXXRewrittenBinaryOperatorClass:

(cast<CXXRewrittenBinaryOperator>(

)->getSemanticForm(),

Expr::VAArgExprClass:

Expr::DeclRefExprClass:

Expr::ConstantExprClass: {

(cast<ConstantExpr>(

)->getSubExpr(), IsKnownNonNull);

Expr::ParenExprClass:

(cast<ParenExpr>(

)->getSubExpr(), IsKnownNonNull);

Expr::GenericSelectionExprClass:

(cast<GenericSelectionExpr>(

)->getResultExpr(),

Expr::PredefinedExprClass:

Expr::StringLiteralClass:

Expr::ObjCEncodeExprClass:

Expr::PseudoObjectExprClass:

Expr::InitListExprClass:

Expr::CXXTemporaryObjectExprClass:

Expr::CXXConstructExprClass:

Expr::CXXBindTemporaryExprClass:

Expr::CXXUuidofExprClass:

Expr::LambdaExprClass:

Expr::ExprWithCleanupsClass: {

*cleanups = cast<ExprWithCleanups>(

);

RunCleanupsScope

(*

);

.ForceCleanup({&

});

Expr::CXXDefaultArgExprClass: {

*DAE = cast<CXXDefaultArgExpr>(

);

CXXDefaultArgExprScope

(*

, DAE);

(DAE->getExpr(), IsKnownNonNull);

Expr::CXXDefaultInitExprClass: {

*DIE = cast<CXXDefaultInitExpr>(

);

CXXDefaultInitExprScope

(*

, DIE);

(DIE->getExpr(), IsKnownNonNull);

Expr::CXXTypeidExprClass:

Expr::ObjCMessageExprClass:

Expr::ObjCIvarRefExprClass:

Expr::StmtExprClass:

Expr::UnaryOperatorClass:

Expr::ArraySubscriptExprClass:

Expr::MatrixSubscriptExprClass:

Expr::ArraySectionExprClass:

Expr::ExtVectorElementExprClass:

Expr::CXXThisExprClass:

Expr::MemberExprClass:

Expr::CompoundLiteralExprClass:

Expr::ConditionalOperatorClass:

Expr::BinaryConditionalOperatorClass:

Expr::ChooseExprClass:

(cast<ChooseExpr>(

)->getChosenSubExpr(), IsKnownNonNull);

Expr::OpaqueValueExprClass:

Expr::SubstNonTypeTemplateParmExprClass:

(cast<SubstNonTypeTemplateParmExpr>(

)->getReplacement(),

Expr::ImplicitCastExprClass:

Expr::CStyleCastExprClass:

Expr::CXXFunctionalCastExprClass:

Expr::CXXStaticCastExprClass:

Expr::CXXDynamicCastExprClass:

Expr::CXXReinterpretCastExprClass:

Expr::CXXConstCastExprClass:

Expr::CXXAddrspaceCastExprClass:

Expr::ObjCBridgedCastExprClass:

Expr::MaterializeTemporaryExprClass:

Expr::CoawaitExprClass:

Expr::CoyieldExprClass:

Expr::PackIndexingExprClass:

(cast<PackIndexingExpr>(

)->getSelectedExpr());

Expr::HLSLOutArgExprClass:

llvm_unreachable(

);

assert(

.isCanonical());

assert(!

->isReferenceType());

(

*RT = dyn_cast<RecordType>(

))

(

*RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))

(RD->hasMutableFields() || !RD->isTrivial())

(

*ref = dyn_cast<ReferenceType>(

)) {

CodeGenFunction::ConstantEmission

(isa<ParmVarDecl>(value)) {

}

(

*var = dyn_cast<VarDecl>(value)) {

}

(isa<EnumConstantDecl>(value)) {

(CEK ==

)

ConstantEmission();

resultIsReference;

resultIsReference =

;

resultType = refExpr->

();

resultIsReference =

;

resultType = value->

();

ConstantEmission();

ConstantEmission();

*MD = dyn_cast_or_null<CXXMethodDecl>(

);

(

(MD) && MD->getOverloadedOperator() == OO_Call) {

(

*VD = dyn_cast<const VarDecl>(

)) {

(!VD->hasAttr<CUDADeviceAttr>()) {

ConstantEmission();

result.

, resultType);

(isa<VarDecl>(value)) {

(!

().DeclMustBeEmitted(cast<VarDecl>(value)))

assert(isa<EnumConstantDecl>(value));

(resultIsReference)

CodeGenFunction::ConstantEmission

ConstantEmission();

CodeGenFunction::ConstantEmission &Constant,

*

) {

assert(Constant &&

);

(Constant.isReference())

Constant.getValue();

ET->getDecl()->getIntegerType()->isBooleanType();

llvm::APInt &

, llvm::APInt &End,

StrictEnums,

IsBool) {

IsRegularCPlusPlusEnum = CGF.

().CPlusPlus && StrictEnums &&

(!IsBool && !IsRegularCPlusPlusEnum)

llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(

Ty) {

llvm::APInt

, End;

MDHelper.createRange(

, End);

HasBoolCheck =

.

(SanitizerKind::Bool);

HasEnumCheck =

.

(SanitizerKind::Enum);

(!HasBoolCheck && !HasEnumCheck)

NeedsBoolCheck = HasBoolCheck && IsBool;

NeedsEnumCheck = HasEnumCheck && Ty->

<

>();

(!NeedsBoolCheck && !NeedsEnumCheck)

cast<llvm::IntegerType>(

->

())->getBitWidth() == 1)

(NeedsEnumCheck &&

llvm::APInt

, End;

SanitizerScope SanScope(

);

Check =

.CreateICmpULE(

, llvm::ConstantInt::get(Ctx, End));

llvm::Value *Upper =

.CreateICmpSLE(

, llvm::ConstantInt::get(Ctx, End));

llvm::Value *Lower =

Check =

.CreateAnd(Upper, Lower);

NeedsEnumCheck ? SanitizerKind::SO_Enum : SanitizerKind::SO_Bool;

(std::make_pair(Check, Kind), SanitizerHandler::LoadInvalidValue,

isNontemporal) {

(

*GV = dyn_cast<llvm::GlobalValue>(Addr.

()))

(GV->isThreadLocal())

(ClangVecTy->isExtVectorBoolType()) {

ValNumElems =

cast<llvm::FixedVectorType>(ValTy)->getNumElements();

*RawIntTy = RawIntV->getType();

assert(RawIntTy->isIntegerTy() &&

);

*PaddedVecTy = llvm::FixedVectorType::get(

.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());

llvm::Value *

=

.CreateBitCast(RawIntV, PaddedVecTy);

*VTy = cast<llvm::FixedVectorType>(Addr.

());

(VTy != NewVecTy) {

OldNumElements = VTy->getNumElements();

std::iota(Mask.begin(), Mask.end(), 0);

=

.CreateShuffleVector(

, Mask,

);

(isNontemporal) {

llvm::MDNode *

= llvm::MDNode::get(

->getContext(), llvm::ConstantAsMetadata::get(

.getInt32(1)));

->setMetadata(llvm::LLVMContext::MD_nontemporal,

);

(llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty)) {

->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);

->setMetadata(llvm::LLVMContext::MD_noundef,

MemNumElems = StoreTy->getPrimitiveSizeInBits();

*PaddedVecTy = llvm::FixedVectorType::get(

.getInt1Ty(), RawIntTy->getPrimitiveSizeInBits());

ValNumElems = cast<llvm::FixedVectorType>(ValTy)->getNumElements();

.CreateTrunc(

, ResTy,

);

IsVector =

) {

*ArrayTy = dyn_cast<llvm::ArrayType>(Addr.

());

(ArrayTy && IsVector) {

*VectorTy = llvm::FixedVectorType::get(ArrayTy->getElementType(),

ArrayTy->getNumElements());

*VectorTy = dyn_cast<llvm::VectorType>(Addr.

());

(VectorTy && !IsVector) {

*ArrayTy = llvm::ArrayType::get(

VectorTy->getElementType(),

cast<llvm::FixedVectorType>(VectorTy)->getNumElements());

value->getType()->isVectorTy());

isInit,

isNontemporal) {

(

*GV = dyn_cast<llvm::GlobalValue>(Addr.

()))

(GV->isThreadLocal())

(

*VecTy = dyn_cast<llvm::FixedVectorType>(SrcTy)) {

(!ClangVecTy->isExtVectorBoolType() && VecTy != NewVecTy) {

std::iota(Mask.begin(), Mask.begin() + VecTy->getNumElements(), 0);

(isNontemporal) {

llvm::MDNode *

=

llvm::MDNode::get(

->getContext(),

llvm::ConstantAsMetadata::get(

.getInt32(1)));

->setMetadata(llvm::LLVMContext::MD_nontemporal,

);

llvm_unreachable(

);

llvm::MatrixBuilder MB(

);

MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());

llvm::LoadInst *

=

assert(LV.

() &&

);

StorageSize =

assert(

(Offset + Info.

) <= StorageSize);

HighBits = StorageSize - Offset - Info.

;

Val =

.CreateShl(Val, HighBits,

);

(Offset + HighBits)

Val =

.CreateAShr(Val, Offset + HighBits,

);

Val =

.CreateLShr(Val, Offset,

);

(

(Offset) + Info.

< StorageSize)

Val, llvm::APInt::getLowBitsSet(StorageSize, Info.

),

);

Val =

.CreateIntCast(Val, ResLTy, Info.

,

);

llvm::Type *DstTy = llvm::FixedVectorType::get(Vec->getType(), 1);

llvm::Value *

= llvm::Constant::getNullValue(

.

);

Vec =

.CreateInsertElement(DstTy, Vec, Zero,

);

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

, InIdx);

(

i = 0; i != NumResultElts; ++i)

Vec =

.CreateShuffleVector(Vec, Mask);

VectorBasePtrPlusIx;

);

llvm::MDNode *RegName = cast<llvm::MDNode>(

cast<llvm::MetadataAsValue>(LV.

())->getMetadata());

llvm::Type *Ty = OrigTy;

(OrigTy->isPointerTy())

llvm::Type *Types[] = { Ty };

llvm::Function *F =

.

(llvm::Intrinsic::read_register, Types);

F, llvm::MetadataAsValue::get(Ty->getContext(), RegName));

(OrigTy->isPointerTy())

*IRStoreTy = dyn_cast<llvm::IntegerType>(Vec->getType());

*IRVecTy = llvm::FixedVectorType::get(

.getInt1Ty(), IRStoreTy->getPrimitiveSizeInBits());

Vec =

.CreateBitCast(Vec, IRVecTy);

(

*EltTy = dyn_cast<llvm::FixedVectorType>(SrcVal->getType());

EltTy && EltTy->getNumElements() == 1)

SrcVal =

.CreateBitCast(SrcVal, EltTy->getElementType());

Vec =

.CreateBitCast(Vec, IRStoreTy);

llvm::MatrixBuilder MB(

);

MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());

assert(Dst.

() &&

);

llvm_unreachable(

);

llvm::Type *ResultType =

;

RHS =

.CreatePtrToInt(RHS, ResultType,

);

ResultType,

);

llvm::Value *BytesBetween =

.CreateSub(LHS, RHS,

);

assert(Src.

() &&

);

llvm::Value **

) {

llvm::Value *MaskedVal = SrcVal;

UseVolatile =

StorageSize =

(StorageSize != Info.

) {

assert(StorageSize > Info.

&&

);

SrcVal, llvm::APInt::getLowBitsSet(StorageSize, Info.

),

SrcVal =

.CreateShl(SrcVal, Offset,

);

Val, ~llvm::APInt::getBitsSet(StorageSize, Offset, Offset + Info.

),

SrcVal =

.CreateOr(Val, SrcVal,

);

assert(Offset == 0);

llvm::Value *ResultVal = MaskedVal;

assert(Info.

<= StorageSize);

HighBits = StorageSize - Info.

;

ResultVal =

.CreateShl(ResultVal, HighBits,

);

ResultVal =

.CreateAShr(ResultVal, HighBits,

);

ResultVal =

.CreateIntCast(ResultVal, ResLTy, Info.

,

);

NumSrcElts = VTy->getNumElements();

NumDstElts =

cast<llvm::FixedVectorType>(Vec->getType())->getNumElements();

(NumDstElts == NumSrcElts) {

(

i = 0; i != NumSrcElts; ++i)

Vec =

.CreateShuffleVector(SrcVal, Mask);

}

(NumDstElts > NumSrcElts) {

(

i = 0; i != NumSrcElts; ++i)

ExtMask.push_back(i);

ExtMask.resize(NumDstElts, -1);

llvm::Value *ExtSrcVal =

.CreateShuffleVector(SrcVal, ExtMask);

(

i = 0; i != NumDstElts; ++i)

(

i = 0; i != NumSrcElts; ++i)

Vec =

.CreateShuffleVector(Vec, ExtSrcVal, Mask);

llvm_unreachable(

);

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

, InIdx);

Vec =

.CreateInsertElement(Vec, SrcVal, Elt);

);

llvm::MDNode *RegName = cast<llvm::MDNode>(

cast<llvm::MetadataAsValue>(Dst.

())->getMetadata());

assert(RegName &&

);

llvm::Type *Ty = OrigTy;

(OrigTy->isPointerTy())

llvm::Type *Types[] = { Ty };

llvm::Function *F =

.

(llvm::Intrinsic::write_register, Types);

(OrigTy->isPointerTy())

F, {llvm::MetadataAsValue::get(Ty->getContext(), RegName),

});

IsMemberAccess=

) {

(isa<ObjCIvarRefExpr>(

)) {

*Exp = cast<ObjCIvarRefExpr>(

*

(

));

(

*Exp = dyn_cast<DeclRefExpr>(

)) {

(

*VD = dyn_cast<VarDecl>(Exp->getDecl())) {

(VD->hasGlobalStorage()) {

(

*Exp = dyn_cast<UnaryOperator>(

)) {

(

*Exp = dyn_cast<ParenExpr>(

)) {

(

*Exp = dyn_cast<GenericSelectionExpr>(

)) {

(

*Exp = dyn_cast<ImplicitCastExpr>(

)) {

(

*Exp = dyn_cast<CStyleCastExpr>(

)) {

(

*Exp = dyn_cast<ObjCBridgedCastExpr>(

)) {

(

*Exp = dyn_cast<ArraySubscriptExpr>(

)) {

(

*Exp = dyn_cast<MemberExpr>(

)) {

CGF, VD, Addr,

);

std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =

OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD);

(!Res || ((*Res == OMPDeclareTargetDeclAttr::MT_To ||

*Res == OMPDeclareTargetDeclAttr::MT_Enter) &&

assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||

((*Res == OMPDeclareTargetDeclAttr::MT_To ||

*Res == OMPDeclareTargetDeclAttr::MT_Enter) &&

);

llvm::LoadInst *

=

PointeeBaseInfo, PointeeTBAAInfo);

PointeeBaseInfo, PointeeTBAAInfo);

BaseInfo, TBAAInfo);

= CGF.

.CreateThreadLocalAddress(

);

Addr(

, RealVarTy, Alignment);

VD->

<OMPThreadPrivateDeclAttr>()) {

(FD->

<WeakRefAttr>()) {

llvm::Value *ThisValue) {

AsmLabelAttr *

= VD->

<AsmLabelAttr>();

assert(

->getLabel().size() < 64-Name.size() &&

);

Name.append(

->getLabel());

llvm::NamedMDNode *M =

CGM.

().getOrInsertNamedMetadata(Name);

(M->getNumOperands() == 0) {

llvm::MDString *Str = llvm::MDString::get(CGM.

(),

llvm::Metadata *Ops[] = {Str};

llvm::MetadataAsValue::get(CGM.

(), M->getOperand(0));

(

->refersToEnclosingVariableOrCapture())

llvm::GlobalValue::ExternalLinkage:

llvm::GlobalValue::LinkOnceODRLinkage:

llvm::GlobalValue::WeakODRLinkage:

llvm::GlobalValue::InternalLinkage:

llvm::GlobalValue::PrivateLinkage:

);

(

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

VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())

(VD->getType()->isReferenceType() ||

VD->getAnyInitializer(VD);

->getLocation(), *VD->evaluateValue(), VD->

());

assert(Val &&

);

(!VD->getType()->isReferenceType()) {

*PTy = llvm::PointerType::get(

VarTy,

().getTargetAddressSpace(VD->getType()));

(

->refersToEnclosingVariableOrCapture()) {

VD = VD->getCanonicalDecl();

I = LocalDeclMap.find(VD);

(I != LocalDeclMap.end()) {

(VD->getType()->isReferenceType())

assert((ND->

(

) || !isa<VarDecl>(ND) ||

->isNonOdrUse() ||

!

->getLocation().isValid()) &&

);

(ND->

<WeakRefAttr>()) {

*VD = cast<ValueDecl>(ND);

(

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

(VD->hasLinkage() || VD->isStaticDataMember())

iter = LocalDeclMap.find(VD);

(iter != LocalDeclMap.end()) {

addr = iter->second;

}

(VD->isStaticLocal()) {

llvm_unreachable(

);

VD->hasAttr<OMPThreadPrivateDeclAttr>()) {

isBlockByref = VD->isEscapingByref();

isLocalStorage = VD->hasLocalStorage();

NonGCable = isLocalStorage &&

isImpreciseLifetime =

(isLocalStorage && !VD->hasAttr<ObjCPreciseLifetimeAttr>());

(isImpreciseLifetime)

(

*FD = dyn_cast<FunctionDecl>(ND))

(

*BD = dyn_cast<BindingDecl>(ND)) {

(

->refersToEnclosingVariableOrCapture()) {

(

*GD = dyn_cast<MSGuidDecl>(ND))

(

*TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {

(AS !=

.getAddressSpace()) {

, ATPO.getPointer(), AS,

.getAddressSpace(), PtrTy);

ATPO =

(ASC, ATPO.getElementType(), ATPO.getAlignment());

llvm_unreachable(

);

(

->getOpcode() == UO_Extension)

(

->getOpcode()) {

: llvm_unreachable(

);

assert(!

.isNull() &&

);

assert(LV.

() &&

);

(

->getOpcode() == UO_Real &&

(

->getOpcode() == UO_Real

isInc =

->getOpcode() == UO_PreInc;

SL =

->getFunctionName();

assert(SL !=

&&

);

StringRef FnName =

->getName();

(FnName.starts_with(

))

FnName = FnName.substr(1);

StringRef NameItems[] = {

std::string GVName = llvm::join(NameItems, NameItems + 2,

);

(

*BD = dyn_cast_or_null<BlockDecl>(

)) {

std::string Name = std::string(SL->getString());

(!Name.empty()) {

Discriminator =

Name +=

+ Twine(Discriminator + 1).str();

IsBitInt =

;

);

);

(

)

.getAsOpaquePtr(), StringRef(),

StringRef(), {}, Buffer, {});

S[6] = {

,

,

,

,

,

};

llvm::support::endian::write32(S + 1, Bits,

? llvm::endianness::big

: llvm::endianness::little);

StringRef Str = StringRef(S,

(S) /

(

(S[0])));

llvm::Constant *Components[] = {

llvm::Constant *Descriptor = llvm::ConstantStruct::getAnon(Components);

*GV =

llvm::GlobalVariable(

, llvm::GlobalVariable::PrivateLinkage, Descriptor);

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

(

->getType() == TargetTy)

(

->getType()->isFloatingPointTy()) {

Bits =

->getType()->getPrimitiveSizeInBits().getFixedValue();

(Bits <= TargetTy->getIntegerBitWidth())

(

->getType()->isIntegerTy() &&

->getType()->getIntegerBitWidth() <= TargetTy->getIntegerBitWidth())

.CreateZExt(

, TargetTy);

(!

->getType()->isPointerTy()) {

.CreatePtrToInt(

, TargetTy);

PathComponentsToStrip =

(PathComponentsToStrip < 0) {

assert(PathComponentsToStrip !=

);

PathComponentsToKeep = -PathComponentsToStrip;

I = llvm::sys::path::rbegin(FilenameString);

= llvm::sys::path::rend(FilenameString);

(I !=

&& --PathComponentsToKeep)

FilenameString = FilenameString.substr(I -

);

}

(PathComponentsToStrip > 0) {

I = llvm::sys::path::begin(FilenameString);

= llvm::sys::path::end(FilenameString);

(I !=

&& PathComponentsToStrip--)

FilenameString.substr(I - llvm::sys::path::begin(FilenameString));

FilenameString = llvm::sys::path::filename(FilenameString);

cast<llvm::GlobalVariable>(

FilenameGV.getPointer()->stripPointerCasts()));

= FilenameGV.getPointer();

llvm::ConstantStruct::getAnon(

);

CheckRecoverableKind {

CheckRecoverableKind

(Ordinal == SanitizerKind::SO_Vptr)

CheckRecoverableKind::AlwaysRecoverable;

(Ordinal == SanitizerKind::SO_Return ||

Ordinal == SanitizerKind::SO_Unreachable)

CheckRecoverableKind::Unrecoverable;

CheckRecoverableKind::Recoverable;

SanitizerHandlerInfo {

*

Name;

llvm::FunctionType *FnType,

CheckRecoverableKind RecoverKind,

IsFatal,

llvm::BasicBlock *ContBB,

NoMerge) {

assert(IsFatal || RecoverKind != CheckRecoverableKind::Unrecoverable);

std::optional<ApplyDebugLocation> DL;

(!CGF.

.getCurrentDebugLocation()) {

NeedsAbortSuffix =

IsFatal && RecoverKind != CheckRecoverableKind::Unrecoverable;

StringRef CheckName = CheckInfo.Name;

std::string FnName =

+ CheckName.str();

(CheckInfo.Version && !MinimalRuntime)

FnName +=

+ llvm::utostr(CheckInfo.Version);

FnName +=

;

(NeedsAbortSuffix)

FnName +=

;

!IsFatal || RecoverKind == CheckRecoverableKind::AlwaysRecoverable;

B.addAttribute(llvm::Attribute::NoReturn)

.addAttribute(llvm::Attribute::NoUnwind);

B.addUWTableAttr(llvm::UWTableKind::Default);

llvm::AttributeList::FunctionIndex, B),

HandlerCall->addFnAttr(llvm::Attribute::NoMerge);

HandlerCall->setDoesNotReturn();

CGF.

.CreateUnreachable();

CGF.

.CreateBr(ContBB);

<std::pair<llvm::Value *, SanitizerKind::SanitizerOrdinal>> Checked,

assert(Checked.size() > 0);

assert(CheckHandler >= 0 &&

llvm::Value *FatalCond =

;

llvm::Value *RecoverableCond =

;

llvm::Value *TrapCond =

;

NoMerge =

;

(

&[Check, Ord] : Checked) {

llvm::Value *GuardedCheck = Check;

llvm::Value *Allow =

.CreateCall(

llvm::ConstantInt::get(

.

, Ord));

GuardedCheck =

.CreateOr(Check,

.CreateNot(Allow));

Cond = Cond ?

.CreateAnd(Cond, GuardedCheck) : GuardedCheck;

(!FatalCond && !RecoverableCond)

llvm::Value *JointCond;

(FatalCond && RecoverableCond)

JointCond =

.CreateAnd(FatalCond, RecoverableCond);

JointCond = FatalCond ? FatalCond : RecoverableCond;

(

i = 1, n = Checked.size(); i < n; ++i) {

);

llvm::Instruction *Branch =

.CreateCondBr(JointCond, Cont, Handlers);

llvm::MDNode *

= MDHelper.createLikelyBranchWeights();

Branch->setMetadata(llvm::LLVMContext::MD_prof,

);

Args.reserve(DynamicArgs.size() + 1);

ArgTypes.reserve(DynamicArgs.size() + 1);

(!StaticArgs.empty()) {

llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);

*InfoPtr =

llvm::GlobalVariable(

llvm::GlobalVariable::PrivateLinkage, Info,

,

,

llvm::GlobalVariable::NotThreadLocal,

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

Args.push_back(InfoPtr);

ArgTypes.push_back(Args.back()->getType());

(

i = 0, n = DynamicArgs.size(); i != n; ++i) {

llvm::FunctionType *FnType =

llvm::FunctionType::get(

.

, ArgTypes,

);

(!FatalCond || !RecoverableCond) {

(FatalCond !=

), Cont, NoMerge);

llvm::BasicBlock *NonFatalHandlerBB =

llvm::BasicBlock *FatalHandlerBB =

(

+ CheckName);

.CreateCondBr(FatalCond, NonFatalHandlerBB, FatalHandlerBB);

NonFatalHandlerBB, NoMerge);

llvm::ConstantInt *TypeId, llvm::Value *Ptr,

llvm::BranchInst *BI =

.CreateCondBr(Cond, Cont, CheckBB);

llvm::MDNode *

= MDHelper.createLikelyBranchWeights();

BI->setMetadata(llvm::LLVMContext::MD_prof,

);

llvm::CallInst *CheckCall;

llvm::FunctionCallee SlowPathFn;

llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);

llvm::GlobalVariable(

.

(), Info->getType(),

,

llvm::GlobalVariable::PrivateLinkage, Info);

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

,

CheckCall =

.CreateCall(SlowPathFn, {TypeId, Ptr, InfoPtr});

CheckCall =

.CreateCall(SlowPathFn, {TypeId, Ptr});

cast<llvm::GlobalValue>(SlowPathFn.getCallee()->stripPointerCasts()));

CheckCall->setDoesNotThrow();

QInt64Ty =

.getIntTypeForBitwidth(64,

);

.push_back(&ArgCallsiteTypeId);

.push_back(&ArgAddr);

.push_back(&ArgCFICheckFailData);

llvm::Function *F = llvm::Function::Create(

llvm::GlobalValue::WeakAnyLinkage,

, M);

F->setAlignment(llvm::Align(4096));

llvm::LLVMContext &Ctx = M->getContext();

llvm::BasicBlock *BB = llvm::BasicBlock::Create(Ctx,

, F);

llvm::CallInst::Create(M->getFunction(

), Args,

, BB);

llvm::ReturnInst::Create(Ctx,

, BB);

SanitizerScope SanScope(

);

Args.push_back(&ArgData);

Args.push_back(&ArgAddr);

llvm::Function *F = llvm::Function::Create(

llvm::GlobalValue::WeakODRLinkage,

, &

.

());

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

llvm::Value *

=

llvm::Value *DataIsNotNullPtr =

(DataIsNotNullPtr, SanitizerHandler::CFICheckFail);

llvm::StructType *SourceLocationTy =

llvm::StructType *CfiCheckFailDataTy =

llvm::Value *AllVtables = llvm::MetadataAsValue::get(

llvm::Value *ValidVtable =

.CreateZExt(

{Addr, AllVtables}),

std::pair<int, SanitizerKind::SanitizerOrdinal> CheckKinds[] = {

(

CheckKindOrdinalPair : CheckKinds) {

= CheckKindOrdinalPair.first;

.CreateICmpNE(CheckKind, llvm::ConstantInt::get(

, Kind));

(std::make_pair(Cond, Ordinal), SanitizerHandler::CFICheckFail,

{}, {

, Addr, ValidVtable});

(

.

(SanitizerKind::Unreachable)) {

SanitizerScope SanScope(

);

(std::make_pair(

llvm::Value *

(

.getFalse()),

SanitizerKind::SO_Unreachable),

SanitizerHandler::BuiltinUnreachable,

((

)TrapBBs.size() <= CheckHandlerID)

TrapBBs.resize(CheckHandlerID + 1);

llvm::BasicBlock *&TrapBB = TrapBBs[CheckHandlerID];

(TrapBB && !NoMerge) {

= TrapBB->begin();

assert(isa<llvm::CallInst>(

) &&

);

->applyMergedLocation(

->getDebugLoc(),

.getCurrentDebugLocation());

.CreateCondBr(Checked, Cont, TrapBB);

.CreateCondBr(Checked, Cont, TrapBB);

llvm::CallInst *TrapCall =

llvm::ConstantInt::get(

.

, CheckHandlerID));

A = llvm::Attribute::get(

(),

,

TrapCall->addFnAttr(A);

TrapCall->addFnAttr(llvm::Attribute::NoMerge);

TrapCall->setDoesNotReturn();

TrapCall->setDoesNotThrow();

llvm::CallInst *TrapCall =

A = llvm::Attribute::get(

(),

,

TrapCall->addFnAttr(A);

TrapCall->addFnAttr(llvm::Attribute::NoMerge);

);

);

*CE = dyn_cast<CastExpr>(

);

(!CE || CE->getCastKind() != CK_ArrayToPointerDecay)

llvm::Type *elemType,

llvm::Twine &name =

) {

llvm::Type *elementType,

inbounds,

llvm::Twine &name =

) {

(

constantIdx = dyn_cast<llvm::ConstantInt>(idx)) {

offset = constantIdx->getZExtValue() * eltSize;

&&

->

<BPFPreserveStaticOffsetAttr>();

(PointeeType.

())

llvm::Function *Fn =

(

*ME = dyn_cast<MemberExpr>(

))

(

*DRE = dyn_cast<DeclRefExpr>(

)) {

*VarDef = dyn_cast<VarDecl>(DRE->getDecl());

*PtrT = VarDef->getType()->getAs<

>();

(

*RecT = dyn_cast<RecordType>(PointeeT))

RecT->getDecl()->

<BPFPreserveAccessIndexAttr>();

llvm::Twine &name =

) {

(

*idx : indices.drop_back())

assert(isa<llvm::ConstantInt>(idx) &&

cast<llvm::ConstantInt>(idx)->isZero());

llvm::Value *eltPtr;

LastIndex = dyn_cast<llvm::ConstantInt>(indices.back());

signedIndices, loc, eltAlign, name);

idx = LastIndex->getZExtValue();

llvm::DIType *DbgInfo =

;

eltPtr = CGF.

.CreatePreserveArrayAccessIndex(

*Field, int64_t &Offset) {

FieldNo = 0;

(FD1OuterRec != FD2OuterRec)

std::optional<int64_t>();

int64_t FD1Offset = 0;

std::optional<int64_t>();

int64_t FD2Offset = 0;

std::optional<int64_t>();

std::make_optional<int64_t>(FD1Offset - FD2Offset);

llvm::Value *IdxPre =

SignedIndices =

;

EmitIdxAfterBase = [&, IdxPre](

Promote) -> llvm::Value * {

(

->getLHS() !=

->getIdx()) {

assert(

->getRHS() ==

->getIdx() &&

);

SignedIndices |= IdxSigned;

(

.

(SanitizerKind::ArrayBounds))

(Promote && Idx->getType() !=

)

!isa<ExtVectorElementExpr>(

->getBase())) {

*Idx = EmitIdxAfterBase(

);

assert(LHS.

() &&

);

(isa<ExtVectorElementExpr>(

->getBase())) {

*Idx = EmitIdxAfterBase(

);

*Idx = EmitIdxAfterBase(

);

Idx =

.CreateMul(Idx, numElements);

Idx =

.CreateNSWMul(Idx, numElements);

*Idx = EmitIdxAfterBase(

);

llvm::Value *InterfaceSizeVal =

llvm::ConstantInt::get(Idx->getType(), InterfaceSize.

());

llvm::Value *ScaledIdx =

.CreateMul(Idx, InterfaceSizeVal);

llvm::Value *EltPtr =

ScaledIdx,

, SignedIndices,

->

());

Addr =

(EltPtr, OrigBaseElemTy, EltAlign);

assert(Array->getType()->isArrayType() &&

);

(

*ASE = dyn_cast<ArraySubscriptExpr>(Array))

*Idx = EmitIdxAfterBase(

);

(

.

(SanitizerKind::ArrayBounds)) {

(

*ME = dyn_cast<MemberExpr>(Array);

(std::optional<int64_t> Diff =

llvm::Type *CountTy =

(CountFD->getType());

);

Array->getType(), Accessed);

*

, ArrayLV.

(), {CGM.getSize(CharUnits::Zero()), Idx},

*Idx = EmitIdxAfterBase(

);

SignedIndices,

->

(), &ptrType,

->getBase());

!

->isIncomplete() &&

);

llvm::Value *NumRows =

.getIntN(

RowIdx->getType()->getScalarSizeInBits(),

llvm::Value *FinalIdx =

.CreateAdd(

.CreateMul(ColIdx, NumRows), RowIdx);

IsLowerBound) {

(

*ASE = dyn_cast<ArraySectionExpr>(

->IgnoreParenImpCasts())) {

);

IsLowerBound) {

assert(!

->isOpenACCArraySection() &&

);

(

*AT =

().getAsArrayType(BaseTy))

ResultExprTy = AT->getElementType();

llvm::Value *Idx =

;

(IsLowerBound ||

->getColonLocFirst().isInvalid()) {

(

*LowerBound =

->getLowerBound()) {

LowerBound->getType()->hasSignedIntegerRepresentation());

Idx = llvm::ConstantInt::getNullValue(

);

*Length =

->getLength();

llvm::APSInt ConstLength;

(std::optional<llvm::APSInt> CL = Length->getIntegerConstantExpr(

)) {

*LowerBound =

->getLowerBound();

(std::optional<llvm::APSInt> LB =

LowerBound->getIntegerConstantExpr(

)) {

LowerBound =

;

(!LowerBound)

(Length || LowerBound) {

*LowerBoundVal =

LowerBound->getType()->hasSignedIntegerRepresentation())

: llvm::ConstantInt::get(

, ConstLowerBound);

Length->getType()->hasSignedIntegerRepresentation())

: llvm::ConstantInt::get(

, ConstLength);

Idx =

.CreateAdd(LowerBoundVal, LengthVal,

,

(Length && LowerBound) {

Idx, llvm::ConstantInt::get(

,

1),

,

Idx = llvm::ConstantInt::get(

, ConstLength + ConstLowerBound);

(

*VAT =

.getAsVariableArrayType(ArrayTy)) {

Length = VAT->getSizeExpr();

(std::optional<llvm::APSInt> L = Length->getIntegerConstantExpr(

)) {

*CAT =

.getAsConstantArrayType(ArrayTy);

assert(CAT &&

);

ConstLength = CAT->getSize();

*LengthVal =

.CreateIntCast(

Length->getType()->hasSignedIntegerRepresentation());

LengthVal, llvm::ConstantInt::get(

,

1),

,

Idx = llvm::ConstantInt::get(

, ConstLength);

(

*VLA =

().getAsVariableArrayType(ResultExprTy)) {

BaseTy, VLA->getElementType(), IsLowerBound);

Idx =

.CreateMul(Idx, NumElements);

Idx =

.CreateNSWMul(Idx, NumElements);

assert(Array->getType()->isArrayType() &&

);

(

*ASE = dyn_cast<ArraySubscriptExpr>(Array))

*

, ArrayLV.

(), {CGM.getSize(CharUnits::Zero()), Idx},

ResultExprTy, !

().PointerOverflowDefined,

ResultExprTy, IsLowerBound);

(EltPtr, ResultExprTy, BaseInfo, TBAAInfo);

(

->isArrow()) {

.getQuals().removeObjCGCAttr();

);

->getEncodedElementAccess(Indices);

(

.isSimple()) {

llvm::Constant *CV =

assert(

.isExtVectorElt() &&

);

llvm::Constant *BaseElts =

.getExtVectorElts();

(

i = 0, e = Indices.size(); i != e; ++i)

CElts.push_back(BaseElts->getAggregateElement(Indices[i]));

llvm::Constant *CV = llvm::ConstantVector::get(CElts);

*BaseExpr =

->getBase();

(

->isArrow()) {

SkippedChecks.

(SanitizerKind::Alignment,

);

(IsBaseCXXThis || isa<DeclRefExpr>(BaseExpr))

SkippedChecks.

(SanitizerKind::Null,

);

(

*Field = dyn_cast<FieldDecl>(ND)) {

(

*FD = dyn_cast<FunctionDecl>(ND))

llvm_unreachable(

);

llvm::Value *ThisValue) {

HasExplicitObjectParameter =

;

*MD = dyn_cast_if_present<CXXMethodDecl>(

);

HasExplicitObjectParameter = MD->isExplicitObjectMemberFunction();

assert(MD->getParent()->isLambda());

assert(MD->getParent() ==

->getParent());

(HasExplicitObjectParameter) {

It = LocalDeclMap.find(

);

assert(It != LocalDeclMap.end() &&

);

AddrOfExplicitObject = It->getSecond();

(

->getType()->isReferenceType())

->getType().getNonReferenceType());

*ThisTy =

->getType().getNonReferenceType()->getAsCXXRecordDecl();

*LambdaTy = cast<CXXRecordDecl>(

->getParent());

(ThisTy != LambdaTy) {

LambdaLV.

(), ThisTy, BasePathArray.begin(),

FieldIndex) {

I = 0, Skipped = 0;

(I == FieldIndex)

(F->isUnnamedBitField())

FieldIndex - Skipped;

(Offset.isZero())

(RD->isDynamicClass())

(

&

: RD->bases())

llvm::Type *FieldIntTy = llvm::Type::getIntNTy(

(), SS);

}

(rec->

()) {

assert(!FieldTBAAInfo.

&&

);

FieldTBAAInfo.

=

(

*ClassDef = dyn_cast<CXXRecordDecl>(rec)) {

ClassDef->isDynamicClass()) {

(field->

<AnnotateAttr>())

=

.withElementType(llvmType);

(

->isFileScope()) {

*InitExpr =

->getInitializer();

assert(

->isTransparent() &&

);

*Operand) {

(

*ThrowExpr = dyn_cast<CXXThrowExpr>(Operand->IgnoreParens())) {

std::nullopt;

std::optional<LValue> HandleConditionalOperatorLValueSimpleCase(

*condExpr =

->getCond();

*Live =

->getTrueExpr(), *Dead =

->getFalseExpr();

std::swap(Live, Dead);

(

*ThrowExpr = dyn_cast<CXXThrowExpr>(Live->

())) {

llvm::Type *ElemTy = CGF.

(Dead->getType());

std::nullopt;

ConditionalInfo {

llvm::BasicBlock *lhsBlock, *rhsBlock;

std::optional<LValue> LHS, RHS;

<

FuncTy>

FuncTy &BranchGenFunc) {

CodeGenFunction::ConditionalEvaluation eval(CGF);

Info.LHS = BranchGenFunc(CGF,

->getTrueExpr());

Info.lhsBlock = CGF.

.GetInsertBlock();

CGF.

.CreateBr(endBlock);

Info.RHS = BranchGenFunc(CGF,

->getFalseExpr());

Info.rhsBlock = CGF.

.GetInsertBlock();

);

OpaqueValueMapping binding(*

,

);

(HandleConditionalOperatorLValueSimpleCase(*

,

))

(!

->isGLValue()) {

);

OpaqueValueMapping binding(*

,

);

(std::optional<LValue> Res =

HandleConditionalOperatorLValueSimpleCase(*

,

))

ConditionalInfo Info = EmitConditionalBlocks(

((Info.LHS && !Info.LHS->isSimple()) ||

(Info.RHS && !Info.RHS->isSimple()))

(Info.LHS && Info.RHS) {

lhsAddr = Info.LHS->getAddress();

rhsAddr = Info.RHS->getAddress();

lhsAddr, rhsAddr, Info.lhsBlock, Info.rhsBlock,

std::max(Info.LHS->getBaseInfo().getAlignmentSource(),

Info.RHS->getBaseInfo().getAlignmentSource());

Info.LHS->getTBAAInfo(), Info.RHS->getTBAAInfo());

assert((Info.LHS || Info.RHS) &&

);

Info.LHS ? *Info.LHS : *Info.RHS;

(

->getCastKind()) {

CK_LValueToRValueBitCast:

CK_ArrayToPointerDecay:

CK_FunctionToPointerDecay:

CK_NullToMemberPointer:

CK_NullToPointer:

CK_IntegralToPointer:

CK_PointerToIntegral:

CK_PointerToBoolean:

CK_IntegralCast:

CK_BooleanToSignedIntegral:

CK_IntegralToBoolean:

CK_IntegralToFloating:

CK_FloatingToIntegral:

CK_FloatingToBoolean:

CK_FloatingCast:

CK_FloatingRealToComplex:

CK_FloatingComplexToReal:

CK_FloatingComplexToBoolean:

CK_FloatingComplexCast:

CK_FloatingComplexToIntegralComplex:

CK_IntegralRealToComplex:

CK_IntegralComplexToReal:

CK_IntegralComplexToBoolean:

CK_IntegralComplexCast:

CK_IntegralComplexToFloatingComplex:

CK_DerivedToBaseMemberPointer:

CK_BaseToDerivedMemberPointer:

CK_MemberPointerToBoolean:

CK_ReinterpretMemberPointer:

CK_AnyPointerToBlockPointerCast:

CK_ARCProduceObject:

CK_ARCConsumeObject:

CK_ARCReclaimReturnedObject:

CK_ARCExtendBlockObject:

CK_CopyAndAutoreleaseBlockObject:

CK_IntToOCLSampler:

CK_FloatingToFixedPoint:

CK_FixedPointToFloating:

CK_FixedPointCast:

CK_FixedPointToBoolean:

CK_FixedPointToIntegral:

CK_IntegralToFixedPoint:

CK_HLSLVectorTruncation:

CK_HLSLArrayRValue:

llvm_unreachable(

);

CK_BuiltinFnToFnPtr:

llvm_unreachable(

);

CK_NonAtomicToAtomic:

CK_AtomicToNonAtomic:

*DCE = cast<CXXDynamicCastExpr>(

);

CK_ConstructorConversion:

CK_UserDefinedConversion:

CK_CPointerToObjCPointerCast:

CK_BlockPointerToObjCPointerCast:

CK_LValueToRValue:

(

->changesVolatileQualification())

(

.isValid()) {

(

.getElementType() !=

)

CK_UncheckedDerivedToBase:

CK_DerivedToBase: {

*DerivedClassTy =

*DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl());

This, DerivedClassDecl,

->path_begin(),

->path_end(),

CK_BaseToDerived: {

*DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl());

LV.

(), DerivedClassDecl,

->path_begin(),

->path_end(),

(

.

(SanitizerKind::CFIDerivedCast))

CK_LValueBitCast: {

*CE = cast<ExplicitCastExpr>(

);

(

.

(SanitizerKind::CFIUnrelatedCast))

CK_AddressSpaceConversion: {

CK_ObjCObjectLValueCast: {

CK_ZeroToOCLOpaqueType:

llvm_unreachable(

);

CK_VectorSplat: {

llvm_unreachable(

);

std::pair<LValue, LValue>

std::make_pair(BaseLV, TempLV);

Args.

(BaseLV, TmpAddr,

,

->getWritebackCast(),

llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator

it = OpaqueLValues.find(e);

(it != OpaqueLValues.end())

assert(e->

() &&

);

llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator

it = OpaqueRValues.find(e);

(it != OpaqueRValues.end())

assert(e->

() &&

);

llvm_unreachable(

);

llvm::CallBase **CallOrInvoke) {

llvm::CallBase *CallOrInvokeStorage;

(!CallOrInvoke) {

CallOrInvoke = &CallOrInvokeStorage;

AddCoroElideSafeOnExit = llvm::make_scope_exit([&] {

(

->isCoroElideSafe()) {

auto *I = *CallOrInvoke;

I->addFnAttr(llvm::Attribute::CoroElideSafe);

(

*CE = dyn_cast<CXXMemberCallExpr>(

))

(

*CE = dyn_cast<CUDAKernelCallExpr>(

))

(

*CE = dyn_cast<CXXOperatorCallExpr>(

))

(

*MD =

dyn_cast_if_present<CXXMethodDecl>(CE->getCalleeDecl());

MD && MD->isImplicitObjectMemberFunction())

, CallOrInvoke);

llvm::CallBase **CallOrInvoke) {

, CallOrInvoke);

(!PD->isInlineBuiltinDeclaration())

std::string NoBuiltinFD = (

+ FD->

()).str();

std::string NoBuiltins =

;

std::string FDInlineName = (Ident +

).str();

IsPredefinedLibFunction =

HasAttributeNoBuiltin =

CGF.

->getAttributes().hasFnAttr(NoBuiltinFD) ||

CGF.

->getAttributes().hasFnAttr(NoBuiltins);

(CGF.

->getName() != FDInlineName &&

llvm::Function *Fn = llvm::cast<llvm::Function>(CalleePtr);

llvm::Module *M = Fn->getParent();

llvm::Function *Clone = M->getFunction(FDInlineName);

Clone = llvm::Function::Create(Fn->getFunctionType(),

llvm::GlobalValue::InternalLinkage,

Fn->getAddressSpace(), FDInlineName, M);

Clone->addFnAttr(llvm::Attribute::AlwaysInline);

(!IsPredefinedLibFunction || !HasAttributeNoBuiltin)

FD->

<CUDAGlobalAttr>())

cast<llvm::GlobalValue>(CalleePtr->stripPointerCasts()));

(

ICE = dyn_cast<ImplicitCastExpr>(

)) {

(ICE->getCastKind() == CK_FunctionToPointerDecay ||

ICE->getCastKind() == CK_BuiltinFnToFnPtr) {

}

(

DRE = dyn_cast<DeclRefExpr>(

)) {

(

FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {

}

(

ME = dyn_cast<MemberExpr>(

)) {

(

FD = dyn_cast<FunctionDecl>(ME->

())) {

}

(

NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(

)) {

}

(

PDE = dyn_cast<CXXPseudoDestructorExpr>(

)) {

llvm::Value *calleePtr;

(

*VD =

callee(calleeInfo, calleePtr, pointerAuth);

(

->getOpcode() == BO_Comma) {

(

->getOpcode() == BO_PtrMemD ||

->getOpcode() == BO_PtrMemI)

assert(

->getOpcode() == BO_Assign &&

);

llvm::Value *

=

;

(

.

(SanitizerKind::ImplicitBitfieldConversion))

llvm_unreachable(

);

llvm::CallBase **CallOrInvoke) {

assert(

->getCallReturnType(

())->isReferenceType() &&

);

&&

);

assert(

->getMethodDecl()->getReturnType()->isReferenceType() &&

);

.CreateZExtOrTrunc(OffsetValue,

llvm::Value *BaseValue,

CVRQualifiers) {

Ivar, CVRQualifiers);

llvm::Value *BaseValue =

;

*BaseExpr =

->getBase();

(

->isArrow()) {

ObjectTy = BaseExpr->

();

llvm::CallBase **CallOrInvoke,

);

*TargetDecl =

assert((!isa_and_present<FunctionDecl>(TargetDecl) ||

!cast<FunctionDecl>(TargetDecl)->isImmediateFunction()) &&

);

PointeeType = cast<PointerType>(CalleeType)->getPointeeType();

(

.

(SanitizerKind::Function) &&

(!TargetDecl || !isa<FunctionDecl>(TargetDecl)) &&

!isa<FunctionNoProtoType>(PointeeType)) {

(llvm::Constant *PrefixSig =

SanitizerScope SanScope(

);

llvm::Type *PrefixSigType = PrefixSig->getType();

llvm::StructType *PrefixStructTy = llvm::StructType::get(

llvm::Value *CalleePtr =

.getFunctionPointer();

(CalleePtr, CalleePtr->getType(),

.getPointerAuthInfo(),

);

llvm::Value *AlignedCalleePtr;

llvm::Value *CalleeAddress =

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

, ~1);

llvm::Value *AlignedCalleeAddress =

.CreateAnd(CalleeAddress, Mask);

.CreateIntToPtr(AlignedCalleeAddress, CalleePtr->getType());

AlignedCalleePtr = CalleePtr;

llvm::Value *CalleePrefixStruct = AlignedCalleePtr;

llvm::Value *CalleeSigPtr =

llvm::Value *CalleeSig =

llvm::Value *CalleeSigMatch =

.CreateICmpEQ(CalleeSig, PrefixSig);

.CreateCondBr(CalleeSigMatch, TypeCheck, Cont);

llvm::Value *CalleeTypeHashMatch =

.CreateICmpEQ(CalleeTypeHash, TypeHash);

(std::make_pair(CalleeTypeHashMatch, SanitizerKind::SO_Function),

SanitizerHandler::FunctionTypeMismatch, StaticData,

*FnType = cast<FunctionType>(PointeeType);

(

.

(SanitizerKind::CFIICall) &&

(!TargetDecl || !isa<FunctionDecl>(TargetDecl))) {

SanitizerScope SanScope(

);

llvm::Value *TypeId = llvm::MetadataAsValue::get(

(), MD);

llvm::Value *CalleePtr =

.getFunctionPointer();

llvm::Value *TypeTest =

.CreateCall(

.

(llvm::Intrinsic::type_test), {CalleePtr, TypeId});

llvm::Constant *StaticData[] = {

CalleePtr, StaticData);

(std::make_pair(TypeTest, SanitizerKind::SO_CFIICall),

SanitizerHandler::CFICheckFail, StaticData,

{CalleePtr, llvm::UndefValue::get(

)});

StaticOperator =

;

(

*OCE = dyn_cast<CXXOperatorCallExpr>(

)) {

(OCE->isAssignmentOp())

(OCE->getOperator()) {

OO_GreaterGreater:

(

*MD =

dyn_cast_if_present<CXXMethodDecl>(OCE->getCalleeDecl());

MD && MD->isStatic())

StaticOperator =

;

(StaticOperator) {

(Args, dyn_cast<FunctionProtoType>(FnType), Arguments,

->getDirectCallee(),

0, Order);

Args, FnType,

Chain);

*ResolvedFnInfo = &FnInfo;

isa<CUDAKernelCallExpr>(

) &&

(!TargetDecl || !isa<FunctionDecl>(TargetDecl))) {

llvm::Value *Handle =

.getFunctionPointer();

llvm::CallBase *LocalCallOrInvoke =

;

(

*CalleeDecl = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {

DI->EmitFuncDeclForCallSite(LocalCallOrInvoke,

DI->getFunctionType(CalleeDecl, ResTy, Args),

*CallOrInvoke = LocalCallOrInvoke;

(

->getOpcode() == BO_PtrMemI) {

(MemberAddr, MPT->getPointeeType(), BaseInfo, TBAAInfo);

llvm_unreachable(

);

assert(Val->getType()->isFPOrFPVectorTy());

(Accuracy == 0.0 || !isa<llvm::Instruction>(Val))

llvm::MDNode *

= MDHelper.createFPMath(Accuracy);

cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath,

);

llvm::Type *EltTy = Val->getType()->getScalarType();

(!EltTy->isFloatTy())

llvm::Type *EltTy = Val->getType()->getScalarType();

(!EltTy->isFloatTy())

LValueOrRValue {

*resultExpr =

->getResultExpr();

LValueOrRValue result;

i =

->semantics_begin(), e =

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

*semantic = *i;

(

*ov = dyn_cast<OpaqueValueExpr>(semantic)) {

(ov->isUnique()) {

assert(ov != resultExpr &&

);

CodeGenFunction::OpaqueValueMappingData OVMA;

(ov == resultExpr && ov->

() && !forLValue &&

opaqueData = OVMA::bind(CGF, ov, LV);

opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());

(ov == resultExpr) {

opaques.push_back(opaqueData);

}

(semantic == resultExpr) {

(

i = 0, e = opaques.size(); i != e; ++i)

opaques[i].unbind(CGF);

Defines the clang::ASTContext interface.

This file provides some common utility functions for processing Lambda related AST Constructs.

Defines enum values for all the target-independent builtin functions.

CodeGenFunction::ComplexPairTy ComplexPairTy

static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, LValue &LV, bool IsMemberAccess=false)

static LValue EmitGlobalNamedRegister(const VarDecl *VD, CodeGenModule &CGM)

Named Registers are named metadata pointing to the register name which will be read from/written to a...

static llvm::Value * emitHashMix(CGBuilderTy &Builder, llvm::Value *Acc, llvm::Value *Ptr)

static const Expr * isSimpleArrayDecayOperand(const Expr *E)

isSimpleArrayDecayOperand - If the specified expr is a simple decay from an array to pointer,...

static bool hasBooleanRepresentation(QualType Ty)

static bool getFieldOffsetInBits(CodeGenFunction &CGF, const RecordDecl *RD, const FieldDecl *Field, int64_t &Offset)

The offset of a field from the beginning of the record.

static bool hasBPFPreserveStaticOffset(const RecordDecl *D)

static Address emitAddrOfFieldStorage(CodeGenFunction &CGF, Address base, const FieldDecl *field)

Drill down to the storage of a field without walking into reference types.

ConstantEmissionKind

Can we constant-emit a load of a reference to a variable of the given type? This is different from pr...

static bool isConstantEmittableObjectType(QualType type)

Given an object of the given canonical type, can we safely copy a value out of it based on its initia...

static QualType getFixedSizeElementType(const ASTContext &ctx, const VariableArrayType *vla)

static LValue EmitCapturedFieldLValue(CodeGenFunction &CGF, const FieldDecl *FD, llvm::Value *ThisValue)

static std::optional< LValue > EmitLValueOrThrowExpression(CodeGenFunction &CGF, const Expr *Operand)

Emit the operand of a glvalue conditional operator.

static CheckRecoverableKind getRecoverableKind(SanitizerKind::SanitizerOrdinal Ordinal)

static llvm::Value * emitArraySubscriptGEP(CodeGenFunction &CGF, llvm::Type *elemType, llvm::Value *ptr, ArrayRef< llvm::Value * > indices, bool inbounds, bool signedIndices, SourceLocation loc, const llvm::Twine &name="arrayidx")

static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, const Expr *E, GlobalDecl GD)

static RawAddress MaybeConvertMatrixAddress(RawAddress Addr, CodeGenFunction &CGF, bool IsVector=true)

static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF, const PseudoObjectExpr *E, bool forLValue, AggValueSlot slot)

static Address wrapWithBPFPreserveStaticOffset(CodeGenFunction &CGF, Address &Addr)

static DeclRefExpr * tryToConvertMemberExprToDeclRefExpr(CodeGenFunction &CGF, const MemberExpr *ME)

static llvm::Value * getArrayIndexingBound(CodeGenFunction &CGF, const Expr *Base, QualType &IndexedType, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel)

If Base is known to point to the start of an array, return the length of that array.

static RValue EmitLoadOfMatrixLValue(LValue LV, SourceLocation Loc, CodeGenFunction &CGF)

static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type)

static QualType getConstantExprReferredType(const FullExpr *E, const ASTContext &Ctx)

static bool getRangeForType(CodeGenFunction &CGF, QualType Ty, llvm::APInt &Min, llvm::APInt &End, bool StrictEnums, bool IsBool)

static std::optional< int64_t > getOffsetDifferenceInBits(CodeGenFunction &CGF, const FieldDecl *FD1, const FieldDecl *FD2)

Returns the relative offset difference between FD1 and FD2.

static CGCallee EmitDirectCallee(CodeGenFunction &CGF, GlobalDecl GD)

static LValue EmitThreadPrivateVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD, QualType T, Address Addr, llvm::Type *RealVarTy, SourceLocation Loc)

static bool getGEPIndicesToField(CodeGenFunction &CGF, const RecordDecl *RD, const FieldDecl *Field, RecIndicesTy &Indices)

static bool OnlyHasInlineBuiltinDeclaration(const FunctionDecl *FD)

static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, const Expr *E, const VarDecl *VD)

static bool hasAnyVptr(const QualType Type, const ASTContext &Context)

static bool IsPreserveAIArrayBase(CodeGenFunction &CGF, const Expr *ArrayBase)

Given an array base, check whether its member access belongs to a record with preserve_access_index a...

static Address emitDeclTargetVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD, QualType T)

static bool canEmitSpuriousReferenceToVariable(CodeGenFunction &CGF, const DeclRefExpr *E, const VarDecl *VD)

Determine whether we can emit a reference to VD from the current context, despite not necessarily hav...

VariableTypeDescriptorKind

@ TK_Float

A floating-point type.

@ TK_Unknown

Any other type. The value representation is unspecified.

@ TK_Integer

An integer type.

@ TK_BitInt

An _BitInt(N) type.

static CharUnits getArrayElementAlign(CharUnits arrayAlign, llvm::Value *idx, CharUnits eltSize)

static RawAddress createReferenceTemporary(CodeGenFunction &CGF, const MaterializeTemporaryExpr *M, const Expr *Inner, RawAddress *Alloca=nullptr)

static bool isAAPCS(const TargetInfo &TargetInfo)

Helper method to check if the underlying ABI is AAPCS.

static void EmitStoreOfMatrixScalar(llvm::Value *value, LValue lvalue, bool isInit, CodeGenFunction &CGF)

static Address EmitPointerWithAlignment(const Expr *E, LValueBaseInfo *BaseInfo, TBAAAccessInfo *TBAAInfo, KnownNonNull_t IsKnownNonNull, CodeGenFunction &CGF)

static Address emitPreserveStructAccess(CodeGenFunction &CGF, LValue base, Address addr, const FieldDecl *field)

const SanitizerHandlerInfo SanitizerHandlers[]

static Address emitAddrOfZeroSizeField(CodeGenFunction &CGF, Address Base, const FieldDecl *Field)

Get the address of a zero-sized field within a record.

static void emitCheckHandlerCall(CodeGenFunction &CGF, llvm::FunctionType *FnType, ArrayRef< llvm::Value * > FnArgs, SanitizerHandler CheckHandler, CheckRecoverableKind RecoverKind, bool IsFatal, llvm::BasicBlock *ContBB, bool NoMerge)

static Address emitOMPArraySectionBase(CodeGenFunction &CGF, const Expr *Base, LValueBaseInfo &BaseInfo, TBAAAccessInfo &TBAAInfo, QualType BaseTy, QualType ElTy, bool IsLowerBound)

static void pushTemporaryCleanup(CodeGenFunction &CGF, const MaterializeTemporaryExpr *M, const Expr *E, Address ReferenceTemporary)

static const SanitizerMask AlwaysRecoverable

static const SanitizerMask Unrecoverable

static const RecordType * getRecordType(QualType QT)

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

Defines the SourceManager interface.

static QualType getPointeeType(const MemRegion *R)

const LValueBase getLValueBase() const

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

SourceManager & getSourceManager()

CharUnits getTypeAlignInChars(QualType T) const

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

uint64_t getFieldOffset(const ValueDecl *FD) const

Get the offset of a FieldDecl or IndirectFieldDecl, in bits.

QualType getTagDeclType(const TagDecl *Decl) const

Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

Get or compute information about the layout of the specified record (struct/union/class) D,...

CanQualType getCanonicalType(QualType T) const

Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...

QualType getPointerType(QualType T) const

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

Builtin::Context & BuiltinInfo

const LangOptions & getLangOpts() const

bool isTypeIgnoredBySanitizer(const SanitizerMask &Mask, const QualType &Ty) const

Check if a type can have its sanitizer instrumentation elided based on its presence within an ignorel...

QualType getPointerDiffType() const

Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.

const NoSanitizeList & getNoSanitizeList() const

llvm::DenseMap< const CXXMethodDecl *, CXXCastPath > LambdaCastPaths

For capturing lambdas with an explicit object parameter whose type is derived from the lambda type,...

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

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

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

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

unsigned getTargetAddressSpace(LangAS AS) const

uint64_t getCharWidth() const

Return the size of the character type, in bits.

ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...

uint64_t getFieldOffset(unsigned FieldNo) const

getFieldOffset - Get the offset of the given field index, in bits.

AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...

This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...

static QualType getBaseOriginalType(const Expr *Base)

Return original type of the base expression for array section.

ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.

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

QualType getElementType() const

A builtin binary operation expression such as "x + y" or "x <= y".

A fixed int type of a specified bitwidth.

bool isPredefinedLibFunction(unsigned ID) const

Determines whether this builtin is a predefined libc/libm function, such as "malloc",...

Represents binding an expression to a temporary.

Represents a call to a C++ constructor.

Represents a C++ destructor within a class.

Represents a C++ struct/union/class.

bool hasTrivialDestructor() const

Determine whether this class has a trivial destructor (C++ [class.dtor]p3)

bool isDynamicClass() const

bool hasDefinition() const

A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...

A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

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::MaybeAlign getAsMaybeAlign() const

getAsMaybeAlign - Returns Quantity as a valid llvm::Align or std::nullopt, Beware llvm::MaybeAlign as...

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

static CharUnits fromQuantity(QuantityType Quantity)

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

static CharUnits Zero()

Zero - Construct a CharUnits quantity of zero.

SanitizerSet SanitizeMergeHandlers

Set of sanitizer checks that can merge handlers (smaller code size at the expense of debuggability).

PointerAuthOptions PointerAuth

Configuration for pointer-signing.

SanitizerSet SanitizeTrap

Set of sanitizer checks that trap rather than diagnose.

SanitizerSet SanitizeRecover

Set of sanitizer checks that are non-fatal (i.e.

std::string TrapFuncName

If not an empty string, trap intrinsics are lowered to calls to this function instead of to trap inst...

SanitizerMaskCutoffs SanitizeSkipHotCutoffs

Set of thresholds in a range [0.0, 1.0]: the top hottest code responsible for the given fraction of P...

virtual llvm::FixedVectorType * getOptimalVectorMemoryType(llvm::FixedVectorType *T, const LangOptions &Opt) const

Returns the optimal vector memory type based on the given vector type.

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

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.

Address setKnownNonNull()

void setAlignment(CharUnits Value)

void replaceBasePointer(llvm::Value *P)

This function is used in situations where the caller is doing some sort of opaque "laundering" of the...

llvm::PointerType * getType() const

Return the type of the pointer value.

static AggValueSlot ignored()

ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored.

Address getAddress() const

void setExternallyDestructed(bool destructed=true)

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

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

Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")

Given a pointer to i8, adjust it by a given constant offset.

Address CreateGEP(CodeGenFunction &CGF, Address Addr, llvm::Value *Index, const llvm::Twine &Name="")

Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, llvm::Type *ElementTy, const llvm::Twine &Name="")

Address CreateConstGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1, const llvm::Twine &Name="")

Address CreateConstArrayGEP(Address Addr, uint64_t Index, const llvm::Twine &Name="")

Given addr = [n x T]* ... produce name = getelementptr inbounds addr, i64 0, i64 index where i64 is a...

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

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

Address CreatePreserveStructAccessIndex(Address Addr, unsigned Index, unsigned FieldIndex, llvm::MDNode *DbgInfo)

Address CreateLaunderInvariantGroup(Address Addr)

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

Address CreatePreserveUnionAccessIndex(Address Addr, unsigned FieldIndex, llvm::MDNode *DbgInfo)

Address CreateStripInvariantGroup(Address Addr)

Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty, llvm::Type *ElementTy, const llvm::Twine &Name="")

Address CreateConstInBoundsGEP(Address Addr, uint64_t Index, const llvm::Twine &Name="")

Given addr = T* ... produce name = getelementptr inbounds addr, i64 index where i64 is actually the t...

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

virtual llvm::Function * getKernelStub(llvm::GlobalValue *Handle)=0

Get kernel stub by kernel handle.

virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D, llvm::FunctionCallee Dtor, llvm::Constant *Addr)=0

Emit code to force the execution of a destructor during global teardown.

virtual llvm::Value * EmitMemberPointerIsNotNull(CodeGenFunction &CGF, llvm::Value *MemPtr, const MemberPointerType *MPT)

Determine if a member pointer is non-null. Returns an i1.

virtual LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD, QualType LValType)=0

Emit a reference to a non-local thread_local variable (including triggering the initialization of all...

virtual bool usesThreadWrapperFunction(const VarDecl *VD) const =0

MangleContext & getMangleContext()

Gets the mangle context.

Abstract information about a function or function prototype.

const GlobalDecl getCalleeDecl() const

All available information about a concrete callee.

CGCalleeInfo getAbstractInfo() const

const CXXPseudoDestructorExpr * getPseudoDestructorExpr() const

bool isPseudoDestructor() const

static CGCallee forBuiltin(unsigned builtinID, const FunctionDecl *builtinDecl)

unsigned getBuiltinID() const

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

const FunctionDecl * getBuiltinDecl() const

static CGCallee forPseudoDestructor(const CXXPseudoDestructorExpr *E)

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

llvm::DIType * getOrCreateStandaloneType(QualType Ty, SourceLocation Loc)

Emit standalone debug info for a type.

llvm::DIType * getOrCreateRecordType(QualType Ty, SourceLocation L)

Emit record type's standalone debug info.

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

virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, llvm::Value *ivarOffset)=0

virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0

virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)=0

virtual llvm::Value * EmitIvarOffset(CodeGen::CodeGenFunction &CGF, const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)=0

virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, Address AddrWeakObj)=0

virtual Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel)=0

Get the address of a selector for the specified name and type values.

virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0

virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, bool threadlocal=false)=0

virtual Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)

Returns address of the threadprivate variable for the current thread.

virtual ConstantAddress getAddrOfDeclareTargetVar(const VarDecl *VD)

Returns the address of the variable marked as declare target with link clause OR as declare target wi...

bool hasRequiresUnifiedSharedMemory() const

Return whether the unified_shared_memory has been specified.

bool isNontemporalDecl(const ValueDecl *VD) const

Checks if the VD variable is marked as nontemporal declaration in current context.

virtual void checkAndEmitLastprivateConditional(CodeGenFunction &CGF, const Expr *LHS)

Checks if the provided LVal is lastprivate conditional and emits the code to update the value of the ...

CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...

const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const

Return the BitFieldInfo that corresponds to the field FD.

unsigned getLLVMFieldNo(const FieldDecl *FD) const

Return llvm::StructType element number that corresponds to the field FD.

bool containsFieldDecl(const FieldDecl *FD) const

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

void add(RValue rvalue, QualType type)

void addWriteback(LValue srcLV, Address temporary, llvm::Value *toUse, const Expr *writebackExpr=nullptr, llvm::Value *lifetimeSz=nullptr)

virtual llvm::Value * getContextValue() const

virtual const FieldDecl * lookup(const VarDecl *VD) const

Lookup the captured field decl for a variable.

static ConstantEmission forValue(llvm::Constant *C)

static ConstantEmission forReference(llvm::Constant *C)

static bool shouldBindAsLValue(const Expr *expr)

static OpaqueValueMappingData bind(CodeGenFunction &CGF, const OpaqueValueExpr *ov, const Expr *e)

static bool shouldBindAsLValue(const Expr *expr)

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

llvm::Value * EmitFromMemory(llvm::Value *Value, QualType Ty)

EmitFromMemory - Change a scalar value from its memory representation to its value representation.

LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e)

RValue EmitLoadOfGlobalRegLValue(LValue LV)

LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E)

void FinishFunction(SourceLocation EndLoc=SourceLocation())

FinishFunction - Complete IR generation of the current function.

LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E)

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

llvm::Value * GetVTablePtr(Address This, llvm::Type *VTableTy, const CXXRecordDecl *VTableClass, VTableAuthMode AuthMode=VTableAuthMode::Authenticate)

GetVTablePtr - Return the Value of the vtable pointer member pointed to by This.

Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base, llvm::Value *memberPtr, const MemberPointerType *memberPtrType, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)

llvm::Value * EmitNonNullRValueCheck(RValue RV, QualType T)

Create a check that a scalar RValue is non-null.

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.

LValue EmitCastLValue(const CastExpr *E)

void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr)

EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.

llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)

Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified.

bool sanitizePerformTypeCheck() const

Whether any type-checking sanitizers are enabled.

void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK)

SanitizerSet SanOpts

Sanitizers enabled for this function.

LValue EmitCoawaitLValue(const CoawaitExpr *E)

LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)

Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.

LValue EmitAggExprToLValue(const Expr *E)

EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...

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

llvm::Value * EmitIvarOffsetAsPointerDiff(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)

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)

RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)

LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E)

CGCapturedStmtInfo * CapturedStmtInfo

void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)

LValue EmitCallExprLValue(const CallExpr *E, llvm::CallBase **CallOrInvoke=nullptr)

void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index, QualType IndexType, bool Accessed)

Emit a check that Base points into an array object, which we can access at index Index.

void EmitBitfieldConversionCheck(llvm::Value *Src, QualType SrcType, llvm::Value *Dst, QualType DstType, const CGBitFieldInfo &Info, SourceLocation Loc)

Emit a check that an [implicit] conversion of a bitfield.

void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID, bool NoMerge=false)

Create a basic block that will call the trap intrinsic, and emit a conditional branch to it,...

LValue EmitHLSLArrayAssignLValue(const BinaryOperator *E)

bool inSuspendBlock() const

Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)

Load a pointer with type PtrTy stored at address Ptr.

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 * EmitLoadOfCountedByField(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl)

Build an expression accessing the "counted_by" field.

VlaSizePair getVLASize(const VariableArrayType *vla)

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

LValue EmitHLSLOutArgExpr(const HLSLOutArgExpr *E, CallArgList &Args, QualType Ty)

CleanupKind getARCCleanupKind()

Retrieves the default cleanup kind for an ARC cleanup.

RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc)

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

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

void EmitVTablePtrCheckForCast(QualType T, Address Derived, bool MayBeNull, CFITypeCheckKind TCK, SourceLocation Loc)

Derived is the presumed address of an object of type T after a cast.

RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())

llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)

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

LValue EmitBinaryOperatorLValue(const BinaryOperator *E)

void EmitVariablyModifiedType(QualType Ty)

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

RawAddress CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)

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

createBasicBlock - Create an LLVM basic block.

RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E)

LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E)

llvm::Value * EmitARCLoadWeakRetained(Address addr)

const LangOptions & getLangOpts() const

llvm::Value * LoadPassedObjectSize(const Expr *E, QualType EltTy)

If E references a parameter with pass_object_size info or a constant array size modifier,...

llvm::Constant * EmitCheckTypeDescriptor(QualType T)

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

LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)

EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference,...

LValue EmitInitListLValue(const InitListExpr *E)

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

EmitBlock - Emit the given block.

void EmitUnreachable(SourceLocation Loc)

Emit a reached-unreachable diagnostic if Loc is valid and runtime checking is enabled.

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

Address makeNaturalAddressForPointer(llvm::Value *Ptr, QualType T, CharUnits Alignment=CharUnits::Zero(), bool ForPointeeType=false, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)

Construct an address with the natural alignment of T.

Address EmitLoadOfReference(LValue RefLVal, LValueBaseInfo *PointeeBaseInfo=nullptr, TBAAAccessInfo *PointeeTBAAInfo=nullptr)

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

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

RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)

EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...

RValue convertTempToRValue(Address addr, QualType type, SourceLocation Loc)

Address EmitExtVectorElementLValue(LValue V)

void EmitAnyExprToMem(const Expr *E, Address Location, Qualifiers Quals, bool IsInitializer)

EmitAnyExprToMem - Emits the code necessary to evaluate an arbitrary expression into the given memory...

@ TCK_DowncastPointer

Checking the operand of a static_cast to a derived pointer type.

@ TCK_DowncastReference

Checking the operand of a static_cast to a derived reference type.

@ TCK_MemberAccess

Checking the object expression in a non-static data member access.

@ TCK_Store

Checking the destination of a store. Must be suitably sized and aligned.

@ TCK_UpcastToVirtualBase

Checking the operand of a cast to a virtual base object.

@ TCK_MemberCall

Checking the 'this' pointer for a call to a non-static member function.

@ TCK_DynamicOperation

Checking the operand of a dynamic_cast or a typeid expression.

@ TCK_ReferenceBinding

Checking the bound value in a reference binding.

@ TCK_Upcast

Checking the operand of a cast to a base object.

void SetDivFPAccuracy(llvm::Value *Val)

Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.

RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())

void EmitIgnoredExpr(const Expr *E)

EmitIgnoredExpr - Emit an expression in a context which ignores the result.

bool InNoMergeAttributedStmt

True if the current statement has nomerge attribute.

LValue EmitUnsupportedLValue(const Expr *E, const char *Name)

EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue an ErrorUnsupported style ...

llvm::Type * ConvertTypeForMem(QualType T)

const Decl * CurCodeDecl

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

llvm::AssertingVH< llvm::Instruction > AllocaInsertPt

AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...

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

unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex)

Get the record field index as represented in debug info.

LValue EmitLValueForField(LValue Base, const FieldDecl *Field)

LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)

Same as EmitLValue but additionally we generate checking code to guard against undefined behavior.

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 markStmtMaybeUsed(const Stmt *S)

static Destroyer destroyCXXObject

@ ForceLeftToRight

! Language semantics require left-to-right evaluation.

@ Default

! No language constraints on evaluation order.

@ ForceRightToLeft

! Language semantics require right-to-left evaluation.

Destroyer * getDestroyer(QualType::DestructionKind destructionKind)

RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name="tmp")

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

void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)

EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.

void EmitCfiCheckStub()

Emit a stub for the cross-DSO CFI check function.

llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)

ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr)

llvm::Value * EmitARCLoadWeak(Address addr)

const TargetInfo & getTarget() const

LValue EmitCXXConstructLValue(const CXXConstructExpr *E)

bool isInConditionalBranch() const

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

llvm::Value * getTypeSize(QualType Ty)

Returns calculated size of the specified type.

std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)

LValue EmitVAArgExprLValue(const VAArgExpr *E)

bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty, SourceLocation Loc)

Check if the scalar Value is within the valid range for the given type Ty.

llvm::Function * generateDestroyHelper(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD)

Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)

EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...

llvm::Value * EmitMatrixIndexExpr(const Expr *E)

LValue EmitCoyieldLValue(const CoyieldExpr *E)

RValue EmitAnyExprToTemp(const Expr *E)

EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will always be accessible even if...

void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)

EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...

RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)

Address EmitArrayToPointerDecay(const Expr *Array, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)

Address mergeAddressesInConditionalExpr(Address LHS, Address RHS, llvm::BasicBlock *LHSBlock, llvm::BasicBlock *RHSBlock, llvm::BasicBlock *MergeBlock, QualType MergedType)

LValue EmitUnaryOpLValue(const UnaryOperator *E)

ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)

RValue EmitUnsupportedRValue(const Expr *E, const char *Name)

EmitUnsupportedRValue - Emit a dummy r-value using the type of E and issue an ErrorUnsupported style ...

static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts)

getAccessedFieldNo - Given an encoded value and a result number, return the input field number being ...

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

RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, const CallExpr *E, ReturnValueSlot ReturnValue)

RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)

EmitAnyExpr - Emit code to compute the specified expression which can have any type.

void EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound, llvm::Value *Index, QualType IndexType, QualType IndexedType, bool Accessed)

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

Emit a cross-DSO CFI failure handling function.

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

CreateAggTemp - Create a temporary memory object for the given aggregate type.

RValue EmitLoadOfExtVectorElementLValue(LValue V)

ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)

EmitLoadOfComplex - Load a complex number from the specified l-value.

static bool ShouldNullCheckClassCastValue(const CastExpr *Cast)

llvm::Value * EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)

Emit a conversion from the specified complex type to the specified destination type,...

llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)

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

LValue EmitComplexAssignmentLValue(const BinaryOperator *E)

Emit an l-value for an assignment (simple or compound) of complex type.

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

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

CGDebugInfo * getDebugInfo()

LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E)

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 EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E)

Address emitAddrOfImagComponent(Address complex, QualType complexType)

LValue EmitDeclRefLValue(const DeclRefExpr *E)

const TargetCodeGenInfo & getTargetHooks() const

llvm::Value * emitBoolVecConversion(llvm::Value *SrcVec, unsigned NumElementsDst, const llvm::Twine &Name="")

LValue MakeNaturalAlignRawAddrLValue(llvm::Value *V, QualType T)

LValue EmitPredefinedLValue(const PredefinedExpr *E)

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.

Address GetAddressOfDerivedClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue)

void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst)

RValue EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)

llvm::Value * EmitToMemory(llvm::Value *Value, QualType Ty)

EmitToMemory - Change a scalar value from its value representation to its in-memory representation.

llvm::Value * EmitCheckValue(llvm::Value *V)

Convert a value into a format suitable for passing to a runtime sanitizer handler.

void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, Address Ptr)

bool IsInPreservedAIRegion

True if CodeGen currently emits code inside presereved access index region.

llvm::Value * EmitARCRetain(QualType type, llvm::Value *value)

llvm::Value * authPointerToPointerCast(llvm::Value *ResultPtr, QualType SourceType, QualType DestType)

void SetSqrtFPAccuracy(llvm::Value *Val)

Set the minimum required accuracy of the given sqrt operation based on CodeGenOpts.

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

RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())

void EmitCfiSlowPathCheck(SanitizerKind::SanitizerOrdinal Ordinal, llvm::Value *Cond, llvm::ConstantInt *TypeId, llvm::Value *Ptr, ArrayRef< llvm::Constant * > StaticArgs)

Emit a slow path cross-DSO CFI check which calls __cfi_slowpath if Cond if false.

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

ASTContext & getContext() const

llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)

LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E)

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

CGCallee EmitCallee(const Expr *E)

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 EmitAggFinalDestCopy(QualType Type, AggValueSlot Dest, const LValue &Src, ExprValueKind SrcKind)

EmitAggFinalDestCopy - Emit copy of the specified aggregate into destination address.

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

LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy)

std::pair< LValue, LValue > EmitHLSLOutArgLValues(const HLSLOutArgExpr *E, QualType Ty)

void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init)

void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)

llvm::Instruction * getPostAllocaInsertPoint()

Return PostAllocaInsertPt.

Address GetAddressOfBaseClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue, SourceLocation Loc)

GetAddressOfBaseClass - This function will add the necessary delta to the load of 'this' and returns ...

LValue EmitMemberExpr(const MemberExpr *E)

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

LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E, bool Accessed=false)

bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)

ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...

llvm::ConstantInt * getUBSanFunctionTypeHash(QualType T) const

Return a type hash constant for a function instrumented by -fsanitize=function.

static Destroyer destroyARCWeak

llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields

CleanupKind getCleanupKind(QualType::DestructionKind kind)

void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)

RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)

llvm::Type * ConvertType(QualType T)

llvm::Value * EmitCXXTypeidExpr(const CXXTypeidExpr *E)

Address GetAddrOfBlockDecl(const VarDecl *var)

CodeGenTypes & getTypes() const

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

LValue EmitArraySectionExpr(const ArraySectionExpr *E, bool IsLowerBound=true)

bool IsSanitizerScope

True if CodeGen currently emits code implementing sanitizer checks.

LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E)

void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst)

Address EmitCXXUuidofExpr(const CXXUuidofExpr *E)

void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, LValue LV, QualType Type, SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)

llvm::SmallVector< const ParmVarDecl *, 4 > FnArgs

Save Parameter Decl for coroutine.

QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)

LValue EmitStringLiteralLValue(const StringLiteral *E)

static Destroyer destroyARCStrongPrecise

llvm::Value * EvaluateExprAsBool(const Expr *E)

EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...

Address LoadCXXThisAddress()

llvm::Value * EmitWithOriginalRHSBitfieldAssignment(const BinaryOperator *E, llvm::Value **Previous, QualType *SrcType)

Retrieve the implicit cast expression of the rhs in a binary operator expression by passing pointers ...

llvm::Value * EmitCheckedInBoundsGEP(llvm::Type *ElemTy, llvm::Value *Ptr, ArrayRef< llvm::Value * > IdxList, bool SignedIndices, bool IsSubtraction, SourceLocation Loc, const Twine &Name="")

Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to detect undefined behavior whe...

llvm::Value * EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr)

llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)

uint64_t getProfileCount(const Stmt *S)

Get the profiler's count for the given statement.

LValue EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E)

LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)

static bool hasAggregateEvaluationKind(QualType T)

llvm::Value * EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)

RawAddress CreateIRTemp(QualType T, const Twine &Name="tmp")

CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.

void SetFPAccuracy(llvm::Value *Val, float Accuracy)

SetFPAccuracy - Set the minimum required accuracy of the given floating point operation,...

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.

llvm::Value * GetCountedByFieldExprGEP(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl)

LValue EmitLoadOfReferenceLValue(LValue RefLVal)

const CallExpr * MustTailCall

LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)

Address GetAddrOfLocalVar(const VarDecl *VD)

GetAddrOfLocalVar - Return the address of a local variable.

LValue EmitObjCIsaExpr(const ObjCIsaExpr *E)

void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)

void EmitInitializationToLValue(const Expr *E, LValue LV, AggValueSlot::IsZeroed_t IsZeroed=AggValueSlot::IsNotZeroed)

EmitInitializationToLValue - Emit an initializer to an LValue.

Address EmitFieldAnnotations(const FieldDecl *D, Address V)

Emit field annotations for the given field & value.

llvm::Value * EmitScalarConversion(llvm::Value *Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)

Emit a conversion from the specified type to the specified destination type, both of which are LLVM s...

LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E)

std::pair< llvm::Value *, llvm::Value * > ComplexPairTy

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

static bool isNullPointerAllowed(TypeCheckKind TCK)

Determine whether the pointer type check TCK permits null pointers.

static Destroyer destroyARCStrongImprecise

RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e)

Given an opaque value expression, return its RValue mapping if it exists, otherwise create one.

void EmitIgnoredConditionalOperator(const AbstractConditionalOperator *E)

RValue GetUndefRValue(QualType Ty)

GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.

LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)

llvm::Value * emitScalarConstant(const ConstantEmission &Constant, Expr *E)

LValue EmitStmtExprLValue(const StmtExpr *E)

RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot(), llvm::CallBase **CallOrInvoke=nullptr)

void EnsureInsertPoint()

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

LValue MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T)

Given a value of type T* that may not be to a complete object, construct an l-value with the natural ...

llvm::LLVMContext & getLLVMContext()

llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)

EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...

bool LValueIsSuitableForInlineAtomic(LValue Src)

void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)

Increment the profiler's counter for the given statement by StepV.

RValue EmitLoadOfAnyValue(LValue V, AggValueSlot Slot=AggValueSlot::ignored(), SourceLocation Loc={})

Like EmitLoadOfLValue but also handles complex and aggregate types.

Address emitAddrOfRealComponent(Address complex, QualType complexType)

static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty)

Determine whether the pointer type check TCK requires a vptr check.

LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E)

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

LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E)

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

LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E)

RValue EmitLoadOfBitfieldLValue(LValue LV, SourceLocation Loc)

LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E)

LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)

LValue EmitLValueForLambdaField(const FieldDecl *Field)

static bool IsWrappedCXXThis(const Expr *E)

Check if E is a C++ "this" pointer wrapped in value-preserving casts.

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

ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)

Get the address of a GUID.

void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)

Emit type info if type of an expression is a variably modified type.

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.

CGDebugInfo * getModuleDebugInfo()

ConstantAddress GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E)

Returns a pointer to a constant global variable for the given file-scope compound literal expression.

llvm::ConstantInt * CreateCrossDsoCfiTypeId(llvm::Metadata *MD)

Generate a cross-DSO type identifier for MD.

void setTypeDescriptorInMap(QualType Ty, llvm::Constant *C)

llvm::Constant * getRawFunctionPointer(GlobalDecl GD, llvm::Type *Ty=nullptr)

Return a function pointer for a reference to the given function.

llvm::FunctionCallee getAddrAndTypeOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)

llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)

Get the address of the RTTI descriptor for the given type.

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 * getFunctionPointer(GlobalDecl GD, llvm::Type *Ty=nullptr)

Return the ABI-correct function pointer value for a reference to the given function.

const ABIInfo & getABIInfo()

DiagnosticsEngine & getDiags() const

void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)

Run some code with "sufficient" stack space.

const LangOptions & getLangOpts() const

CGCUDARuntime & getCUDARuntime()

Return a reference to the configured CUDA runtime.

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

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

llvm::Metadata * CreateMetadataIdentifierForType(QualType T)

Create a metadata identifier for the given type.

llvm::Constant * getTypeDescriptorFromMap(QualType Ty)

void addUsedGlobal(llvm::GlobalValue *GV)

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

llvm::MDNode * getTBAABaseTypeInfo(QualType QTy)

getTBAABaseTypeInfo - Get metadata that describes the given base access type.

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

Returns LLVM linkage for a declarator.

const llvm::DataLayout & getDataLayout() const

CGCXXABI & getCXXABI() const

ConstantAddress GetWeakRefReference(const ValueDecl *VD)

Get a reference to the target of VD.

CGPointerAuthInfo getFunctionPointerAuthInfo(QualType T)

Return the abstract pointer authentication schema for a pointer to the given function type.

CGOpenMPRuntime & getOpenMPRuntime()

Return a reference to the configured OpenMP runtime.

SanitizerMetadata * getSanitizerMetadata()

llvm::Metadata * CreateMetadataIdentifierGeneralized(QualType T)

Create a metadata identifier for the generalization of the given type.

const llvm::Triple & getTriple() const

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

void DecorateInstructionWithTBAA(llvm::Instruction *Inst, TBAAAccessInfo TBAAInfo)

DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.

TBAAAccessInfo getTBAAInfoForSubobject(LValue Base, QualType AccessType)

getTBAAInfoForSubobject - Get TBAA information for an access with a given base lvalue.

llvm::Constant * CreateRuntimeVariable(llvm::Type *Ty, StringRef Name)

Create a new runtime global variable with the specified type and name.

TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)

getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type.

ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")

Return a pointer to a constant array for the given string literal.

ASTContext & getContext() const

ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)

Get the address of a template parameter object.

TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo)

mergeTBAAInfoForCast - Get merged TBAA information for the purposes of type casts.

llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)

Return the llvm::Constant for the address of the given global variable.

llvm::MDNode * getTBAATypeInfo(QualType QTy)

getTBAATypeInfo - Get metadata used to describe accesses to objects of the given type.

const TargetCodeGenInfo & getTargetCodeGenInfo()

const CodeGenOptions & getCodeGenOpts() const

StringRef getMangledName(GlobalDecl GD)

CharUnits getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)

TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB)

mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the purposes of conditional ope...

llvm::LLVMContext & getLLVMContext()

llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})

CGObjCRuntime & getObjCRuntime()

Return a reference to the configured Objective-C runtime.

ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)

Returns a pointer to a global variable representing a temporary with static or thread storage duratio...

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

void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)

Set the LLVM function attributes (sext, zext, etc).

CharUnits getMinimumObjectSize(QualType Ty)

Returns the minimum object size for an object of the given type.

void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)

Set the LLVM function attributes which only apply to a function definition.

ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)

Return a pointer to a constant array for the given ObjCEncodeExpr node.

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 setCurrentStmt(const Stmt *S)

If the execution count for the current statement is known, record that as the current count.

llvm::Type * ConvertType(QualType T)

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

const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)

A builtin function is a freestanding function using the default C conventions.

const CGRecordLayout & getCGRecordLayout(const RecordDecl *)

getCGRecordLayout - Return record layout info for the given record decl.

llvm::Type * ConvertTypeForMem(QualType T)

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

const llvm::DataLayout & getDataLayout() const

const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)

Figure out the rules for calling a function with the given formal type using the given arguments.

A specialization of Address that requires the address to be an LLVM Constant.

ConstantAddress withElementType(llvm::Type *ElemTy) const

llvm::Constant * getPointer() const

llvm::Constant * emitAbstract(const Expr *E, QualType T)

Emit the result of the given expression as an abstract constant, asserting that it succeeded.

llvm::Constant * tryEmitConstantExpr(const ConstantExpr *CE)

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

void mergeForCast(const LValueBaseInfo &Info)

AlignmentSource getAlignmentSource() const

LValue - This represents an lvalue references.

Expr * getBaseIvarExp() const

llvm::Constant * getExtVectorElts() const

static LValue MakeGlobalReg(llvm::Value *V, CharUnits alignment, QualType type)

void setObjCIvar(bool Value)

bool isObjCStrong() const

bool isGlobalObjCRef() const

void setObjCArray(bool Value)

bool isVolatileQualified() const

RValue asAggregateRValue() const

CharUnits getAlignment() const

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

llvm::Value * getMatrixIdx() const

llvm::Value * getGlobalReg() const

static LValue MakeAddr(Address Addr, QualType type, ASTContext &Context, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)

const Qualifiers & getQuals() const

static LValue MakeExtVectorElt(Address Addr, llvm::Constant *Elts, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)

Address getAddress() const

unsigned getVRQualifiers() const

void setThreadLocalRef(bool Value)

void setGlobalObjCRef(bool Value)

bool isExtVectorElt() const

llvm::Value * getVectorIdx() const

void setNontemporal(bool Value)

LValueBaseInfo getBaseInfo() const

void setARCPreciseLifetime(ARCPreciseLifetime_t value)

const CGBitFieldInfo & getBitFieldInfo() const

bool isThreadLocalRef() const

KnownNonNull_t isKnownNonNull() const

TBAAAccessInfo getTBAAInfo() const

void setNonGC(bool Value)

Address getVectorAddress() const

bool isNontemporal() const

static LValue MakeBitfield(Address Addr, const CGBitFieldInfo &Info, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)

Create a new object to represent a bit-field access.

static LValue MakeVectorElt(Address vecAddress, llvm::Value *Idx, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)

void setAddress(Address address)

void setBaseIvarExp(Expr *V)

Address getExtVectorAddress() const

static LValue MakeMatrixElt(Address matAddress, llvm::Value *Idx, QualType type, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)

Address getMatrixAddress() const

Address getBitFieldAddress() const

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

static RValue get(llvm::Value *V)

static RValue getAggregate(Address addr, bool isVolatile=false)

Convert an Address to an RValue.

static RValue getComplex(llvm::Value *V1, llvm::Value *V2)

Address getAggregateAddress() const

getAggregateAddr() - Return the Value* of the address of the aggregate.

llvm::Value * getScalarVal() const

getScalarVal() - Return the Value* of this scalar value.

An abstract representation of an aligned address.

RawAddress withElementType(llvm::Type *ElemTy) const

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

llvm::Type * getElementType() const

Return the type of the values stored in this address.

llvm::Value * getPointer() const

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 llvm::Constant * getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const

Return a constant used by UBSan as a signature to identify functions possessing type information,...

Complex values, per C99 6.2.5p11.

QualType getElementType() const

CompoundLiteralExpr - [C99 6.5.2.5].

ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.

ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...

Represents a concrete matrix type with constant number of rows and columns.

unsigned getNumRows() const

Returns the number of rows in the matrix.

RecordDecl * getOuterLexicalRecordContext()

Retrieve the outermost lexically enclosing record context.

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

bool refersToEnclosingVariableOrCapture() const

Does this DeclRefExpr refer to an enclosing local or a captured variable?

static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)

SourceLocation getLocation() const

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

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

void ConvertArgToString(ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, ArrayRef< intptr_t > QualTypeVals) const

Converts a diagnostic argument (as an intptr_t) into the string that represents it.

bool isFixed() const

Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...

void getValueRange(llvm::APInt &Max, llvm::APInt &Min) const

Calculates the [Min,Max) values the enum can store based on the NumPositiveBits and NumNegativeBits.

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

EnumDecl * getDecl() const

ExplicitCastExpr - An explicit cast written in the source code.

This represents one expression.

const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const

Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...

Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY

Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...

ExprValueKind getValueKind() const

getValueKind - The value kind that this expression produces.

Expr * IgnoreParenImpCasts() LLVM_READONLY

Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...

Expr * IgnoreImplicit() LLVM_READONLY

Skip past any implicit AST nodes 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 EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const

EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...

bool isLValue() const

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

bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const

EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...

Decl * getReferencedDeclOfCallee()

bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const

HasSideEffects - This routine returns true for all those expressions which have any effect other than...

Expr * IgnoreImpCasts() LLVM_READONLY

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

SourceLocation getExprLoc() const LLVM_READONLY

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

bool refersToBitField() const

Returns true if this expression is a gl-value that potentially refers to a bit-field.

bool isFlexibleArrayMemberLike(ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const

Check whether this array fits the idiom of a flexible array member, depending on the value of -fstric...

bool isOBJCGCCandidate(ASTContext &Ctx) const

isOBJCGCCandidate - Return true if this expression may be used in a read/ write barrier.

ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...

Represents a member of a struct/union/class.

bool isBitField() const

Determines whether this field is a bitfield.

unsigned getFieldIndex() const

Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...

const RecordDecl * getParent() const

Returns the parent of this field declaration, which is the struct in which this field is defined.

const FieldDecl * findCountedByField() const

Find the FieldDecl specified in a FAM's "counted_by" attribute.

FullExpr - Represents a "full-expression" node.

const Expr * getSubExpr() const

Represents a function declaration or definition.

unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const

Returns a value indicating whether this function corresponds to a builtin function.

Represents a prototype with parameter type info, e.g.

GlobalDecl - represents a global declaration.

const Decl * getDecl() const

This class represents temporary values used to represent inout and out arguments in HLSL.

Describes an C or C++ initializer list.

StrictFlexArraysLevelKind

SanitizerSet Sanitize

Set of enabled sanitizers.

virtual void mangleCXXRTTI(QualType T, raw_ostream &)=0

unsigned getBlockId(const BlockDecl *BD, bool Local)

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

StorageDuration getStorageDuration() const

Retrieve the storage duration for the materialized temporary.

Expr * getSubExpr() const

Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.

ValueDecl * getExtendingDecl()

Get the declaration which triggered the lifetime-extension of this temporary, if any.

MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

ValueDecl * getMemberDecl() const

Retrieve the member declaration to which this expression refers.

NonOdrUseReason isNonOdrUse() const

Is this expression a non-odr-use reference, and if so, why? This is only meaningful if the named memb...

SourceLocation getExprLoc() const LLVM_READONLY

A pointer to member type per C++ 8.3.3 - Pointers to members.

bool isObjCBOOLType(QualType T) const

Returns true if.

This represents a decl that may have a name.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

A C++ nested-name-specifier augmented with source location information.

bool containsType(SanitizerMask Mask, StringRef MangledTypeName, StringRef Category=StringRef()) const

ObjCEncodeExpr, used for @encode in Objective-C.

Represents an ObjC class declaration.

ObjCIvarDecl - Represents an ObjC instance variable.

ObjCIvarRefExpr - A reference to an ObjC instance variable.

An expression that sends a message to the given Objective-C object or class.

Represents a class type in Objective C.

ObjCSelectorExpr used for @selector in Objective-C.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

Expr * getSourceExpr() const

The source expression of an opaque value expression is the expression which originally generated the ...

ParenExpr - This represents a parenthesized expression, e.g.

PointerType - C99 6.7.5.1 - Pointer Declarators.

QualType getPointeeType() const

[C99 6.4.2.2] - A predefined identifier such as func.

StringRef getIdentKindName() const

Represents an unpacked "presumed" location which can be presented to the user.

unsigned getColumn() const

Return the presumed column number of this location.

const char * getFilename() const

Return the presumed filename of this location.

unsigned getLine() const

Return the presumed line number of this location.

PseudoObjectExpr - An expression which accesses a pseudo-object l-value.

const Expr *const * const_semantics_iterator

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

LangAS getAddressSpace() const

Return the address space of this type.

Qualifiers getQualifiers() const

Retrieve the set of qualifiers applied to this type.

Qualifiers::ObjCLifetime getObjCLifetime() const

Returns lifetime attribute of this type.

QualType getUnqualifiedType() const

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

QualType withCVRQualifiers(unsigned CVR) const

DestructionKind isDestructedType() const

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

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

The collection of all-type qualifiers we support.

unsigned getCVRQualifiers() const

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

void addCVRQualifiers(unsigned mask)

void addQualifiers(Qualifiers Q)

Add the qualifiers from the given set to this set.

void setAddressSpace(LangAS space)

ObjCLifetime getObjCLifetime() const

Represents a struct/union/class.

field_range fields() const

RecordDecl * getDefinition() const

Returns the RecordDecl that actually defines this struct/union/class.

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

decl_type * getPreviousDecl()

Return the previous declaration of this declaration or NULL if this is the first declaration.

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

Encodes a location in the source.

PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const

Returns the "presumed" location of a SourceLocation specifies.

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

Stmt - This represents one statement.

StmtClass getStmtClass() const

SourceLocation getBeginLoc() const LLVM_READONLY

StringLiteral - This represents a string literal expression, e.g.

Exposes information about the current target.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

virtual StringRef getABI() const

Get the ABI currently in use.

const Type * getTypeForDecl() const

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

bool isBooleanType() const

bool isSignedIntegerOrEnumerationType() const

Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...

bool hasAttr(attr::Kind AK) const

Determine whether this type had the specified attribute applied to it (looking through top-level type...

bool isSignedIntegerType() const

Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...

const ArrayType * castAsArrayTypeUnsafe() const

A variant of castAs<> for array type which silently discards qualifiers from the outermost type.

bool isConstantArrayType() const

bool isFunctionPointerType() const

bool isCountAttributedType() const

bool isArithmeticType() const

bool isConstantMatrixType() const

bool isPointerType() const

bool isIntegerType() const

isIntegerType() does not include complex integers (a GCC extension).

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

bool isVariableArrayType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isExtVectorBoolType() const

bool isBitIntType() const

bool isAnyComplexType() const

const Type * getBaseElementTypeUnsafe() const

Get the base element type of this type, potentially discarding type qualifiers.

bool isAtomicType() const

bool isVariablyModifiedType() const

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

bool isIncompleteType(NamedDecl **Def=nullptr) const

Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...

bool isFunctionType() const

bool isObjCObjectPointerType() const

bool isVectorType() const

bool isFloatingType() const

bool isSubscriptableVectorType() const

const T * getAs() const

Member-template getAs<specific type>'.

const Type * getUnqualifiedDesugaredType() const

Return the specified type with any "sugar" removed from the type, removing any typedefs,...

bool isRecordType() const

RecordDecl * getAsRecordDecl() const

Retrieves the RecordDecl this type refers to.

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

Represents a call to the builtin function __builtin_va_arg.

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.

TLSKind getTLSKind() const

VarDecl * getDefinition(ASTContext &)

Get the real (not just tentative) definition for this declaration.

bool hasLocalStorage() const

Returns true if a variable with function scope is a non-static local variable.

@ TLS_Dynamic

TLS with a dynamic initializer.

@ TLS_None

Not a TLS variable.

Represents a C array with a specified size that is not an integer-constant-expression.

Represents a GCC generic vector type.

unsigned getNumElements() const

AlignmentSource

The source of the alignment of an l-value; an expression of confidence in the alignment actually matc...

@ Decl

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

bool isEmptyFieldForLayout(const ASTContext &Context, const FieldDecl *FD)

isEmptyFieldForLayout - Return true iff the field is "empty", that is, either a zero-width bit-field ...

@ EHCleanup

Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...

static AlignmentSource getFieldAlignmentSource(AlignmentSource Source)

Given that the base address has the given alignment source, what's our confidence in the alignment of...

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

const AstTypeMatcher< ArrayType > arrayType

Matches all kinds of arrays.

const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr

Matches expressions.

const AstTypeMatcher< FunctionType > functionType

Matches FunctionType nodes.

constexpr Variable var(Literal L)

Returns the variable of L.

const void * Store

Store - This opaque type encapsulates an immutable mapping from locations to values.

bool This(InterpState &S, CodePtr OpPC)

bool Zero(InterpState &S, CodePtr OpPC)

bool IsNonNull(InterpState &S, CodePtr OpPC)

bool Load(InterpState &S, CodePtr OpPC)

bool Cast(InterpState &S, CodePtr OpPC)

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

@ OK_BitField

A bitfield object is a bitfield on a C or C++ record.

@ Asm

Assembly: we accept this only so that we can preprocess it.

StorageDuration

The storage duration for an object (per C++ [basic.stc]).

@ SD_Thread

Thread storage duration.

@ SD_Static

Static storage duration.

@ SD_FullExpression

Full-expression storage duration (for temporaries).

@ SD_Automatic

Automatic storage duration (most local variables).

@ SD_Dynamic

Dynamic storage duration.

@ Result

The result type of a method or function.

@ Dtor_Complete

Complete object dtor.

llvm::cl::opt< bool > ClSanitizeGuardChecks

const FunctionProtoType * T

LangAS getLangASFromTargetAS(unsigned TargetAS)

@ Interface

The "__interface" keyword introduces the elaborated-type-specifier.

bool isLambdaMethod(const DeclContext *DC)

@ Other

Other implicit parameter.

@ NOUR_Unevaluated

This name appears in an unevaluated operand.

@ NOUR_Constant

This name appears as a potential result of an lvalue-to-rvalue conversion that is a constant expressi...

__INTPTR_TYPE__ intptr_t

A signed integer type with the property that any valid pointer to void can be converted to this type,...

Structure with information about how a bitfield should be accessed.

CharUnits VolatileStorageOffset

The offset of the bitfield storage from the start of the struct.

unsigned VolatileOffset

The offset within a contiguous run of bitfields that are represented as a single "field" within the L...

unsigned Offset

The offset within a contiguous run of bitfields that are represented as a single "field" within the L...

unsigned VolatileStorageSize

The storage size in bits which should be used when accessing this bitfield.

unsigned Size

The total size of the bit-field, in bits.

unsigned StorageSize

The storage size in bits which should be used when accessing this bitfield.

unsigned IsSigned

Whether the bit-field is signed.

static Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc)

Returns address of the threadprivate variable for the current thread.

llvm::PointerType * VoidPtrTy

llvm::IntegerType * Int64Ty

CharUnits getIntAlign() const

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

unsigned char PointerWidthInBits

The width of a pointer into the generic address space.

llvm::IntegerType * SizeTy

llvm::IntegerType * Int32Ty

llvm::IntegerType * IntPtrTy

llvm::PointerType * Int8PtrTy

llvm::PointerType * UnqualPtrTy

CharUnits getPointerAlign() const

LangAS getASTAllocaAddressSpace() const

llvm::MDNode * AccessType

AccessType - The final access type.

uint64_t Offset

Offset - The byte offset of the final access within the base one.

static TBAAAccessInfo getMayAliasInfo()

uint64_t Size

Size - The size of access, in bytes.

llvm::MDNode * BaseType

BaseType - The base/leading access type.

EvalResult is a struct with detailed info about an evaluated expression.

APValue Val

Val - This is the value the expression can be folded to.

bool HasSideEffects

Whether the evaluated expression has side effects.

PointerAuthSchema FunctionPointers

The ABI for C function pointers.

void set(SanitizerMask K, bool Value)

Enable or disable a certain (single) sanitizer.

bool has(SanitizerMask K) const

Check if a certain (single) sanitizer is enabled.

An adjustment to be made to the temporary created when emitting a reference binding,...

@ DerivedToBaseAdjustment

@ MemberPointerAdjustment

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