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

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

clang: lib/CodeGen/ItaniumCXXABI.cpp Source File

;

CodeGen;

llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> VTables;

UseARMMethodPtrABI;

UseARMGuardVarABI;

Use32BitVTableOffsetABI;

UseARMMethodPtrABI =

,

UseARMGuardVarABI =

) :

(CGM), UseARMMethodPtrABI(UseARMMethodPtrABI),

UseARMGuardVarABI(UseARMGuardVarABI),

Use32BitVTableOffsetABI(

) { }

(isa<CXXDestructorDecl>(GD.

())) {

llvm_unreachable(

);

llvm_unreachable(

);

(isa<CXXConstructorDecl>(GD.

())) {

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

llvm::Value *&ThisPtrForCall,

llvm::Value *MemFnPtr,

llvm::Value *Src)

;

llvm::Constant *Src)

;

llvm::Value *L, llvm::Value *R,

Inequality)

;

llvm::Value *Exn)

;

EmitFundamentalRTTIDescriptors(

*RD);

CatchHandlerType)

{

llvm::Type *StdTypeInfoPtrTy)

;

hasUniqueVTablePointer(

RecordTy) {

(!CGM.getCodeGenOpts().AssumeUniqueVTables ||

getContext().getLangOpts().AppleKext)

(!CGM.shouldEmitRTTI())

(!llvm::GlobalValue::isWeakForLinker(CGM.getVTableLinkage(RD)))

llvm::GlobalValue::DefaultVisibility)

hasUniqueVTablePointer(DestRecordTy);

llvm::BasicBlock *CastEnd)

;

llvm::BasicBlock *CastSuccess,

llvm::BasicBlock *CastFail)

;

AddedStructorArgCounts

CodeGenFunction::VPtr Vptr)

;

llvm::Value *getVTableAddressPointInStructorWithVTT(

DeleteOrMemberCallExpr

,

llvm::CallBase **CallOrInvoke)

;

canSpeculativelyEmitVTableAsBaseClass(

*RD)

;

(ForVTable && !Thunk->hasLocalLinkage())

Thunk->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);

CGM.setGVProperties(Thunk, GD);

assert(!Args.empty() &&

);

Args.size() - 1;

{

; }

llvm::Value *NumElements,

llvm::GlobalVariable *DeclPtr,

PerformInit)

;

llvm::FunctionCallee dtor,

llvm::Constant *addr)

;

llvm::Function *getOrCreateThreadLocalWrapper(

*VD,

getOrCreateVirtualFunctionPointerThunk(

*MD);

shouldRTTIBeUnique()

{

; }

RTTIUniquenessKind {

classifyRTTIUniqueness(

CanTy,

llvm::GlobalValue::LinkageTypes

)

;

ItaniumRTTIBuilder;

std::pair<llvm::Value *, const CXXRecordDecl *>

getSignedVirtualMemberFunctionPointer(

*MD);

hasAnyUnusedVirtualInlineFunction(

*RD)

{

&VtableLayout =

CGM.getItaniumVTableContext().getVTableLayout(RD);

(

&VtableComponent : VtableLayout.vtable_components()) {

(!VtableComponent.isUsedFunctionPointerKind())

*Method = VtableComponent.getFunctionDecl();

IsInlined =

StringRef Name = CGM.getMangledName(VtableComponent.getGlobalDecl());

*Entry = CGM.GetGlobalValue(Name);

(!Entry || Entry->isDeclaration())

&VtableLayout =

CGM.getItaniumVTableContext().getVTableLayout(RD);

(

&VtableComponent : VtableLayout.vtable_components()) {

(VtableComponent.isRTTIKind()) {

*RTTIDecl = VtableComponent.getRTTIDecl();

(RTTIDecl->

() == Visibility::HiddenVisibility)

}

(VtableComponent.isUsedFunctionPointerKind()) {

*Method = VtableComponent.getFunctionDecl();

(Method->

() == Visibility::HiddenVisibility &&

ARMCXXABI :

ItaniumCXXABI {

ItaniumCXXABI(CGM,

,

constructorsAndDestructorsReturnThis()

{

; }

llvm::Value *NumElements,

AppleARM64CXXABI :

ARMCXXABI {

Use32BitVTableOffsetABI =

;

shouldRTTIBeUnique()

{

; }

FuchsiaCXXABI final :

ItaniumCXXABI {

: ItaniumCXXABI(CGM) {}

constructorsAndDestructorsReturnThis()

{

; }

WebAssemblyCXXABI final :

ItaniumCXXABI {

: ItaniumCXXABI(CGM,

,

llvm::Value *Exn)

;

constructorsAndDestructorsReturnThis()

{

; }

canCallMismatchedFunctionType()

{

; }

XLCXXABI final :

ItaniumCXXABI {

: ItaniumCXXABI(CGM) {}

llvm::FunctionCallee dtor,

llvm::Constant *addr)

;

useSinitAndSterm()

{

; }

emitCXXStermFinalizer(

&

, llvm::Function *dtorStub,

llvm::Constant *addr);

TargetCXXABI::GenericARM:

TargetCXXABI::iOS:

TargetCXXABI::WatchOS:

ARMCXXABI(CGM);

TargetCXXABI::AppleARM64:

AppleARM64CXXABI(CGM);

TargetCXXABI::Fuchsia:

FuchsiaCXXABI(CGM);

TargetCXXABI::GenericAArch64:

ItaniumCXXABI(CGM,

,

TargetCXXABI::GenericMIPS:

ItaniumCXXABI(CGM,

);

TargetCXXABI::WebAssembly:

WebAssemblyCXXABI(CGM);

TargetCXXABI::XL:

XLCXXABI(CGM);

TargetCXXABI::GenericItanium:

ItaniumCXXABI(CGM);

TargetCXXABI::Microsoft:

llvm_unreachable(

);

llvm_unreachable(

);

CGM.PtrDiffTy;

llvm::StructType::get(CGM.PtrDiffTy, CGM.PtrDiffTy);

ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(

llvm::Value *&ThisPtrForCall,

llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);

llvm::BasicBlock *FnNonVirtual = CGF.

(

);

llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1,

);

llvm::Value *Adj = RawAdj;

(UseARMMethodPtrABI)

Adj = Builder.CreateAShr(Adj, ptrdiff_1,

);

This = Builder.CreateInBoundsGEP(Builder.getInt8Ty(), This, Adj);

ThisPtrForCall = This;

llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0,

);

llvm::Value *IsVirtual;

(UseARMMethodPtrABI)

IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1);

IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1);

IsVirtual = Builder.CreateIsNotNull(IsVirtual,

);

Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);

llvm::Value *VTableOffset = FnAsInt;

(!UseARMMethodPtrABI)

VTableOffset = Builder.CreateSub(VTableOffset, ptrdiff_1);

(Use32BitVTableOffsetABI) {

VTableOffset = Builder.CreateTrunc(VTableOffset, CGF.

);

VTableOffset = Builder.CreateZExt(VTableOffset, CGM.PtrDiffTy);

llvm::Constant *CheckSourceLocation;

llvm::Constant *CheckTypeDesc;

ShouldEmitCFICheck = CGF.

.

(SanitizerKind::CFIMFCall) &&

CGM.HasHiddenLTOVisibility(RD);

ShouldEmitVFEInfo = CGM.getCodeGenOpts().VirtualFunctionElimination &&

CGM.HasHiddenLTOVisibility(RD);

ShouldEmitWPDInfo =

CGM.getCodeGenOpts().WholeProgramVTables &&

!CGM.AlwaysHasLTOVisibilityPublic(RD);

llvm::Value *VirtualFn =

;

CodeGenFunction::SanitizerScope SanScope(&CGF);

llvm::Value *TypeId =

;

llvm::Value *CheckResult =

;

(ShouldEmitCFICheck || ShouldEmitVFEInfo || ShouldEmitWPDInfo) {

CGM.CreateMetadataIdentifierForVirtualMemPtrType(

(MPT, 0));

(ShouldEmitVFEInfo) {

llvm::Value *VFPAddr =

Builder.CreateGEP(CGF.

, VTable, VTableOffset);

llvm::Value *CheckedLoad = Builder.CreateCall(

CGM.getIntrinsic(llvm::Intrinsic::type_checked_load),

{VFPAddr, llvm::ConstantInt::get(CGM.Int32Ty, 0), TypeId});

CheckResult = Builder.CreateExtractValue(CheckedLoad, 1);

VirtualFn = Builder.CreateExtractValue(CheckedLoad, 0);

(ShouldEmitCFICheck || ShouldEmitWPDInfo) {

llvm::Value *VFPAddr =

Builder.CreateGEP(CGF.

, VTable, VTableOffset);

llvm::Intrinsic::ID IID = CGM.HasHiddenLTOVisibility(RD)

? llvm::Intrinsic::type_test

: llvm::Intrinsic::public_type_test;

Builder.CreateCall(CGM.getIntrinsic(IID), {VFPAddr, TypeId});

(CGM.getItaniumVTableContext().isRelativeLayout()) {

VirtualFn = CGF.

.CreateCall(

CGM.getIntrinsic(llvm::Intrinsic::load_relative,

{VTableOffset->getType()}),

{VTable, VTableOffset});

llvm::Value *VFPAddr =

);

assert(VirtualFn &&

);

assert((!ShouldEmitCFICheck || !ShouldEmitVFEInfo || !ShouldEmitWPDInfo ||

);

(ShouldEmitCFICheck) {

llvm::Constant *StaticData[] = {

llvm::ConstantInt::get(CGF.

, CodeGenFunction::CFITCK_VMFCall),

(CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIMFCall)) {

CGF.

(CheckResult, SanitizerHandler::CFICheckFail);

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

CGM.getLLVMContext(),

llvm::MDString::get(CGM.getLLVMContext(),

));

llvm::Value *ValidVtable = Builder.CreateCall(

CGM.getIntrinsic(llvm::Intrinsic::type_test), {VTable, AllVtables});

CGF.

(std::make_pair(CheckResult, SanitizerKind::SO_CFIMFCall),

SanitizerHandler::CFICheckFail, StaticData,

{VTable, ValidVtable});

FnVirtual = Builder.GetInsertBlock();

llvm::Value *NonVirtualFn =

Builder.CreateIntToPtr(FnAsInt, CGF.

,

);

(ShouldEmitCFICheck) {

CodeGenFunction::SanitizerScope SanScope(&CGF);

llvm::Constant *StaticData[] = {

llvm::ConstantInt::get(CGF.

, CodeGenFunction::CFITCK_NVMFCall),

llvm::Value *Bit = Builder.getFalse();

llvm::Metadata *MD = CGM.CreateMetadataIdentifierForType(

getContext().getMemberPointerType(

llvm::Value *TypeId =

llvm::Value *TypeTest =

Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::type_test),

{NonVirtualFn, TypeId});

Bit = Builder.CreateOr(Bit, TypeTest);

CGF.

(std::make_pair(Bit, SanitizerKind::SO_CFIMFCall),

SanitizerHandler::CFICheckFail, StaticData,

{NonVirtualFn, llvm::UndefValue::get(CGF.

)});

FnNonVirtual = Builder.GetInsertBlock();

llvm::PHINode *CalleePtr = Builder.CreatePHI(CGF.

, 2);

CalleePtr->addIncoming(VirtualFn, FnVirtual);

CalleePtr->addIncoming(NonVirtualFn, FnNonVirtual);

(

&Schema =

CGM.getCodeGenOpts().PointerAuth.CXXMemberFunctionPointers) {

llvm::PHINode *DiscriminatorPHI = Builder.CreatePHI(CGF.

, 2);

DiscriminatorPHI->addIncoming(llvm::ConstantInt::get(CGF.

, 0),

&AuthInfo =

CGM.getMemberFunctionPointerAuthInfo(

(MPT, 0));

assert(Schema.getKey() == AuthInfo.getKey() &&

);

*NonVirtualDiscriminator = AuthInfo.getDiscriminator();

DiscriminatorPHI->addIncoming(NonVirtualDiscriminator, FnNonVirtual);

Schema.getKey(), Schema.getAuthenticationMode(), Schema.isIsaPointer(),

Schema.authenticatesNullValues(), DiscriminatorPHI);

llvm::Value *ItaniumCXXABI::EmitMemberDataPointerAddress(

assert(MemPtr->getType() == CGM.PtrDiffTy);

Builder.CreateInBoundsGEP(CGF.

,

.emitRawPointer(CGF), MemPtr,

*CPA = dyn_cast<llvm::ConstantPtrAuth>(Ptr);

assert(CPA->getKey()->getZExtValue() == CurAuthInfo.

() &&

CPA->getAddrDiscriminator()->isZeroValue() &&

);

CPA->getPointer(), NewAuthInfo.

(),

,

(isa<llvm::Constant>(src))

EmitMemberPointerConversion(

, cast<llvm::Constant>(src));

assert(

->getCastKind() == CK_DerivedToBaseMemberPointer ||

->getCastKind() == CK_BaseToDerivedMemberPointer ||

->getCastKind() == CK_ReinterpretMemberPointer);

(

&NewAuthInfo =

CGM.getMemberFunctionPointerAuthInfo(DstType)) {

&CurAuthInfo = CGM.getMemberFunctionPointerAuthInfo(SrcType);

llvm::Value *MemFnPtr = Builder.CreateExtractValue(src, 0,

);

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

llvm::BasicBlock *StartBB = Builder.GetInsertBlock();

assert(UseARMMethodPtrABI &&

);

llvm::Value *Adj = Builder.CreateExtractValue(src, 1,

);

llvm::Constant *Ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);

llvm::Value *AndVal = Builder.CreateAnd(Adj, Ptrdiff_1);

llvm::Value *IsVirtualOffset =

Builder.CreateIsNotNull(AndVal,

);

Builder.CreateCondBr(IsVirtualOffset, MergeBB, ResignBB);

llvm::Type *PtrTy = llvm::PointerType::getUnqual(CGM.Int8Ty);

MemFnPtr = Builder.CreateIntToPtr(MemFnPtr, PtrTy);

isa<llvm::Constant>(src));

MemFnPtr = Builder.CreatePtrToInt(MemFnPtr, OrigTy);

llvm::Value *ResignedVal = Builder.CreateInsertValue(src, MemFnPtr, 0);

ResignBB = Builder.GetInsertBlock();

llvm::PHINode *NewSrc = Builder.CreatePHI(src->getType(), 2);

NewSrc->addIncoming(src, StartBB);

NewSrc->addIncoming(ResignedVal, ResignBB);

(

->getCastKind() == CK_ReinterpretMemberPointer)

src;

llvm::Constant *adj = getMemberPointerAdjustment(

);

(!adj)

src;

isDerivedToBase = (

->getCastKind() == CK_DerivedToBaseMemberPointer);

dst = Builder.CreateNSWSub(src, adj,

);

dst = Builder.CreateNSWAdd(src, adj,

);

llvm::Value *null = llvm::Constant::getAllOnesValue(src->getType());

llvm::Value *isNull = Builder.CreateICmpEQ(src, null,

);

Builder.CreateSelect(isNull, src, dst);

(UseARMMethodPtrABI) {

offset = cast<llvm::ConstantInt>(adj)->getZExtValue();

adj = llvm::ConstantInt::get(adj->getType(), offset);

llvm::Value *srcAdj = Builder.CreateExtractValue(src, 1,

);

llvm::Value *dstAdj;

(isDerivedToBase)

dstAdj = Builder.CreateNSWSub(srcAdj, adj,

);

dstAdj = Builder.CreateNSWAdd(srcAdj, adj,

);

Builder.CreateInsertValue(src, dstAdj, 1);

llvm::Constant *

);

(DestType == SrcType)

(!NewAuthInfo && !CurAuthInfo)

llvm::Constant *MemFnPtr = Src->getAggregateElement(0u);

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

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

);

cast<llvm::User>(MemFnPtr)->getOperand(0), CurAuthInfo, NewAuthInfo, CGM);

ConstPtr = llvm::ConstantExpr::getPtrToInt(ConstPtr, MemFnPtr->getType());

ConstantFoldInsertValueInstruction(Src, ConstPtr, 0);

ItaniumCXXABI::EmitMemberPointerConversion(

*

,

llvm::Constant *src) {

assert(

->getCastKind() == CK_DerivedToBaseMemberPointer ||

->getCastKind() == CK_BaseToDerivedMemberPointer ||

->getCastKind() == CK_ReinterpretMemberPointer);

src, DstType,

->getSubExpr()->

(), CGM);

(

->getCastKind() == CK_ReinterpretMemberPointer)

src;

llvm::Constant *adj = getMemberPointerAdjustment(

);

(!adj)

src;

isDerivedToBase = (

->getCastKind() == CK_DerivedToBaseMemberPointer);

(src->isAllOnesValue())

src;

(isDerivedToBase)

llvm::ConstantExpr::getNSWSub(src, adj);

llvm::ConstantExpr::getNSWAdd(src, adj);

(UseARMMethodPtrABI) {

offset = cast<llvm::ConstantInt>(adj)->getZExtValue();

adj = llvm::ConstantInt::get(adj->getType(), offset);

llvm::Constant *srcAdj = src->getAggregateElement(1);

llvm::Constant *dstAdj;

(isDerivedToBase)

dstAdj = llvm::ConstantExpr::getNSWSub(srcAdj, adj);

dstAdj = llvm::ConstantExpr::getNSWAdd(srcAdj, adj);

llvm::Constant *res = ConstantFoldInsertValueInstruction(src, dstAdj, 1);

assert(res !=

&&

);

llvm::ConstantInt::get(CGM.PtrDiffTy, -1ULL,

);

llvm::Constant *

= llvm::ConstantInt::get(CGM.PtrDiffTy, 0);

llvm::Constant *Values[2] = {

,

};

llvm::ConstantStruct::getAnon(Values);

llvm::ConstantInt::get(CGM.PtrDiffTy, offset.

());

ItaniumCXXABI::EmitMemberFunctionPointer(

*MD) {

llvm::Constant *ItaniumCXXABI::BuildMemberPointer(

*MD,

assert(MD->

() &&

);

llvm::Constant *MemPtr[2];

Index = CGM.getItaniumVTableContext().getMethodVTableIndex(MD);

(CGM.getItaniumVTableContext().isRelativeLayout()) {

VTableOffset = Index * 4;

VTableOffset = Index * PointerWidth.

();

(UseARMMethodPtrABI) {

&Schema =

CGM.getCodeGenOpts().PointerAuth.CXXMemberFunctionPointers;

MemPtr[0] = llvm::ConstantExpr::getPtrToInt(

getSignedVirtualMemberFunctionPointer(MD), CGM.PtrDiffTy);

MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset);

MemPtr[1] = llvm::ConstantInt::get(

MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset + 1);

MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,

(Types.isFuncTypeConvertible(FPT)) {

Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));

llvm::Constant *addr = CGM.getMemberFunctionPointer(MD, Ty);

MemPtr[0] = llvm::ConstantExpr::getPtrToInt(addr, CGM.PtrDiffTy);

MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,

(UseARMMethodPtrABI ? 2 : 1) *

llvm::ConstantStruct::getAnon(MemPtr);

llvm::Constant *ItaniumCXXABI::EmitMemberPointer(

&MP,

EmitNullMemberPointer(MPT);

(

*MD = dyn_cast<CXXMethodDecl>(MPD)) {

SrcType = getContext().getMemberPointerType(

getContext().toCharUnitsFromBits(getContext().

(MPD));

llvm::ICmpInst::Predicate

;

llvm::Instruction::BinaryOps

,

;

= llvm::ICmpInst::ICMP_NE;

= llvm::Instruction::Or;

= llvm::Instruction::And;

= llvm::ICmpInst::ICMP_EQ;

= llvm::Instruction::And;

= llvm::Instruction::Or;

Builder.CreateICmp(

, L, R);

llvm::Value *LPtr = Builder.CreateExtractValue(L, 0,

);

llvm::Value *RPtr = Builder.CreateExtractValue(R, 0,

);

llvm::Value *PtrEq = Builder.CreateICmp(

, LPtr, RPtr,

);

llvm::Value *

= llvm::Constant::getNullValue(LPtr->getType());

llvm::Value *EqZero = Builder.CreateICmp(

, LPtr, Zero,

);

llvm::Value *LAdj = Builder.CreateExtractValue(L, 1,

);

llvm::Value *RAdj = Builder.CreateExtractValue(R, 1,

);

llvm::Value *AdjEq = Builder.CreateICmp(

, LAdj, RAdj,

);

(UseARMMethodPtrABI) {

llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1);

llvm::Value *OrAdj = Builder.CreateOr(LAdj, RAdj,

);

llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One);

llvm::Value *OrAdjAnd1EqZero = Builder.CreateICmp(

, OrAdjAnd1, Zero,

EqZero = Builder.CreateBinOp(

, EqZero, OrAdjAnd1EqZero);

llvm::Value *Result = Builder.CreateBinOp(

, EqZero, AdjEq);

Result = Builder.CreateBinOp(

, PtrEq, Result,

Inequality ?

:

);

llvm::Value *MemPtr,

assert(MemPtr->getType() == CGM.PtrDiffTy);

llvm::Value *NegativeOne =

llvm::Constant::getAllOnesValue(MemPtr->getType());

Builder.CreateICmpNE(MemPtr, NegativeOne,

);

llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0,

);

llvm::Constant *

= llvm::ConstantInt::get(Ptr->getType(), 0);

llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero,

);

(UseARMMethodPtrABI) {

llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);

llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1,

);

llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One,

);

llvm::Value *IsVirtual = Builder.CreateICmpNE(VirtualBit, Zero,

);

Result = Builder.CreateOr(Result, IsVirtual);

ItaniumCXXABI::classifyReturnType(

&FI)

{

Align = CGM.getContext().getTypeAlignInChars(FI.

());

(UseGlobalDelete) {

llvm::Value *OffsetPtr = CGF.

.CreateConstInBoundsGEP1_64(

CGF.

, VTable, -2,

);

EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, DE,

(UseGlobalDelete)

ItaniumCXXABI::emitRethrow(

&CGF,

isNoReturn) {

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.VoidTy,

);

llvm::FunctionCallee

= CGM.CreateRuntimeFunction(FTy,

);

llvm::FunctionType *FTy =

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

, Args,

);

llvm::Type *SizeTy = CGF.

(getContext().getSizeType());

TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity();

AllocExceptionFn, llvm::ConstantInt::get(SizeTy, TypeSize),

);

->getSubExpr(),

(ExceptionPtr, CGM.Int8Ty, ExnAlign));

llvm::Constant *

= CGM.GetAddrOfRTTIDescriptor(ThrowType,

llvm::Constant *Dtor =

;

(!

->hasTrivialDestructor()) {

Dtor = CGM.getFunctionPointer(Dtor, DtorTy);

(!Dtor) Dtor = llvm::Constant::getNullValue(CGM.Int8PtrTy);

llvm::Value *args[] = { ExceptionPtr,

, Dtor };

llvm::Type *Int8PtrTy = CGF.

;

llvm::Type *PtrDiffTy =

llvm::Type *Args[4] = { Int8PtrTy, GlobInt8PtrTy, GlobInt8PtrTy, PtrDiffTy };

llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args,

);

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

FuncAttrs.addAttribute(llvm::Attribute::WillReturn);

FuncAttrs.addMemoryAttr(llvm::MemoryEffects::readOnly());

llvm::AttributeList Attrs = llvm::AttributeList::get(

CGF.

(), llvm::AttributeList::FunctionIndex, FuncAttrs);

llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.

,

);

NumPublicPaths = 0;

(PathElement.Base->isVirtual())

(NumPublicPaths > 1)

PathElement.Base->getType()->getAsCXXRecordDecl());

(NumPublicPaths == 0)

(NumPublicPaths > 1)

llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.

,

);

ItaniumCXXABI::shouldTypeidBeNullChecked(

SrcRecordTy) {

->setDoesNotReturn();

CGF.

.CreateUnreachable();

llvm::Type *StdTypeInfoPtrTy) {

(CGM.getItaniumVTableContext().isRelativeLayout()) {

CGM.getIntrinsic(llvm::Intrinsic::load_relative, {CGM.Int32Ty}),

{Value, llvm::ConstantInt::get(CGM.Int32Ty, -4)});

CGF.

.CreateConstInBoundsGEP1_64(StdTypeInfoPtrTy,

, -1ULL);

ItaniumCXXABI::shouldDynamicCastCallBeNullChecked(

SrcIsPtr,

llvm::Value *ItaniumCXXABI::emitDynamicCastCall(

llvm::Type *PtrDiffLTy =

llvm::Value *SrcRTTI =

llvm::Value *DestRTTI =

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

(CGM.getCodeGenOpts().PointerAuth.CXXVTablePointers) {

llvm::Value *Vtable =

CodeGenFunction::VTableAuthMode::MustTrap);

llvm::Value *args[] = {

, SrcRTTI, DestRTTI, OffsetHint};

llvm::BasicBlock *BadCastBlock =

CGF.

.CreateCondBr(

, BadCastBlock, CastEnd);

EmitBadCastCall(CGF);

llvm::Value *ItaniumCXXABI::emitExactDynamicCast(

llvm::BasicBlock *CastFail) {

std::optional<CharUnits> Offset;

PathElement.Base->getType()->getAsCXXRecordDecl();

(PathElement.Base->isVirtual()) {

Offset = PathOffset;

(Offset != PathOffset) {

ThisAddr =

(emitDynamicCastToVoid(CGF, ThisAddr, SrcRecordTy),

llvm::PoisonValue::get(CGF.

);

CGM.DecorateInstructionWithTBAA(

VPtr, CGM.getTBAAVTablePtrAccessInfo(CGF.

));

VPtr, getVTableAddressPoint(

(SrcDecl, *Offset), DestDecl));

(!Offset->isZero())

{llvm::ConstantInt::get(CGF.PtrDiffTy, -Offset->getQuantity())});

llvm::Value *ItaniumCXXABI::emitDynamicCastToVoid(

&CGF,

llvm::Value *OffsetToTop;

(CGM.getItaniumVTableContext().isRelativeLayout()) {

llvm::Value *VTable =

CGF.

.CreateConstInBoundsGEP1_32(CGM.Int32Ty, VTable, -2U);

llvm::Type *PtrDiffLTy =

llvm::Value *VTable =

CGF.

.CreateConstInBoundsGEP1_64(PtrDiffLTy, VTable, -2ULL);

->setDoesNotReturn();

CGF.

.CreateUnreachable();

llvm::Value *VTablePtr = CGF.

(This, CGM.Int8PtrTy, ClassDecl);

CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(ClassDecl,

llvm::Value *VBaseOffsetPtr =

CGF.

.CreateConstGEP1_64(

);

llvm::Value *VBaseOffset;

(CGM.getItaniumVTableContext().isRelativeLayout()) {

CGM.PtrDiffTy, VBaseOffsetPtr, CGF.

(),

);

assert(CGM.getTarget().getCXXABI().hasConstructorVariants());

(!

->getParent()->isAbstract()) {

ItaniumCXXABI::buildStructorSignature(

GD,

cast<CXXMethodDecl>(GD.

())->getParent()->getNumVBases() != 0) {

AS = CGM.GetGlobalVarAddressSpace(

);

ArgTys.insert(ArgTys.begin() + 1,

AddedStructorArgCounts::prefix(1);

AddedStructorArgCounts{};

(

->isVirtual())

assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD));

(NeedsVTTParameter(CGF.

)) {

AS = CGM.GetGlobalVarAddressSpace(

);

, ImplicitParamKind::CXXVTT);

Params.insert(Params.begin() + 1, VTTDecl);

getStructorImplicitParamDecl(CGF) = VTTDecl;

ItaniumCXXABI::EmitInstanceFunctionProlog(

&CGF) {

setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));

(getStructorImplicitParamDecl(CGF)) {

(HasThisReturn(CGF.

))

AddedStructorArgs{};

AS = CGM.GetGlobalVarAddressSpace(

);

Q = getContext().getAddrSpaceQualType(getContext().VoidPtrTy, AS);

VTTTy = getContext().getPointerType(Q);

AddedStructorArgs::prefix({{VTT, VTTTy}});

llvm::Value *ItaniumCXXABI::getCXXDestructorImplicitParam(

VTTTy = getContext().getPointerType(getContext().VoidPtrTy);

(getContext().getLangOpts().AppleKext &&

ThisTy, VTT, VTTTy,

);

<

T>

(

*FD = dyn_cast<FunctionDecl>(

)) {

llvm::GlobalVariable *VTable,

(VTable->getDLLStorageClass() !=

llvm::GlobalVariable::DefaultStorageClass ||

RD->

<DLLImportAttr>() || RD->

<DLLExportAttr>())

(CXXRecordNonInlineHasAttr<DLLImportAttr>(RD))

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

}

(CXXRecordNonInlineHasAttr<DLLExportAttr>(RD))

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

llvm::GlobalVariable *VTable = getAddrOfVTable(RD,

());

(VTable->hasInitializer())

llvm::GlobalVariable::LinkageTypes

= CGM.getVTableLinkage(RD);

llvm::Constant *RTTI =

CGM.GetAddrOfRTTIDescriptor(CGM.getContext().getTagDeclType(RD));

components = builder.beginStruct();

llvm::GlobalValue::isLocalLinkage(

));

components.finishAndSetAsInitializer(VTable);

VTable->setLinkage(

);

(CGM.supportsCOMDAT() && VTable->isWeakForLinker())

VTable->setComdat(CGM.getModule().getOrInsertComdat(VTable->getName()));

(CGM.getTarget().hasPS4DLLImportExport())

CGM.setGVProperties(VTable, RD);

isa<NamespaceDecl>(DC) && cast<NamespaceDecl>(DC)->getIdentifier() &&

cast<NamespaceDecl>(DC)->getIdentifier()->isStr(

) &&

EmitFundamentalRTTIDescriptors(RD);

(!VTable->isDeclarationForLinker() ||

CGM.getCodeGenOpts().WholeProgramVTables) {

CGM.EmitVTableTypeMetadata(RD, VTable, VTLayout);

(VTable->isDeclarationForLinker()) {

assert(CGM.getCodeGenOpts().WholeProgramVTables);

CGM.addCompilerUsedGlobal(VTable);

(!VTable->isDSOLocal())

ItaniumCXXABI::isVirtualOffsetNeededForVTableField(

(Vptr.NearestVBase ==

)

NeedsVTTParameter(CGF.

);

llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructor(

((

.getBase()->getNumVBases() || NearestVBase !=

) &&

NeedsVTTParameter(CGF.

)) {

getVTableAddressPointInStructorWithVTT(CGF, VTableClass,

,

getVTableAddressPoint(

, VTableClass);

llvm::GlobalValue *VTable = getAddrOfVTable(VTableClass,

());

CGM.getItaniumVTableContext().getVTableLayout(VTableClass);

llvm::Value *Indices[] = {

llvm::ConstantInt::get(CGM.Int32Ty, 0),

llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.

),

ComponentSize =

CGM.getDataLayout().getTypeAllocSize(CGM.getVTableComponentType());

VTableSize =

llvm::APInt(32, (

)-Offset,

),

llvm::APInt(32, (

)(VTableSize - Offset),

));

llvm::ConstantExpr::getGetElementPtr(

VTable->getValueType(), VTable, Indices,

, InRange);

llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructorWithVTT(

assert((

.getBase()->getNumVBases() || NearestVBase !=

) &&

NeedsVTTParameter(CGF.

) &&

);

CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass,

);

(VirtualPointerIndex)

VirtualPointerIndex);

llvm::GlobalVariable *ItaniumCXXABI::getAddrOfVTable(

*RD,

assert(VPtrOffset.

() &&

);

llvm::GlobalVariable *&VTable = VTables[RD];

CGM.addDeferredVTable(RD);

llvm::raw_svector_ostream Out(Name);

getMangleContext().mangleCXXVTable(RD, Out);

CGM.getItaniumVTableContext().getVTableLayout(RD);

llvm::Type *VTableType = CGM.getVTables().getVTableType(VTLayout);

AS = CGM.GetGlobalVarAddressSpace(

);

PAlign = CGM.getItaniumVTableContext().isRelativeLayout()

: CGM.getTarget().getPointerAlign(AS);

VTable = CGM.CreateOrReplaceCXXRuntimeVariable(

Name, VTableType, llvm::GlobalValue::ExternalLinkage,

getContext().toCharUnitsFromBits(PAlign).getAsAlign());

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

(CGM.getTarget().hasPS4DLLImportExport())

CGM.setGVProperties(VTable, RD);

llvm::Type *PtrTy = CGM.GlobalsInt8PtrTy;

*MethodDecl = cast<CXXMethodDecl>(GD.

());

llvm::Value *VTable = CGF.

(This, PtrTy, MethodDecl->getParent());

VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);

llvm::Value *VFunc, *VTableSlotPtr =

;

&Schema = CGM.getCodeGenOpts().PointerAuth.CXXVirtualFunctionPointers;

MethodDecl->getParent(), VTable, PtrTy,

CGM.getContext().getTargetInfo().getPointerWidth(LangAS::Default) /

llvm::Value *VFuncLoad;

(CGM.getItaniumVTableContext().isRelativeLayout()) {

VFuncLoad = CGF.

.CreateCall(

CGM.getIntrinsic(llvm::Intrinsic::load_relative, {CGM.Int32Ty}),

{VTable, llvm::ConstantInt::get(CGM.Int32Ty, 4 * VTableIndex)});

VTableSlotPtr = CGF.

.CreateConstInBoundsGEP1_64(

PtrTy, VTable, VTableIndex,

);

(CGM.getCodeGenOpts().OptimizationLevel > 0 &&

CGM.getCodeGenOpts().StrictVTablePointers) {

(

*VFuncLoadInstr = dyn_cast<llvm::Instruction>(VFuncLoad)) {

VFuncLoadInstr->setMetadata(

llvm::LLVMContext::MD_invariant_load,

llvm::MDNode::get(CGM.getLLVMContext(),

assert(VTableSlotPtr &&

);

GD = CGM.getItaniumVTableContext().findOriginalMethod(GD.

());

llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall(

This, DeleteOrMemberCallExpr

, llvm::CallBase **CallOrInvoke) {

assert((CE !=

) ^ (

!=

));

assert(CE ==

|| CE->arg_begin() == CE->arg_end());

&CGM.getTypes().arrangeCXXStructorDeclaration(GD);

ThisTy = CE->getObjectType();

ThisTy =

->getDestroyedType();

,

(),

, CallOrInvoke);

ItaniumCXXABI::emitVirtualInheritanceTables(

*RD) {

llvm::GlobalVariable *VTT = VTables.

(RD);

ItaniumCXXABI::canSpeculativelyEmitVTableAsBaseClass(

(CGM.getLangOpts().AppleKext)

(isVTableHidden(RD))

(CGM.getCodeGenOpts().ForceEmitVTables)

(hasAnyUnusedVirtualInlineFunction(RD))

(

&B : RD->

()) {

*BRD = B.getType()->getAsCXXRecordDecl();

assert(BRD &&

);

(B.isVirtual() || !BRD->isDynamicClass())

(!canSpeculativelyEmitVTableAsBaseClass(BRD))

ItaniumCXXABI::canSpeculativelyEmitVTable(

*RD)

{

(!canSpeculativelyEmitVTableAsBaseClass(RD))

(

&B : RD->

()) {

*BRD = B.getType()->getAsCXXRecordDecl();

assert(BRD &&

);

(!BRD->isDynamicClass())

(!canSpeculativelyEmitVTableAsBaseClass(BRD))

int64_t NonVirtualAdjustment,

int64_t VirtualAdjustment,

IsReturnAdjustment) {

(!NonVirtualAdjustment && !VirtualAdjustment)

(NonVirtualAdjustment && !IsReturnAdjustment) {

llvm::Value *ResultPtr;

(VirtualAdjustment) {

llvm::Value *VTablePtr =

llvm::Value *Offset;

llvm::Value *OffsetPtr = CGF.

.CreateConstInBoundsGEP1_64(

CGF.

, VTablePtr, VirtualAdjustment);

llvm::Type *PtrDiffTy =

.emitRawPointer(CGF), Offset);

ResultPtr =

.emitRawPointer(CGF);

(NonVirtualAdjustment && IsReturnAdjustment) {

ResultPtr = CGF.

.CreateConstInBoundsGEP1_64(CGF.

, ResultPtr,

NonVirtualAdjustment);

ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);

ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);

CGM.getContext().getPreferredTypeAlignInChars(elementType));

llvm::Value *NumElements,

assert(requiresArrayCookie(

));

assert(CookieSize == getArrayCookieSizeImpl(ElementType));

CookieOffset = CookieSize - SizeSize;

(!CookieOffset.

())

(CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) && AS == 0 &&

(

->getOperatorNew()->isReplaceableGlobalAllocationFunction() ||

CGM.getCodeGenOpts().SanitizeAddressPoisonCustomArrayCookie)) {

SI->setNoSanitizeMetadata();

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.VoidTy, NumElementsPtr.

(),

);

llvm::FunctionCallee F =

CGM.CreateRuntimeFunction(FTy,

);

llvm::Value *ItaniumCXXABI::readArrayCookieImpl(

&CGF,

numElementsPtr = allocPtr;

(!numElementsOffset.

())

(!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) || AS != 0)

llvm::FunctionType *FTy =

llvm::FunctionCallee F =

CGM.CreateRuntimeFunction(FTy,

);

CGM.getContext().getTypeAlignInChars(elementType));

llvm::Value *numElements,

assert(requiresArrayCookie(

));

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

,

getContext().getTypeSizeInChars(elementType).getQuantity());

cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);

llvm::PointerType *GuardPtrTy) {

llvm::FunctionType *FTy =

GuardPtrTy,

);

FTy,

,

llvm::AttributeList::FunctionIndex,

llvm::Attribute::NoUnwind));

llvm::PointerType *GuardPtrTy) {

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

, GuardPtrTy,

);

FTy,

,

llvm::AttributeList::FunctionIndex,

llvm::Attribute::NoUnwind));

llvm::PointerType *GuardPtrTy) {

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

, GuardPtrTy,

);

FTy,

,

llvm::AttributeList::FunctionIndex,

llvm::Attribute::NoUnwind));

llvm::GlobalVariable *Guard;

CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}

llvm::GlobalVariable *var,

shouldPerformInit) {

NonTemplateInline =

threadsafe = getContext().getLangOpts().ThreadsafeStatics &&

(

.isLocalVarDecl() || NonTemplateInline) &&

useInt8GuardVariable = !threadsafe &&

->hasInternalLinkage();

llvm::IntegerType *guardTy;

(useInt8GuardVariable) {

(UseARMGuardVarABI) {

llvm::PointerType *guardPtrTy = llvm::PointerType::get(

llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&

);

llvm::raw_svector_ostream out(guardName);

getMangleContext().mangleStaticGuardVariable(&

, out);

guard =

llvm::GlobalVariable(CGM.getModule(), guardTy,

,

->getLinkage(),

llvm::ConstantInt::get(guardTy, 0),

guard->setDSOLocal(

->isDSOLocal());

guard->setVisibility(

->getVisibility());

guard->setDLLStorageClass(

->getDLLStorageClass());

guard->setThreadLocalMode(

->getThreadLocalMode());

guard->setAlignment(guardAlignment.

());

llvm::Comdat *

=

->getComdat();

(!

.isLocalVarDecl() &&

&&

(CGM.getTarget().getTriple().isOSBinFormatELF() ||

CGM.getTarget().getTriple().isOSBinFormatWasm())) {

guard->setComdat(

);

}

(CGM.supportsCOMDAT() && guard->isWeakForLinker()) {

guard->setComdat(CGM.getModule().getOrInsertComdat(guard->getName()));

CGM.setStaticLocalDeclGuardAddress(&

, guard);

guardAddr =

(guard, guard->getValueType(), guardAlignment);

(!threadsafe || MaxInlineWidthInBits) {

llvm::LoadInst *LI =

LI->setAtomic(llvm::AtomicOrdering::Acquire);

(UseARMGuardVarABI && !useInt8GuardVariable)

? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))

llvm::Value *NeedsInit = Builder.CreateIsNull(

,

);

CodeGenFunction::GuardKind::VariableGuard, &

);

Builder.CreateCondBr(Builder.CreateIsNotNull(

,

),

InitBlock, EndBlock);

}

(!

.isLocalVarDecl()) {

Builder.CreateStore(llvm::ConstantInt::get(CGM.Int8Ty, 1),

}

(

.isLocalVarDecl()) {

Builder.CreateStore(llvm::ConstantInt::get(CGM.Int8Ty, 1),

llvm::FunctionCallee dtor,

llvm::Constant *addr,

TLS) {

);

);

*Name =

;

Name =

.isOSDarwin() ?

:

;

AddrAS = addr ? addr->getType()->getPointerAddressSpace() : 0;

AddrPtrTy = AddrAS ? llvm::PointerType::get(CGF.

(), AddrAS)

llvm::Constant *handle =

*GV = cast<llvm::GlobalValue>(handle->stripPointerCasts());

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

llvm::Type *paramTys[] = {

, AddrPtrTy, handle->getType()};

llvm::FunctionType *atexitTy =

llvm::FunctionType::get(CGF.

, paramTys,

);

(llvm::Function *fn = dyn_cast<llvm::Function>(atexit.getCallee()))

fn->setDoesNotThrow();

llvm::Constant *dtorCallee = cast<llvm::Constant>(dtor.getCallee());

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

);

llvm::Value *args[] = {dtorCallee, addr, handle};

llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.

,

);

GlobalInitOrCleanupFn;

CodeGenModule::unregisterGlobalDtorsWithUnAtExit() {

(

&I : DtorsUsingAtExit) {

std::string GlobalCleanupFnName =

std::string(

) + llvm::to_string(Priority);

llvm::Function *GlobalCleanupFn =

llvm::FunctionType *dtorFuncTy = llvm::FunctionType::get(CGF.

,

);

llvm::TinyPtrVector<llvm::Function *> &Dtors = I.second;

itv = Dtors.rbegin();

(itv != Dtors.rend()) {

llvm::Function *Dtor = *itv;

llvm::Value *NeedsDestruct =

llvm::BasicBlock *DestructCallBlock =

(itv + 1) != Dtors.rend() ?

:

);

CGF.

.CreateCondBr(NeedsDestruct, DestructCallBlock, EndBlock);

llvm::CallInst *CI = CGF.

.CreateCall(dtorFuncTy, Dtor);

CI->setCallingConv(Dtor->getCallingConv());

CodeGenModule::registerGlobalDtorsWithAtExit() {

(

&I : DtorsUsingAtExit) {

std::string GlobalInitFnName =

std::string(

) + llvm::to_string(Priority);

llvm::Function *GlobalInitFn =

llvm::TinyPtrVector<llvm::Function *> &Dtors = I.second;

(

*Dtor : Dtors) {

unregisterGlobalDtorsWithUnAtExit();

llvm::FunctionCallee dtor,

llvm::Constant *addr) {

(

.isNoDestroy(CGM.getContext()))

(CGM.getLangOpts().HLSL)

CGM.AddCXXDtorEntry(dtor, addr);

(!CGM.getLangOpts().hasAtExit() && !

.isStaticLocal())

(CGM.getCodeGenOpts().CXAAtExit ||

.getTLSKind())

(CGM.getLangOpts().AppleKext) {

CGM.AddCXXDtorEntry(dtor, addr);

assert(!VD->

() &&

);

llvm::GlobalValue::LinkageTypes

llvm::GlobalValue::LinkageTypes VarLinkage =

(llvm::GlobalValue::isLocalLinkage(VarLinkage))

(!llvm::GlobalVariable::isLinkOnceLinkage(VarLinkage) &&

!llvm::GlobalVariable::isWeakODRLinkage(VarLinkage))

llvm::GlobalValue::WeakODRLinkage;

ItaniumCXXABI::getOrCreateThreadLocalWrapper(

*VD,

llvm::raw_svector_ostream Out(WrapperName);

getMangleContext().mangleItaniumThreadLocalWrapper(VD, Out);

(llvm::Value *

= CGM.getModule().getNamedValue(WrapperName))

cast<llvm::Function>(

);

&FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(

llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);

llvm::Function *Wrapper =

WrapperName.str(), &CGM.getModule());

(CGM.supportsCOMDAT() && Wrapper->isWeakForLinker())

Wrapper->setComdat(CGM.getModule().getOrInsertComdat(Wrapper->getName()));

CGM.SetLLVMFunctionAttributes(

(), FI, Wrapper,

);

(!Wrapper->hasLocalLinkage())

llvm::GlobalVariable::isLinkOnceLinkage(Wrapper->getLinkage()) ||

llvm::GlobalVariable::isWeakODRLinkage(Wrapper->getLinkage()) ||

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

Wrapper->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);

Wrapper->addFnAttr(llvm::Attribute::NoUnwind);

ThreadWrappers.push_back({VD, Wrapper});

ItaniumCXXABI::EmitThreadLocalInitFuncs(

llvm::Function *InitFunc =

;

llvm::SmallDenseMap<const VarDecl *, llvm::Function *> UnorderedInits;

(

I = 0; I != CXXThreadLocalInits.size(); ++I) {

UnorderedInits[CXXThreadLocalInitVars[I]->getCanonicalDecl()] =

CXXThreadLocalInits[I];

OrderedInits.push_back(CXXThreadLocalInits[I]);

(!OrderedInits.empty()) {

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

,

);

llvm::GlobalVariable *Guard =

llvm::GlobalVariable(

llvm::GlobalVariable::InternalLinkage,

llvm::ConstantInt::get(CGM.

, 0),

);

Guard->setThreadLocal(

);

Guard->setAlignment(GuardAlign.

());

InitFunc->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);

InitFunc->addFnAttr(llvm::Attribute::NoUnwind);

(

*VD : CXXThreadLocals) {

getOrCreateThreadLocalWrapper(VD, GV);

(

VDAndWrapper : ThreadWrappers) {

*VD = VDAndWrapper.first;

llvm::GlobalVariable *Var =

llvm::Function *Wrapper = VDAndWrapper.second;

Wrapper->setLinkage(llvm::Function::ExternalLinkage);

(Wrapper->getLinkage() == llvm::Function::WeakODRLinkage)

Wrapper->setLinkage(llvm::Function::LinkOnceODRLinkage);

llvm::raw_svector_ostream Out(InitFnName);

getMangleContext().mangleItaniumThreadLocalInit(VD, Out);

llvm::FunctionType *InitFnTy = llvm::FunctionType::get(CGM.

,

);

llvm::GlobalValue *

=

;

InitIsInitFunc =

;

HasConstantInitialization =

;

(!usesThreadWrapperFunction(VD)) {

HasConstantInitialization =

;

InitIsInitFunc =

;

llvm::Function *InitFuncToUse = InitFunc;

= llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),

= llvm::Function::Create(InitFnTy,

llvm::GlobalVariable::ExternalWeakLinkage,

->setVisibility(Var->getVisibility());

(!CGM.

().isOSWindows() || !

->hasExternalWeakLinkage())

->setDSOLocal(Var->isDSOLocal());

llvm::LLVMContext &Context = CGM.

().getContext();

isEmittedWithConstantInitializer(VD,

) &&

!mayNeedDestruction(VD)) {

assert(

==

&&

);

llvm::Function *

= llvm::Function::Create(

InitFnTy, Var->getLinkage(), InitFnName.str(), &CGM.

());

cast<llvm::Function>(

),

llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context,

,

);

Builder.CreateRetVoid();

llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context,

, Wrapper);

(HasConstantInitialization) {

}

(InitIsInitFunc) {

llvm::CallInst *CallVal = Builder.CreateCall(InitFnTy,

);

CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);

llvm::Function *

=

cast<llvm::Function>(cast<llvm::GlobalAlias>(

)->getAliasee());

->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);

}

(CGM.

().isOSAIX()) {

Builder.CreateCall(InitFnTy,

);

llvm::Value *Have = Builder.CreateIsNotNull(

);

llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context,

, Wrapper);

llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context,

, Wrapper);

Builder.CreateCondBr(Have, InitBB, ExitBB);

Builder.SetInsertPoint(InitBB);

Builder.CreateCall(InitFnTy,

);

Builder.CreateBr(ExitBB);

Builder.SetInsertPoint(ExitBB);

llvm::Value *Val = Builder.CreateThreadLocalAddress(Var);

Val = Builder.CreateAlignedLoad(Var->getValueType(), Val, Align);

Val = Builder.CreateAddrSpaceCast(Val, Wrapper->getReturnType());

Builder.CreateRet(Val);

llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Val);

llvm::CallInst *CallVal = CGF.

.CreateCall(Wrapper);

CallVal->setCallingConv(Wrapper->getCallingConv());

ItaniumCXXABI::NeedsVTTParameter(

GD) {

ItaniumCXXABI::getOrCreateVirtualFunctionPointerThunk(

*MD) {

llvm::raw_svector_ostream Out(MethodName);

getMangleContext().mangleCXXName(MD, Out);

MethodName +=

;

StringRef ThunkName = MethodName.str();

llvm::Function *ThunkFn;

((ThunkFn = cast_or_null<llvm::Function>(

CGM.

().getNamedValue(ThunkName))))

llvm::GlobalValue::LinkageTypes

=

: llvm::GlobalValue::InternalLinkage;

(

== llvm::GlobalValue::LinkOnceODRLinkage)

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

assert(ThunkFn->getName() == ThunkName &&

);

ThunkFn->removeFnAttr(llvm::Attribute::StackProtect);

ThunkFn->removeFnAttr(llvm::Attribute::StackProtectStrong);

ThunkFn->removeFnAttr(llvm::Attribute::StackProtectReq);

llvm::Value *ThisVal = loadIncomingCXXThis(CGF);

setCXXABIThisValue(CGF, ThisVal);

(

*VD : FunctionArgs)

getThisAddress(CGF), ThunkTy);

llvm::CallBase *CallOrInvoke;

*

= cast<llvm::CallInst>(CallOrInvoke);

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

(

->getType()->isVoidTy())

CGF.

.CreateRetVoid();

ItaniumRTTIBuilder {

llvm::LLVMContext &VMContext;

ItaniumCXXABI &

;

llvm::GlobalVariable *

GetAddrOfTypeName(

Ty, llvm::GlobalVariable::LinkageTypes

);

llvm::Constant *GetAddrOfExternalRTTIDescriptor(

Ty);

BuildVTablePointer(

*Ty, llvm::Constant *StorageAddress);

BuildPointerTypeInfo(

PointeeTy);

ItaniumRTTIBuilder(

ItaniumCXXABI &ABI)

: CGM(ABI.CGM), VMContext(CGM.getModule().getContext()),

(ABI) {}

PTI_Incomplete = 0x8,

PTI_ContainingClassIncomplete = 0x10,

PTI_Noexcept = 0x40,

VMI_NonDiamondRepeat = 0x1,

VMI_DiamondShaped = 0x2

llvm::Constant *BuildTypeInfo(

Ty);

llvm::Constant *BuildTypeInfo(

llvm::GlobalVariable::LinkageTypes

,

llvm::GlobalValue::VisibilityTypes

,

llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass);

llvm::GlobalVariable *ItaniumRTTIBuilder::GetAddrOfTypeName(

llvm::raw_svector_ostream Out(Name);

llvm::Constant *

= llvm::ConstantDataArray::getString(VMContext,

GV->setInitializer(

);

ItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(

Ty) {

llvm::raw_svector_ostream Out(Name);

llvm::GlobalVariable *GV = CGM.

().getNamedGlobal(Name);

GV =

llvm::GlobalVariable(

, llvm::GlobalValue::ExternalLinkage,

, Name);

(RD && CXXRecordNonInlineHasAttr<DLLImportAttr>(RD)) {

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

BuiltinType::Void:

BuiltinType::NullPtr:

BuiltinType::Bool:

BuiltinType::WChar_S:

BuiltinType::WChar_U:

BuiltinType::Char_U:

BuiltinType::Char_S:

BuiltinType::UChar:

BuiltinType::SChar:

BuiltinType::Short:

BuiltinType::UShort:

BuiltinType::Int:

BuiltinType::UInt:

BuiltinType::Long:

BuiltinType::ULong:

BuiltinType::LongLong:

BuiltinType::ULongLong:

BuiltinType::Half:

BuiltinType::Float:

BuiltinType::Double:

BuiltinType::LongDouble:

BuiltinType::Float16:

BuiltinType::Float128:

BuiltinType::Ibm128:

BuiltinType::Char8:

BuiltinType::Char16:

BuiltinType::Char32:

BuiltinType::Int128:

BuiltinType::UInt128:

BuiltinType::OCLSampler:

BuiltinType::OCLEvent:

BuiltinType::OCLClkEvent:

BuiltinType::OCLQueue:

BuiltinType::OCLReserveID:

BuiltinType::ShortAccum:

BuiltinType::Accum:

BuiltinType::LongAccum:

BuiltinType::UShortAccum:

BuiltinType::UAccum:

BuiltinType::ULongAccum:

BuiltinType::ShortFract:

BuiltinType::Fract:

BuiltinType::LongFract:

BuiltinType::UShortFract:

BuiltinType::UFract:

BuiltinType::ULongFract:

BuiltinType::SatShortAccum:

BuiltinType::SatAccum:

BuiltinType::SatLongAccum:

BuiltinType::SatUShortAccum:

BuiltinType::SatUAccum:

BuiltinType::SatULongAccum:

BuiltinType::SatShortFract:

BuiltinType::SatFract:

BuiltinType::SatLongFract:

BuiltinType::SatUShortFract:

BuiltinType::SatUFract:

BuiltinType::SatULongFract:

BuiltinType::BFloat16:

BuiltinType::Dependent:

llvm_unreachable(

);

BuiltinType::ObjCId:

BuiltinType::ObjCClass:

BuiltinType::ObjCSel:

llvm_unreachable(

);

llvm_unreachable(

);

*BuiltinTy = dyn_cast<BuiltinType>(PointeeTy);

(!Quals.

())

(

*BuiltinTy = dyn_cast<BuiltinType>(Ty))

(

*PointerTy = dyn_cast<PointerType>(Ty))

(

*RecordTy = dyn_cast<RecordType>(Ty)) {

*RD = cast<CXXRecordDecl>(RecordTy->getDecl());

IsDLLImport = RD->

<DLLImportAttr>();

(CGM.

().isWindowsGNUEnvironment())

IsDLLImport && !CGM.

().isWindowsItaniumEnvironment()

(

*RecordTy = dyn_cast<RecordType>(Ty)) {

(

*PointerTy = dyn_cast<PointerType>(Ty))

dyn_cast<MemberPointerType>(Ty)) {

*ClassType = cast<RecordType>(MemberPointerTy->getClass());

(

->isVirtual())

(!BaseDecl->isEmpty() &&

ItaniumRTTIBuilder::BuildVTablePointer(

*Ty,

llvm::Constant *StorageAddress) {

*

ClassTypeInfo =

;

*

SIClassTypeInfo =

;

*

VMIClassTypeInfo =

;

*VTableName =

;

llvm_unreachable(

);

Type::LValueReference:

Type::RValueReference:

llvm_unreachable(

);

Type::DeducedTemplateSpecialization:

llvm_unreachable(

);

llvm_unreachable(

);

Type::ArrayParameter:

llvm_unreachable(

);

Type::ExtVector:

Type::ConstantMatrix:

Type::BlockPointer:

VTableName =

;

Type::ConstantArray:

Type::IncompleteArray:

Type::VariableArray:

VTableName =

;

Type::FunctionNoProto:

Type::FunctionProto:

VTableName =

;

VTableName =

;

Type::Record: {

cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());

VTableName = ClassTypeInfo;

VTableName = SIClassTypeInfo;

VTableName = VMIClassTypeInfo;

Type::ObjCObject:

Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr();

(isa<BuiltinType>(Ty)) {

VTableName = ClassTypeInfo;

assert(isa<ObjCInterfaceType>(Ty));

Type::ObjCInterface:

(cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {

VTableName = SIClassTypeInfo;

VTableName = ClassTypeInfo;

Type::ObjCObjectPointer:

VTableName =

;

Type::MemberPointer:

VTableName =

;

Type::HLSLAttributedResource:

llvm_unreachable(

);

llvm::Constant *VTable =

;

VTable = CGM.

().getNamedAlias(VTableName);

VTable = CGM.

().getOrInsertGlobal(VTableName, Ty);

CGM.

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

llvm::Type *PtrDiffTy =

llvm::Constant *Eight = llvm::ConstantInt::get(CGM.

, 8);

llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.

, VTable, Eight);

llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);

VTable = llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.

,

(

&Schema =

Schema.isAddressDiscriminated() ? StorageAddress :

,

Fields.push_back(VTable);

llvm::GlobalValue::InternalLinkage;

llvm_unreachable(

);

llvm::GlobalValue::InternalLinkage;

llvm::GlobalValue::LinkOnceODRLinkage;

(RD->

<WeakAttr>())

llvm::GlobalValue::WeakODRLinkage;

(CGM.

().isWindowsItaniumEnvironment())

(RD->

<DLLImportAttr>() &&

llvm::GlobalValue::ExternalLinkage;

.isWindowsGNUEnvironment())

llvm::GlobalValue::LinkOnceODRLinkage;

llvm_unreachable(

);

llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(

Ty) {

llvm::raw_svector_ostream Out(Name);

llvm::GlobalVariable *OldGV = CGM.

().getNamedGlobal(Name);

(OldGV && !OldGV->isDeclaration()) {

assert(!OldGV->hasAvailableExternallyLinkage() &&

);

GetAddrOfExternalRTTIDescriptor(Ty);

llvm::GlobalValue::VisibilityTypes llvmVisibility;

(llvm::GlobalValue::isLocalLinkage(

))

llvmVisibility = llvm::GlobalValue::DefaultVisibility;

ItaniumCXXABI::RUK_NonUniqueHidden)

llvmVisibility = llvm::GlobalValue::HiddenVisibility;

llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass =

llvm::GlobalValue::DefaultStorageClass;

((CGM.

().isWindowsItaniumEnvironment() &&

RD->

<DLLExportAttr>()) ||

!llvm::GlobalValue::isLocalLinkage(

) &&

llvmVisibility == llvm::GlobalValue::DefaultVisibility))

DLLStorageClass = llvm::GlobalValue::DLLExportStorageClass;

BuildTypeInfo(Ty,

, llvmVisibility, DLLStorageClass);

llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(

llvm::GlobalVariable::LinkageTypes

,

llvm::GlobalValue::VisibilityTypes

,

llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass) {

llvm::raw_svector_ostream Out(Name);

llvm::GlobalVariable *OldGV = M.getNamedGlobal(Name);

llvm::GlobalVariable *GV =

BuildVTablePointer(cast<Type>(Ty), GV);

llvm::Constant *TypeNameField;

ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =

(RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {

TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.

);

llvm::Constant *flag =

llvm::ConstantInt::get(CGM.

, ((uint64_t)1) << 63);

TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);

Fields.push_back(TypeNameField);

llvm_unreachable(

);

Type::ExtVector:

Type::ConstantMatrix:

Type::BlockPointer:

Type::LValueReference:

Type::RValueReference:

llvm_unreachable(

);

Type::DeducedTemplateSpecialization:

llvm_unreachable(

);

Type::ConstantArray:

Type::IncompleteArray:

Type::VariableArray:

Type::ArrayParameter:

Type::FunctionNoProto:

Type::FunctionProto:

Type::Record: {

cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());

BuildSIClassTypeInfo(RD);

BuildVMIClassTypeInfo(RD);

Type::ObjCObject:

Type::ObjCInterface:

BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty));

Type::ObjCObjectPointer:

BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->

());

Type::MemberPointer:

BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty));

Type::HLSLAttributedResource:

llvm_unreachable(

);

GV->replaceInitializer(llvm::ConstantStruct::getAnon(Fields));

GVDLLStorageClass = DLLStorageClass;

GVDLLStorageClass != llvm::GlobalVariable::DLLExportStorageClass) {

(

*RecordTy = dyn_cast<RecordType>(Ty)) {

*RD = cast<CXXRecordDecl>(RecordTy->getDecl());

(RD->

<DLLExportAttr>() ||

CXXRecordNonInlineHasAttr<DLLExportAttr>(RD))

GVDLLStorageClass = llvm::GlobalVariable::DLLExportStorageClass;

GV->takeName(OldGV);

OldGV->replaceAllUsesWith(GV);

OldGV->eraseFromParent();

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

->setDLLStorageClass(DLLStorageClass);

GV->setDLLStorageClass(GVDLLStorageClass);

ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(

*OT) {

assert(isa<BuiltinType>(

) || isa<ObjCInterfaceType>(

));

(isa<BuiltinType>(

))

;

(!Super)

;

llvm::Constant *BaseTypeInfo =

ItaniumRTTIBuilder(

).BuildTypeInfo(SuperTy);

Fields.push_back(BaseTypeInfo);

ItaniumRTTIBuilder::BuildSIClassTypeInfo(

*RD) {

llvm::Constant *BaseTypeInfo =

Fields.push_back(BaseTypeInfo);

(

->isVirtual()) {

(!Bases.VirtualBases.insert(BaseDecl).second) {

Flags |= ItaniumRTTIBuilder::VMI_DiamondShaped;

(Bases.NonVirtualBases.count(BaseDecl))

Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;

(!Bases.NonVirtualBases.insert(BaseDecl).second) {

Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;

(Bases.VirtualBases.count(BaseDecl))

Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;

(

&I : BaseDecl->bases())

(

&I : RD->

())

ItaniumRTTIBuilder::BuildVMIClassTypeInfo(

*RD) {

llvm::Type *UnsignedIntLTy =

Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));

Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->

()));

llvm::Type *OffsetFlagsLTy =

(

&

: RD->

()) {

Fields.push_back(ItaniumRTTIBuilder(

).BuildTypeInfo(

.getType()));

(

.isVirtual())

OffsetFlags =

(Offset.getQuantity()) << 8;

(

.isVirtual())

OffsetFlags |= BCTI_Virtual;

OffsetFlags |= BCTI_Public;

Fields.push_back(llvm::ConstantInt::get(OffsetFlagsLTy, OffsetFlags));

(

.isConstQualified())

Flags |= ItaniumRTTIBuilder::PTI_Const;

(

.isVolatileQualified())

Flags |= ItaniumRTTIBuilder::PTI_Volatile;

(

.isRestrictQualified())

Flags |= ItaniumRTTIBuilder::PTI_Restrict;

Flags |= ItaniumRTTIBuilder::PTI_Incomplete;

(Proto->isNothrow()) {

Flags |= ItaniumRTTIBuilder::PTI_Noexcept;

ItaniumRTTIBuilder::BuildPointerTypeInfo(

PointeeTy) {

llvm::Type *UnsignedIntLTy =

Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));

llvm::Constant *PointeeTypeInfo =

ItaniumRTTIBuilder(

).BuildTypeInfo(PointeeTy);

Fields.push_back(PointeeTypeInfo);

ItaniumRTTIBuilder::BuildPointerToMemberTypeInfo(

*Ty) {

Flags |= PTI_ContainingClassIncomplete;

llvm::Type *UnsignedIntLTy =

Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));

llvm::Constant *PointeeTypeInfo =

ItaniumRTTIBuilder(

).BuildTypeInfo(PointeeTy);

Fields.push_back(PointeeTypeInfo);

ItaniumRTTIBuilder(

).BuildTypeInfo(

(ClassType, 0)));

llvm::Constant *ItaniumCXXABI::getAddrOfRTTIDescriptor(

Ty) {

ItaniumRTTIBuilder(*this).BuildTypeInfo(Ty);

ItaniumCXXABI::EmitFundamentalRTTIDescriptors(

*RD) {

getContext().VoidTy, getContext().NullPtrTy,

getContext().BoolTy, getContext().WCharTy,

getContext().CharTy, getContext().UnsignedCharTy,

getContext().SignedCharTy, getContext().ShortTy,

getContext().UnsignedShortTy, getContext().IntTy,

getContext().UnsignedIntTy, getContext().LongTy,

getContext().UnsignedLongTy, getContext().LongLongTy,

getContext().UnsignedLongLongTy, getContext().Int128Ty,

getContext().UnsignedInt128Ty, getContext().HalfTy,

getContext().FloatTy, getContext().DoubleTy,

getContext().LongDoubleTy, getContext().Float128Ty,

getContext().Char8Ty, getContext().Char16Ty,

getContext().Char32Ty

llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass =

? llvm::GlobalValue::DLLExportStorageClass

: llvm::GlobalValue::DefaultStorageClass;

llvm::GlobalValue::VisibilityTypes

=

(

&FundamentalType : FundamentalTypes) {

PointerTypeConst = getContext().getPointerType(

FundamentalType.withConst());

ItaniumRTTIBuilder(*this).BuildTypeInfo(

, llvm::GlobalValue::ExternalLinkage,

ItaniumCXXABI::RTTIUniquenessKind ItaniumCXXABI::classifyRTTIUniqueness(

(shouldRTTIBeUnique())

(

!= llvm::GlobalValue::LinkOnceODRLinkage &&

!= llvm::GlobalValue::WeakODRLinkage)

(

== llvm::GlobalValue::LinkOnceODRLinkage)

RUK_NonUniqueHidden;

assert(

== llvm::GlobalValue::WeakODRLinkage);

RUK_NonUniqueVisible;

StructorCodegen { Emit, RAUW, Alias, COMDAT };

StructorCodegen::Emit;

StructorCodegen::Emit;

(

*DD = dyn_cast<CXXDestructorDecl>(MD)) {

*CD = cast<CXXConstructorDecl>(MD);

(llvm::GlobalValue::isDiscardableIfUnused(

))

StructorCodegen::RAUW;

(!llvm::GlobalAlias::isValidLinkage(

))

StructorCodegen::RAUW;

(llvm::GlobalValue::isWeakForLinker(

)) {

StructorCodegen::COMDAT;

StructorCodegen::Emit;

StructorCodegen::Alias;

(Entry && !Entry->isDeclaration())

*Aliasee = cast<llvm::GlobalValue>(CGM.

(TargetDecl));

*Alias = llvm::GlobalAlias::create(

,

, Aliasee);

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

assert(Entry->getType() == Aliasee->getType() &&

);

Alias->takeName(Entry);

Entry->replaceAllUsesWith(Alias);

Entry->eraseFromParent();

Alias->setName(MangledName);

ItaniumCXXABI::emitCXXStructor(

GD) {

*MD = cast<CXXMethodDecl>(GD.

());

*CD = dyn_cast<CXXConstructorDecl>(MD);

(CGType == StructorCodegen::Alias || CGType == StructorCodegen::COMDAT) {

(CGType == StructorCodegen::RAUW) {

CGType != StructorCodegen::COMDAT &&

(CGType == StructorCodegen::COMDAT) {

llvm::raw_svector_ostream Out(Buffer);

getMangleContext().mangleCXXDtorComdat(DD, Out);

getMangleContext().mangleCXXCtorComdat(CD, Out);

llvm::Comdat *

= CGM.

().getOrInsertComdat(Out.str());

->setComdat(

);

llvm::FunctionType *FTy = llvm::FunctionType::get(

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

,

);

llvm::FunctionType *FTy = llvm::FunctionType::get(

CallEndCatch(

MightThrow) : MightThrow(MightThrow) {}

EndMightThrow) {

llvm::CallInst *call =

CGF.

.pushCleanup<CallEndCatch>(

EndMightThrow && !CGF.

.

().AssumeNothrowExceptionDtor);

(isa<ReferenceType>(CatchType)) {

EndCatchMightThrow = CaughtType->

();

llvm::Value *AdjustedExn =

(CGF, Exn, EndCatchMightThrow);

(

*PT = dyn_cast<PointerType>(CaughtType)) {

HeaderSize =

CGF.

.CreateConstGEP1_32(CGF.

, Exn, HeaderSize);

llvm::Value *Casted = CGF.

.CreateBitCast(AdjustedExn, PtrTy);

llvm::Value *ExnCast =

CGF.

.CreateBitCast(AdjustedExn, LLVMCatchTy,

);

(CatchType->hasPointerRepresentation()) {

llvm::Value *CastExn =

CGF.

.CreateBitCast(AdjustedExn, LLVMCatchTy,

);

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

assert(isa<RecordType>(CatchType) &&

);

catchRD = CatchType->getAsCXXRecordDecl();

adjustedExn(CGF.

.CreateBitCast(rawAdjustedExn, PtrTy),

LLVMCatchTy, caughtExnAlignment);

llvm::CallInst *rawAdjustedExn =

adjustedExn(CGF.

.CreateBitCast(rawAdjustedExn, PtrTy),

LLVMCatchTy, caughtExnAlignment);

CodeGenFunction::OpaqueValueMapping

*CatchParam = S->getExceptionDecl();

(CGF, *CatchParam,

.getObjectAddress(CGF), S->getBeginLoc());

.VoidTy, {C.getPointerType(C.CharTy)});

fnTy,

, llvm::AttributeList(),

);

llvm::Function *fn =

cast<llvm::Function>(fnRef.getCallee()->stripPointerCasts());

fn->setDoesNotThrow();

fn->setDoesNotReturn();

fn->addFnAttr(llvm::Attribute::NoInline);

fn->setLinkage(llvm::Function::LinkOnceODRLinkage);

fn->setVisibility(llvm::Function::HiddenVisibility);

fn->setComdat(CGM.

().getOrInsertComdat(fn->getName()));

llvm::BasicBlock *entry =

llvm::Value *exn = &*fn->arg_begin();

llvm::CallInst *catchCall = builder.CreateCall(

(CGM), exn);

catchCall->setDoesNotThrow();

llvm::CallInst *termCall = builder.CreateCall(CGM.

());

termCall->setDoesNotThrow();

termCall->setDoesNotReturn();

builder.CreateUnreachable();

ItaniumCXXABI::emitTerminateForUnexpectedException(

&CGF,

std::pair<llvm::Value *, const CXXRecordDecl *>

ItaniumCXXABI::getSignedVirtualMemberFunctionPointer(

*MD) {

llvm::Constant *thunk = getOrCreateVirtualFunctionPointerThunk(origMD);

ItaniumCXXABI::emitBeginCatch(CGF,

);

WebAssemblyCXXABI::emitTerminateForUnexpectedException(

&CGF,

llvm::FunctionCallee Dtor,

llvm::Constant *Addr) {

llvm::FunctionType *AtExitTy =

llvm::FunctionType::get(CGM.

, {CGM.IntTy, PtrTy},

);

llvm::FunctionCallee

=

llvm::Value *NV = llvm::Constant::getNullValue(CGM.

);

llvm::Function *DtorStub =

emitCXXStermFinalizer(

, DtorStub, Addr);

XLCXXABI::emitCXXStermFinalizer(

&

, llvm::Function *dtorStub,

llvm::Constant *addr) {

llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.

,

);

llvm::raw_svector_ostream Out(FnName);

getMangleContext().mangleDynamicStermFinalizer(&

, Out);

.getInit()->getExprLoc());

llvm::BasicBlock *DestructCallBlock = CGF.

(

);

CGF.

.CreateCondBr(NeedsDestruct, DestructCallBlock, EndBlock);

llvm::CallInst *CI = CGF.

.CreateCall(dtorStub);

CI->setCallingConv(dtorStub->getCallingConv());

(

*IPA =

.

<InitPriorityAttr>()) {

IPA->getPriority());

static StructorCodegen getCodegenToUse(CodeGenModule &CGM, const CXXMethodDecl *MD)

static llvm::FunctionCallee getItaniumDynamicCastFn(CodeGenFunction &CGF)

static llvm::FunctionCallee getClangCallTerminateFn(CodeGenModule &CGM)

Get or define the following function: void @__clang_call_terminate(i8* exn) nounwind noreturn This co...

static bool CXXRecordNonInlineHasAttr(const CXXRecordDecl *RD)

static unsigned extractPBaseFlags(ASTContext &Ctx, QualType &Type)

Compute the flags for a __pbase_type_info, and remove the corresponding pieces from Type.

static bool ShouldUseExternalRTTIDescriptor(CodeGenModule &CGM, QualType Ty)

ShouldUseExternalRTTIDescriptor - Returns whether the type information for the given type exists some...

static bool IsIncompleteClassType(const RecordType *RecordTy)

IsIncompleteClassType - Returns whether the given record type is incomplete.

static unsigned ComputeVMIClassTypeInfoFlags(const CXXBaseSpecifier *Base, SeenBases &Bases)

ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in abi::__vmi_class_type_info.

static llvm::FunctionCallee getBadTypeidFn(CodeGenFunction &CGF)

static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF, llvm::FunctionCallee dtor, llvm::Constant *addr, bool TLS)

Register a global destructor using __cxa_atexit.

static llvm::FunctionCallee getBadCastFn(CodeGenFunction &CGF)

static llvm::FunctionCallee getBeginCatchFn(CodeGenModule &CGM)

static llvm::Constant * pointerAuthResignMemberFunctionPointer(llvm::Constant *Src, QualType DestType, QualType SrcType, CodeGenModule &CGM)

static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM, QualType Ty)

Return the linkage that the type info and type info name constants should have for the given type.

static llvm::FunctionCallee getGuardReleaseFn(CodeGenModule &CGM, llvm::PointerType *GuardPtrTy)

static llvm::Value * performTypeAdjustment(CodeGenFunction &CGF, Address InitialPtr, const CXXRecordDecl *UnadjustedClass, int64_t NonVirtualAdjustment, int64_t VirtualAdjustment, bool IsReturnAdjustment)

static llvm::Function * createGlobalInitOrCleanupFn(CodeGen::CodeGenModule &CGM, StringRef FnName)

static llvm::FunctionCallee getAllocateExceptionFn(CodeGenModule &CGM)

static bool IsStandardLibraryRTTIDescriptor(QualType Ty)

IsStandardLibraryRTTIDescriptor - Returns whether the type information for the given type exists in t...

static llvm::Value * CallBeginCatch(CodeGenFunction &CGF, llvm::Value *Exn, bool EndMightThrow)

Emits a call to __cxa_begin_catch and enters a cleanup to call __cxa_end_catch.

static llvm::FunctionCallee getGuardAbortFn(CodeGenModule &CGM, llvm::PointerType *GuardPtrTy)

static CharUnits computeOffsetHint(ASTContext &Context, const CXXRecordDecl *Src, const CXXRecordDecl *Dst)

Compute the src2dst_offset hint as described in the Itanium C++ ABI [2.9.7].

static bool isThreadWrapperReplaceable(const VarDecl *VD, CodeGen::CodeGenModule &CGM)

static void InitCatchParam(CodeGenFunction &CGF, const VarDecl &CatchParam, Address ParamAddr, SourceLocation Loc)

A "special initializer" callback for initializing a catch parameter during catch initialization.

static bool TypeInfoIsInStandardLibrary(const BuiltinType *Ty)

TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type info for that type is de...

static bool CanUseSingleInheritance(const CXXRecordDecl *RD)

static llvm::FunctionCallee getEndCatchFn(CodeGenModule &CGM)

static llvm::GlobalValue::LinkageTypes getThreadLocalWrapperLinkage(const VarDecl *VD, CodeGen::CodeGenModule &CGM)

Get the appropriate linkage for the wrapper function.

static llvm::FunctionCallee getThrowFn(CodeGenModule &CGM)

static void setVTableSelectiveDLLImportExport(CodeGenModule &CGM, llvm::GlobalVariable *VTable, const CXXRecordDecl *RD)

static llvm::FunctionCallee getGuardAcquireFn(CodeGenModule &CGM, llvm::PointerType *GuardPtrTy)

static bool ContainsIncompleteClassType(QualType Ty)

ContainsIncompleteClassType - Returns whether the given type contains an incomplete class type.

static llvm::Constant * pointerAuthResignConstant(llvm::Value *Ptr, const CGPointerAuthInfo &CurAuthInfo, const CGPointerAuthInfo &NewAuthInfo, CodeGenModule &CGM)

static void emitConstructorDestructorAlias(CodeGenModule &CGM, GlobalDecl AliasDecl, GlobalDecl TargetDecl)

static llvm::FunctionCallee getGetExceptionPtrFn(CodeGenModule &CGM)

static void dtorTy(Block *, std::byte *Ptr, const Descriptor *)

llvm::MachO::Record Record

static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD)

static const RecordType * getRecordType(QualType QT)

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

static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)

Determine what kind of template specialization the given declaration is.

static QualType getPointeeType(const MemRegion *R)

#define CXXABI(Name, Str)

C Language Family Type Representation.

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

const ValueDecl * getMemberPointerDecl() const

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

CharUnits getTypeAlignInChars(QualType T) const

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

QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const

getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.

QualType getMemberPointerType(QualType T, const Type *Cls) const

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

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

CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const

Retrieves the default calling convention for the current target.

QualType getPointerType(QualType T) const

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

const LangOptions & getLangOpts() const

QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const

Get a function type and produce the equivalent function type with the specified exception specificati...

QualType getPointerDiffType() const

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

CharUnits getExnObjectAlignment() const

Return the alignment (in bytes) of the thrown exception object.

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

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

CharUnits getPreferredTypeAlignInChars(QualType T) const

Return the PreferredAlignment of a (complete) type T, in characters.

CanQualType UnsignedIntTy

QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const

Return a normal function type with a typed argument list.

const TargetInfo & getTargetInfo() const

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

TargetCXXABI::Kind getCXXABIKind() const

Return the C++ ABI kind that should be used.

QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const

Return the uniqued reference to the type for an address space qualified type with the specified type ...

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

CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const

getBaseClassOffset - Get the offset, in chars, for the given base class.

CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const

getVBaseClassOffset - Get the offset, in chars, for the given base class.

This class is used for builtin types like 'int'.

Implements C++ ABI-specific semantic analysis functions.

Represents a path from a specific derived class (which is not represented as part of the path) to a p...

BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...

Represents a base class of a C++ class.

QualType getType() const

Retrieves the type of the base class.

CXXCatchStmt - This represents a C++ catch block.

Represents a C++ constructor within a class.

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

FunctionDecl * getOperatorDelete() const

bool isGlobalDelete() const

Represents a C++ destructor within a class.

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.

const CXXRecordDecl * getParent() const

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

CXXMethodDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

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

Represents a C++ struct/union/class.

unsigned getNumBases() const

Retrieves the number of base classes of this class.

base_class_iterator bases_begin()

base_class_range vbases()

bool isDynamicClass() const

bool hasDefinition() const

unsigned getNumVBases() const

Retrieves the number of virtual base classes of this class.

bool isDerivedFrom(const CXXRecordDecl *Base) const

Determine whether this class is derived from the class Base.

A C++ throw-expression (C++ [except.throw]).

static CanQual< Type > CreateUnsafe(QualType Other)

Builds a canonical type from a QualType.

Qualifiers getQualifiers() const

Retrieve all qualifiers.

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.

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.

static CharUnits One()

One - Construct a CharUnits quantity of one.

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.

PointerAuthOptions PointerAuth

Configuration for pointer-signing.

std::string SymbolPartition

The name of the partition that symbols are assigned to, specified with -fsymbol-partition (see https:...

static ABIArgInfo getIndirect(CharUnits Alignment, bool ByVal=true, bool Realign=false, llvm::Type *Padding=nullptr)

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.

unsigned getAddressSpace() const

Return the address space that this address resides in.

llvm::PointerType * getType() const

Return the type of the pointer value.

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.

static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)

Apply TemporaryLocation if it is valid.

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="")

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

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

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

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="")

Implements C++ ABI-specific code generation functions.

virtual bool shouldEmitExactDynamicCast(QualType DestRecordTy)=0

virtual void EmitCXXConstructors(const CXXConstructorDecl *D)=0

Emit constructor variants required by this ABI.

virtual llvm::Constant * getAddrOfRTTIDescriptor(QualType Ty)=0

virtual llvm::Value * getVTableAddressPointInStructor(CodeGenFunction &CGF, const CXXRecordDecl *RD, BaseSubobject Base, const CXXRecordDecl *NearestVBase)=0

Get the address point of the vtable for the given base subobject while building a constructor or a de...

virtual void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C)=0

virtual void emitRethrow(CodeGenFunction &CGF, bool isNoReturn)=0

virtual size_t getSrcArgforCopyCtor(const CXXConstructorDecl *, FunctionArgList &Args) const =0

virtual bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr)=0

Checks if ABI requires extra virtual offset for vtable field.

virtual void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)=0

Emits the guarded initializer and destructor setup for the given variable, given that it couldn't be ...

virtual void EmitCXXDestructors(const CXXDestructorDecl *D)=0

Emit destructor variants required by this ABI.

virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF)=0

Emit the ABI-specific prolog for the function.

virtual bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor, CXXDtorType DT) const =0

Returns true if the given destructor type should be emitted as a linkonce delegating thunk,...

virtual bool NeedsVTTParameter(GlobalDecl GD)

Return whether the given global decl needs a VTT parameter.

virtual llvm::CallInst * emitTerminateForUnexpectedException(CodeGenFunction &CGF, llvm::Value *Exn)

@ RAA_Default

Pass it using the normal C aggregate rules for the ABI, potentially introducing extra copies and pass...

@ RAA_Indirect

Pass it as a pointer to temporary memory.

virtual bool shouldTypeidBeNullChecked(QualType SrcRecordTy)=0

virtual llvm::Type * ConvertMemberPointerType(const MemberPointerType *MPT)

Find the LLVM type used to represent the given member pointer type.

virtual llvm::Value * performThisAdjustment(CodeGenFunction &CGF, Address This, const CXXRecordDecl *UnadjustedClass, const ThunkInfo &TI)=0

virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)

Create a null member pointer of the given type.

virtual StringRef GetPureVirtualCallName()=0

Gets the pure virtual member call function.

virtual CharUnits getArrayCookieSizeImpl(QualType elementType)

Returns the extra size required in order to store the array cookie for the given type.

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 bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const =0

Determine whether it's possible to emit a vtable for RD, even though we do not know that the vtable h...

virtual StringRef GetDeletedVirtualCallName()=0

Gets the deleted virtual member call name.

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

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

virtual llvm::Value * performReturnAdjustment(CodeGenFunction &CGF, Address Ret, const CXXRecordDecl *UnadjustedClass, const ReturnAdjustment &RA)=0

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

bool isEmittedWithConstantInitializer(const VarDecl *VD, bool InspectInitForWeakDef=false) const

Determine whether we will definitely emit this variable with a constant initializer,...

virtual llvm::Value * EmitMemberPointerComparison(CodeGenFunction &CGF, llvm::Value *L, llvm::Value *R, const MemberPointerType *MPT, bool Inequality)

Emit a comparison between two member pointers. Returns an i1.

virtual llvm::Constant * EmitMemberPointer(const APValue &MP, QualType MPT)

Create a member pointer for the given member pointer constant.

virtual llvm::Constant * getVTableAddressPoint(BaseSubobject Base, const CXXRecordDecl *VTableClass)=0

Get the address point of the vtable for the given base subobject.

virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, FunctionArgList &Params)=0

Insert any ABI-specific implicit parameters into the parameter list for a function.

virtual llvm::Value * readArrayCookieImpl(CodeGenFunction &IGF, Address ptr, CharUnits cookieSize)

Reads the array cookie for an allocation which is known to have one.

virtual llvm::Value * EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr, const MemberPointerType *MPT)

Calculate an l-value from an object and a data member pointer.

virtual llvm::Value * getCXXDestructorImplicitParam(CodeGenFunction &CGF, const CXXDestructorDecl *DD, CXXDtorType Type, bool ForVirtualBase, bool Delegating)=0

Get the implicit (second) parameter that comes after the "this" pointer, or nullptr if there is isn't...

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 void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, GlobalDecl GD, bool ReturnAdjustment)=0

bool mayNeedDestruction(const VarDecl *VD) const

virtual bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass)=0

Checks if ABI requires to initialize vptrs for given dynamic class.

virtual void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E)=0

virtual llvm::Value * GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This, const CXXRecordDecl *ClassDecl, const CXXRecordDecl *BaseClassDecl)=0

virtual bool isThisCompleteObject(GlobalDecl GD) const =0

Determine whether there's something special about the rules of the ABI tell us that 'this' is a compl...

virtual CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, Address This, llvm::Type *Ty, SourceLocation Loc)=0

Build a virtual function pointer in the ABI-specific way.

virtual bool classifyReturnType(CGFunctionInfo &FI) const =0

If the C++ ABI requires the given type be returned in a particular way, this method sets RetAI and re...

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

virtual CatchTypeInfo getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType)=0

virtual void EmitThreadLocalInitFuncs(CodeGenModule &CGM, ArrayRef< const VarDecl * > CXXThreadLocals, ArrayRef< llvm::Function * > CXXThreadLocalInits, ArrayRef< const VarDecl * > CXXThreadLocalInitVars)=0

Emits ABI-required functions necessary to initialize thread_local variables in this translation unit.

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

virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const =0

Returns how an argument of the given record type should be passed.

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 void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This, QualType ThisTy)=0

Emit the destructor call.

virtual llvm::GlobalVariable * getAddrOfVTable(const CXXRecordDecl *RD, CharUnits VPtrOffset)=0

Get the address of the vtable for the given record decl which should be used for the vptr at the give...

virtual bool EmitBadCastCall(CodeGenFunction &CGF)=0

virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)

Create a member pointer for the given field.

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

virtual void emitVirtualInheritanceTables(const CXXRecordDecl *RD)=0

Emit any tables needed to implement virtual inheritance.

virtual void emitVTableDefinitions(CodeGenVTables &CGVT, const CXXRecordDecl *RD)=0

Emits the VTable definitions required for the given record type.

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 void emitCXXStructor(GlobalDecl GD)=0

Emit a single constructor/destructor with the given type from a C++ constructor Decl.

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 bool exportThunk()=0

virtual void EmitBadTypeidCall(CodeGenFunction &CGF)=0

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

virtual bool isZeroInitializable(const MemberPointerType *MPT)

Return true if the given member pointer can be zero-initialized (in the C++ sense) with an LLVM zeroi...

virtual llvm::Value * EmitMemberPointerConversion(CodeGenFunction &CGF, const CastExpr *E, llvm::Value *Src)

Perform a derived-to-base, base-to-derived, or bitcast member pointer conversion.

virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)

Create a member pointer for the given method.

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

virtual AddedStructorArgCounts buildStructorSignature(GlobalDecl GD, SmallVectorImpl< CanQualType > &ArgTys)=0

Build the signature of the given constructor or destructor variant by adding any required parameters.

MangleContext & getMangleContext()

Gets the mangle context.

virtual AddedStructorArgs getImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating)=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())

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

ABIArgInfo & getReturnInfo()

CanQualType getReturnType() const

llvm::Value * getDiscriminator() const

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

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

void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function * > CXXThreadLocals, ConstantAddress Guard=ConstantAddress::invalid())

GenerateCXXGlobalInitFunc - Generates code for initializing global variables.

llvm::Value * EmitPointerAuthAuth(const CGPointerAuthInfo &Info, llvm::Value *Pointer)

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

void FinishFunction(SourceLocation EndLoc=SourceLocation())

FinishFunction - Complete IR generation of the current function.

GlobalDecl CurGD

CurGD - The GlobalDecl for the current function being compiled.

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.

static TypeEvaluationKind getEvaluationKind(QualType T)

getEvaluationKind - Return the TypeEvaluationKind of QualType T.

SanitizerSet SanOpts

Sanitizers enabled for this function.

llvm::Constant * createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr)

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

bool CurFuncIsThunk

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

void EmitAnyExprToExn(const Expr *E, Address Addr)

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

llvm::Value * getAsNaturalPointerTo(Address Addr, QualType PointeeType)

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

createBasicBlock - Create an LLVM basic block.

llvm::Constant * EmitCheckTypeDescriptor(QualType T)

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

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

llvm::Value * EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD, llvm::Value *VTable, llvm::Type *VTableTy, uint64_t VTableByteOffset)

Emit a type checked load from the given vtable.

llvm::Value * GetVTTParameter(GlobalDecl GD, bool ForVirtualBase, bool Delegating)

GetVTTParameter - Return the VTT parameter that should be passed to a base constructor/destructor wit...

llvm::Type * ConvertTypeForMem(QualType T)

llvm::Function * createTLSAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr, llvm::FunctionCallee &AtExit)

void registerGlobalDtorWithLLVM(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)

Registers the dtor using 'llvm.global_dtors' for platforms that do not support an 'atexit()' function...

const TargetInfo & getTarget() const

void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV, bool PerformInit)

EmitCXXGlobalVarDeclInit - Create the initializer for a C++ variable with global storage.

llvm::Value * emitPointerAuthResign(llvm::Value *Pointer, QualType PointerType, const CGPointerAuthInfo &CurAuthInfo, const CGPointerAuthInfo &NewAuthInfo, bool IsKnownNonNull)

bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD)

Returns whether we should perform a type checked load when loading a virtual function for virtual cal...

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

CGCallee BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD, CXXDtorType Type, const CXXRecordDecl *RD)

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 EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc)

EmitDelegateCallArg - We are performing a delegate call; that is, the current function is delegating ...

ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)

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

llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)

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

void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)

Call atexit() with a function that passes the given argument to the given function.

void EmitBranch(llvm::BasicBlock *Block)

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

LValue MakeRawAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment, AlignmentSource Source=AlignmentSource::Type)

Same as MakeAddrLValue above except that the pointer is known to be unsigned.

void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)

EmitAggregateCopy - Emit an aggregate copy.

llvm::Value * unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub)

Call unatexit() with function dtorStub.

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

void EmitAggExpr(const Expr *E, AggValueSlot AS)

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

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

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

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

ASTContext & getContext() const

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

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

const Decl * CurFuncDecl

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

llvm::Value * LoadCXXVTT()

LoadCXXVTT - Load the VTT parameter to base constructors/destructors have virtual bases.

AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)

void EmitAutoVarCleanups(const AutoVarEmission &emission)

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

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

void EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD, llvm::Value *VTable, SourceLocation Loc)

If whole-program virtual table optimization is enabled, emit an assumption that VTable is a member of...

llvm::Type * ConvertType(QualType T)

void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args)

CodeGenTypes & getTypes() const

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

llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")

QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)

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

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.

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

Address GetAddrOfLocalVar(const VarDecl *VD)

GetAddrOfLocalVar - Return the address of a local variable.

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

llvm::Instruction * CurrentFuncletPad

llvm::LLVMContext & getLLVMContext()

llvm::Value * getExceptionFromSlot()

Returns the contents of the function's exception object and selector slots.

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

CGPointerAuthInfo EmitPointerAuthInfo(const PointerAuthSchema &Schema, llvm::Value *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)

void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, llvm::BasicBlock *InitBlock, llvm::BasicBlock *NoInitBlock, GuardKind Kind, const VarDecl *D)

Emit a branch to select whether or not to perform guarded initialization.

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

void AddCXXPrioritizedStermFinalizerEntry(llvm::Function *StermFinalizer, int Priority)

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

Set visibility, dllimport/dllexport and dso_local.

void AddCXXStermFinalizerToGlobalDtor(llvm::Function *StermFinalizer, int Priority)

Add an sterm finalizer to its own llvm.global_dtors entry.

llvm::GlobalVariable::ThreadLocalMode GetDefaultLLVMTLSModel() const

Get LLVM TLS mode from CodeGenOptions.

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.

CodeGenVTables & getVTables()

void AddCXXStermFinalizerEntry(llvm::FunctionCallee DtorFn)

Add an sterm finalizer to the C++ global cleanup function.

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

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

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

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

CGPointerAuthInfo getMemberFunctionPointerAuthInfo(QualType FT)

const LangOptions & getLangOpts() const

CodeGenTypes & getTypes()

bool shouldMapVisibilityToDLLExport(const NamedDecl *D) const

const TargetInfo & getTarget() const

bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D)

Try to emit a base destructor as an alias to its primary base-class destructor.

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

Returns LLVM linkage for a declarator.

const llvm::DataLayout & getDataLayout() const

CGCXXABI & getCXXABI() const

static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V)

llvm::Constant * getMemberFunctionPointer(const FunctionDecl *FD, llvm::Type *Ty=nullptr)

llvm::Function * codegenCXXStructor(GlobalDecl GD)

CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)

Returns the assumed alignment of an opaque pointer to the given class.

const llvm::Triple & getTriple() const

llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD)

void AddGlobalDtor(llvm::Function *Dtor, int Priority=65535, bool IsDtorAttrFunc=false)

AddGlobalDtor - Add a function to the list that will be called when the module is unloaded.

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

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

CharUnits getDynamicOffsetAlignment(CharUnits ActualAlign, const CXXRecordDecl *Class, CharUnits ExpectedTargetAlign)

Given a class pointer with an actual known alignment, and the expected alignment of an object at a dy...

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

ItaniumVTableContext & getItaniumVTableContext()

ASTContext & getContext() const

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.

bool supportsCOMDAT() const

const TargetCodeGenInfo & getTargetCodeGenInfo()

const CodeGenOptions & getCodeGenOpts() const

StringRef getMangledName(GlobalDecl GD)

void SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV)

Set attributes which are common to any form of a global definition (alias, Objective-C method,...

llvm::GlobalVariable * CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage, llvm::Align Alignment)

Will return a global variable of the given type.

llvm::FunctionCallee getTerminateFn()

Get the declaration of std::terminate for the platform.

llvm::LLVMContext & getLLVMContext()

llvm::GlobalValue * GetGlobalValue(StringRef Ref)

void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO)

LangAS GetGlobalVarAddressSpace(const VarDecl *D)

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

llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD)

Return the appropriate linkage for the vtable, VTT, and type information of the given class.

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

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

void addReplacement(StringRef Name, llvm::Constant *C)

llvm::Constant * getConstantSignedPointer(llvm::Constant *Pointer, const PointerAuthSchema &Schema, llvm::Constant *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)

Sign a constant pointer using the given scheme, producing a constant with the same IR type.

void AddGlobalCtor(llvm::Function *Ctor, int Priority=65535, unsigned LexOrder=~0U, llvm::Constant *AssociatedData=nullptr)

AddGlobalCtor - Add a function to the list that will be called before main() runs.

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

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

llvm::Function * CreateGlobalInitOrCleanUpFunction(llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI, SourceLocation Loc=SourceLocation(), bool TLS=false, llvm::GlobalVariable::LinkageTypes Linkage=llvm::GlobalVariable::InternalLinkage)

This class organizes the cross-module state that is used while lowering AST types to LLVM types.

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.

const CodeGenOptions & getCodeGenOpts() const

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

GetFunctionType - Get the LLVM function type for.

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

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

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

A nullary function is a freestanding function of type 'void ()'.

llvm::GlobalVariable * GetAddrOfVTT(const CXXRecordDecl *RD)

GetAddrOfVTT - Get the address of the VTT for the given record decl.

void createVTableInitializer(ConstantStructBuilder &builder, const VTableLayout &layout, llvm::Constant *rtti, bool vtableHasLocalLinkage)

Add vtable components for the given vtable layout to the given global initializer.

void GenerateRelativeVTableAlias(llvm::GlobalVariable *VTable, llvm::StringRef AliasNameRef)

Generate a public facing alias for the vtable and make the vtable either hidden or private.

bool isVTableExternal(const CXXRecordDecl *RD)

At this point in the translation unit, does it appear that can we rely on the vtable being defined el...

void RemoveHwasanMetadata(llvm::GlobalValue *GV) const

Specify a global should not be instrumented with hwasan.

void EmitVTTDefinition(llvm::GlobalVariable *VTT, llvm::GlobalVariable::LinkageTypes Linkage, const CXXRecordDecl *RD)

EmitVTTDefinition - Emit the definition of the given vtable.

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

The standard implementation of ConstantInitBuilder used in Clang.

Information for lazily generating a cleanup.

void popTerminate()

Pops a terminate handler off the stack.

void pushTerminate()

Push a terminate handler on the stack.

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

LValue - This represents an lvalue references.

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

static RValue get(llvm::Value *V)

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

virtual unsigned getSizeOfUnwindException() const

Determines the size of struct _Unwind_Exception on this platform, in 8-bit units.

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

DeclContext * getParent()

getParent - Returns the containing DeclContext.

bool isTranslationUnit() const

decl_range noload_decls() const

noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...

SourceLocation getLocation() const

DeclContext * getDeclContext()

bool shouldEmitInExternalSource() const

Whether the definition of the declaration should be emitted in external sources.

This represents one expression.

Represents a function declaration or definition.

bool isInlined() const

Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...

bool doesThisDeclarationHaveABody() const

Returns whether this specific declaration of the function has a body.

bool isPureVirtual() const

Whether this virtual function is pure, i.e.

FunctionDecl * getDefinition()

Get the definition for this declaration.

bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const

Returns true if the function has a definition that does not need to be instantiated.

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

GlobalDecl - represents a global declaration.

GlobalDecl getWithCtorType(CXXCtorType Type)

CXXCtorType getCtorType() const

GlobalDecl getCanonicalDecl() const

GlobalDecl getWithDtorType(CXXDtorType Type)

CXXDtorType getDtorType() const

const Decl * getDecl() const

bool isStr(const char(&Str)[StrLen]) const

Return true if this is the identifier for the specified string.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)

Create implicit parameter.

bool isRelativeLayout() const

const VTableLayout & getVTableLayout(const CXXRecordDecl *RD)

CharUnits getVirtualBaseOffsetOffset(const CXXRecordDecl *RD, const CXXRecordDecl *VBase)

Return the offset in chars (relative to the vtable address point) where the offset of the virtual bas...

GlobalDecl findOriginalMethod(GlobalDecl GD)

Return the method that added the v-table slot that will be used to call the given method.

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

virtual void mangleCXXRTTIName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0

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

QualType getPointeeType() const

bool isMemberFunctionPointer() const

Returns true if the member type (i.e.

bool isMemberDataPointer() const

Returns true if the member type (i.e.

const Type * getClass() const

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

Visibility getVisibility() const

Determines the visibility of this entity.

bool isExternallyVisible() const

Represents an ObjC class declaration.

Represents a class type in Objective C.

QualType getBaseType() const

Gets the base type of this object type.

static const OpaqueValueExpr * findInCopyConstruct(const Expr *expr)

Given an expression which invokes a copy constructor — i.e.

PointerType - C99 6.7.5.1 - Pointer Declarators.

QualType getPointeeType() const

A (possibly-)qualified type.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

Qualifiers getQualifiers() const

Retrieve the set of qualifiers applied to this type.

QualType getNonReferenceType() const

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

QualType getCanonicalType() const

QualType getUnqualifiedType() const

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

The collection of all-type qualifiers we support.

@ OCL_Strong

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

@ OCL_ExplicitNone

This object can be modified without requiring retains or releases.

@ OCL_None

There is no lifetime qualification on this type.

@ OCL_Weak

Reading or writing from this object requires a barrier call.

@ OCL_Autoreleasing

Assigning into this object requires a lifetime extension.

ObjCLifetime getObjCLifetime() const

bool canPassInRegisters() const

Determine whether this class can be passed in registers.

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

RecordDecl * getDecl() const

Encodes a location in the source.

SourceLocation getBeginLoc() const LLVM_READONLY

bool isCompleteDefinition() const

Return true if this decl has its body fully specified.

Exposes information about the current target.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

unsigned getMaxAtomicInlineWidth() const

Return the maximum width lock-free atomic operation which can be inlined given the supported features...

uint64_t getPointerWidth(LangAS AddrSpace) const

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

virtual bool hasPS4DLLImportExport() const

uint64_t getPointerAlign(LangAS AddrSpace) const

unsigned getLongWidth() const

getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...

virtual bool hasFeature(StringRef Feature) const

Determine whether the given target has the given feature.

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

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

QualType getPointeeType() const

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

Visibility getVisibility() const

Determine the visibility of this type.

bool isMemberFunctionPointerType() const

Linkage getLinkage() const

Determine the linkage of this type.

TypeClass getTypeClass() const

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

AddressPointLocation getAddressPoint(BaseSubobject Base) const

size_t getVTableSize(size_t i) const

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 * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

bool isStaticLocal() const

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

const Expr * getInit() const

@ TLS_Dynamic

TLS with a dynamic initializer.

@ TLS_None

Not a TLS variable.

DefinitionKind hasDefinition(ASTContext &) const

Check whether this variable is defined in this translation unit.

TemplateSpecializationKind getTemplateSpecializationKind() const

If this variable is an instantiation of a variable template or a static data member of a class templa...

llvm::Value * getCXXDestructorImplicitParam(CodeGenModule &CGM, llvm::BasicBlock *InsertBlock, llvm::BasicBlock::iterator InsertPoint, const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating)

TypeEvaluationKind

The kind of evaluation to perform on values of a particular type.

@ NormalCleanup

Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...

@ EHCleanup

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

CGCXXABI * CreateItaniumCXXABI(CodeGenModule &CGM)

Creates an Itanium-family ABI.

const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr

Matches expressions.

constexpr Variable var(Literal L)

Returns the variable of L.

bool This(InterpState &S, CodePtr OpPC)

bool Zero(InterpState &S, CodePtr OpPC)

bool InRange(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_DefaultClosure

Default closure variant of a ctor.

@ Ctor_CopyingClosure

Copying closure variant of a ctor.

@ Ctor_Complete

Complete object ctor.

@ Ctor_Comdat

The COMDAT used for ctors.

bool isTemplateInstantiation(TemplateSpecializationKind Kind)

Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...

Linkage

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

@ VisibleNone

No linkage according to the standard, but is visible from other translation units because of types de...

@ None

No linkage, which means that the entity is unique and can only be referred to from within its scope.

@ UniqueExternal

External linkage within a unique namespace.

@ Internal

Internal linkage, which indicates that the entity can be referred to from within the translation unit...

@ External

External linkage, which indicates that the entity can be referred to from other translation units.

@ Module

Module linkage, which indicates that the entity can be referred to from other translation units withi...

CXXDtorType

C++ destructor types.

@ Dtor_Comdat

The COMDAT used for dtors.

@ Dtor_Base

Base object dtor.

@ Dtor_Complete

Complete object dtor.

@ Dtor_Deleting

Deleting dtor.

bool isDiscardableGVALinkage(GVALinkage L)

LangAS

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

const FunctionProtoType * T

@ Success

Template argument deduction was successful.

@ Class

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

@ EST_None

no exception specification

Visibility

Describes the different kinds of visibility that a declaration may have.

@ HiddenVisibility

Objects with "hidden" visibility are not seen by the dynamic linker.

@ DefaultVisibility

Objects with "default" visibility are seen by the dynamic linker and act like normal objects.

Represents an element in a path from a derived class to a base class.

Similar to AddedStructorArgs, but only notes the number of additional arguments.

Additional implicit arguments to add to the beginning (Prefix) and end (Suffix) of a constructor / de...

The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler,...

llvm::PointerType * VoidPtrTy

llvm::IntegerType * Int64Ty

llvm::PointerType * GlobalsVoidPtrTy

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * CharTy

char

llvm::CallingConv::ID getRuntimeCC() const

llvm::IntegerType * SizeTy

llvm::PointerType * VoidPtrPtrTy

llvm::PointerType * GlobalsInt8PtrTy

llvm::IntegerType * Int32Ty

llvm::IntegerType * IntPtrTy

llvm::IntegerType * IntTy

int

CharUnits getSizeSize() const

CharUnits getSizeAlign() const

llvm::PointerType * Int8PtrTy

llvm::PointerType * UnqualPtrTy

CharUnits getPointerAlign() const

Extra information about a function prototype.

PointerAuthSchema CXXVTTVTablePointers

The ABI for C++ virtual table pointers as installed in a VTT.

PointerAuthSchema CXXTypeInfoVTablePointer

TypeInfo has external ABI requirements and is emitted without actually having parsed the libcxx defin...

union clang::ReturnAdjustment::VirtualAdjustment Virtual

int64_t NonVirtual

The non-virtual adjustment from the derived object to its nearest virtual base.

bool has(SanitizerMask K) const

Check if a certain (single) sanitizer is enabled.

A this pointer adjustment.

union clang::ThisAdjustment::VirtualAdjustment Virtual

int64_t NonVirtual

The non-virtual adjustment from the derived object to its nearest virtual base.

The this pointer adjustment as well as an optional return adjustment for a thunk.

ThisAdjustment This

The this pointer adjustment.

unsigned AddressPointIndex

struct clang::ReturnAdjustment::VirtualAdjustment::@192 Itanium

int64_t VBaseOffsetOffset

The offset (in bytes), relative to the address point of the virtual base class offset.

int64_t VCallOffsetOffset

The offset (in bytes), relative to the address point, of the virtual call offset.

struct clang::ThisAdjustment::VirtualAdjustment::@194 Itanium

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