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

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

clang: lib/CodeGen/MicrosoftCXXABI.cpp Source File

;

CodeGen;

VBTableGlobals {

MicrosoftCXXABI :

{

:

(CGM), BaseClassDescriptorType(nullptr),

ClassHierarchyDescriptorType(nullptr),

CompleteObjectLocatorType(nullptr), CatchableTypeType(nullptr),

ThrowInfoType(nullptr) {

);

(isa<CXXDestructorDecl>(GD.

())) {

: llvm_unreachable(

);

llvm_unreachable(

);

assert(Args.size() >= 2 &&

);

std::vector<CharUnits> VBPtrOffsets;

VBTableGlobals &VBGlobals = enumerateVBTables(RD);

(

std::unique_ptr<VPtrInfo> &VBT : *VBGlobals.VBTables) {

(VBT->getVBaseWithVPtr())

VBPtrOffsets.push_back(Offs);

llvm::array_pod_sort(VBPtrOffsets.begin(), VBPtrOffsets.end());

llvm::GlobalVariable *getMSCompleteObjectLocator(

*RD,

llvm::Type *StdTypeInfoPtrTy)

;

llvm::BasicBlock *CastSuccess,

llvm::BasicBlock *CastFail)

{

llvm_unreachable(

);

llvm::BasicBlock *CastEnd)

;

AddedStructorArgCounts

llvm::GlobalValue::LinkageTypes

*MD = cast<CXXMethodDecl>(GD.

());

(MD->isVirtual()) {

(

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

MD->getParent();

MD->getParent();

VirtualCall)

;

llvm::GlobalVariable *VTable);

CodeGenFunction::VPtr Vptr)

;

!VTableClass->

<MSNoVTableAttr>();

DeleteOrMemberCallExpr

,

llvm::CallBase **CallOrInvoke)

;

);

llvm::GlobalVariable *

llvm::GlobalVariable::LinkageTypes

);

llvm::GlobalVariable *

llvm::raw_svector_ostream Out(OutName);

StringRef MangledName = OutName.str();

(

*VDispMap = CGM.

().getNamedGlobal(MangledName))

llvm::UndefValue::get(CGM.

));

Map[0] = llvm::ConstantInt::get(CGM.

, 0);

AnyDifferent =

;

(

&I : SrcRD->

()) {

*VBase = I.getType()->getAsCXXRecordDecl();

Map[SrcVBIndex] = llvm::ConstantInt::get(CGM.

, DstVBIndex * 4);

AnyDifferent |= SrcVBIndex != DstVBIndex;

llvm::ArrayType *VDispMapTy = llvm::ArrayType::get(CGM.

, Map.size());

llvm::Constant *

= llvm::ConstantArray::get(VDispMapTy, Map);

llvm::GlobalValue::LinkageTypes

=

? llvm::GlobalValue::LinkOnceODRLinkage

: llvm::GlobalValue::InternalLinkage;

*VDispMap =

llvm::GlobalVariable(

llvm::GlobalVariable *GV)

;

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

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

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

LangOptions::MSVC2019_5) &&

llvm::GlobalVariable *DeclPtr,

PerformInit)

;

llvm::FunctionCallee Dtor,

llvm::Constant *Addr)

;

llvm::Value *NumElements,

MSRTTIBuilder;

isImageRelative()

{

llvm::StructType *getTypeDescriptorType(StringRef TypeInfoString) {

TDTypeName += llvm::utostr(TypeInfoString.size());

llvm::StructType *&TypeDescriptorType =

TypeDescriptorTypeMap[TypeInfoString.size()];

(TypeDescriptorType)

TypeDescriptorType;

llvm::Type *FieldTypes[] = {

llvm::ArrayType::get(CGM.

, TypeInfoString.size() + 1)};

llvm::StructType::create(CGM.

(), FieldTypes, TDTypeName);

TypeDescriptorType;

llvm::Type *getImageRelativeType(llvm::Type *PtrType) {

(!isImageRelative())

llvm::StructType *getBaseClassDescriptorType() {

(BaseClassDescriptorType)

BaseClassDescriptorType;

llvm::Type *FieldTypes[] = {

BaseClassDescriptorType = llvm::StructType::create(

BaseClassDescriptorType;

llvm::StructType *getClassHierarchyDescriptorType() {

(ClassHierarchyDescriptorType)

ClassHierarchyDescriptorType;

ClassHierarchyDescriptorType =

llvm::StructType::create(FieldTypes,

);

ClassHierarchyDescriptorType;

llvm::StructType *getCompleteObjectLocatorType() {

(CompleteObjectLocatorType)

CompleteObjectLocatorType;

llvm::Type *FieldTypes[] = {

getImageRelativeType(CGM.

),

(!isImageRelative())

FieldTypesRef = FieldTypesRef.drop_back();

CompleteObjectLocatorType =

llvm::StructType::create(FieldTypesRef,

);

CompleteObjectLocatorType;

llvm::GlobalVariable *getImageBase() {

StringRef Name =

;

(llvm::GlobalVariable *GV = CGM.

().getNamedGlobal(Name))

llvm::GlobalValue::ExternalLinkage,

llvm::Constant *getImageRelativeConstant(llvm::Constant *PtrVal) {

(!isImageRelative())

(PtrVal->isNullValue())

llvm::Constant::getNullValue(CGM.

);

llvm::Constant *ImageBaseAsInt =

llvm::ConstantExpr::getPtrToInt(getImageBase(), CGM.

);

llvm::Constant *PtrValAsInt =

llvm::ConstantExpr::getPtrToInt(PtrVal, CGM.

);

llvm::Constant *Diff =

llvm::ConstantExpr::getSub(PtrValAsInt, ImageBaseAsInt,

llvm::ConstantExpr::getTrunc(Diff, CGM.

);

llvm::Constant *getZeroInt() {

llvm::ConstantInt::get(CGM.

, 0);

llvm::Constant *getAllOnesInt() {

llvm::Constant::getAllOnesValue(CGM.

);

llvm::Value *VBPtrOffset,

llvm::Value *VBTableOffset,

llvm::Value **VBPtr =

);

int32_t VBTableOffset,

llvm::Value **VBPtr =

) {

assert(VBTableOffset % 4 == 0 &&

);

llvm::Value *VBPOffset = llvm::ConstantInt::get(CGM.

, VBPtrOffset),

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

, VBTableOffset);

GetVBaseOffsetFromVBPtr(CGF,

, VBPOffset, VBTOffset, VBPtr);

std::tuple<Address, llvm::Value *, const CXXRecordDecl *>

llvm::Value *VirtualBaseAdjustmentOffset,

llvm::Value *VBPtrOffset

);

llvm::Constant *EmitFullMemberPointer(llvm::Constant *FirstField,

IsMemberFunction,

VBTableIndex);

VBTableGlobals &enumerateVBTables(

*RD);

llvm::Function *EmitVirtualMemPtrThunk(

*MD,

RD->

<MSInheritanceAttr>();

Inequality)

;

llvm::Value *EmitNonNullMemberPointerConversion(

llvm::Value *Src)

;

llvm::Constant *Src)

;

This, llvm::Value *&ThisPtrForCall,

llvm::StructType *getCatchableTypeType() {

(CatchableTypeType)

CatchableTypeType;

llvm::Type *FieldTypes[] = {

CatchableTypeType = llvm::StructType::create(

CatchableTypeType;

llvm::StructType *getCatchableTypeArrayType(uint32_t NumEntries) {

llvm::StructType *&CatchableTypeArrayType =

CatchableTypeArrayTypeMap[NumEntries];

(CatchableTypeArrayType)

CatchableTypeArrayType;

CTATypeName += llvm::utostr(NumEntries);

llvm::Type *CTType = getImageRelativeType(CGM.

);

llvm::Type *FieldTypes[] = {

llvm::ArrayType::get(CTType, NumEntries)

CatchableTypeArrayType =

llvm::StructType::create(CGM.

(), FieldTypes, CTATypeName);

CatchableTypeArrayType;

llvm::StructType *getThrowInfoType() {

ThrowInfoType;

llvm::Type *FieldTypes[] = {

ThrowInfoType = llvm::StructType::create(CGM.

(), FieldTypes,

ThrowInfoType;

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

, Args,

);

llvm::FunctionCallee Throw =

(

*Fn = dyn_cast<llvm::Function>(Throw.getCallee()))

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

llvm::Constant *getCatchableType(

,

uint32_t NVOffset = 0,

int32_t VBPtrOffset = -1,

uint32_t VBIndex = 0);

llvm::GlobalVariable *getCatchableTypeArray(

);

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

std::pair<const CXXRecordDecl *, CharUnits> VFTableIdTy;

llvm::DenseMap<VFTableIdTy, llvm::GlobalVariable *> VTablesMapTy;

llvm::DenseMap<VFTableIdTy, llvm::GlobalValue *> VFTablesMapTy;

VFTablesMapTy VFTablesMap;

VTablesMapTy VTablesMap;

llvm::DenseMap<const CXXRecordDecl *, VBTableGlobals> VBTablesMap;

GuardInfo() =

;

llvm::GlobalVariable *Guard =

;

BitIndex = 0;

llvm::DenseMap<const DeclContext *, GuardInfo> GuardVariableMap;

llvm::DenseMap<const DeclContext *, GuardInfo> ThreadLocalGuardVariableMap;

llvm::DenseMap<const DeclContext *, unsigned> ThreadSafeGuardNumMap;

llvm::DenseMap<size_t, llvm::StructType *> TypeDescriptorTypeMap;

llvm::StructType *BaseClassDescriptorType;

llvm::StructType *ClassHierarchyDescriptorType;

llvm::StructType *CompleteObjectLocatorType;

llvm::DenseMap<QualType, llvm::GlobalVariable *> CatchableTypeArrays;

llvm::StructType *CatchableTypeType;

llvm::DenseMap<uint32_t, llvm::StructType *> CatchableTypeArrayTypeMap;

llvm::StructType *ThrowInfoType;

MicrosoftCXXABI::getRecordArgABI(

*RD)

{

llvm::Triple::thumb:

llvm::Triple::x86: {

RAA_DirectInMemory;

llvm::Triple::x86_64:

llvm::Triple::aarch64:

llvm_unreachable(

);

llvm::Value *MDThis = EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, DE,

MicrosoftCXXABI::emitRethrow(

&CGF,

isNoReturn) {

llvm::Value *Args[] = {llvm::ConstantPointerNull::get(CGM.

),

llvm::ConstantPointerNull::get(CGM.

)};

*CatchParam = S->getExceptionDecl();

llvm::BasicBlock *CatchPadBB = CGF.

.GetInsertBlock();

llvm::CatchPadInst *CPI =

cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHIIt());

CPI->setArgOperand(2,

.getObjectAddress(CGF).emitRawPointer(CGF));

std::tuple<Address, llvm::Value *, const CXXRecordDecl *>

std::make_tuple(

, llvm::ConstantInt::get(CGF.

, 0),

PolymorphicBase = BaseDecl;

assert(PolymorphicBase &&

);

llvm::Value *Offset =

GetVirtualBaseClassOffset(CGF,

, SrcDecl, PolymorphicBase);

.getElementType(),

.emitRawPointer(CGF), Offset);

std::make_tuple(

(Ptr, CGF.

, VBaseAlign), Offset,

MicrosoftCXXABI::shouldTypeidBeNullChecked(

SrcRecordTy) {

!getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr();

llvm::Value *Argument) {

llvm::Type *ArgTypes[] = {CGF.

};

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGF.

, ArgTypes,

);

llvm::Value *Args[] = {Argument};

llvm::CallBase *

=

->setDoesNotReturn();

CGF.

.CreateUnreachable();

llvm::Type *StdTypeInfoPtrTy) {

std::tie(ThisPtr, std::ignore, std::ignore) =

performBaseAdjustment(CGF, ThisPtr, SrcRecordTy);

CGF.

.CreateBitCast(Typeid, StdTypeInfoPtrTy);

MicrosoftCXXABI::shouldDynamicCastCallBeNullChecked(

SrcIsPtr,

!getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr();

llvm::Value *MicrosoftCXXABI::emitDynamicCastCall(

DestRecordTy, llvm::BasicBlock *CastEnd) {

llvm::Value *SrcRTTI =

llvm::Value *DestRTTI =

llvm::Value *Offset;

std::tie(This, Offset, std::ignore) =

performBaseAdjustment(CGF, This, SrcRecordTy);

llvm::Value *ThisPtr =

.emitRawPointer(CGF);

llvm::FunctionType::get(CGF.

, ArgTypes,

),

);

llvm::Value *Args[] = {

ThisPtr, Offset, SrcRTTI, DestRTTI,

llvm::Value *MicrosoftCXXABI::emitDynamicCastToVoid(

&CGF,

std::tie(

, std::ignore, std::ignore) =

performBaseAdjustment(CGF,

, SrcRecordTy);

llvm::Type *ArgTypes[] = {CGF.

};

llvm::FunctionType::get(CGF.

, ArgTypes,

),

llvm::Value *Args[] = {

.emitRawPointer(CGF)};

llvm::Value *MicrosoftCXXABI::GetVirtualBaseClassOffset(

llvm::Value *VBPtrOffset = llvm::ConstantInt::get(CGM.

, VBPtrChars);

llvm::Value *VBTableOffset =

llvm::Value *VBPtrToNewBase =

GetVBaseOffsetFromVBPtr(CGF, This, VBPtrOffset, VBTableOffset);

CGF.

.CreateNSWAdd(VBPtrOffset, VBPtrToNewBase);

MicrosoftCXXABI::HasThisReturn(

GD)

{

isa<CXXConstructorDecl>(GD.

());

isa<CXXDestructorDecl>(GD.

()) &&

MicrosoftCXXABI::hasMostDerivedReturn(

GD)

{

uint64_t NumElts = 0;

isa<VectorType>(

)) {

(

*Ctor = dyn_cast<CXXConstructorDecl>(

)) {

(Ctor->isUserProvided())

}

(

*Template = dyn_cast<FunctionTemplateDecl>(

)) {

(isa<CXXConstructorDecl>(Template->getTemplatedDecl()))

}

(

*MethodDecl = dyn_cast<CXXMethodDecl>(

)) {

(MethodDecl->isCopyAssignmentOperator() && MethodDecl->isDeleted())

MicrosoftCXXABI::classifyReturnType(

&FI)

{

(isIndirectReturn) {

llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);

assert(IsMostDerivedClass &&

);

llvm::Value *IsCompleteObject =

CGF.

.CreateIsNotNull(IsMostDerivedClass,

);

llvm::BasicBlock *CallVbaseCtorsBB = CGF.

(

);

llvm::BasicBlock *SkipVbaseCtorsBB = CGF.

(

);

CGF.

.CreateCondBr(IsCompleteObject,

CallVbaseCtorsBB, SkipVbaseCtorsBB);

EmitVBPtrStores(CGF, RD);

SkipVbaseCtorsBB;

MicrosoftCXXABI::EmitDtorCompleteObjectHandler(

&CGF) {

llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);

assert(IsMostDerivedClass &&

);

llvm::Value *IsCompleteObject =

CGF.

.CreateIsNotNull(IsMostDerivedClass,

);

llvm::BasicBlock *CallVbaseDtorsBB = CGF.

(

);

llvm::BasicBlock *SkipVbaseDtorsBB = CGF.

(

);

CGF.

.CreateCondBr(IsCompleteObject,

CallVbaseDtorsBB, SkipVbaseDtorsBB);

SkipVbaseDtorsBB;

MicrosoftCXXABI::initializeHiddenVirtualInheritanceMembers(

llvm::Value *Int8This =

;

*VBase = S.getType()->getAsCXXRecordDecl();

I = VBaseMap.find(VBase);

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

(!I->second.hasVtorDisp())

llvm::Value *VBaseOffset =

GetVirtualBaseClassOffset(CGF, getThisAddress(CGF), RD, VBase);

ConstantVBaseOffset = I->second.VBaseOffset.getQuantity();

llvm::Value *VtorDispValue = Builder.CreateSub(

VBaseOffset, llvm::ConstantInt::get(CGM.

, ConstantVBaseOffset),

VtorDispValue = Builder.CreateTruncOrBitCast(VtorDispValue, CGF.

);

Int8This = getThisValue(CGF);

llvm::Value *VtorDispPtr =

Builder.CreateInBoundsGEP(CGF.

, Int8This, VBaseOffset);

VtorDispPtr = Builder.CreateConstGEP1_32(CGF.

, VtorDispPtr, -4);

Builder.CreateAlignedStore(VtorDispValue, VtorDispPtr,

ExpectedCallingConv == ActualCallingConv;

(

->

<DLLExportAttr>() &&

->isDefaultConstructor() &&

->setLinkage(llvm::GlobalValue::WeakODRLinkage);

VBTableGlobals &VBGlobals = enumerateVBTables(RD);

(

I = 0,

= VBGlobals.VBTables->size(); I !=

; ++I) {

std::unique_ptr<VPtrInfo> &VBT = (*VBGlobals.VBTables)[I];

llvm::GlobalVariable *GV = VBGlobals.Globals[I];

(VBT->getVBaseWithVPtr())

llvm::Value *GVPtr =

MicrosoftCXXABI::buildStructorSignature(

GD,

AddedStructorArgCounts Added;

(isa<CXXDestructorDecl>(GD.

()) &&

ArgTys.push_back(getContext().IntTy);

*CD = dyn_cast<CXXConstructorDecl>(GD.

());

(

->getNumVBases()) {

ArgTys.insert(ArgTys.begin() + 1, getContext().IntTy);

ArgTys.push_back(getContext().IntTy);

MicrosoftCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,

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

llvm::GlobalValue::LinkageTypes MicrosoftCXXABI::getCXXDestructorLinkage(

llvm::GlobalValue::InternalLinkage;

(Dtor->

<DLLExportAttr>())

llvm::GlobalValue::WeakODRLinkage;

(Dtor->

<DLLImportAttr>())

llvm::GlobalValue::AvailableExternallyLinkage;

llvm::GlobalValue::LinkOnceODRLinkage;

llvm::GlobalValue::LinkOnceODRLinkage;

llvm_unreachable(

);

llvm_unreachable(

);

(

->getParent()->getNumVBases() > 0 &&

->

<DLLExportAttr>())

MicrosoftCXXABI::getVirtualFunctionPrologueThisAdjustment(

GD) {

(isa<CXXDestructorDecl>(MD))

getContext().getASTRecordLayout(MD->

());

MicrosoftCXXABI::adjustThisArgumentForVirtualFunctionCall(

Adjustment = getVirtualFunctionPrologueThisAdjustment(GD);

(Adjustment.

())

Result = Result.withElementType(CGF.

);

llvm::Value *VBaseOffset =

GetVirtualBaseClassOffset(CGF, Result, Derived, VBase);

Result.getElementType(), Result.emitRawPointer(CGF), VBaseOffset);

(!StaticOffset.

()) {

Result = Result.withElementType(CGF.

);

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

ImplicitParamKind::Other);

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

Params.push_back(IsMostDerived);

getStructorImplicitParamDecl(CGF) = IsMostDerived;

&Context.

.

(

), Context.

,

ImplicitParamKind::Other);

Params.push_back(ShouldDelete);

getStructorImplicitParamDecl(CGF) = ShouldDelete;

MicrosoftCXXABI::EmitInstanceFunctionProlog(

&CGF) {

llvm::Value *

= loadIncomingCXXThis(CGF);

Adjustment = getVirtualFunctionPrologueThisAdjustment(CGF.

);

(!Adjustment.

()) {

setCXXABIThisValue(CGF, This);

(HasThisReturn(CGF.

) || hasMostDerivedReturn(CGF.

))

assert(getStructorImplicitParamDecl(CGF) &&

);

getStructorImplicitParamValue(CGF)

);

assert(getStructorImplicitParamDecl(CGF) &&

);

getStructorImplicitParamValue(CGF)

);

(!

->getParent()->getNumVBases())

AddedStructorArgs{};

llvm::Value *MostDerivedArg;

MostDerivedArg = getStructorImplicitParamValue(CGF);

AddedStructorArgs::prefix({{MostDerivedArg, getContext().IntTy}});

AddedStructorArgs::suffix({{MostDerivedArg, getContext().IntTy}});

llvm::Value *MicrosoftCXXABI::getCXXDestructorImplicitParam(

assert(

!= CXXDtorType::Dtor_Deleting &&

);

llvm::BasicBlock *BaseDtorEndBB =

;

(ForVirtualBase && isa<CXXConstructorDecl>(CGF.

)) {

BaseDtorEndBB = EmitDtorCompleteObjectHandler(CGF);

(BaseDtorEndBB) {

CGF.

.CreateBr(BaseDtorEndBB);

MicrosoftCXXABI::emitVTableTypeMetadata(

&Info,

llvm::GlobalVariable *VTable) {

llvm::DenseSet<const CXXRecordDecl *>

;

llvm::GlobalObject::VCallVisibility TypeVis =

(TypeVis != llvm::GlobalObject::VCallVisibilityPublic)

VTable->setVCallVisibilityMetadata(TypeVis);

getContext().getLangOpts().RTTIData

? getContext().toCharUnitsFromBits(

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

getContext().getASTRecordLayout(DerivedRD);

Offset = VBI->second.VBaseOffset;

(!Offset.isZero())

MicrosoftCXXABI::emitVTableDefinitions(

&CGVT,

(

std::unique_ptr<VPtrInfo>& Info : VFPtrs) {

llvm::GlobalVariable *VTable = getAddrOfVTable(RD, Info->

);

(VTable->hasInitializer())

llvm::Constant *RTTI =

;

RTTI = getMSCompleteObjectLocator(RD, *Info);

components = builder.beginStruct();

VTable->hasLocalLinkage());

components.finishAndSetAsInitializer(VTable);

emitVTableTypeMetadata(*Info, RD, VTable);

MicrosoftCXXABI::isVirtualOffsetNeededForVTableField(

Vptr.NearestVBase !=

;

llvm::Value *MicrosoftCXXABI::getVTableAddressPointInStructor(

llvm::Constant *VTableAddressPoint = getVTableAddressPoint(

, VTableClass);

(!VTableAddressPoint) {

assert(

.getBase()->getNumVBases() &&

!getContext().getASTRecordLayout(

.getBase()).hasOwnVFPtr());

VTableAddressPoint;

llvm::raw_svector_ostream Out(Name);

(void)getAddrOfVTable(VTableClass,

.getBaseOffset());

VFTableIdTy

(VTableClass,

.getBaseOffset());

VFTablesMap[

];

llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(

*RD,

VFTableIdTy

(RD, VPtrOffset);

VTablesMapTy::iterator I;

std::tie(I, Inserted) = VTablesMap.insert(std::make_pair(ID,

));

llvm::GlobalVariable *&VTable = I->second;

(DeferredVFTables.insert(RD).second) {

llvm::StringSet<> ObservedMangledNames;

(

J = 0, F = VFPtrs.size(); J != F; ++J) {

(!ObservedMangledNames.insert(Name.str()).second)

llvm_unreachable(

);

std::unique_ptr<VPtrInfo> *VFPtrI =

llvm::find_if(VFPtrs, [&](

std::unique_ptr<VPtrInfo> &VPI) {

VPI->FullOffsetInMDC == VPtrOffset;

(VFPtrI == VFPtrs.end()) {

VFTablesMap[

] =

;

std::unique_ptr<VPtrInfo> &VFPtr = *VFPtrI;

llvm::GlobalValue::LinkageTypes VFTableLinkage =

RD->

<DLLImportAttr>() ? llvm::GlobalValue::LinkOnceODRLinkage

VFTableComesFromAnotherTU =

llvm::GlobalValue::isAvailableExternallyLinkage(VFTableLinkage) ||

llvm::GlobalValue::isExternalLinkage(VFTableLinkage);

VTableAliasIsRequred =

!VFTableComesFromAnotherTU && getContext().getLangOpts().RTTIData;

(llvm::GlobalValue *VFTable =

CGM.

().getNamedGlobal(VFTableName)) {

VFTablesMap[

] = VFTable;

VTable = VTableAliasIsRequred

? cast<llvm::GlobalVariable>(

cast<llvm::GlobalAlias>(VFTable)->getAliaseeObject())

:

<

::GlobalVariable>(VFTable);

llvm::GlobalValue::LinkageTypes VTableLinkage =

VTableAliasIsRequred ? llvm::GlobalValue::PrivateLinkage : VFTableLinkage;

StringRef VTableName = VTableAliasIsRequred ? StringRef() : VFTableName.str();

llvm::GlobalValue *VFTable;

VTable =

llvm::GlobalVariable(CGM.

(), VTableType,

, VTableLinkage,

, VTableName);

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

llvm::Comdat *

=

;

(!VFTableComesFromAnotherTU &&

llvm::GlobalValue::isWeakForLinker(VFTableLinkage))

= CGM.

().getOrInsertComdat(VFTableName.str());

(VTableAliasIsRequred) {

llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.

, 0),

llvm::ConstantInt::get(CGM.

, 0),

llvm::ConstantInt::get(CGM.

, 1)};

llvm::Constant *VTableGEP = llvm::ConstantExpr::getInBoundsGetElementPtr(

VTable->getValueType(), VTable, GEPIndices);

(llvm::GlobalValue::isWeakForLinker(VFTableLinkage)) {

VFTableLinkage = llvm::GlobalValue::ExternalLinkage;

->setSelectionKind(llvm::Comdat::Largest);

VFTable = llvm::GlobalAlias::create(CGM.

,

VFTableName.str(), VTableGEP,

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

VTable->setComdat(

);

(RD->

<DLLExportAttr>())

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

VFTablesMap[

] = VFTable;

adjustThisArgumentForVirtualFunctionCall(CGF, GD, This,

);

*MethodDecl = cast<CXXMethodDecl>(GD.

());

llvm::Value *VTable =

getObjectWithVPtr = [&] {

[&](

std::unique_ptr<VPtrInfo> &Info) {

return Info->FullOffsetInMDC == ML.VFPtrOffset;

getObjectWithVPtr(), VTable, Ty,

llvm::Value *VFuncPtr =

Builder.CreateConstInBoundsGEP1_64(Ty, VTable, ML.

,

);

VFunc = Builder.CreateAlignedLoad(Ty, VFuncPtr, CGF.

());

llvm::Value *MicrosoftCXXABI::EmitVirtualDestructorCall(

This, DeleteOrMemberCallExpr

, llvm::CallBase **CallOrInvoke) {

*CE = dyn_cast<const CXXMemberCallExpr *>(

);

*

= dyn_cast<const CXXDeleteExpr *>(

);

assert((CE !=

) ^ (

!=

));

assert(CE ==

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

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

ThisTy = CE->getObjectType();

ThisTy =

->getDestroyedType();

= adjustThisArgumentForVirtualFunctionCall(CGF, GD, This,

);

ImplicitParam, Context.

, CE, CallOrInvoke);

VBTableGlobals &

MicrosoftCXXABI::enumerateVBTables(

*RD) {

llvm::DenseMap<const CXXRecordDecl*, VBTableGlobals>::iterator Entry;

std::tie(Entry, Added) =

VBTablesMap.insert(std::make_pair(RD, VBTableGlobals()));

VBTableGlobals &VBGlobals = Entry->second;

VBGlobals.VBTables = &Context.enumerateVBTables(RD);

(VPtrInfoVector::const_iterator I = VBGlobals.VBTables->begin(),

= VBGlobals.VBTables->end();

VBGlobals.Globals.push_back(getAddrOfVBTable(**I, RD,

));

MicrosoftCXXABI::EmitVirtualMemPtrThunk(

*MD,

assert(!isa<CXXConstructorDecl>(MD) && !isa<CXXDestructorDecl>(MD) &&

);

llvm::raw_svector_ostream Out(ThunkName);

getMangleContext().mangleVirtualMemPtrThunk(MD, ML, Out);

(llvm::GlobalValue *GV = CGM.

().getNamedValue(ThunkName))

cast<llvm::Function>(GV);

llvm::Function *ThunkFn =

llvm::Function::Create(ThunkTy, llvm::Function::ExternalLinkage,

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

);

? llvm::GlobalValue::LinkOnceODRLinkage

: llvm::GlobalValue::InternalLinkage);

ThunkFn->setComdat(CGM.

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

ThunkFn->addFnAttr(

);

ThunkFn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::None);

buildThisParam(CGF, FunctionArgs);

setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));

llvm::Value *VTable =

llvm::Value *VFuncPtr = CGF.

.CreateConstInBoundsGEP1_64(

ThunkPtrTy, VTable, ML.

,

);

MicrosoftCXXABI::emitVirtualInheritanceTables(

*RD) {

VBTableGlobals &VBGlobals = enumerateVBTables(RD);

(

I = 0,

= VBGlobals.VBTables->size(); I !=

; ++I) {

std::unique_ptr<VPtrInfo>& VBT = (*VBGlobals.VBTables)[I];

llvm::GlobalVariable *GV = VBGlobals.Globals[I];

(GV->isDeclaration())

emitVBTableDefinition(*VBT, RD, GV);

llvm::GlobalVariable *

llvm::GlobalVariable::LinkageTypes

) {

llvm::raw_svector_ostream Out(OutName);

getMangleContext().mangleCXXVBTable(RD, VBT.

, Out);

StringRef Name = OutName.str();

llvm::ArrayType *VBTableType =

assert(!CGM.

().getNamedGlobal(Name) &&

);

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

(RD->

<DLLImportAttr>())

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

(RD->

<DLLExportAttr>())

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

(!GV->hasExternalLinkage())

emitVBTableDefinition(VBT, RD, GV);

MicrosoftCXXABI::emitVBTableDefinition(

&VBT,

llvm::GlobalVariable *GV)

{

);

&DerivedLayout = getContext().getASTRecordLayout(RD);

Offsets[0] = llvm::ConstantInt::get(CGM.

, -VBPtrOffset.

());

(

&I : ObjectWithVPtr->

()) {

*VBase = I.getType()->getAsCXXRecordDecl();

assert(!Offset.isNegative());

CompleteVBPtrOffset +=

Offset -= CompleteVBPtrOffset;

VBIndex = Context.getVBTableIndex(ObjectWithVPtr, VBase);

assert(Offsets[VBIndex] ==

&&

);

Offsets[VBIndex] = llvm::ConstantInt::get(CGM.

, Offset.getQuantity());

assert(Offsets.size() ==

cast<llvm::ArrayType>(GV->getValueType())->getNumElements());

llvm::ArrayType *VBTableType =

llvm::ArrayType::get(CGM.

, Offsets.size());

llvm::Constant *

= llvm::ConstantArray::get(VBTableType, Offsets);

GV->setInitializer(

);

(RD->

<DLLImportAttr>())

GV->setLinkage(llvm::GlobalVariable::AvailableExternallyLinkage);

llvm::Value *MicrosoftCXXABI::performThisAdjustment(

.emitRawPointer(CGF);

=

.emitRawPointer(CGF);

CGF.

.CreateNeg(VtorDisp));

llvm::Value *VBaseOffset = GetVBaseOffsetFromVBPtr(

llvm::Value *MicrosoftCXXABI::performReturnAdjustment(

.emitRawPointer(CGF);

llvm::Value *

=

.emitRawPointer(CGF);

llvm::Value *VBaseOffset =

MicrosoftCXXABI::requiresArrayCookie(

*

) {

->getAllocatedType().isDestructedType();

llvm::Value *MicrosoftCXXABI::readArrayCookieImpl(

&CGF,

llvm::Value *numElements,

assert(requiresArrayCookie(

));

cookieSize = getArrayCookieSizeImpl(elementType);

llvm::FunctionCallee Dtor,

llvm::Constant *Addr) {

llvm::FunctionType *TLRegDtorTy = llvm::FunctionType::get(

CGF.

, DtorStub->getType(),

);

TLRegDtorTy,

, llvm::AttributeList(),

);

(llvm::Function *TLRegDtorFn =

dyn_cast<llvm::Function>(TLRegDtor.getCallee()))

TLRegDtorFn->setDoesNotThrow();

llvm::FunctionCallee Dtor,

llvm::Constant *Addr) {

(

.getTLSKind())

MicrosoftCXXABI::EmitThreadLocalInitFuncs(

(CXXThreadLocalInits.empty())

?

:

);

AddToXDU = [&CGM](llvm::Function *InitFunc) {

llvm::GlobalVariable *InitFuncPtr =

llvm::GlobalVariable(

CGM.

(), InitFunc->getType(),

,

llvm::GlobalVariable::InternalLinkage, InitFunc,

Twine(InitFunc->getName(),

));

InitFuncPtr->setSection(

);

std::vector<llvm::Function *> NonComdatInits;

(

I = 0,

= CXXThreadLocalInitVars.size(); I !=

; ++I) {

llvm::GlobalVariable *GV = cast<llvm::GlobalVariable>(

llvm::Function *F = CXXThreadLocalInits[I];

(llvm::Comdat *

= GV->getComdat())

AddToXDU(F)->setComdat(

);

NonComdatInits.push_back(F);

(!NonComdatInits.empty()) {

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

,

);

llvm::Constant *TlsGuardConstant =

llvm::GlobalValue *TlsGuard = cast<llvm::GlobalValue>(TlsGuardConstant);

TlsGuard->setThreadLocal(

);

llvm::FunctionType *FTy =

llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.

()), {},

FTy,

,

llvm::AttributeList::FunctionIndex,

llvm::Attribute::NoUnwind),

llvm::BasicBlock *DynInitBB,

llvm::BasicBlock *ContinueBB) {

llvm::LoadInst *TlsGuardValue =

llvm::Value *CmpResult =

CGF.

.CreateICmpEQ(TlsGuardValue, CGF.

.getInt8(0));

CGF.

.CreateCondBr(CmpResult, DynInitBB, ContinueBB);

llvm::GlobalValue *TlsGuard,

llvm::BasicBlock *ContinueBB) {

llvm::Function *InitializerFunction =

llvm::CallInst *CallVal = CGF.

.CreateCall(InitializerFunction);

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

CGF.

.CreateBr(ContinueBB);

llvm::BasicBlock *DynInitBB =

llvm::BasicBlock *ContinueBB =

CGF.

.SetInsertPoint(DynInitBB);

CGF.

.SetInsertPoint(ContinueBB);

Addr(

, RealVarTy, Alignment);

AlignmentSource::Decl)

StringRef VarName(

);

(

*GV = CGM.

().getNamedGlobal(VarName))

*GV =

llvm::GlobalVariable(

, llvm::GlobalVariable::ExternalLinkage,

, llvm::GlobalVariable::GeneralDynamicTLSModel);

llvm::FunctionType *FTy =

llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.

()),

FTy,

,

llvm::AttributeList::FunctionIndex,

llvm::Attribute::NoUnwind),

llvm::FunctionType *FTy =

llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.

()),

FTy,

,

llvm::AttributeList::FunctionIndex,

llvm::Attribute::NoUnwind),

llvm::FunctionType *FTy =

llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.

()),

FTy,

,

llvm::AttributeList::FunctionIndex,

llvm::Attribute::NoUnwind),

ResetGuardBit(

Guard,

GuardNum)

: Guard(Guard), GuardNum(GuardNum) {}

llvm::LoadInst *LI = Builder.CreateLoad(Guard);

llvm::ConstantInt *Mask =

llvm::ConstantInt::get(CGF.

, ~(1ULL << GuardNum));

Builder.CreateStore(Builder.CreateAnd(LI, Mask), Guard);

CallInitThreadAbort(

Guard) : Guard(Guard.getPointer()) {}

llvm::GlobalVariable *GV,

(!

.isStaticLocal()) {

assert(GV->hasWeakLinkage() || GV->hasLinkOnceLinkage());

llvm::Function *F = CGF.

;

F->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage);

F->setComdat(CGM.

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

ThreadlocalStatic =

.getTLSKind();

ThreadsafeStatic = getContext().

().ThreadsafeStatics;

HasPerVariableGuard = ThreadsafeStatic && !ThreadlocalStatic;

llvm::IntegerType *GuardTy = CGF.

;

llvm::ConstantInt *

= llvm::ConstantInt::get(GuardTy, 0);

GuardInfo *GI =

;

(ThreadlocalStatic)

(!ThreadsafeStatic)

llvm::GlobalVariable *GuardVar = GI ? GI->Guard :

;

(

.isExternallyVisible()) {

GuardNum = getContext().getStaticLocalNumber(&

);

assert(GuardNum > 0);

}

(HasPerVariableGuard) {

GuardNum = GI->BitIndex++;

(!HasPerVariableGuard && GuardNum >= 32) {

(

.isExternallyVisible())

ErrorUnsupportedABI(CGF,

);

GuardVar =

;

llvm::raw_svector_ostream Out(GuardName);

(HasPerVariableGuard)

getMangleContext().mangleThreadSafeStaticGuardVariable(&

, GuardNum,

getMangleContext().mangleStaticGuardVariable(&

, Out);

llvm::GlobalVariable(CGM.

(), GuardTy,

,

GV->getLinkage(), Zero, GuardName.str());

GuardVar->setVisibility(GV->getVisibility());

GuardVar->setDLLStorageClass(GV->getDLLStorageClass());

GuardVar->setAlignment(GuardAlign.

());

(GuardVar->isWeakForLinker())

GuardVar->setComdat(

CGM.

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

(

.getTLSKind())

(GI && !HasPerVariableGuard)

GI->Guard = GuardVar;

assert(GuardVar->getLinkage() == GV->getLinkage() &&

);

(!HasPerVariableGuard) {

llvm::ConstantInt *Bit = llvm::ConstantInt::get(GuardTy, 1ULL << GuardNum);

llvm::LoadInst *LI = Builder.CreateLoad(GuardAddr);

llvm::Value *NeedsInit =

Builder.CreateICmpEQ(Builder.CreateAnd(LI, Bit), Zero);

CodeGenFunction::GuardKind::VariableGuard, &

);

Builder.CreateStore(Builder.CreateOr(LI, Bit), GuardAddr);

CGF.

.pushCleanup<ResetGuardBit>(

, GuardAddr, GuardNum);

Builder.CreateBr(EndBlock);

llvm::LoadInst *FirstGuardLoad = Builder.CreateLoad(GuardAddr);

FirstGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered);

llvm::LoadInst *InitThreadEpoch =

llvm::Value *IsUninitialized =

Builder.CreateICmpSGT(FirstGuardLoad, InitThreadEpoch);

llvm::BasicBlock *AttemptInitBlock = CGF.

(

);

CodeGenFunction::GuardKind::VariableGuard, &

);

GuardAddr.getPointer());

llvm::LoadInst *SecondGuardLoad = Builder.CreateLoad(GuardAddr);

SecondGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered);

llvm::Value *ShouldDoInit =

Builder.CreateICmpEQ(SecondGuardLoad, getAllOnesInt());

Builder.CreateCondBr(ShouldDoInit, InitBlock, EndBlock);

GuardAddr.getPointer());

Builder.CreateBr(EndBlock);

fields.push_back(CGM.

);

fields.push_back(CGM.

);

fields.push_back(CGM.

);

fields.push_back(CGM.

);

(fields.size() == 1)

MicrosoftCXXABI::

assert(fields.empty());

fields.push_back(llvm::Constant::getNullValue(CGM.

));

fields.push_back(getZeroInt());

fields.push_back(getAllOnesInt());

fields.push_back(getZeroInt());

fields.push_back(getZeroInt());

fields.push_back(getAllOnesInt());

GetNullMemberPointerFields(MPT, fields);

(fields.size() == 1)

llvm::Constant *Res = llvm::ConstantStruct::getAnon(fields);

assert(Res->getType() == ConvertMemberPointerType(MPT));

MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField,

IsMemberFunction,

VBTableIndex) {

fields.push_back(FirstField);

fields.push_back(llvm::ConstantInt::get(

Offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();

fields.push_back(llvm::ConstantInt::get(CGM.

, Offs.

()));

fields.push_back(llvm::ConstantInt::get(CGM.

, VBTableIndex));

llvm::ConstantStruct::getAnon(fields);

llvm::Constant *MicrosoftCXXABI::EmitMemberDataPointer(

*RD,

MSInheritanceModel::Virtual)

offset -= getContext().getOffsetOfBaseWithVBPtr(RD);

llvm::Constant *FirstField =

EmitFullMemberPointer(FirstField,

, RD,

llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(

&MP,

EmitNullMemberPointer(DstTy);

llvm::Constant *

;

(

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

= EmitMemberFunctionPointer(MD);

*FD = dyn_cast<FieldDecl>(MPD);

FD = cast<FieldDecl>(*cast<IndirectFieldDecl>(MPD)->chain_begin());

= EmitMemberDataPointer(RD, FieldOffset);

(!MemberPointerPath.empty()) {

*SrcRD = cast<CXXRecordDecl>(MPD->getDeclContext());

(DerivedMember) {

(BS.getType()->getAsCXXRecordDecl()->getCanonicalDecl() ==

->getCanonicalDecl())

DerivedToBasePath.push_back(&BS);

assert(DerivedToBasePath.size() == MemberPointerPath.size());

CK = DerivedMember ? CK_DerivedToBaseMemberPointer

: CK_BaseToDerivedMemberPointer;

= EmitMemberPointerConversion(SrcTy, DstTy, CK, DerivedToBasePath.begin(),

DerivedToBasePath.end(),

);

MicrosoftCXXABI::EmitMemberFunctionPointer(

*MD) {

assert(MD->

() &&

);

VBTableIndex = 0;

llvm::Constant *FirstField;

(Types.isFuncTypeConvertible(FPT)) {

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

FirstField = EmitVirtualMemPtrThunk(MD, ML);

VBTableIndex = VTableContext.getVBTableIndex(RD, ML.

) * 4;

(VBTableIndex == 0 &&

MSInheritanceModel::Virtual)

NonVirtualBaseAdjustment -= getContext().getOffsetOfBaseWithVBPtr(RD);

EmitFullMemberPointer(FirstField,

, RD,

NonVirtualBaseAdjustment, VBTableIndex);

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 *L0 = Builder.CreateExtractValue(L, 0,

);

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

);

llvm::Value *Cmp0 = Builder.CreateICmp(

, L0, R0,

);

llvm::Value *Res =

;

llvm::StructType *LType = cast<llvm::StructType>(L->getType());

(

I = 1,

= LType->getNumElements(); I !=

; ++I) {

llvm::Value *LF = Builder.CreateExtractValue(L, I);

llvm::Value *RF = Builder.CreateExtractValue(R, I);

llvm::Value *Cmp = Builder.CreateICmp(

, LF, RF,

);

Res = Builder.CreateBinOp(

, Res, Cmp);

llvm::Value *

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

llvm::Value *IsZero = Builder.CreateICmp(

, L0, Zero,

);

Res = Builder.CreateBinOp(

, Res, IsZero);

Builder.CreateBinOp(

, Res, Cmp0,

);

llvm::Value *MemPtr,

fields.push_back(llvm::Constant::getNullValue(CGM.

));

GetNullMemberPointerFields(MPT, fields);

assert(!fields.empty());

llvm::Value *FirstField = MemPtr;

(MemPtr->getType()->isStructTy())

FirstField = Builder.CreateExtractValue(MemPtr, 0);

llvm::Value *Res = Builder.CreateICmpNE(FirstField, fields[0],

);

(

I = 1,

= fields.size(); I <

; ++I) {

llvm::Value *

= Builder.CreateExtractValue(MemPtr, I);

llvm::Value *Next = Builder.CreateICmpNE(Field, fields[I],

);

Res = Builder.CreateOr(Res, Next,

);

llvm::Constant *Val) {

llvm::Constant *FirstField = Val->getType()->isStructTy() ?

Val->getAggregateElement(0

) : Val;

FirstField->isNullValue();

(isZeroInitializable(MPT) && Val->isNullValue())

GetNullMemberPointerFields(MPT, Fields);

(Fields.size() == 1) {

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

Val == Fields[0];

(I = 0,

= Fields.size(); I !=

; ++I) {

(Val->getAggregateElement(I) != Fields[I])

llvm::Value *VBPtrOffset,

llvm::Value *VBTableOffset,

llvm::Value **VBPtrOut) {

llvm::Value *VBPtr = Builder.CreateInBoundsGEP(

CGM.

,

.emitRawPointer(CGF), VBPtrOffset,

);

(

CI = dyn_cast<llvm::ConstantInt>(VBPtrOffset)) {

VBPtrAlign =

.getAlignment().alignmentAtOffset(

llvm::Value *VBTable =

Builder.CreateAlignedLoad(CGM.

, VBPtr, VBPtrAlign,

);

llvm::Value *VBTableIndex = Builder.CreateAShr(

VBTableOffset, llvm::ConstantInt::get(VBTableOffset->getType(), 2),

,

);

llvm::Value *VBaseOffs =

Builder.CreateInBoundsGEP(CGM.

, VBTable, VBTableIndex);

Builder.CreateAlignedLoad(CGM.

, VBaseOffs,

llvm::Value *MicrosoftCXXABI::AdjustVirtualBase(

, llvm::Value *VBTableOffset, llvm::Value *VBPtrOffset) {

llvm::BasicBlock *OriginalBB =

;

llvm::BasicBlock *SkipAdjustBB =

;

llvm::BasicBlock *VBaseAdjustBB =

;

OriginalBB = Builder.GetInsertBlock();

llvm::Value *IsVirtual =

Builder.CreateICmpNE(VBTableOffset, getZeroInt(),

);

Builder.CreateCondBr(IsVirtual, VBaseAdjustBB, SkipAdjustBB);

);

offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();

llvm::Value *VBPtr =

;

llvm::Value *VBaseOffs =

GetVBaseOffsetFromVBPtr(CGF,

, VBPtrOffset, VBTableOffset, &VBPtr);

llvm::Value *AdjustedBase =

Builder.CreateInBoundsGEP(CGM.

, VBPtr, VBaseOffs);

(VBaseAdjustBB) {

Builder.CreateBr(SkipAdjustBB);

llvm::PHINode *Phi = Builder.CreatePHI(CGM.

, 2,

);

Phi->addIncoming(

.emitRawPointer(CGF), OriginalBB);

Phi->addIncoming(AdjustedBase, VBaseAdjustBB);

AdjustedBase;

llvm::Value *MicrosoftCXXABI::EmitMemberDataPointerAddress(

llvm::Value *FieldOffset = MemPtr;

llvm::Value *VirtualBaseAdjustmentOffset =

;

llvm::Value *VBPtrOffset =

;

(MemPtr->getType()->isStructTy()) {

FieldOffset = Builder.CreateExtractValue(MemPtr, I++);

VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);

VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);

(VirtualBaseAdjustmentOffset) {

Addr = AdjustVirtualBase(CGF,

, RD,

, VirtualBaseAdjustmentOffset,

Addr =

.emitRawPointer(CGF);

Builder.CreateInBoundsGEP(CGF.

, Addr, FieldOffset,

assert(

->getCastKind() == CK_DerivedToBaseMemberPointer ||

->getCastKind() == CK_BaseToDerivedMemberPointer ||

->getCastKind() == CK_ReinterpretMemberPointer);

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

EmitMemberPointerConversion(

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

IsReinterpret =

->getCastKind() == CK_ReinterpretMemberPointer;

(IsReinterpret && IsFunc)

(IsReinterpret &&

llvm::Value *

= EmitMemberPointerIsNotNull(CGF, Src, SrcTy);

llvm::Constant *DstNull = EmitNullMemberPointer(DstTy);

(IsReinterpret) {

assert(Src->getType() == DstNull->getType());

Builder.CreateSelect(

, Src, DstNull);

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

llvm::BasicBlock *ContinueBB = CGF.

(

);

Builder.CreateCondBr(

, ConvertBB, ContinueBB);

llvm::Value *Dst = EmitNonNullMemberPointerConversion(

SrcTy, DstTy,

->getCastKind(),

->path_begin(),

->path_end(), Src,

Builder.CreateBr(ContinueBB);

llvm::PHINode *Phi = Builder.CreatePHI(DstNull->getType(), 2,

);

Phi->addIncoming(DstNull, OriginalBB);

Phi->addIncoming(Dst, ConvertBB);

llvm::Value *MicrosoftCXXABI::EmitNonNullMemberPointerConversion(

IsConstant = isa<llvm::Constant>(Src);

llvm::Value *FirstField = Src;

llvm::Value *NonVirtualBaseAdjustment = getZeroInt();

llvm::Value *VirtualBaseAdjustmentOffset = getZeroInt();

llvm::Value *VBPtrOffset = getZeroInt();

FirstField = Builder.CreateExtractValue(Src, I++);

NonVirtualBaseAdjustment = Builder.CreateExtractValue(Src, I++);

VBPtrOffset = Builder.CreateExtractValue(Src, I++);

VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(Src, I++);

IsDerivedToBase = (CK == CK_DerivedToBaseMemberPointer);

llvm::Value *&NVAdjustField = IsFunc ? NonVirtualBaseAdjustment : FirstField;

llvm::Value *SrcVBIndexEqZero =

Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt());

(SrcInheritance == MSInheritanceModel::Virtual) {

(int64_t SrcOffsetToFirstVBase =

getContext().getOffsetOfBaseWithVBPtr(SrcRD).getQuantity()) {

llvm::Value *UndoSrcAdjustment = Builder.CreateSelect(

llvm::ConstantInt::get(CGM.

, SrcOffsetToFirstVBase),

NVAdjustField = Builder.CreateNSWAdd(NVAdjustField, UndoSrcAdjustment);

llvm::Constant *BaseClassOffset = llvm::ConstantInt::get(

llvm::Value *NVDisp;

(IsDerivedToBase)

NVDisp = Builder.CreateNSWSub(NVAdjustField, BaseClassOffset,

);

NVDisp = Builder.CreateNSWAdd(NVAdjustField, BaseClassOffset,

);

NVAdjustField = Builder.CreateSelect(SrcVBIndexEqZero, NVDisp, getZeroInt());

llvm::Value *DstVBIndexEqZero = SrcVBIndexEqZero;

(llvm::GlobalVariable *VDispMap =

getAddrOfVirtualDisplacementMap(SrcRD, DstRD)) {

llvm::Value *VBIndex = Builder.CreateExactUDiv(

VirtualBaseAdjustmentOffset, llvm::ConstantInt::get(CGM.

, 4));

llvm::Constant *Mapping = VDispMap->getInitializer();

VirtualBaseAdjustmentOffset =

Mapping->getAggregateElement(cast<llvm::Constant>(VBIndex));

llvm::Value *Idxs[] = {getZeroInt(), VBIndex};

VirtualBaseAdjustmentOffset = Builder.CreateAlignedLoad(

CGM.

, Builder.CreateInBoundsGEP(VDispMap->getValueType(),

Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt());

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

getContext().getASTRecordLayout(DstRD).getVBPtrOffset().getQuantity());

Builder.CreateSelect(DstVBIndexEqZero, getZeroInt(), DstVBPtrOffset);

(DstInheritance == MSInheritanceModel::Virtual) {

(int64_t DstOffsetToFirstVBase =

getContext().getOffsetOfBaseWithVBPtr(DstRD).getQuantity()) {

llvm::Value *DoDstAdjustment = Builder.CreateSelect(

llvm::ConstantInt::get(CGM.

, DstOffsetToFirstVBase),

NVAdjustField = Builder.CreateNSWSub(NVAdjustField, DoDstAdjustment);

Dst = llvm::PoisonValue::get(ConvertMemberPointerType(DstTy));

Dst = Builder.CreateInsertValue(Dst, FirstField, Idx++);

Dst = Builder.CreateInsertValue(Dst, NonVirtualBaseAdjustment, Idx++);

Dst = Builder.CreateInsertValue(Dst, VBPtrOffset, Idx++);

Dst = Builder.CreateInsertValue(Dst, VirtualBaseAdjustmentOffset, Idx++);

MicrosoftCXXABI::EmitMemberPointerConversion(

*

,

llvm::Constant *Src) {

EmitMemberPointerConversion(SrcTy, DstTy, CK,

->path_begin(),

->path_end(), Src);

llvm::Constant *MicrosoftCXXABI::EmitMemberPointerConversion(

assert(CK == CK_DerivedToBaseMemberPointer ||

CK == CK_BaseToDerivedMemberPointer ||

CK == CK_ReinterpretMemberPointer);

(MemberPointerConstantIsNull(SrcTy, Src))

EmitNullMemberPointer(DstTy);

(CK == CK_ReinterpretMemberPointer)

*Dst = cast<llvm::Constant>(EmitNonNullMemberPointerConversion(

SrcTy, DstTy, CK, PathBegin, PathEnd, Src, Builder));

MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer(

llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr,

llvm::Value *FunctionPointer = MemPtr;

llvm::Value *NonVirtualBaseAdjustment =

;

llvm::Value *VirtualBaseAdjustmentOffset =

;

llvm::Value *VBPtrOffset =

;

(MemPtr->getType()->isStructTy()) {

FunctionPointer = Builder.CreateExtractValue(MemPtr, I++);

NonVirtualBaseAdjustment = Builder.CreateExtractValue(MemPtr, I++);

VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);

VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);

(VirtualBaseAdjustmentOffset) {

ThisPtrForCall = AdjustVirtualBase(CGF,

, RD, This,

VirtualBaseAdjustmentOffset, VBPtrOffset);

ThisPtrForCall =

.emitRawPointer(CGF);

(NonVirtualBaseAdjustment)

ThisPtrForCall = Builder.CreateInBoundsGEP(CGF.

, ThisPtrForCall,

NonVirtualBaseAdjustment);

MicrosoftCXXABI(CGM);

StringRef MangledName(

);

(

VTable = CGM.

().getNamedGlobal(MangledName))

llvm::GlobalVariable::ExternalLinkage,

, MangledName);

IsPrivateOnPath = 1 | 8,

HasHierarchyDescriptor = 64

MSRTTIClass *getFirstChild() {

+ 1; }

MSRTTIClass *getNextChild(MSRTTIClass *Child) {

Child + 1 + Child->NumBases;

Flags, NumBases, OffsetInVBase;

Flags = HasHierarchyDescriptor;

VirtualRoot =

;

Flags |= IsPrivate | IsPrivateOnPath;

(

->Flags & IsPrivateOnPath)

Flags |= IsPrivateOnPath;

VirtualRoot =

->VirtualRoot;

OffsetInVBase =

->OffsetInVBase + RD->getASTContext()

.getASTRecordLayout(

->RD).getBaseClassOffset(RD).getQuantity();

MSRTTIClass *Child = getFirstChild();

NumBases += Child->initialize(

, &

) + 1;

Child = getNextChild(Child);

llvm::GlobalValue::LinkageTypes getLinkageForRTTI(

Ty) {

Linkage::Invalid:

llvm_unreachable(

);

Linkage::Internal:

Linkage::UniqueExternal:

llvm::GlobalValue::InternalLinkage;

Linkage::VisibleNone:

Linkage::Module:

Linkage::External:

llvm::GlobalValue::LinkOnceODRLinkage;

llvm_unreachable(

);

MSRTTIBuilder {

HasBranchingHierarchy = 1,

HasVirtualBranchingHierarchy = 2,

HasAmbiguousBases = 4

MSRTTIBuilder(MicrosoftCXXABI &ABI,

*RD)

: CGM(ABI.CGM), Context(CGM.getContext()),

VMContext(CGM.getLLVMContext()),

(CGM.getModule()), RD(RD),

(getLinkageForRTTI(CGM.getContext().getTagDeclType(RD))),

llvm::GlobalVariable *getBaseClassDescriptor(

MSRTTIClass &Classes);

llvm::GlobalVariable *

llvm::GlobalVariable *getClassHierarchyDescriptor();

llvm::GlobalVariable *getCompleteObjectLocator(

&Info);

llvm::LLVMContext &VMContext;

llvm::GlobalVariable::LinkageTypes

;

MicrosoftCXXABI &ABI;

Classes.push_back(MSRTTIClass(RD));

(MSRTTIClass *

= &Classes.front();

<= &Classes.back();) {

((

->Flags & MSRTTIClass::IsVirtual) &&

!VirtualBases.insert(

->RD).second) {

(!UniqueBases.insert(

->RD).second)

AmbiguousBases.insert(

->RD);

(AmbiguousBases.empty())

(MSRTTIClass &

: Classes)

(AmbiguousBases.count(

.RD))

.Flags |= MSRTTIClass::IsAmbiguous;

llvm::GlobalVariable *MSRTTIBuilder::getClassHierarchyDescriptor() {

llvm::raw_svector_ostream Out(MangledName);

ABI.getMangleContext().mangleCXXRTTIClassHierarchyDescriptor(RD, Out);

(

CHD =

.getNamedGlobal(MangledName))

Classes.front().initialize(

,

);

(

MSRTTIClass &Class : Classes) {

(

.RD->getNumBases() > 1)

Flags |= HasBranchingHierarchy;

(

.Flags & MSRTTIClass::IsAmbiguous)

Flags |= HasAmbiguousBases;

((Flags & HasBranchingHierarchy) && RD->getNumVBases() != 0)

Flags |= HasVirtualBranchingHierarchy;

llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.

, 0),

llvm::ConstantInt::get(CGM.

, 0)};

= ABI.getClassHierarchyDescriptorType();

(CHD->isWeakForLinker())

CHD->setComdat(CGM.

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

*Bases = getBaseClassArray(Classes);

llvm::Constant *Fields[] = {

llvm::ConstantInt::get(CGM.

, 0),

llvm::ConstantInt::get(CGM.

, Flags),

llvm::ConstantInt::get(CGM.

, Classes.size()),

ABI.getImageRelativeConstant(llvm::ConstantExpr::getInBoundsGetElementPtr(

Bases->getValueType(), Bases,

CHD->setInitializer(llvm::ConstantStruct::get(

, Fields));

llvm::GlobalVariable *

llvm::raw_svector_ostream Out(MangledName);

ABI.getMangleContext().mangleCXXRTTIBaseClassArray(RD, Out);

llvm::Type *PtrType = ABI.getImageRelativeType(CGM.

);

*ArrType = llvm::ArrayType::get(PtrType, Classes.size() + 1);

llvm::GlobalVariable(

, ArrType,

, MangledName);

(BCA->isWeakForLinker())

BCA->setComdat(CGM.

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

(MSRTTIClass &Class : Classes)

BaseClassArrayData.push_back(

ABI.getImageRelativeConstant(getBaseClassDescriptor(Class)));

BaseClassArrayData.push_back(llvm::Constant::getNullValue(PtrType));

BCA->setInitializer(llvm::ConstantArray::get(ArrType, BaseClassArrayData));

llvm::GlobalVariable *

MSRTTIBuilder::getBaseClassDescriptor(

MSRTTIClass &Class) {

(

.VirtualRoot) {

llvm::raw_svector_ostream Out(MangledName);

ABI.getMangleContext().mangleCXXRTTIBaseClassDescriptor(

.RD,

.OffsetInVBase, VBPtrOffset, OffsetInVBTable,

(

BCD =

.getNamedGlobal(MangledName))

= ABI.getBaseClassDescriptorType();

, MangledName);

(BCD->isWeakForLinker())

BCD->setComdat(CGM.

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

llvm::Constant *Fields[] = {

ABI.getImageRelativeConstant(

llvm::ConstantInt::get(CGM.

,

.NumBases),

llvm::ConstantInt::get(CGM.

,

.OffsetInVBase),

llvm::ConstantInt::get(CGM.

, VBPtrOffset),

llvm::ConstantInt::get(CGM.

, OffsetInVBTable),

llvm::ConstantInt::get(CGM.

,

.Flags),

ABI.getImageRelativeConstant(

MSRTTIBuilder(ABI,

.RD).getClassHierarchyDescriptor()),

BCD->setInitializer(llvm::ConstantStruct::get(

, Fields));

llvm::GlobalVariable *

MSRTTIBuilder::getCompleteObjectLocator(

&Info) {

llvm::raw_svector_ostream Out(MangledName);

ABI.getMangleContext().mangleCXXRTTICompleteObjectLocator(RD, Info.

, Out);

(

COL =

.getNamedGlobal(MangledName))

VFPtrOffset = 0;

->second.hasVtorDisp())

llvm::StructType *

= ABI.getCompleteObjectLocatorType();

, MangledName);

llvm::Constant *Fields[] = {

llvm::ConstantInt::get(CGM.

, ABI.isImageRelative()),

llvm::ConstantInt::get(CGM.

, OffsetToTop),

llvm::ConstantInt::get(CGM.

, VFPtrOffset),

ABI.getImageRelativeConstant(

ABI.getImageRelativeConstant(getClassHierarchyDescriptor()),

ABI.getImageRelativeConstant(COL),

(!ABI.isImageRelative())

FieldsRef = FieldsRef.drop_back();

COL->setInitializer(llvm::ConstantStruct::get(

, FieldsRef));

(COL->isWeakForLinker())

COL->setComdat(CGM.

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

&IsConst,

&IsVolatile,

&IsUnaligned) {

IsVolatile =

;

IsUnaligned =

;

(!PointeeType.

()) {

MicrosoftCXXABI::getAddrOfCXXCatchHandlerType(

,

IsConst, IsVolatile, IsUnaligned;

llvm::Constant *MicrosoftCXXABI::getAddrOfRTTIDescriptor(

) {

llvm::raw_svector_ostream Out(MangledName);

getMangleContext().mangleCXXRTTI(

, Out);

(llvm::GlobalVariable *GV = CGM.

().getNamedGlobal(MangledName))

llvm::raw_svector_ostream Out(TypeInfoString);

getMangleContext().mangleCXXRTTIName(

, Out);

llvm::Constant *Fields[] = {

llvm::ConstantPointerNull::get(CGM.

),

llvm::ConstantDataArray::getString(CGM.

(), TypeInfoString)};

llvm::StructType *TypeDescriptorType =

getTypeDescriptorType(TypeInfoString);

*Var =

llvm::GlobalVariable(

CGM.

(), TypeDescriptorType,

,

getLinkageForRTTI(

),

llvm::ConstantStruct::get(TypeDescriptorType, Fields),

(Var->isWeakForLinker())

Var->setComdat(CGM.

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

llvm::GlobalVariable *

MicrosoftCXXABI::getMSCompleteObjectLocator(

*RD,

MSRTTIBuilder(*

, RD).getCompleteObjectLocator(Info);

MicrosoftCXXABI::emitCXXStructor(

GD) {

(

*ctor = dyn_cast<CXXConstructorDecl>(GD.

())) {

llvm::Function *

=

*dtor = cast<CXXDestructorDecl>(GD.

());

dtor->getParent()->getNumVBases() == 0)

(

->isWeakForLinker())

->setComdat(CGM.

().getOrInsertComdat(

->getName()));

llvm::raw_svector_ostream Out(ThunkName);

getMangleContext().mangleName(

(CD, CT), Out);

(llvm::GlobalValue *GV = CGM.

().getNamedValue(ThunkName))

cast<llvm::Function>(GV);

RecordTy = getContext().getRecordType(RD);

llvm::Function *ThunkFn = llvm::Function::Create(

ThunkTy, getLinkageForRTTI(RecordTy), ThunkName.str(), &CGM.

());

ThunkFn->setCallingConv(

llvm::CallingConv::ID

(

(ThunkFn->isWeakForLinker())

ThunkFn->setComdat(CGM.

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

buildThisParam(CGF, FunctionArgs);

&getContext().Idents.get(

),

getContext().getLValueReferenceType(RecordTy,

ImplicitParamKind::Other);

FunctionArgs.push_back(&SrcParam);

&getContext().Idents.get(

),

getContext().IntTy, ImplicitParamKind::Other);

FunctionArgs.push_back(&IsMostDerived);

setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));

llvm::Value *

= getThisValue(CGF);

llvm::Value *SrcVal =

assert(PD->hasDefaultArg() &&

);

ArgVec.push_back(PD->getDefaultArg());

CodeGenFunction::RunCleanupsScope Cleanups(CGF);

AddedStructorArgCounts ExtraArgs =

llvm::Constant *CalleePtr =

Args, CD,

, ExtraArgs.Prefix, ExtraArgs.Suffix);

Cleanups.ForceCleanup();

llvm::Constant *MicrosoftCXXABI::getCatchableType(

,

int32_t VBPtrOffset,

= getContext().getTypeSizeInChars(

).getQuantity();

llvm::raw_svector_ostream Out(MangledName);

getMangleContext().mangleCXXCatchableType(

, CD, CT, Size, NVOffset,

VBPtrOffset, VBIndex, Out);

(llvm::GlobalVariable *GV = CGM.

().getNamedGlobal(MangledName))

getImageRelativeConstant(GV);

llvm::Constant *TD = getImageRelativeConstant(getAddrOfRTTIDescriptor(

));

llvm::Constant *CopyCtor;

CopyCtor = llvm::Constant::getNullValue(CGM.

);

CopyCtor = getImageRelativeConstant(CopyCtor);

IsScalar = !RD;

HasVirtualBases =

;

IsStdBadAlloc =

;

(HasVirtualBases)

llvm::Constant *Fields[] = {

llvm::ConstantInt::get(CGM.

, Flags),

llvm::ConstantInt::get(CGM.

, NVOffset),

llvm::ConstantInt::get(CGM.

, VBPtrOffset),

llvm::ConstantInt::get(CGM.

, VBIndex),

llvm::ConstantInt::get(CGM.

, Size),

llvm::StructType *CTType = getCatchableTypeType();

*GV =

llvm::GlobalVariable(

CGM.

(), CTType,

, getLinkageForRTTI(

),

llvm::ConstantStruct::get(CTType, Fields), MangledName);

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

GV->setSection(

);

(GV->isWeakForLinker())

GV->setComdat(CGM.

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

getImageRelativeConstant(GV);

llvm::GlobalVariable *MicrosoftCXXABI::getCatchableTypeArray(

) {

llvm::GlobalVariable *&CTA = CatchableTypeArrays[

];

(MostDerivedClass) {

Classes.front().initialize(

,

);

(

MSRTTIClass &Class : Classes) {

(MSRTTIClass::IsPrivateOnPath | MSRTTIClass::IsAmbiguous))

(

.VirtualRoot) {

CatchableTypes.insert(getCatchableType(RTTITy,

.OffsetInVBase,

VBPtrOffset, OffsetInVBTable));

CatchableTypes.insert(getCatchableType(

));

CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy));

CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy));

NumEntries = CatchableTypes.size();

llvm::Type *CTType = getImageRelativeType(CGM.

);

llvm::ArrayType *AT = llvm::ArrayType::get(CTType, NumEntries);

llvm::StructType *CTAType = getCatchableTypeArrayType(NumEntries);

llvm::Constant *Fields[] = {

llvm::ConstantInt::get(CGM.

, NumEntries),

llvm::ConstantArray::get(

CatchableTypes.end()))

llvm::raw_svector_ostream Out(MangledName);

getMangleContext().mangleCXXCatchableTypeArray(

, NumEntries, Out);

CTA =

llvm::GlobalVariable(

CGM.

(), CTAType,

, getLinkageForRTTI(

),

llvm::ConstantStruct::get(CTAType, Fields), MangledName);

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

CTA->setSection(

);

(CTA->isWeakForLinker())

CTA->setComdat(CGM.

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

llvm::GlobalVariable *MicrosoftCXXABI::getThrowInfo(

) {

IsConst, IsVolatile, IsUnaligned;

llvm::GlobalVariable *CTA = getCatchableTypeArray(

);

cast<llvm::ConstantInt>(CTA->getInitializer()->getAggregateElement(0

))

->getLimitedValue();

llvm::raw_svector_ostream Out(MangledName);

getMangleContext().mangleCXXThrowInfo(

, IsConst, IsVolatile, IsUnaligned,

(llvm::GlobalVariable *GV = CGM.

().getNamedGlobal(MangledName))

llvm::Constant *CleanupFn = llvm::Constant::getNullValue(CGM.

);

(!DtorD->isTrivial())

llvm::Constant *ForwardCompat =

getImageRelativeConstant(llvm::Constant::getNullValue(CGM.

));

llvm::Constant *PointerToCatchableTypes = getImageRelativeConstant(CTA);

llvm::StructType *TIType = getThrowInfoType();

llvm::Constant *Fields[] = {

llvm::ConstantInt::get(CGM.

, Flags),

getImageRelativeConstant(CleanupFn),

PointerToCatchableTypes

*GV =

llvm::GlobalVariable(

CGM.

(), TIType,

, getLinkageForRTTI(

),

llvm::ConstantStruct::get(TIType, Fields), MangledName.str());

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

GV->setSection(

);

(GV->isWeakForLinker())

GV->setComdat(CGM.

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

*SubExpr =

->getSubExpr();

assert(SubExpr &&

);

llvm::GlobalVariable *TI = getThrowInfo(ThrowType);

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

std::tie(This, std::ignore, RD) =

MicrosoftCXXABI::isPermittedToBeHomogeneousAggregate(

(

*FRD = B.getType()->getAsCXXRecordDecl()) {

(!isPermittedToBeHomogeneousAggregate(FRD))

static llvm::FunctionCallee getThrowFn(CodeGenModule &CGM)

static void emitTlsGuardCheck(CodeGenFunction &CGF, llvm::GlobalValue *TlsGuard, llvm::BasicBlock *DynInitBB, llvm::BasicBlock *ContinueBB)

static llvm::GlobalVariable * getTypeInfoVTable(CodeGenModule &CGM)

static bool hasDefaultCXXMethodCC(ASTContext &Context, const CXXMethodDecl *MD)

static bool isTrivialForMSVC(const CXXRecordDecl *RD, QualType Ty, CodeGenModule &CGM)

static llvm::FunctionCallee getInitThreadAbortFn(CodeGenModule &CGM)

static llvm::FunctionCallee getInitThreadHeaderFn(CodeGenModule &CGM)

static llvm::GlobalValue * getTlsGuardVar(CodeGenModule &CGM)

static QualType decomposeTypeForEH(ASTContext &Context, QualType T, bool &IsConst, bool &IsVolatile, bool &IsUnaligned)

static llvm::CallBase * emitRTtypeidCall(CodeGenFunction &CGF, llvm::Value *Argument)

static llvm::FunctionCallee getDynTlsOnDemandInitFn(CodeGenModule &CGM)

static void emitDynamicTlsInitializationCall(CodeGenFunction &CGF, llvm::GlobalValue *TlsGuard, llvm::BasicBlock *ContinueBB)

static void detectAmbiguousBases(SmallVectorImpl< MSRTTIClass > &Classes)

Find ambiguity among base classes.

static void emitDynamicTlsInitialization(CodeGenFunction &CGF)

static void serializeClassHierarchy(SmallVectorImpl< MSRTTIClass > &Classes, const CXXRecordDecl *RD)

Recursively serializes a class hierarchy in pre-order depth first order.

static llvm::FunctionCallee getInitThreadFooterFn(CodeGenModule &CGM)

static bool isDeletingDtor(GlobalDecl GD)

static void emitGlobalDtorWithTLRegDtor(CodeGenFunction &CGF, const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr)

static ConstantAddress getInitThreadEpochPtr(CodeGenModule &CGM)

static void mangleVFTableName(MicrosoftMangleContext &MangleContext, const CXXRecordDecl *RD, const VPtrInfo &VFPtr, SmallString< 256 > &Name)

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

llvm::DenseSet< const void * > Visited

const NestedNameSpecifier * Specifier

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

bool isMemberPointerToDerivedMember() const

const ValueDecl * getMemberPointerDecl() const

ArrayRef< const CXXRecordDecl * > getMemberPointerPath() 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.

uint64_t getFieldOffset(const ValueDecl *FD) const

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

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

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.

QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const

Return the unique reference to the type for the specified type declaration.

const LangOptions & getLangOpts() const

GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const

CanQualType getSizeType() const

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

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

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

CharUnits getTypeSizeInChars(QualType T) const

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

QualType getExceptionObjectType(QualType T) const

const CXXConstructorDecl * getCopyConstructorForExceptionObject(CXXRecordDecl *RD)

const TargetInfo & getTargetInfo() const

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

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

llvm::DenseMap< const CXXRecordDecl *, VBaseInfo > VBaseOffsetsMapTy

CharUnits getVBPtrOffset() const

getVBPtrOffset - Get the offset for virtual base table pointer.

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.

const VBaseOffsetsMapTy & getVBaseOffsetsMap() const

bool hasExtendableVFPtr() const

hasVFPtr - Does this class have a virtual function table pointer that can be extended by a derived cl...

Represents a base class of a C++ 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 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.

QualType getThisType() const

Return the type of the this pointer.

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

Represents a C++ struct/union/class.

bool hasNonTrivialCopyAssignment() const

Determine whether this class has a non-trivial copy assignment operator (C++ [class....

bool hasPrivateFields() const

bool hasProtectedFields() const

bool hasNonTrivialDestructor() const

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

bool isPolymorphic() const

Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...

unsigned getNumBases() const

Retrieves the number of base classes of this class.

CXXRecordDecl * getMostRecentNonInjectedDecl()

base_class_range vbases()

MSInheritanceModel getMSInheritanceModel() const

Returns the inheritance model used for this record.

bool nullFieldOffsetIsZero() const

In the Microsoft C++ ABI, use zero for the field offset of a null data member pointer if we can guara...

bool hasDefinition() const

bool isEmpty() const

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

CXXDestructorDecl * getDestructor() const

Returns the destructor decl for this class.

bool hasNonTrivialDefaultConstructor() const

Determine whether this class has a non-trivial default constructor (C++11 [class.ctor]p5).

bool isVirtuallyDerivedFrom(const CXXRecordDecl *Base) const

Determine whether this class is virtually derived from the class Base.

bool needsImplicitCopyAssignment() const

Determine whether this class needs an implicit copy assignment operator to be lazily declared.

bool hasSimpleCopyAssignment() const

true if we know for sure that this class has a single, accessible, unambiguous copy assignment operat...

unsigned getNumVBases() const

Retrieves the number of virtual base classes of this class.

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

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

const CXXBaseSpecifier *const * path_const_iterator

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

bool isPositive() const

isPositive - Test whether the quantity is greater than zero.

bool isZero() const

isZero - Test whether the quantity equals zero.

llvm::Align getAsAlign() const

getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

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.

bool hasProfileIRInstr() const

Check if IR level profile instrumentation is on.

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

void setSRetAfterThis(bool AfterThis)

bool isHomogeneousAggregate(QualType Ty, const Type *&Base, uint64_t &Members) const

isHomogeneousAggregate - Return true if a type is an ELFv2 homogeneous aggregate.

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

Address withElementType(llvm::Type *ElemTy) const

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

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

static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)

Apply TemporaryLocation if it is valid.

static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)

Set the IRBuilder to not attach debug locations.

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

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

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

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

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

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

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

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

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

llvm::Value *& getStructorImplicitParamValue(CodeGenFunction &CGF)

virtual void EmitCXXConstructors(const CXXConstructorDecl *D)=0

Emit constructor variants required by this ABI.

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

virtual bool hasMostDerivedReturn(GlobalDecl GD) const

virtual bool HasThisReturn(GlobalDecl GD) const

Returns true if the given constructor or destructor is one of the kinds that the ABI says returns 'th...

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 std::vector< CharUnits > getVBPtrOffsets(const CXXRecordDecl *RD)

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

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

virtual void initializeHiddenVirtualInheritanceMembers(CodeGenFunction &CGF, const CXXRecordDecl *RD)

Emit the code to initialize hidden members required to handle virtual inheritance,...

virtual bool isMemberPointerConvertible(const MemberPointerType *MPT) const

Return whether or not a member pointers type is convertible to an IR type.

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 CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD)

Get the ABI-specific "this" parameter adjustment to apply in the prologue of a virtual function.

virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const

RecordArgABI

Specify how one should pass an argument of a record type.

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 bool isSRetParameterAfterThis() const

Returns true if the implicit 'sret' parameter comes after the implicit 'this' parameter of C++ instan...

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 bool requiresArrayCookie(const CXXDeleteExpr *E, QualType eltType)

virtual CatchTypeInfo getCatchAllTypeInfo()

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

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

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

bool mayNeedDestruction(const VarDecl *VD) const

virtual llvm::BasicBlock * EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, const CXXRecordDecl *RD)

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 const CXXRecordDecl * getThisArgumentTypeForMethod(GlobalDecl GD)

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

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 void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF, GlobalDecl GD, CallArgList &CallArgs)

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 bool isPermittedToBeHomogeneousAggregate(const CXXRecordDecl *RD) const

Returns true if the ABI permits the argument to be a homogeneous aggregate.

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 llvm::GlobalVariable * getThrowInfo(QualType T)

virtual llvm::GlobalValue::LinkageTypes getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const

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

Initialize the array cookie for the given allocation.

ASTContext & getContext() const

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.

bool isInstanceMethod() const

ABIArgInfo & getReturnInfo()

CanQualType getReturnType() const

unsigned getEffectiveCallingConvention() const

getEffectiveCallingConvention - Return the actual calling convention to use, which may depend on the ...

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

void add(RValue rvalue, QualType type)

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

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

GenerateCXXGlobalInitFunc - Generates code for initializing global variables.

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.

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

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

bool CurFuncIsThunk

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

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

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

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

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

createBasicBlock - Create an LLVM basic block.

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

EmitBlock - Emit the given block.

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

Emit a type checked load from the given vtable.

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

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

const Decl * CurCodeDecl

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

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

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

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

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

bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD)

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

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 registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)

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

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

const Decl * CurFuncDecl

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

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::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

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

CodeGenTypes & getTypes() const

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

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

LValue EmitLoadOfReferenceLValue(LValue RefLVal)

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

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.

void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr, llvm::FunctionCallee Callee)

Emit a musttail call for a thunk with a potentially adjusted this pointer.

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

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

Set visibility, dllimport/dllexport and dso_local.

void AddCXXDtorEntry(llvm::FunctionCallee DtorFn, llvm::Constant *Object)

Add a destructor and object to add to the C++ global destructor function.

void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD)

Create and attach type metadata for the given vtable.

void setDSOLocal(llvm::GlobalValue *GV) const

llvm::GlobalObject::VCallVisibility GetVCallVisibilityLevel(const CXXRecordDecl *RD, llvm::DenseSet< const CXXRecordDecl * > &Visited)

Returns the vcall visibility of the given type.

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

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

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

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

Return the address of the given function.

const ABIInfo & getABIInfo()

DiagnosticsEngine & getDiags() const

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

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

llvm::GlobalValue::LinkageTypes getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage)

Returns LLVM linkage for a declarator.

const LangOptions & getLangOpts() const

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

void EmitGlobal(GlobalDecl D)

Emit code for a single global function or var decl.

void addUsedGlobal(llvm::GlobalValue *GV)

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

void AppendLinkerOptions(StringRef Opts)

Appends Opts to the "llvm.linker.options" metadata value.

bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D)

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

CharUnits computeNonVirtualBaseClassOffset(const CXXRecordDecl *DerivedClass, CastExpr::path_const_iterator Start, CastExpr::path_const_iterator End)

CharUnits getVBaseAlignment(CharUnits DerivedAlign, const CXXRecordDecl *Derived, const CXXRecordDecl *VBase)

Returns the assumed alignment of a virtual base of a class.

llvm::Function * codegenCXXStructor(GlobalDecl GD)

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

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

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

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

ASTContext & getContext() const

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.

MicrosoftVTableContext & getMicrosoftVTableContext()

const CodeGenOptions & getCodeGenOpts() const

StringRef getMangledName(GlobalDecl GD)

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::LLVMContext & getLLVMContext()

llvm::GlobalValue * GetGlobalValue(StringRef Ref)

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

void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const

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 addDeferredVTable(const CXXRecordDecl *RD)

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::FunctionType * GetFunctionType(const CGFunctionInfo &Info)

GetFunctionType - Get the LLVM function type for.

llvm::Type * ConvertTypeForMem(QualType T)

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

const CGFunctionInfo & arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD)

Arrange a thunk that takes 'this' as the first parameter followed by varargs.

const CGFunctionInfo & arrangeCXXConstructorCall(const CallArgList &Args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraPrefixArgs, unsigned ExtraSuffixArgs, bool PassProtoArgs=true)

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

const CGFunctionInfo & arrangeCXXStructorDeclaration(GlobalDecl GD)

const CGFunctionInfo & arrangeMSCtorClosure(const CXXConstructorDecl *CD, CXXCtorType CT)

const CGFunctionInfo & arrangeNullaryFunction()

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

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.

llvm::Type * getVTableType(const VTableLayout &layout)

Returns the type of a vtable with the given layout.

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.

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)

llvm::Value * getScalarVal() const

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

An abstract representation of an aligned address.

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

DeclContext * getParent()

getParent - Returns the containing DeclContext.

decl_range decls() const

decls_begin/decls_end - Iterate over the declarations stored in this context.

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

bool isInStdNamespace() const

SourceLocation getLocation() const

DeclContext * getDeclContext()

const LangOptions & getLangOpts() const LLVM_READONLY

Helper to get the language options from the ASTContext.

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

unsigned getCustomDiagID(Level L, const char(&FormatString)[N])

Return an ID for a diagnostic with the specified format string and level.

This represents one expression.

SourceLocation getExprLoc() const LLVM_READONLY

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

Represents a member of a struct/union/class.

const RecordDecl * getParent() const

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

ArrayRef< ParmVarDecl * > parameters() const

unsigned getNumParams() const

Return the number of parameters this function must have based on its FunctionType.

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

bool isVariadic() const

Whether this function prototype is variadic.

GlobalDecl - represents a global declaration.

GlobalDecl getWithCtorType(CXXCtorType Type)

GlobalDecl getWithDtorType(CXXDtorType Type)

CXXDtorType getDtorType() const

const Decl * getDecl() const

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

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

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

Create implicit parameter.

bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const

bool isExplicitDefaultVisibilityExportMapping() const

bool isAllDefaultVisibilityExportMapping() const

MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...

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

CXXRecordDecl * getMostRecentCXXRecordDecl() const

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.

unsigned getVBTableIndex(const CXXRecordDecl *Derived, const CXXRecordDecl *VBase)

Returns the index of VBase in the vbtable of Derived.

MethodVFTableLocation getMethodVFTableLocation(GlobalDecl GD)

const VPtrInfoVector & getVFPtrOffsets(const CXXRecordDecl *RD)

const VTableLayout & getVFTableLayout(const CXXRecordDecl *RD, CharUnits VFPtrOffset)

Describes a module or submodule.

This represents a decl that may have a name.

IdentifierInfo * getIdentifier() const

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

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

bool isExternallyVisible() const

Represents a parameter to a function.

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

bool isNull() const

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

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

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

bool isConstQualified() const

Determine whether this type is const-qualified.

DestructionKind isDestructedType() const

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

bool hasUnaligned() const

bool canPassInRegisters() const

Determine whether this class can be passed in registers.

Encodes a location in the source.

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

uint64_t getPointerWidth(LangAS AddrSpace) const

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

const Type * getTypeForDecl() const

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isPointerType() const

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

QualType getPointeeType() const

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

bool isObjectType() const

Determine whether this type is an object type.

Linkage getLinkage() const

Determine the linkage of this type.

const T * getAs() const

Member-template getAs<specific type>'.

bool isNullPtrType() const

Represents a single component in a vtable.

ArrayRef< VTableComponent > vtable_components() 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.

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

@ 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 * CreateMicrosoftCXXABI(CodeGenModule &CGM)

Creates a Microsoft-family ABI.

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

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 Ret(InterpState &S, CodePtr &PC)

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.

GVALinkage

A more specific kind of linkage than enum Linkage.

void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)

bool inheritanceModelHasNVOffsetField(bool IsMemberFunction, MSInheritanceModel Inheritance)

bool inheritanceModelHasOnlyOneField(bool IsMemberFunction, MSInheritanceModel Inheritance)

bool inheritanceModelHasVBPtrOffsetField(MSInheritanceModel Inheritance)

bool inheritanceModelHasVBTableOffsetField(MSInheritanceModel Inheritance)

Linkage

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

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.

CastKind

CastKind - The kind of operation required for a conversion.

const FunctionProtoType * T

MSInheritanceModel

Assigned inheritance model for a class in the MS C++ ABI.

CallingConv

CallingConv - Specifies the calling convention that a function uses.

U cast(CodeGen::Address addr)

@ Class

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

@ Implicit

An implicit conversion.

Diagnostic wrappers for TextAPI types for error reporting.

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::PointerType * Int8PtrPtrTy

CharUnits getIntAlign() const

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

CharUnits getIntSize() const

llvm::IntegerType * SizeTy

llvm::IntegerType * Int32Ty

llvm::IntegerType * IntPtrTy

llvm::IntegerType * IntTy

int

llvm::PointerType * Int8PtrTy

llvm::PointerType * UnqualPtrTy

llvm::IntegerType * PtrDiffTy

CharUnits getPointerAlign() const

const CXXRecordDecl * VBase

If nonnull, holds the last vbase which contains the vfptr that the method definition is adjusted to.

CharUnits VFPtrOffset

This is the offset of the vfptr from the start of the last vbase, or the complete type if there are n...

uint64_t Index

Method's index in the vftable.

union clang::ReturnAdjustment::VirtualAdjustment Virtual

int64_t NonVirtual

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

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.

Holds information about the inheritance path to a virtual base or function table pointer.

CharUnits NonVirtualOffset

IntroducingObject is at this offset from its containing complete object or virtual base.

CharUnits FullOffsetInMDC

Static offset from the top of the most derived class to this vfptr, including any virtual base offset...

const CXXRecordDecl * getVBaseWithVPtr() const

The vptr is stored inside the non-virtual component of this virtual base.

const CXXRecordDecl * IntroducingObject

This is the class that introduced the vptr by declaring new virtual methods or virtual bases.

BasePath MangledPath

The bases from the inheritance path that got used to mangle the vbtable name.

BasePath PathToIntroducingObject

This holds the base classes path from the complete type to the first base with the given vfptr offset...

const CXXRecordDecl * ObjectWithVPtr

This is the most derived class that has this vptr at offset zero.

struct clang::ReturnAdjustment::VirtualAdjustment::@193 Microsoft

uint32_t VBPtrOffset

The offset (in bytes) of the vbptr, relative to the beginning of the derived class.

uint32_t VBIndex

Index of the virtual base in the vbtable.

int32_t VtordispOffset

The offset of the vtordisp (in bytes), relative to the ECX.

int32_t VBOffsetOffset

The offset (in bytes) of the vbase offset in the vbtable.

int32_t VBPtrOffset

The offset of the vbptr of the derived class (in bytes), relative to the ECX after vtordisp adjustmen...

struct clang::ThisAdjustment::VirtualAdjustment::@195 Microsoft

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