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

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

clang: lib/CodeGen/CGExprCXX.cpp Source File

;

CodeGen;

MemberCallInfo {

llvm::Value *This, llvm::Value *ImplicitParam,

*MD = cast<CXXMethodDecl>(GD.

());

assert(CE ==

|| isa<CXXMemberCallExpr>(CE) ||

isa<CXXOperatorCallExpr>(CE));

assert(MD->isImplicitObjectMemberFunction() &&

);

PrefixSize = Args.size() - 1;

ArgsToSkip = 0;

(

*Op = dyn_cast<CXXOperatorCallExpr>(CE)) {

(

*M = dyn_cast<CXXMethodDecl>(Op->getCalleeDecl()))

(!M->isExplicitObjectMemberFunction());

);

{required, PrefixSize};

CodeGenFunction::EmitCXXMemberOrOperatorCall(

ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam,

llvm::CallBase **CallOrInvoke) {

*

, MD, This, ImplicitParam, ImplicitParamTy, CE, Args, RtlArgs);

Args, FPT, CallInfo.ReqArgs, CallInfo.PrefixSize);

llvm::CallBase **CallOrInvoke) {

assert(!ThisTy.

());

);

(SrcAS != DstAS) {

ImplicitParamTy, CE, Args,

);

DestroyedType =

->getDestroyedType();

*BaseExpr =

->getBase();

(

->isArrow()) {

BaseQuals = PTy->getPointeeType().getQualifiers();

cast<CXXRecordDecl>(Ty->

());

llvm::CallBase **CallOrInvoke) {

(isa<BinaryOperator>(callee))

*ME = cast<MemberExpr>(callee);

IsArrow = ME->

();

HasQualifier, Qualifier, IsArrow,

, CallOrInvoke);

*

, llvm::CallBase **CallOrInvoke) {

assert(isa<CXXMemberCallExpr>(CE) || isa<CXXOperatorCallExpr>(CE));

CanUseVirtualCall = MD->

() && !HasQualifier;

(CanUseVirtualCall &&

assert(DevirtualizedMethod);

*Inner =

->IgnoreParenBaseCasts();

DevirtualizedMethod =

;

DevirtualizedMethod =

;

TrivialForCodegen =

TrivialAssignment =

TrivialAssignmentRHS;

(

*OCE = dyn_cast<CXXOperatorCallExpr>(CE)) {

(OCE->isAssignmentOp()) {

(TrivialAssignment) {

RtlArgs = &RtlArgStorage;

assert(

.isNull() &&

);

,

.getAddress(), Args,

, CallOrInvoke);

(TrivialForCodegen) {

(isa<CXXDestructorDecl>(MD))

(TrivialAssignment) {

RHS = isa<CXXOperatorCallExpr>(CE)

? TrivialAssignmentRHS

);

DevirtualizedMethod ? DevirtualizedMethod : MD;

(

*Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl))

(

*CMCE = dyn_cast<CXXMemberCallExpr>(CE)) {

*IOA = CMCE->getImplicitObjectArgument();

(IsImplicitObjectCXXThis)

SkippedChecks.

(SanitizerKind::Alignment,

);

(IsImplicitObjectCXXThis || isa<DeclRefExpr>(IOA))

SkippedChecks.

(SanitizerKind::Null,

);

.emitRawPointer(*

),

UseVirtualCall = CanUseVirtualCall && !DevirtualizedMethod;

);

assert(

.isNull() &&

);

(UseVirtualCall) {

cast<CXXMemberCallExpr>(CE), CallOrInvoke);

(

().AppleKext && Dtor->isVirtual() && HasQualifier)

(!DevirtualizedMethod)

IsArrow ?

->getType()->getPointeeType() :

->getType();

(UseVirtualCall) {

(

.

(SanitizerKind::CFINVCall) &&

(!DevirtualizedMethod)

*

, CalleeDecl,

.getAddress(), UseVirtualCall);

.setAddress(NewThisAddr);

,

(), CE, RtlArgs, CallOrInvoke);

llvm::CallBase **CallOrInvoke) {

llvm::Value *ThisPtrForCall =

;

ThisPtrForCall, MemFnPtr, MPT);

);

,

->getArg(0), CallOrInvoke);

llvm::CallBase **CallOrInvoke) {

(

->isEmpty())

std::vector<CharUnits> VBPtrOffsets =

(

VBPtrOffset : VBPtrOffsets) {

(VBPtrOffset >= NVSize)

std::pair<CharUnits, CharUnits> LastStore = Stores.pop_back_val();

LastStoreOffset = LastStore.first;

LastStoreSize = LastStore.second;

SplitBeforeOffset = LastStoreOffset;

SplitBeforeSize = VBPtrOffset - SplitBeforeOffset;

assert(!SplitBeforeSize.

() &&

);

(!SplitBeforeSize.

())

Stores.emplace_back(SplitBeforeOffset, SplitBeforeSize);

SplitAfterOffset = VBPtrOffset + VBPtrWidth;

SplitAfterSize = LastStoreSize - SplitAfterOffset;

assert(!SplitAfterSize.

() &&

);

(!SplitAfterSize.

())

Stores.emplace_back(SplitAfterOffset, SplitAfterSize);

(!NullConstantForBase->isNullValue()) {

llvm::GlobalVariable *NullVariable =

llvm::GlobalVariable(

CGF.

.

(), NullConstantForBase->getType(),

, llvm::GlobalVariable::PrivateLinkage,

NullConstantForBase, Twine());

NullVariable->setAlignment(Align.

());

(std::pair<CharUnits, CharUnits> Store : Stores) {

llvm::Value *StoreSizeVal = CGF.

.

(StoreSize);

(std::pair<CharUnits, CharUnits> Store : Stores) {

llvm::Value *StoreSizeVal = CGF.

.

(StoreSize);

CGF.

.getInt8(0), StoreSizeVal);

assert(!Dest.

() &&

);

(

->requiresZeroInitialization() && !Dest.

()) {

(

->getConstructionKind()) {

(

().ElideConstructors &&

->isElidable()) {

*SrcObj =

->getArg(0);

ForVirtualBase =

;

(

->getConstructionKind()) {

ForVirtualBase =

;

Exp =

->getSubExpr();

assert(isa<CXXConstructExpr>(Exp) &&

);

RunCleanupsScope

(*

);

(

->requiresZeroInitialization())

&&

);

(

->getOperatorNew()->isReservedGlobalPlacementOperator())

minElements,

llvm::Value *&numElements,

llvm::Value *&sizeWithoutCookie) {

sizeWithoutCookie;

sizeWidth = CGF.

->getBitWidth();

llvm::APInt cookieSize(sizeWidth,

assert(isa<llvm::IntegerType>(numElements->getType()));

= (*e->

())->getType()->isSignedIntegerOrEnumerationType();

llvm::IntegerType *numElementsType

= cast<llvm::IntegerType>(numElements->getType());

numElementsWidth = numElementsType->getBitWidth();

llvm::APInt arraySizeMultiplier(sizeWidth, 1);

= CAT->getElementType();

arraySizeMultiplier *= CAT->getSize();

llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.

());

typeSizeMultiplier *= arraySizeMultiplier;

(llvm::ConstantInt *numElementsC =

dyn_cast<llvm::ConstantInt>(numElements)) {

llvm::APInt &count = numElementsC->getValue();

hasAnyOverflow =

;

(isSigned && count.isNegative())

hasAnyOverflow =

;

(numElementsWidth > sizeWidth &&

numElementsWidth - sizeWidth > count.countl_zero())

hasAnyOverflow =

;

llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth);

(adjustedCount.ult(minElements))

hasAnyOverflow =

;

numElements = llvm::ConstantInt::get(CGF.

,

adjustedCount * arraySizeMultiplier);

llvm::APInt allocationSize

= adjustedCount.umul_ov(typeSizeMultiplier, overflow);

hasAnyOverflow |= overflow;

(cookieSize != 0) {

sizeWithoutCookie = llvm::ConstantInt::get(CGF.

, allocationSize);

allocationSize = allocationSize.uadd_ov(cookieSize, overflow);

hasAnyOverflow |= overflow;

(hasAnyOverflow) {

size = llvm::Constant::getAllOnesValue(CGF.

);

size = llvm::ConstantInt::get(CGF.

, allocationSize);

llvm::Value *hasOverflow =

;

(numElementsWidth > sizeWidth) {

llvm::APInt threshold =

llvm::APInt::getOneBitSet(numElementsWidth, sizeWidth);

llvm::Value *thresholdV

= llvm::ConstantInt::get(numElementsType, threshold);

hasOverflow = CGF.

.CreateICmpUGE(numElements, thresholdV);

numElements = CGF.

.CreateTrunc(numElements, CGF.

);

}

(isSigned) {

(numElementsWidth < sizeWidth)

numElements = CGF.

.CreateSExt(numElements, CGF.

);

(typeSizeMultiplier == 1)

hasOverflow = CGF.

.CreateICmpSLT(numElements,

llvm::ConstantInt::get(CGF.

, minElements));

}

(numElementsWidth < sizeWidth) {

numElements = CGF.

.CreateZExt(numElements, CGF.

);

assert(numElements->getType() == CGF.

);

hasOverflow = CGF.

.CreateICmpULT(numElements,

llvm::ConstantInt::get(CGF.

, minElements));

}

(numElementsWidth > sizeWidth) {

hasOverflow = CGF.

.CreateOr(hasOverflow,

CGF.

.CreateICmpULT(numElements,

llvm::ConstantInt::get(CGF.

, minElements)));

(typeSizeMultiplier != 1) {

llvm::Function *umul_with_overflow

llvm::ConstantInt::get(CGF.

, typeSizeMultiplier);

llvm::Value *result =

CGF.

.CreateCall(umul_with_overflow, {size, tsmV});

llvm::Value *overflowed = CGF.

.CreateExtractValue(result, 1);

hasOverflow = CGF.

.CreateOr(hasOverflow, overflowed);

hasOverflow = overflowed;

size = CGF.

.CreateExtractValue(result, 0);

(arraySizeMultiplier != 1) {

(typeSize.

()) {

assert(arraySizeMultiplier == typeSizeMultiplier);

llvm::ConstantInt::get(CGF.

, arraySizeMultiplier);

numElements = CGF.

.CreateMul(numElements, asmV);

assert(arraySizeMultiplier == 1);

(cookieSize != 0) {

sizeWithoutCookie = size;

llvm::Function *uadd_with_overflow

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

, cookieSize);

llvm::Value *result =

CGF.

.CreateCall(uadd_with_overflow, {size, cookieSizeV});

llvm::Value *overflowed = CGF.

.CreateExtractValue(result, 1);

hasOverflow = CGF.

.CreateOr(hasOverflow, overflowed);

hasOverflow = overflowed;

size = CGF.

.CreateExtractValue(result, 0);

size = CGF.

.CreateSelect(hasOverflow,

llvm::Constant::getAllOnesValue(CGF.

),

sizeWithoutCookie = size;

assert(sizeWithoutCookie &&

);

llvm_unreachable(

);

BeginPtr, llvm::Value *NumElements,

llvm::Value *AllocSizeWithoutCookie) {

(!

->hasInitializer())

InitListElements = 0;

*

=

->getInitializer();

CleanupDeactivationScope deactivation(*

);

pushedCleanup =

;

TryMemsetInitialization = [&]() ->

{

*RemainingSize = AllocSizeWithoutCookie;

(InitListElements) {

*InitializedSize = llvm::ConstantInt::get(

RemainingSize->getType(),

().getTypeSizeInChars(ElementType).getQuantity() *

RemainingSize =

.CreateSub(RemainingSize, InitializedSize);

*IgnoreParen =

;

IgnoreParen =

->IgnoreParenImpCasts();

CPLIE = dyn_cast<CXXParenListInitExpr>(IgnoreParen);

SL = dyn_cast<StringLiteral>(IgnoreParen);

OCEE = dyn_cast<ObjCEncodeExpr>(IgnoreParen);

(ILE || CPLIE || SL || OCEE) {

cast<ConstantArrayType>(

->getType()->getAsArrayTypeUnsafe())

CurPtr, InitListElements,

);

llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);

(!ConstNum || !ConstNum->equalsInt(InitListElements)) {

OK = TryMemsetInitialization();

assert(OK &&

);

InitListElements = InitExprs.size();

AllocType =

->getAllocatedType();

AllocaTrackerRAII AllocaTracker(*

);

llvm::Instruction *DominatingIP =

EndOfInit, ElementType, ElementAlign,

.AddAuxAllocas(AllocaTracker.Take());

pushedCleanup =

;

(

*IE : InitExprs) {

(

&&

->getType()->isConstantArrayType()) {

*SubILE = dyn_cast<InitListExpr>(

);

assert(SubILE->getNumInits() == 0 &&

);

= SubILE->getArrayFiller();

llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);

(ConstNum && ConstNum->getZExtValue() <= InitListElements) {

assert(

&&

);

(!CCE->requiresZeroInitialization() || Ctor->

()->

())

(TryMemsetInitialization())

(InitListElements)

NumElements =

.CreateSub(

llvm::ConstantInt::get(NumElements->getType(), InitListElements));

CCE->requiresZeroInitialization());

(isa<ImplicitValueInitExpr>(

)) {

(TryMemsetInitialization())

assert(

().hasSameUnqualifiedType(ElementType,

->getType()) &&

);

(

*ILE = dyn_cast<InitListExpr>(

))

(ILE->

() == 0 && TryMemsetInitialization())

(

*ILE = dyn_cast<InitListExpr>(

)) {

(RType->getDecl()->isStruct()) {

NumElements = 0;

(

*CXXRD = dyn_cast<CXXRecordDecl>(RType->getDecl()))

NumElements = CXXRD->getNumBases();

(

*Field : RType->getDecl()->fields())

(!

->isUnnamedBitField())

(

i = 0, e = ILE->

(); i != e; ++i)

(!isa<ImplicitValueInitExpr>(ILE->

(i)))

(ILE->

() == NumElements && TryMemsetInitialization())

llvm::BasicBlock *EntryBB =

.GetInsertBlock();

EndPtr,

);

.CreateCondBr(IsEmpty, ContBB, LoopBB);

llvm::PHINode *CurPtrPhi =

CurPtrPhi->addIncoming(CurPtr.

(*

), EntryBB);

llvm::Instruction *DominatingIP =

deactivation.ForceDeactivate();

llvm::Value *NextPtr =

.CreateConstInBoundsGEP1_32(

llvm::Value *IsEnd =

.CreateICmpEQ(NextPtr, EndPtr,

);

.CreateCondBr(IsEnd, ContBB, LoopBB);

CurPtrPhi->addIncoming(NextPtr,

.GetInsertBlock());

ElementType, llvm::Type *ElementTy,

NewPtr, llvm::Value *NumElements,

llvm::Value *AllocSizeWithoutCookie) {

AllocSizeWithoutCookie);

(

*

=

->getInitializer())

llvm::CallBase *CallOrInvoke;

Args, CalleeType,

),

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

Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {

CallOrInvoke->addFnAttr(llvm::Attribute::Builtin);

(

*FD = dyn_cast<FunctionDecl>(

))

llvm_unreachable(

);

UsualDeleteParams {

DestroyingDelete =

;

Alignment =

;

UsualDeleteParams Params;

Params.DestroyingDelete =

;

Params.Size =

;

Params.Alignment =

;

assert(AI == AE &&

);

<

Traits>

Traits::ValueTy ValueTy;

Traits::RValueTy RValueTy;

PlacementArg {

NumPlacementArgs : 31;

LLVM_PREFERRED_TYPE(

)

PassAlignmentToPlacementDelete : 1;

PlacementArg *getPlacementArgs() {

PlacementArg *

(

+ 1);

getExtraSize(

NumPlacementArgs) {

NumPlacementArgs *

(PlacementArg);

CallDeleteDuringNew(

NumPlacementArgs,

ValueTy AllocSize,

PassAlignmentToPlacementDelete,

: NumPlacementArgs(NumPlacementArgs),

PassAlignmentToPlacementDelete(PassAlignmentToPlacementDelete),

OperatorDelete(OperatorDelete), Ptr(Ptr), AllocSize(AllocSize),

AllocAlign(AllocAlign) {}

setPlacementArg(

I, RValueTy Arg,

) {

assert(I < NumPlacementArgs &&

);

getPlacementArgs()[I] = {Arg,

};

DeleteArgs.

(Traits::get(CGF, Ptr), FPT->getParamType(0));

UsualDeleteParams Params;

(NumPlacementArgs) {

Params.Alignment = PassAlignmentToPlacementDelete;

assert(!Params.DestroyingDelete &&

);

DeleteArgs.add(Traits::get(CGF, AllocSize),

(Params.Alignment)

DeleteArgs.add(

(llvm::ConstantInt::get(

(

I = 0; I != NumPlacementArgs; ++I) {

Arg = getPlacementArgs()[I];

DeleteArgs.add(Traits::get(CGF, Arg.ArgValue), Arg.ArgType);

llvm::Value *AllocSize,

NumNonPlacementArgs =

->passAlignment() ? 2 : 1;

DirectCleanupTraits {

llvm::Value *ValueTy;

CallDeleteDuringNew<DirectCleanupTraits> DirectCleanup;

,

->getNumPlacementArgs(),

->getOperatorDelete(),

NewPtr.

(CGF), AllocSize,

->passAlignment(), AllocAlign);

(

I = 0, N =

->getNumPlacementArgs(); I != N; ++I) {

&Arg = NewArgs[I + NumNonPlacementArgs];

Cleanup->setPlacementArg(I, Arg.getRValue(CGF), Arg.Ty);

ConditionalCleanupTraits {

.restore(CGF);

CallDeleteDuringNew<ConditionalCleanupTraits> ConditionalCleanup;

ConditionalCleanup *Cleanup = CGF.

->getNumPlacementArgs(),

->getOperatorDelete(),

->passAlignment(),

(

I = 0, N =

->getNumPlacementArgs(); I != N; ++I) {

&Arg = NewArgs[I + NumNonPlacementArgs];

Cleanup->setPlacementArg(

minElements = 0;

(

->isArray() &&

->hasInitializer()) {

*

=

->getInitializer();

*IgnoreParen =

->IgnoreParenImpCasts();

isa<StringLiteral>(IgnoreParen) || isa<ObjCEncodeExpr>(IgnoreParen)) {

cast<ConstantArrayType>(

->getType()->getAsArrayTypeUnsafe())

}

(ILE || CPLIE) {

llvm::Value *numElements =

;

llvm::Value *allocSizeWithoutCookie =

;

llvm::Value *allocSize =

allocSizeWithoutCookie);

assert(

->getNumPlacementArgs() == 1);

*

= *

->placement_arguments().begin();

(

->getOperatorDelete() &&

!

->getOperatorDelete()->isReservedGlobalPlacementOperator()) {

ParamsToSkip = 0;

(allocSize != allocSizeWithoutCookie) {

allocAlign = std::max(allocAlign, cookieAlign);

(

->passAlignment()) {

assert(

().hasSameUnqualifiedType(

);

assert(allocator->

() &&

);

allocatorArgs.

(

(allocatorArgs, allocatorType,

->placement_arguments(),

AbstractCallee(),

ParamsToSkip);

(

*newCall = dyn_cast<llvm::CallBase>(RV.

()))

(!

->passAlignment() &&

AllocatorAlign = llvm::bit_floor(std::min<uint64_t>(

allocationAlign = std::max(

allocationAlign,

().toCharUnitsFromBits(AllocatorAlign));

nullCheck =

->shouldNullCheckAllocation() &&

llvm::BasicBlock *nullCheckBB =

;

llvm::BasicBlock *contBB =

;

ConditionalEvaluation conditional(*

);

conditional.begin(*

);

nullCheckBB =

.GetInsertBlock();

.CreateCondBr(isNull, contBB, notNullBB);

llvm::Instruction *cleanupDominator =

;

(

->getOperatorDelete() &&

!

->getOperatorDelete()->isReservedGlobalPlacementOperator()) {

cleanupDominator =

.CreateUnreachable();

assert((allocSize == allocSizeWithoutCookie) ==

(allocSize != allocSizeWithoutCookie) {

assert(

->isArray());

SkippedChecks.

(SanitizerKind::Null, nullCheck);

->getAllocatedTypeSourceInfo()->getTypeLoc().

(),

result, allocType, result.

(), SkippedChecks,

allocSizeWithoutCookie);

(operatorDeleteCleanup.

()) {

cleanupDominator->eraseFromParent();

conditional.end(*

);

llvm::BasicBlock *notNullBB =

.GetInsertBlock();

llvm::PHINode *PHI =

.CreatePHI(resultPtr->getType(), 2);

PHI->addIncoming(resultPtr, notNullBB);

PHI->addIncoming(llvm::Constant::getNullValue(resultPtr->getType()),

llvm::Value *DeletePtr,

DeleteTy,

llvm::Value *NumElements,

assert((!NumElements && CookieSize.

()) ||

ParamTypeIt = DeleteFTy->param_type_begin();

llvm::AllocaInst *DestroyingDeleteTag =

;

(Params.DestroyingDelete) {

DestroyingDeleteTag->setAlignment(Align.

());

SizeType = *ParamTypeIt++;

(!CookieSize.

())

(Params.Alignment) {

AlignValType = *ParamTypeIt++;

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

(AlignValType),

DeleteArgs.add(

(Align), AlignValType);

assert(ParamTypeIt == DeleteFTy->param_type_end() &&

);

(DestroyingDeleteTag && DestroyingDeleteTag->use_empty())

DestroyingDeleteTag->eraseFromParent();

CallObjectDelete(llvm::Value *Ptr,

: Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}

llvm::Value *CompletePtr,

OperatorDelete, ElementType);

(Dtor && Dtor->isVirtual())

llvm::BasicBlock *UnconditionalDeleteBlock) {

assert(!OperatorDelete->isDestroyingOperatorDelete());

UseVirtualCall =

;

(

*DevirtualizedDtor =

dyn_cast_or_null<const CXXDestructorDecl>(

UseVirtualCall =

;

Dtor = DevirtualizedDtor;

UseVirtualCall =

;

(UseVirtualCall) {

CGF.

.pushCleanup<CallObjectDelete>(

CGF.

(UnconditionalDeleteBlock);

llvm::Value *NumElements;

CallArrayDelete(llvm::Value *Ptr,

llvm::Value *NumElements,

: Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),

ElementType(ElementType), CookieSize(CookieSize) {}

CGF.

(OperatorDelete, Ptr, ElementType, NumElements,

llvm::Value *numElements =

;

llvm::Value *allocatedPtr =

;

numElements, allocatedPtr, cookieSize);

assert(allocatedPtr &&

);

*operatorDelete =

->getOperatorDelete();

allocatedPtr, operatorDelete,

numElements, elementType,

assert(numElements &&

);

deletedPtr.

(), arrayBegin, numElements,

);

*Arg =

->getArgument();

DeleteTy =

->getDestroyedType();

(

->getOperatorDelete()->isDestroyingOperatorDelete()) {

GEP.push_back(Zero);

=

().getAsConstantArrayType(DeleteTy)) {

DeleteTy = Arr->getElementType();

GEP.push_back(Zero);

(

->isArrayForm()) {

llvm::Type *StdTypeInfoPtrTy,

HasNullCheck) {

ThisPtr, SrcRecordTy);

llvm::BasicBlock *BadTypeidBlock =

CGF.

.CreateCondBr(

, BadTypeidBlock, EndBlock);

MaybeASCast = [=](

&&

) {

(

->isTypeOperand()) {

(

->isPotentiallyEvaluated() && !

->isMostDerived(

()))

->hasNullCheck());

llvm::Constant::getNullValue(DestLTy);

CGF.

.ClearInsertionPoint();

llvm::PoisonValue::get(DestLTy);

(IsDynamicCastToVoid) {

SrcRecordTy = SrcTy;

(!

.GetInsertBlock())

assert(SrcRecordTy->

() &&

);

IsExact = !IsDynamicCastToVoid &&

ShouldNullCheckSrcValue =

llvm::BasicBlock *CastNull =

;

llvm::BasicBlock *CastNotNull =

;

(ShouldNullCheckSrcValue) {

llvm::Value *

;

(IsDynamicCastToVoid) {

}

(IsExact) {

*

, ThisAddr, SrcRecordTy, DestTy, DestRecordTy, CastEnd, CastNull);

);

DestTy, DestRecordTy, CastEnd);

CastNotNull =

.GetInsertBlock();

llvm::Value *NullValue =

;

(ShouldNullCheckSrcValue) {

CastNull =

.GetInsertBlock();

PHI->addIncoming(

, CastNotNull);

PHI->addIncoming(NullValue, CastNull);

static MemberCallInfo commonEmitCXXMemberOrOperatorCall(CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *CE, CallArgList &Args, CallArgList *RtlArgs)

static llvm::Value * EmitTypeidFromVTable(CodeGenFunction &CGF, const Expr *E, llvm::Type *StdTypeInfoPtrTy, bool HasNullCheck)

static llvm::Value * EmitDynamicCastToNull(CodeGenFunction &CGF, QualType DestTy)

static RValue EmitNewDeleteCall(CodeGenFunction &CGF, const FunctionDecl *CalleeDecl, const FunctionProtoType *CalleeType, const CallArgList &Args)

Emit a call to an operator new or operator delete function, as implicitly created by new-expressions ...

static void EmitDestroyingObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType)

Emit the code for deleting a single object with a destroying operator delete.

static void EmitNullBaseClassInitialization(CodeGenFunction &CGF, Address DestPtr, const CXXRecordDecl *Base)

static void EnterNewDeleteCleanup(CodeGenFunction &CGF, const CXXNewExpr *E, Address NewPtr, llvm::Value *AllocSize, CharUnits AllocAlign, const CallArgList &NewArgs)

Enter a cleanup to call 'operator delete' if the initializer in a new-expression throws.

static bool EmitObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType, llvm::BasicBlock *UnconditionalDeleteBlock)

Emit the code for deleting a single object.

static UsualDeleteParams getUsualDeleteParams(const FunctionDecl *FD)

static CXXRecordDecl * getCXXRecord(const Expr *E)

static CharUnits CalculateCookiePadding(CodeGenFunction &CGF, const CXXNewExpr *E)

static void EmitArrayDelete(CodeGenFunction &CGF, const CXXDeleteExpr *E, Address deletedPtr, QualType elementType)

Emit the code for deleting an array of objects.

static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init, QualType AllocType, Address NewPtr, AggValueSlot::Overlap_t MayOverlap)

static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E, QualType ElementType, llvm::Type *ElementTy, Address NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)

static llvm::Value * EmitCXXNewAllocSize(CodeGenFunction &CGF, const CXXNewExpr *e, unsigned minElements, llvm::Value *&numElements, llvm::Value *&sizeWithoutCookie)

llvm::MachO::Target Target

static QualType getPointeeType(const MemRegion *R)

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

TranslationUnitDecl * getTranslationUnitDecl() const

const ConstantArrayType * getAsConstantArrayType(QualType T) const

CharUnits getTypeAlignInChars(QualType T) const

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

DeclarationNameTable DeclarationNames

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

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

bool hasSameType(QualType T1, QualType T2) const

Determine whether the given types T1 and T2 are equivalent.

QualType getPointerType(QualType T) const

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

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

CanQualType getSizeType() const

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

CharUnits getTypeSizeInChars(QualType T) const

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

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const

Return number of constant array elements.

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

CharUnits getNonVirtualAlignment() const

getNonVirtualAlignment - Get the non-virtual alignment (in chars) of an object, which is the alignmen...

CharUnits getNonVirtualSize() const

getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...

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

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

Represents a call to a CUDA kernel function.

Represents a call to a C++ constructor.

Represents a C++ constructor within a class.

bool isDefaultConstructor() const

Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...

Represents a delete expression for memory deallocation and destructor calls, e.g.

FunctionDecl * getOperatorDelete() const

Represents a C++ destructor within a class.

A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).

bool isAlwaysNull() const

isAlwaysNull - Return whether the result of the dynamic_cast is proven to always be null.

Represents a call to a member function that may be written either with member call syntax (e....

Represents a static or instance method of a struct/union/class.

bool isImplicitObjectMemberFunction() const

[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...

const CXXRecordDecl * getParent() const

Return the parent of this method declaration, which is the class in which this method is defined.

QualType getThisType() const

Return the type of the this pointer.

bool isMoveAssignmentOperator() const

Determine whether this is a move assignment operator.

Qualifiers getMethodQualifiers() const

CXXMethodDecl * getDevirtualizedMethod(const Expr *Base, bool IsAppleKext)

If it's possible to devirtualize a call to this method, return the called function.

CXXMethodDecl * getCorrespondingMethodInClass(const CXXRecordDecl *RD, bool MayBeBase=false)

Find the method in RD that corresponds to this one.

bool isCopyAssignmentOperator() const

Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...

Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".

QualType getAllocatedType() const

std::optional< Expr * > getArraySize()

This might return std::nullopt even if isArray() returns true, since there might not be an array size...

A call to an overloaded operator written using operator syntax.

Represents a list-initialization with parenthesis.

ArrayRef< Expr * > getInitExprs()

Represents a C++ pseudo-destructor (C++ [expr.pseudo]).

Represents a C++ struct/union/class.

bool isEffectivelyFinal() const

Determine whether it's impossible for a class to be derived from this class.

bool hasTrivialDestructor() const

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

bool isDynamicClass() const

bool hasDefinition() const

bool isEmpty() const

Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).

CXXDestructorDecl * getDestructor() const

Returns the destructor decl for this class.

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

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

Expr * getArg(unsigned Arg)

getArg - Return the specified argument.

SourceLocation getBeginLoc() const LLVM_READONLY

FunctionDecl * getDirectCallee()

If the callee is a FunctionDecl, return it. Otherwise return null.

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?

bool isNegative() const

isNegative - Test whether the quantity is less than zero.

bool isZero() const

isZero - Test whether the quantity equals zero.

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.

CharUnits alignmentOfArrayElement(CharUnits elementSize) const

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

bool isOne() const

isOne - Test whether the quantity equals one.

static CharUnits Zero()

Zero - Construct a CharUnits quantity of zero.

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

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

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

CharUnits getAlignment() const

llvm::Type * getElementType() const

Return the type of the values stored in this address.

Address withElementType(llvm::Type *ElemTy) const

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

Address setKnownNonNull()

void setAlignment(CharUnits Value)

llvm::PointerType * getType() const

Return the type of the pointer value.

bool isSanitizerChecked() const

Address getAddress() const

IsZeroed_t isZeroed() const

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

forAddr - Make a slot for an aggregate value.

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

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.

llvm::Value * CreateIsNull(Address Addr, const Twine &Name="")

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

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

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

Emit a load from an i1 flag variable.

Address CreateLaunderInvariantGroup(Address Addr)

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

llvm::ConstantInt * getSize(CharUnits N)

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 RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF, const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke=nullptr)

virtual bool shouldEmitExactDynamicCast(QualType DestRecordTy)=0

virtual std::vector< CharUnits > getVBPtrOffsets(const CXXRecordDecl *RD)

Gets the offsets of all the virtual base pointers in a given class.

virtual void ReadArrayCookie(CodeGenFunction &CGF, Address Ptr, const CXXDeleteExpr *expr, QualType ElementType, llvm::Value *&NumElements, llvm::Value *&AllocPtr, CharUnits &CookieSize)

Reads the array cookie associated with the given pointer, if it has one.

virtual bool shouldTypeidBeNullChecked(QualType SrcRecordTy)=0

virtual std::pair< llvm::Value *, const CXXRecordDecl * > LoadVTablePtr(CodeGenFunction &CGF, Address This, const CXXRecordDecl *RD)=0

Load a vtable from This, an object of polymorphic type RD, or from one of its virtual bases if it doe...

virtual Address adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD, Address This, bool VirtualCall)

Perform ABI-specific "this" argument adjustment required prior to a call of a virtual function.

virtual void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType, const CXXDestructorDecl *Dtor)=0

virtual llvm::Value * emitExactDynamicCast(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy, QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastSuccess, llvm::BasicBlock *CastFail)=0

Emit a dynamic_cast from SrcRecordTy to DestRecordTy.

virtual const CXXRecordDecl * getThisArgumentTypeForMethod(GlobalDecl GD)

Get the type of the implicit "this" parameter used by a method.

virtual bool EmitBadCastCall(CodeGenFunction &CGF)=0

virtual llvm::Value * EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy, Address ThisPtr, llvm::Type *StdTypeInfoPtrTy)=0

virtual CGCallee EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E, Address This, llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr, const MemberPointerType *MPT)

Load a member function from an object and a member function pointer.

virtual llvm::Value * EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType, Address This, DeleteOrMemberCallExpr E, llvm::CallBase **CallOrInvoke)=0

Emit the ABI-specific virtual destructor call.

virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr)

Returns the extra size required in order to store the array cookie for the given new-expression.

virtual void EmitBadTypeidCall(CodeGenFunction &CGF)=0

virtual llvm::Value * emitDynamicCastToVoid(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy)=0

virtual llvm::Value * emitDynamicCastCall(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy, QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd)=0

virtual Address InitializeArrayCookie(CodeGenFunction &CGF, Address NewPtr, llvm::Value *NumElements, const CXXNewExpr *expr, QualType ElementType)

Initialize the array cookie for the given allocation.

virtual bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr, QualType SrcRecordTy)=0

All available information about a concrete callee.

static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr, llvm::FunctionType *FTy)

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

void addHeapAllocSiteMetadata(llvm::CallBase *CallSite, QualType AllocatedTy, SourceLocation Loc)

Add heapallocsite metadata for MSAllocator calls.

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

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

void add(RValue rvalue, QualType type)

void addFrom(const CallArgList &other)

Add all the arguments from another CallArgList to this one.

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

void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, Address This, Address Src, const CXXConstructExpr *E)

void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, llvm::Value *CompletePtr, QualType ElementType)

void EmitARCDestroyWeak(Address addr)

void EmitNullInitialization(Address DestPtr, QualType Ty)

EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...

GlobalDecl CurGD

CurGD - The GlobalDecl for the current function being compiled.

void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)

DeactivateCleanupBlock - Deactivates the given cleanup block.

static TypeEvaluationKind getEvaluationKind(QualType T)

getEvaluationKind - Return the TypeEvaluationKind of QualType T.

bool sanitizePerformTypeCheck() const

Whether any type-checking sanitizers are enabled.

SanitizerSet SanOpts

Sanitizers enabled for this function.

void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)

EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.

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

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

RValue EmitCXXMemberOrOperatorCall(const CXXMethodDecl *Method, const CGCallee &Callee, ReturnValueSlot ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E, CallArgList *RtlArgs, llvm::CallBase **CallOrInvoke)

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

void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp)

void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, const ArrayType *ArrayTy, Address ArrayPtr, const CXXConstructExpr *E, bool NewPointerIsChecked, bool ZeroInitialization=false)

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

RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow, const Expr *Base, llvm::CallBase **CallOrInvoke)

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

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

llvm::SmallVector< DeferredDeactivateCleanup > DeferredDeactivationCleanupStack

void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, QualType DeleteTy, llvm::Value *NumElements=nullptr, CharUnits CookieSize=CharUnits())

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)

const LangOptions & getLangOpts() const

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

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

EmitBlock - Emit the given block.

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

@ TCK_ConstructorCall

Checking the 'this' pointer for a constructor call.

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

void EmitIgnoredExpr(const Expr *E)

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

llvm::Type * ConvertTypeForMem(QualType T)

void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy)

Emit an aggregate assignment.

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

@ ForceRightToLeft

! Language semantics require right-to-left evaluation.

Destroyer * getDestroyer(QualType::DestructionKind destructionKind)

void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType, llvm::Type *ElementTy, Address NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)

void initFullExprCleanup()

Set up the last cleanup that was pushed as a conditional full-expression cleanup.

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.

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

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

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)

RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, const CallExpr *TheCallExpr, bool IsDelete)

void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, AggValueSlot ThisAVS, const CXXConstructExpr *E)

CGDebugInfo * getDebugInfo()

void EmitBranch(llvm::BasicBlock *Block)

EmitBranch - Emit a branch to the specified basic block from the current insert block,...

void EmitCXXDeleteExpr(const CXXDeleteExpr *E)

const TargetCodeGenInfo & getTargetHooks() const

void EmitAggExpr(const Expr *E, AggValueSlot AS)

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

RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue, llvm::CallBase **CallOrInvoke)

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

ASTContext & getContext() const

CGCallee BuildAppleKextVirtualCall(const CXXMethodDecl *MD, NestedNameSpecifier *Qual, llvm::Type *Ty)

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

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

bool needsEHCleanup(QualType::DestructionKind kind)

Determines whether an EH cleanup is required to destroy a type with the given destruction 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)

CodeGenTypes & getTypes() const

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

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

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

const CallExpr * MustTailCall

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

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

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

llvm::Value * EmitCXXNewExpr(const CXXNewExpr *E)

void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)

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

static bool IsWrappedCXXThis(const Expr *E)

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

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

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

llvm::Module & getModule() const

llvm::Constant * EmitNullConstantForBase(const CXXRecordDecl *Record)

Return a null constant appropriate for zero-initializing a base class with the given type.

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.

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

Return the address of the constructor/destructor of the given type.

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

CGCXXABI & getCXXABI() const

const CodeGenOptions & getCodeGenOpts() const

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

LangAS GetGlobalVarAddressSpace(const VarDecl *D)

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

llvm::ConstantInt * getSize(CharUnits numChars)

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

llvm::Type * ConvertType(QualType T)

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

const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)

C++ methods have some special rules and also have implicit parameters.

CanQualType DeriveThisType(const CXXRecordDecl *RD, const CXXMethodDecl *MD)

Derives the 'this' type for codegen purposes, i.e.

llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)

GetFunctionType - Get the LLVM function type for.

const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required, unsigned numPrefixArgs)

Arrange a call to a C++ method, passing the given arguments.

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.

bool isZeroInitializable(QualType T)

IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...

const CGFunctionInfo & arrangeCXXStructorDeclaration(GlobalDecl GD)

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

Try to emit the result of the given expression as an abstract constant.

Information for lazily generating a cleanup.

A saved depth on the scope stack.

stable_iterator stable_begin() const

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

T * pushCleanupWithExtra(CleanupKind Kind, size_t N, As... A)

Push a cleanup with non-constant storage requirements on the stack.

iterator find(stable_iterator save) const

Turn a stable reference to a scope depth into a unstable pointer to the EH stack.

AlignmentSource getAlignmentSource() const

LValue - This represents an lvalue references.

Address getAddress() const

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

static RValue get(llvm::Value *V)

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

Convert an Address to an RValue.

llvm::Value * getScalarVal() const

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

A class for recording the number of arguments that a function signature requires.

static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)

Compute the arguments required by the given formal prototype, given that there may be some additional...

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

Represents the canonical version of C arrays with a specified constant size.

DeclContext * getParent()

getParent - Returns the containing DeclContext.

lookup_result lookup(DeclarationName Name) const

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

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

The name of a declaration.

QualType getIntegerType() const

Return the integer type this enum decl corresponds to.

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

EnumDecl * getDecl() const

QualType getTypeAsWritten() const

getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...

Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...

This represents one expression.

Expr * IgnoreParens() LLVM_READONLY

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

bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const

Determine whether the result of this expression is a temporary object of the given class type.

SourceLocation getExprLoc() const LLVM_READONLY

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

Represents a function declaration or definition.

bool isDestroyingOperatorDelete() const

Determine whether this is a destroying operator delete.

QualType getReturnType() const

bool isTrivial() const

Whether this function is "trivial" in some specialized C++ senses.

bool isVariadic() const

Whether this function is variadic.

bool isReservedGlobalPlacementOperator() const

Determines whether this operator new or delete is one of the reserved global placement operators: voi...

bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const

Determines whether this function is one of the replaceable global allocation functions: void *operato...

bool isDefaulted() const

Whether this function is defaulted.

OverloadedOperatorKind getOverloadedOperator() const

getOverloadedOperator - Which C++ overloaded operator this function represents, if any.

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

param_type_iterator param_type_begin() const

unsigned getNumParams() const

QualType getParamType(unsigned i) const

param_type_iterator param_type_end() const

GlobalDecl - represents a global declaration.

CXXCtorType getCtorType() const

const Decl * getDecl() const

Represents an implicitly-generated value initialization of an object of a given type.

Describes an C or C++ initializer list.

bool isStringLiteralInit() const

Is this an initializer for an array of characters, initialized by a string literal or an @encode?

unsigned getNumInits() const

Expr * getArrayFiller()

If this initializer list initializes an array with more elements than there are initializers in the l...

const Expr * getInit(unsigned Init) const

ArrayRef< Expr * > inits()

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

ValueDecl * getMemberDecl() const

Retrieve the member declaration to which this expression refers.

bool hasQualifier() const

Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...

NestedNameSpecifier * getQualifier() const

If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.

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

Represents a C++ nested name specifier, such as "\::std::vector<int>::".

ObjCEncodeExpr, used for @encode in Objective-C.

PointerType - C99 6.7.5.1 - Pointer Declarators.

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

DestructionKind isDestructedType() const

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

bool isPODType(const ASTContext &Context) const

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

bool hasStrongOrWeakObjCLifetime() const

The collection of all-type qualifiers we support.

@ OCL_Strong

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

@ OCL_ExplicitNone

This object can be modified without requiring retains or releases.

@ OCL_None

There is no lifetime qualification on this type.

@ OCL_Weak

Reading or writing from this object requires a barrier call.

@ OCL_Autoreleasing

Assigning into this object requires a lifetime extension.

LangAS getAddressSpace() const

bool mayInsertExtraPadding(bool EmitRemark=false) const

Whether we are allowed to insert extra padding between fields.

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

RecordDecl * getDecl() const

Base for LValueReferenceType and RValueReferenceType.

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

Encodes a location in the source.

SourceLocation getBeginLoc() const LLVM_READONLY

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

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

bool isVoidPointerType() 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>.

QualType getPointeeType() const

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

const ArrayType * getAsArrayTypeUnsafe() const

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

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

@ Decl

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

@ EHCleanup

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

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

const AstTypeMatcher< ArrayType > arrayType

Matches all kinds of arrays.

bool This(InterpState &S, CodePtr OpPC)

bool Zero(InterpState &S, CodePtr OpPC)

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

CXXCtorType

C++ constructor types.

@ Ctor_Base

Base object ctor.

@ Ctor_Complete

Complete object ctor.

@ Dtor_Complete

Complete object dtor.

LangAS

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

const FunctionProtoType * T

bool declaresSameEntity(const Decl *D1, const Decl *D2)

Determine whether two declarations declare the same entity.

__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

CharUnits getPointerSize() const

llvm::IntegerType * SizeTy

CharUnits getSizeAlign() const

llvm::PointerType * Int8PtrTy

CharUnits getPointerAlign() const

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

static saved_type save(CodeGenFunction &CGF, type value)

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.

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