30#include "llvm/ADT/StringExtras.h"
31#include "llvm/ADT/StringSet.h"
32#include "llvm/IR/Intrinsics.h"
35using namespace CodeGen;
40struct VBTableGlobals {
45class MicrosoftCXXABI :
public CGCXXABI {
48 :
CGCXXABI(CGM), BaseClassDescriptorType(nullptr),
49 ClassHierarchyDescriptorType(nullptr),
50 CompleteObjectLocatorType(nullptr), CatchableTypeType(nullptr),
51 ThrowInfoType(nullptr) {
54 "visibility export mapping option unimplemented in this ABI");
69 if (isa<CXXDestructorDecl>(GD.
getDecl())) {
78 case Dtor_Comdat: llvm_unreachable(
"emitting dtor comdat as function?");
80 llvm_unreachable(
"bad dtor kind");
89 assert(Args.size() >= 2 &&
90 "expected the arglist to have at least two args!");
100 std::vector<CharUnits> VBPtrOffsets;
104 const VBTableGlobals &VBGlobals = enumerateVBTables(RD);
105 for (
const std::unique_ptr<VPtrInfo> &VBT : *VBGlobals.VBTables) {
110 if (VBT->getVBaseWithVPtr())
112 VBPtrOffsets.push_back(Offs);
114 llvm::array_pod_sort(VBPtrOffsets.begin(), VBPtrOffsets.end());
130 llvm::GlobalVariable *getMSCompleteObjectLocator(
const CXXRecordDecl *RD,
151 llvm::Type *StdTypeInfoPtrTy)
override;
163 llvm::BasicBlock *CastSuccess,
164 llvm::BasicBlock *CastFail)
override {
165 llvm_unreachable(
"unsupported");
171 llvm::BasicBlock *CastEnd)
override;
230 AddedStructorArgCounts
244 llvm::GlobalValue::LinkageTypes
251 auto *MD = cast<CXXMethodDecl>(GD.
getDecl());
253 if (MD->isVirtual()) {
255 if (
const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) {
259 return MD->getParent();
277 return MD->getParent();
283 bool VirtualCall)
override;
308 llvm::GlobalVariable *VTable);
314 CodeGenFunction::VPtr Vptr)
override;
319 return !VTableClass->
hasAttr<MSNoVTableAttr>();
340 DeleteOrMemberCallExpr E)
override;
345 "Only deleting destructor thunks are available in this ABI");
352 llvm::GlobalVariable *
354 llvm::GlobalVariable::LinkageTypes
Linkage);
356 llvm::GlobalVariable *
360 llvm::raw_svector_ostream Out(OutName);
362 StringRef MangledName = OutName.str();
364 if (
auto *VDispMap = CGM.
getModule().getNamedGlobal(MangledName))
370 llvm::UndefValue::get(CGM.
IntTy));
371 Map[0] = llvm::ConstantInt::get(CGM.
IntTy, 0);
372 bool AnyDifferent =
false;
373 for (
const auto &I : SrcRD->
vbases()) {
374 const CXXRecordDecl *VBase = I.getType()->getAsCXXRecordDecl();
380 Map[SrcVBIndex] = llvm::ConstantInt::get(CGM.
IntTy, DstVBIndex * 4);
381 AnyDifferent |= SrcVBIndex != DstVBIndex;
387 llvm::ArrayType *VDispMapTy = llvm::ArrayType::get(CGM.
IntTy, Map.size());
388 llvm::Constant *
Init = llvm::ConstantArray::get(VDispMapTy, Map);
389 llvm::GlobalValue::LinkageTypes
Linkage =
391 ? llvm::GlobalValue::LinkOnceODRLinkage
392 : llvm::GlobalValue::InternalLinkage;
393 auto *VDispMap =
new llvm::GlobalVariable(
400 llvm::GlobalVariable *GV)
const;
408 Thunk->setLinkage(llvm::GlobalValue::InternalLinkage);
410 Thunk->setLinkage(llvm::GlobalValue::WeakODRLinkage);
412 Thunk->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage);
430 LangOptions::MSVC2019_5) &&
437 llvm::GlobalVariable *DeclPtr,
438 bool PerformInit)
override;
440 llvm::FunctionCallee Dtor,
441 llvm::Constant *Addr)
override;
472 llvm::Value *NumElements,
479 friend struct MSRTTIBuilder;
481 bool isImageRelative()
const {
486 llvm::StructType *getTypeDescriptorType(StringRef TypeInfoString) {
488 TDTypeName += llvm::utostr(TypeInfoString.size());
489 llvm::StructType *&TypeDescriptorType =
490 TypeDescriptorTypeMap[TypeInfoString.size()];
491 if (TypeDescriptorType)
492 return TypeDescriptorType;
493 llvm::Type *FieldTypes[] = {
496 llvm::ArrayType::get(CGM.
Int8Ty, TypeInfoString.size() + 1)};
498 llvm::StructType::create(CGM.
getLLVMContext(), FieldTypes, TDTypeName);
499 return TypeDescriptorType;
502 llvm::Type *getImageRelativeType(llvm::Type *PtrType) {
503 if (!isImageRelative())
508 llvm::StructType *getBaseClassDescriptorType() {
509 if (BaseClassDescriptorType)
510 return BaseClassDescriptorType;
511 llvm::Type *FieldTypes[] = {
518 getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()),
520 BaseClassDescriptorType = llvm::StructType::create(
522 return BaseClassDescriptorType;
525 llvm::StructType *getClassHierarchyDescriptorType() {
526 if (ClassHierarchyDescriptorType)
527 return ClassHierarchyDescriptorType;
529 ClassHierarchyDescriptorType = llvm::StructType::create(
531 llvm::Type *FieldTypes[] = {
535 getImageRelativeType(
536 getBaseClassDescriptorType()->getPointerTo()->getPointerTo()),
538 ClassHierarchyDescriptorType->setBody(FieldTypes);
539 return ClassHierarchyDescriptorType;
542 llvm::StructType *getCompleteObjectLocatorType() {
543 if (CompleteObjectLocatorType)
544 return CompleteObjectLocatorType;
545 CompleteObjectLocatorType = llvm::StructType::create(
547 llvm::Type *FieldTypes[] = {
552 getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()),
553 getImageRelativeType(CompleteObjectLocatorType),
556 if (!isImageRelative())
557 FieldTypesRef = FieldTypesRef.drop_back();
558 CompleteObjectLocatorType->setBody(FieldTypesRef);
559 return CompleteObjectLocatorType;
562 llvm::GlobalVariable *getImageBase() {
563 StringRef Name =
"__ImageBase";
564 if (llvm::GlobalVariable *GV = CGM.
getModule().getNamedGlobal(Name))
569 llvm::GlobalValue::ExternalLinkage,
575 llvm::Constant *getImageRelativeConstant(llvm::Constant *PtrVal) {
576 if (!isImageRelative())
579 if (PtrVal->isNullValue())
580 return llvm::Constant::getNullValue(CGM.
IntTy);
582 llvm::Constant *ImageBaseAsInt =
583 llvm::ConstantExpr::getPtrToInt(getImageBase(), CGM.
IntPtrTy);
584 llvm::Constant *PtrValAsInt =
585 llvm::ConstantExpr::getPtrToInt(PtrVal, CGM.
IntPtrTy);
586 llvm::Constant *Diff =
587 llvm::ConstantExpr::getSub(PtrValAsInt, ImageBaseAsInt,
589 return llvm::ConstantExpr::getTrunc(Diff, CGM.
IntTy);
597 llvm::Constant *getZeroInt() {
598 return llvm::ConstantInt::get(CGM.
IntTy, 0);
601 llvm::Constant *getAllOnesInt() {
602 return llvm::Constant::getAllOnesValue(CGM.
IntTy);
616 llvm::Value *VBPtrOffset,
617 llvm::Value *VBTableOffset,
618 llvm::Value **VBPtr =
nullptr);
623 int32_t VBTableOffset,
624 llvm::Value **VBPtr =
nullptr) {
625 assert(VBTableOffset % 4 == 0 &&
"should be byte offset into table of i32s");
626 llvm::Value *VBPOffset = llvm::ConstantInt::get(CGM.
IntTy, VBPtrOffset),
627 *VBTOffset = llvm::ConstantInt::get(CGM.
IntTy, VBTableOffset);
628 return GetVBaseOffsetFromVBPtr(CGF,
Base, VBPOffset, VBTOffset, VBPtr);
631 std::tuple<Address, llvm::Value *, const CXXRecordDecl *>
639 llvm::Value *VirtualBaseAdjustmentOffset,
640 llvm::Value *VBPtrOffset );
644 llvm::Constant *EmitFullMemberPointer(llvm::Constant *FirstField,
645 bool IsMemberFunction,
648 unsigned VBTableIndex);
657 const VBTableGlobals &enumerateVBTables(
const CXXRecordDecl *RD);
660 llvm::Function *EmitVirtualMemPtrThunk(
const CXXMethodDecl *MD,
673 return RD->
hasAttr<MSInheritanceAttr>();
687 bool Inequality)
override;
698 llvm::Value *EmitNonNullMemberPointerConversion(
706 llvm::Value *Src)
override;
709 llvm::Constant *Src)
override;
718 Address This, llvm::Value *&ThisPtrForCall,
724 llvm::StructType *getCatchableTypeType() {
725 if (CatchableTypeType)
726 return CatchableTypeType;
727 llvm::Type *FieldTypes[] = {
736 CatchableTypeType = llvm::StructType::create(
738 return CatchableTypeType;
741 llvm::StructType *getCatchableTypeArrayType(uint32_t NumEntries) {
742 llvm::StructType *&CatchableTypeArrayType =
743 CatchableTypeArrayTypeMap[NumEntries];
744 if (CatchableTypeArrayType)
745 return CatchableTypeArrayType;
748 CTATypeName += llvm::utostr(NumEntries);
750 getImageRelativeType(getCatchableTypeType()->getPointerTo());
751 llvm::Type *FieldTypes[] = {
753 llvm::ArrayType::get(CTType, NumEntries)
755 CatchableTypeArrayType =
756 llvm::StructType::create(CGM.
getLLVMContext(), FieldTypes, CTATypeName);
757 return CatchableTypeArrayType;
760 llvm::StructType *getThrowInfoType() {
762 return ThrowInfoType;
763 llvm::Type *FieldTypes[] = {
769 ThrowInfoType = llvm::StructType::create(CGM.
getLLVMContext(), FieldTypes,
771 return ThrowInfoType;
777 llvm::Type *Args[] = {CGM.
Int8PtrTy, getThrowInfoType()->getPointerTo()};
778 llvm::FunctionType *FTy =
779 llvm::FunctionType::get(CGM.
VoidTy, Args,
false);
780 llvm::FunctionCallee Throw =
784 if (
auto *Fn = dyn_cast<llvm::Function>(Throw.getCallee()))
785 Fn->setCallingConv(llvm::CallingConv::X86_StdCall);
793 llvm::Constant *getCatchableType(
QualType T,
794 uint32_t NVOffset = 0,
795 int32_t VBPtrOffset = -1,
796 uint32_t VBIndex = 0);
798 llvm::GlobalVariable *getCatchableTypeArray(
QualType T);
802 std::pair<llvm::Value *, const CXXRecordDecl *>
810 typedef std::pair<const CXXRecordDecl *, CharUnits> VFTableIdTy;
811 typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalVariable *> VTablesMapTy;
812 typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalValue *> VFTablesMapTy;
814 VFTablesMapTy VFTablesMap;
815 VTablesMapTy VTablesMap;
822 llvm::DenseMap<const CXXRecordDecl *, VBTableGlobals> VBTablesMap;
827 GuardInfo() =
default;
828 llvm::GlobalVariable *Guard =
nullptr;
829 unsigned BitIndex = 0;
834 llvm::DenseMap<const DeclContext *, GuardInfo> GuardVariableMap;
835 llvm::DenseMap<const DeclContext *, GuardInfo> ThreadLocalGuardVariableMap;
836 llvm::DenseMap<const DeclContext *, unsigned> ThreadSafeGuardNumMap;
838 llvm::DenseMap<size_t, llvm::StructType *> TypeDescriptorTypeMap;
839 llvm::StructType *BaseClassDescriptorType;
840 llvm::StructType *ClassHierarchyDescriptorType;
841 llvm::StructType *CompleteObjectLocatorType;
843 llvm::DenseMap<QualType, llvm::GlobalVariable *> CatchableTypeArrays;
845 llvm::StructType *CatchableTypeType;
846 llvm::DenseMap<uint32_t, llvm::StructType *> CatchableTypeArrayTypeMap;
847 llvm::StructType *ThrowInfoType;
853MicrosoftCXXABI::getRecordArgABI(
const CXXRecordDecl *RD)
const {
865 case llvm::Triple::thumb:
871 case llvm::Triple::x86: {
882 return RAA_DirectInMemory;
885 case llvm::Triple::x86_64:
886 case llvm::Triple::aarch64:
890 llvm_unreachable(
"invalid enum");
902 llvm::Value *MDThis = EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, DE);
907void MicrosoftCXXABI::emitRethrow(
CodeGenFunction &CGF,
bool isNoReturn) {
908 llvm::Value *Args[] = {
909 llvm::ConstantPointerNull::get(CGM.
Int8PtrTy),
910 llvm::ConstantPointerNull::get(getThrowInfoType()->getPointerTo())};
922 VarDecl *CatchParam = S->getExceptionDecl();
923 llvm::BasicBlock *CatchPadBB = CGF.
Builder.GetInsertBlock();
924 llvm::CatchPadInst *CPI =
925 cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHI());
936 CPI->setArgOperand(2, var.getObjectAddress(CGF).emitRawPointer(CGF));
944std::tuple<Address, llvm::Value *, const CXXRecordDecl *>
955 return std::make_tuple(
Value, llvm::ConstantInt::get(CGF.
Int32Ty, 0),
964 PolymorphicBase = BaseDecl;
968 assert(PolymorphicBase &&
"polymorphic class has no apparent vfptr?");
970 llvm::Value *Offset =
971 GetVirtualBaseClassOffset(CGF,
Value, SrcDecl, PolymorphicBase);
973 Value.getElementType(),
Value.emitRawPointer(CGF), Offset);
976 return std::make_tuple(
Address(Ptr, CGF.
Int8Ty, VBaseAlign), Offset,
980bool MicrosoftCXXABI::shouldTypeidBeNullChecked(
bool IsDeref,
984 !getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr();
988 llvm::Value *Argument) {
989 llvm::Type *ArgTypes[] = {CGF.
Int8PtrTy};
990 llvm::FunctionType *FTy =
991 llvm::FunctionType::get(CGF.
Int8PtrTy, ArgTypes,
false);
992 llvm::Value *Args[] = {Argument};
998 llvm::CallBase *
Call =
1000 Call->setDoesNotReturn();
1001 CGF.
Builder.CreateUnreachable();
1007 llvm::Type *StdTypeInfoPtrTy) {
1008 std::tie(ThisPtr, std::ignore, std::ignore) =
1009 performBaseAdjustment(CGF, ThisPtr, SrcRecordTy);
1011 return CGF.
Builder.CreateBitCast(Typeid, StdTypeInfoPtrTy);
1014bool MicrosoftCXXABI::shouldDynamicCastCallBeNullChecked(
bool SrcIsPtr,
1018 !getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr();
1021llvm::Value *MicrosoftCXXABI::emitDynamicCastCall(
1023 QualType DestRecordTy, llvm::BasicBlock *CastEnd) {
1024 llvm::Value *SrcRTTI =
1026 llvm::Value *DestRTTI =
1029 llvm::Value *Offset;
1030 std::tie(This, Offset, std::ignore) =
1031 performBaseAdjustment(CGF, This, SrcRecordTy);
1032 llvm::Value *ThisPtr =
This.emitRawPointer(CGF);
1044 llvm::FunctionType::get(CGF.
Int8PtrTy, ArgTypes,
false),
1046 llvm::Value *Args[] = {
1047 ThisPtr, Offset, SrcRTTI, DestRTTI,
1052llvm::Value *MicrosoftCXXABI::emitDynamicCastToVoid(
CodeGenFunction &CGF,
1055 std::tie(
Value, std::ignore, std::ignore) =
1056 performBaseAdjustment(CGF,
Value, SrcRecordTy);
1060 llvm::Type *ArgTypes[] = {CGF.
Int8PtrTy};
1062 llvm::FunctionType::get(CGF.
Int8PtrTy, ArgTypes,
false),
1064 llvm::Value *Args[] = {
Value.emitRawPointer(CGF)};
1072llvm::Value *MicrosoftCXXABI::GetVirtualBaseClassOffset(
1078 llvm::Value *VBPtrOffset = llvm::ConstantInt::get(CGM.
PtrDiffTy, VBPtrChars);
1083 llvm::Value *VBTableOffset =
1086 llvm::Value *VBPtrToNewBase =
1087 GetVBaseOffsetFromVBPtr(CGF, This, VBPtrOffset, VBTableOffset);
1090 return CGF.
Builder.CreateNSWAdd(VBPtrOffset, VBPtrToNewBase);
1093bool MicrosoftCXXABI::HasThisReturn(
GlobalDecl GD)
const {
1094 return isa<CXXConstructorDecl>(GD.
getDecl());
1098 return isa<CXXDestructorDecl>(GD.
getDecl()) &&
1102bool MicrosoftCXXABI::hasMostDerivedReturn(
GlobalDecl GD)
const {
1112 uint64_t NumElts = 0;
1115 isa<VectorType>(
Base)) {
1152 if (
auto *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
1153 if (Ctor->isUserProvided())
1155 }
else if (
auto *Template = dyn_cast<FunctionTemplateDecl>(D)) {
1156 if (isa<CXXConstructorDecl>(Template->getTemplatedDecl()))
1158 }
else if (
auto *MethodDecl = dyn_cast<CXXMethodDecl>(D)) {
1159 if (MethodDecl->isCopyAssignmentOperator() && MethodDecl->isDeleted())
1168bool MicrosoftCXXABI::classifyReturnType(
CGFunctionInfo &FI)
const {
1179 if (isIndirectReturn) {
1200 llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
1201 assert(IsMostDerivedClass &&
1202 "ctor for a class with virtual bases must have an implicit parameter");
1203 llvm::Value *IsCompleteObject =
1204 CGF.
Builder.CreateIsNotNull(IsMostDerivedClass,
"is_complete_object");
1206 llvm::BasicBlock *CallVbaseCtorsBB = CGF.
createBasicBlock(
"ctor.init_vbases");
1207 llvm::BasicBlock *SkipVbaseCtorsBB = CGF.
createBasicBlock(
"ctor.skip_vbases");
1208 CGF.
Builder.CreateCondBr(IsCompleteObject,
1209 CallVbaseCtorsBB, SkipVbaseCtorsBB);
1214 EmitVBPtrStores(CGF, RD);
1218 return SkipVbaseCtorsBB;
1223 llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF);
1224 assert(IsMostDerivedClass &&
1225 "ctor for a class with virtual bases must have an implicit parameter");
1226 llvm::Value *IsCompleteObject =
1227 CGF.
Builder.CreateIsNotNull(IsMostDerivedClass,
"is_complete_object");
1229 llvm::BasicBlock *CallVbaseDtorsBB = CGF.
createBasicBlock(
"Dtor.dtor_vbases");
1230 llvm::BasicBlock *SkipVbaseDtorsBB = CGF.
createBasicBlock(
"Dtor.skip_vbases");
1231 CGF.
Builder.CreateCondBr(IsCompleteObject,
1232 CallVbaseDtorsBB, SkipVbaseDtorsBB);
1237 return SkipVbaseDtorsBB;
1240void MicrosoftCXXABI::initializeHiddenVirtualInheritanceMembers(
1260 llvm::Value *Int8This =
nullptr;
1263 const CXXRecordDecl *VBase = S.getType()->getAsCXXRecordDecl();
1264 auto I = VBaseMap.find(VBase);
1265 assert(I != VBaseMap.end());
1266 if (!I->second.hasVtorDisp())
1269 llvm::Value *VBaseOffset =
1270 GetVirtualBaseClassOffset(CGF, getThisAddress(CGF), RD, VBase);
1271 uint64_t ConstantVBaseOffset = I->second.VBaseOffset.getQuantity();
1274 llvm::Value *VtorDispValue = Builder.CreateSub(
1275 VBaseOffset, llvm::ConstantInt::get(CGM.
PtrDiffTy, ConstantVBaseOffset),
1277 VtorDispValue = Builder.CreateTruncOrBitCast(VtorDispValue, CGF.
Int32Ty);
1280 Int8This = getThisValue(CGF);
1282 llvm::Value *VtorDispPtr =
1283 Builder.CreateInBoundsGEP(CGF.
Int8Ty, Int8This, VBaseOffset);
1285 VtorDispPtr = Builder.CreateConstGEP1_32(CGF.
Int8Ty, VtorDispPtr, -4);
1287 Builder.CreateAlignedStore(VtorDispValue, VtorDispPtr,
1298 return ExpectedCallingConv == ActualCallingConv;
1313 Fn->setLinkage(llvm::GlobalValue::WeakODRLinkage);
1326 const VBTableGlobals &VBGlobals = enumerateVBTables(RD);
1327 for (
unsigned I = 0, E = VBGlobals.VBTables->size(); I != E; ++I) {
1328 const std::unique_ptr<VPtrInfo> &VBT = (*VBGlobals.VBTables)[I];
1329 llvm::GlobalVariable *GV = VBGlobals.Globals[I];
1334 if (VBT->getVBaseWithVPtr())
1337 llvm::Value *GVPtr =
1345MicrosoftCXXABI::buildStructorSignature(
GlobalDecl GD,
1347 AddedStructorArgCounts Added;
1349 if (isa<CXXDestructorDecl>(GD.
getDecl()) &&
1352 ArgTys.push_back(getContext().IntTy);
1355 auto *CD = dyn_cast<CXXConstructorDecl>(GD.
getDecl());
1364 if (
Class->getNumVBases()) {
1366 ArgTys.insert(ArgTys.begin() + 1, getContext().IntTy);
1369 ArgTys.push_back(getContext().IntTy);
1377void MicrosoftCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
1383 GV->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
1390llvm::GlobalValue::LinkageTypes MicrosoftCXXABI::getCXXDestructorLinkage(
1395 return llvm::GlobalValue::InternalLinkage;
1406 if (Dtor->
hasAttr<DLLExportAttr>())
1407 return llvm::GlobalValue::WeakODRLinkage;
1408 if (Dtor->
hasAttr<DLLImportAttr>())
1409 return llvm::GlobalValue::AvailableExternallyLinkage;
1410 return llvm::GlobalValue::LinkOnceODRLinkage;
1415 return llvm::GlobalValue::LinkOnceODRLinkage;
1417 llvm_unreachable(
"MS C++ ABI does not support comdat dtors");
1419 llvm_unreachable(
"invalid dtor type");
1436MicrosoftCXXABI::getVirtualFunctionPrologueThisAdjustment(
GlobalDecl GD) {
1458 if (isa<CXXDestructorDecl>(MD))
1463 getContext().getASTRecordLayout(MD->
getParent());
1470Address MicrosoftCXXABI::adjustThisArgumentForVirtualFunctionCall(
1476 CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD);
1511 Result = Result.withElementType(CGF.
Int8Ty);
1515 llvm::Value *VBaseOffset =
1516 GetVirtualBaseClassOffset(CGF, Result, Derived, VBase);
1518 Result.getElementType(), Result.emitRawPointer(CGF), VBaseOffset);
1523 if (!StaticOffset.
isZero()) {
1525 Result = Result.withElementType(CGF.
Int8Ty);
1544 assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD));
1549 ImplicitParamKind::Other);
1554 Params.insert(Params.begin() + 1, IsMostDerived);
1556 Params.push_back(IsMostDerived);
1557 getStructorImplicitParamDecl(CGF) = IsMostDerived;
1562 ImplicitParamKind::Other);
1563 Params.push_back(ShouldDelete);
1564 getStructorImplicitParamDecl(CGF) = ShouldDelete;
1568void MicrosoftCXXABI::EmitInstanceFunctionProlog(
CodeGenFunction &CGF) {
1585 llvm::Value *
This = loadIncomingCXXThis(CGF);
1588 CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(CGF.
CurGD);
1589 if (!Adjustment.
isZero()) {
1595 setCXXABIThisValue(CGF, This);
1605 if (HasThisReturn(CGF.
CurGD) || hasMostDerivedReturn(CGF.
CurGD))
1609 assert(getStructorImplicitParamDecl(CGF) &&
1610 "no implicit parameter for a constructor with virtual bases?");
1611 getStructorImplicitParamValue(CGF)
1618 assert(getStructorImplicitParamDecl(CGF) &&
1619 "no implicit parameter for a deleting destructor?");
1620 getStructorImplicitParamValue(CGF)
1623 "should_call_delete");
1634 return AddedStructorArgs{};
1638 llvm::Value *MostDerivedArg;
1640 MostDerivedArg = getStructorImplicitParamValue(CGF);
1645 return AddedStructorArgs::prefix({{MostDerivedArg, getContext().IntTy}});
1647 return AddedStructorArgs::suffix({{MostDerivedArg, getContext().IntTy}});
1650llvm::Value *MicrosoftCXXABI::getCXXDestructorImplicitParam(
1671 assert(
Type != CXXDtorType::Dtor_Deleting &&
1672 "The deleting destructor should only be called via a virtual call");
1677 llvm::BasicBlock *BaseDtorEndBB =
nullptr;
1678 if (ForVirtualBase && isa<CXXConstructorDecl>(CGF.
CurCodeDecl)) {
1679 BaseDtorEndBB = EmitDtorCompleteObjectHandler(CGF);
1689 if (BaseDtorEndBB) {
1691 CGF.
Builder.CreateBr(BaseDtorEndBB);
1696void MicrosoftCXXABI::emitVTableTypeMetadata(
const VPtrInfo &Info,
1698 llvm::GlobalVariable *VTable) {
1710 llvm::GlobalObject::VCallVisibility TypeVis =
1712 if (TypeVis != llvm::GlobalObject::VCallVisibilityPublic)
1713 VTable->setVCallVisibilityMetadata(TypeVis);
1720 getContext().getLangOpts().RTTIData
1721 ? getContext().toCharUnitsFromBits(
1722 getContext().getTargetInfo().getPointerWidth(LangAS::Default))
1741 getContext().getASTRecordLayout(DerivedRD);
1747 Offset = VBI->second.VBaseOffset;
1748 if (!Offset.isZero())
1763 for (
const std::unique_ptr<VPtrInfo>& Info : VFPtrs) {
1764 llvm::GlobalVariable *VTable = getAddrOfVTable(RD, Info->
FullOffsetInMDC);
1765 if (VTable->hasInitializer())
1771 llvm::Constant *RTTI =
nullptr;
1774 RTTI = getMSCompleteObjectLocator(RD, *Info);
1777 auto components = builder.beginStruct();
1779 VTable->hasLocalLinkage());
1780 components.finishAndSetAsInitializer(VTable);
1782 emitVTableTypeMetadata(*Info, RD, VTable);
1786bool MicrosoftCXXABI::isVirtualOffsetNeededForVTableField(
1788 return Vptr.NearestVBase !=
nullptr;
1791llvm::Value *MicrosoftCXXABI::getVTableAddressPointInStructor(
1794 llvm::Constant *VTableAddressPoint = getVTableAddressPoint(
Base, VTableClass);
1795 if (!VTableAddressPoint) {
1796 assert(
Base.getBase()->getNumVBases() &&
1797 !getContext().getASTRecordLayout(
Base.getBase()).hasOwnVFPtr());
1799 return VTableAddressPoint;
1805 llvm::raw_svector_ostream Out(Name);
1812 (void)getAddrOfVTable(VTableClass,
Base.getBaseOffset());
1813 VFTableIdTy
ID(VTableClass,
Base.getBaseOffset());
1814 return VFTablesMap[
ID];
1817llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(
const CXXRecordDecl *RD,
1823 VFTableIdTy
ID(RD, VPtrOffset);
1824 VTablesMapTy::iterator I;
1826 std::tie(I, Inserted) = VTablesMap.insert(std::make_pair(ID,
nullptr));
1830 llvm::GlobalVariable *&VTable = I->second;
1835 if (DeferredVFTables.insert(RD).second) {
1843 llvm::StringSet<> ObservedMangledNames;
1844 for (
size_t J = 0, F = VFPtrs.size(); J != F; ++J) {
1847 if (!ObservedMangledNames.insert(Name.str()).second)
1848 llvm_unreachable(
"Already saw this mangling before?");
1853 const std::unique_ptr<VPtrInfo> *VFPtrI =
1854 llvm::find_if(VFPtrs, [&](
const std::unique_ptr<VPtrInfo> &VPI) {
1855 return VPI->FullOffsetInMDC == VPtrOffset;
1857 if (VFPtrI == VFPtrs.end()) {
1858 VFTablesMap[
ID] =
nullptr;
1861 const std::unique_ptr<VPtrInfo> &VFPtr = *VFPtrI;
1873 llvm::GlobalValue::LinkageTypes VFTableLinkage =
1874 RD->
hasAttr<DLLImportAttr>() ? llvm::GlobalValue::LinkOnceODRLinkage
1876 bool VFTableComesFromAnotherTU =
1877 llvm::GlobalValue::isAvailableExternallyLinkage(VFTableLinkage) ||
1878 llvm::GlobalValue::isExternalLinkage(VFTableLinkage);
1879 bool VTableAliasIsRequred =
1880 !VFTableComesFromAnotherTU && getContext().getLangOpts().RTTIData;
1882 if (llvm::GlobalValue *VFTable =
1883 CGM.
getModule().getNamedGlobal(VFTableName)) {
1884 VFTablesMap[
ID] = VFTable;
1885 VTable = VTableAliasIsRequred
1886 ? cast<llvm::GlobalVariable>(
1887 cast<llvm::GlobalAlias>(VFTable)->getAliaseeObject())
1888 :
cast<
llvm::GlobalVariable>(VFTable);
1894 llvm::GlobalValue::LinkageTypes VTableLinkage =
1895 VTableAliasIsRequred ? llvm::GlobalValue::PrivateLinkage : VFTableLinkage;
1897 StringRef VTableName = VTableAliasIsRequred ? StringRef() : VFTableName.str();
1903 llvm::GlobalValue *VFTable;
1904 VTable =
new llvm::GlobalVariable(CGM.
getModule(), VTableType,
1905 true, VTableLinkage,
1906 nullptr, VTableName);
1907 VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1909 llvm::Comdat *
C =
nullptr;
1910 if (!VFTableComesFromAnotherTU &&
1911 llvm::GlobalValue::isWeakForLinker(VFTableLinkage))
1912 C = CGM.
getModule().getOrInsertComdat(VFTableName.str());
1917 if (VTableAliasIsRequred) {
1918 llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.
Int32Ty, 0),
1919 llvm::ConstantInt::get(CGM.
Int32Ty, 0),
1920 llvm::ConstantInt::get(CGM.
Int32Ty, 1)};
1923 llvm::Constant *VTableGEP = llvm::ConstantExpr::getInBoundsGetElementPtr(
1924 VTable->getValueType(), VTable, GEPIndices);
1925 if (llvm::GlobalValue::isWeakForLinker(VFTableLinkage)) {
1926 VFTableLinkage = llvm::GlobalValue::ExternalLinkage;
1928 C->setSelectionKind(llvm::Comdat::Largest);
1930 VFTable = llvm::GlobalAlias::create(CGM.
Int8PtrTy,
1932 VFTableName.str(), VTableGEP,
1934 VFTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1943 VTable->setComdat(
C);
1945 if (RD->
hasAttr<DLLExportAttr>())
1946 VFTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1948 VFTablesMap[
ID] = VFTable;
1959 Ty = Ty->getPointerTo();
1961 adjustThisArgumentForVirtualFunctionCall(CGF, GD, This,
true);
1963 auto *MethodDecl = cast<CXXMethodDecl>(GD.
getDecl());
1964 llvm::Value *VTable = CGF.
GetVTablePtr(VPtr, Ty->getPointerTo(),
1965 MethodDecl->getParent());
1972 auto getObjectWithVPtr = [&] {
1975 [&](
const std::unique_ptr<VPtrInfo> &Info) {
1976 return Info->FullOffsetInMDC == ML.VFPtrOffset;
1985 getObjectWithVPtr(), VTable, Ty,
1993 llvm::Value *VFuncPtr =
1994 Builder.CreateConstInBoundsGEP1_64(Ty, VTable, ML.
Index,
"vfn");
1995 VFunc = Builder.CreateAlignedLoad(Ty, VFuncPtr, CGF.
getPointerAlign());
2002llvm::Value *MicrosoftCXXABI::EmitVirtualDestructorCall(
2004 Address This, DeleteOrMemberCallExpr E) {
2007 assert((CE !=
nullptr) ^ (D !=
nullptr));
2008 assert(CE ==
nullptr || CE->arg_begin() == CE->arg_end());
2020 llvm::Value *ImplicitParam = llvm::ConstantInt::get(
2026 ThisTy = CE->getObjectType();
2028 ThisTy = D->getDestroyedType();
2031 This = adjustThisArgumentForVirtualFunctionCall(CGF, GD, This,
true);
2034 ImplicitParam, Context.
IntTy, CE);
2038const VBTableGlobals &
2039MicrosoftCXXABI::enumerateVBTables(
const CXXRecordDecl *RD) {
2042 llvm::DenseMap<const CXXRecordDecl*, VBTableGlobals>::iterator Entry;
2044 std::tie(Entry, Added) =
2045 VBTablesMap.insert(std::make_pair(RD, VBTableGlobals()));
2046 VBTableGlobals &VBGlobals = Entry->second;
2051 VBGlobals.VBTables = &Context.enumerateVBTables(RD);
2056 for (VPtrInfoVector::const_iterator I = VBGlobals.VBTables->begin(),
2057 E = VBGlobals.VBTables->end();
2059 VBGlobals.Globals.push_back(getAddrOfVBTable(**I, RD,
Linkage));
2066MicrosoftCXXABI::EmitVirtualMemPtrThunk(
const CXXMethodDecl *MD,
2068 assert(!isa<CXXConstructorDecl>(MD) && !isa<CXXDestructorDecl>(MD) &&
2069 "can't form pointers to ctors or virtual dtors");
2073 llvm::raw_svector_ostream Out(ThunkName);
2074 getMangleContext().mangleVirtualMemPtrThunk(MD, ML, Out);
2077 if (llvm::GlobalValue *GV = CGM.
getModule().getNamedValue(ThunkName))
2078 return cast<llvm::Function>(GV);
2084 llvm::Function *ThunkFn =
2085 llvm::Function::Create(ThunkTy, llvm::Function::ExternalLinkage,
2087 assert(ThunkFn->getName() == ThunkName &&
"name was uniqued!");
2090 ? llvm::GlobalValue::LinkOnceODRLinkage
2091 : llvm::GlobalValue::InternalLinkage);
2093 ThunkFn->setComdat(CGM.
getModule().getOrInsertComdat(ThunkFn->getName()));
2102 ThunkFn->addFnAttr(
"thunk");
2105 ThunkFn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::None);
2115 buildThisParam(CGF, FunctionArgs);
2122 setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
2126 llvm::Type *ThunkPtrTy = ThunkTy->getPointerTo();
2128 getThisAddress(CGF), ThunkPtrTy->getPointerTo(), MD->
getParent());
2130 llvm::Value *VFuncPtr = CGF.
Builder.CreateConstInBoundsGEP1_64(
2131 ThunkPtrTy, VTable, ML.
Index,
"vfn");
2140void MicrosoftCXXABI::emitVirtualInheritanceTables(
const CXXRecordDecl *RD) {
2141 const VBTableGlobals &VBGlobals = enumerateVBTables(RD);
2142 for (
unsigned I = 0, E = VBGlobals.VBTables->size(); I != E; ++I) {
2143 const std::unique_ptr<VPtrInfo>& VBT = (*VBGlobals.VBTables)[I];
2144 llvm::GlobalVariable *GV = VBGlobals.Globals[I];
2145 if (GV->isDeclaration())
2146 emitVBTableDefinition(*VBT, RD, GV);
2150llvm::GlobalVariable *
2152 llvm::GlobalVariable::LinkageTypes
Linkage) {
2154 llvm::raw_svector_ostream Out(OutName);
2155 getMangleContext().mangleCXXVBTable(RD, VBT.
MangledPath, Out);
2156 StringRef Name = OutName.str();
2158 llvm::ArrayType *VBTableType =
2161 assert(!CGM.
getModule().getNamedGlobal(Name) &&
2162 "vbtable with this name already exists: mangling bug?");
2167 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2169 if (RD->
hasAttr<DLLImportAttr>())
2170 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
2171 else if (RD->
hasAttr<DLLExportAttr>())
2172 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
2174 if (!GV->hasExternalLinkage())
2175 emitVBTableDefinition(VBT, RD, GV);
2180void MicrosoftCXXABI::emitVBTableDefinition(
const VPtrInfo &VBT,
2182 llvm::GlobalVariable *GV)
const {
2186 "should only emit vbtables for classes with vbtables");
2190 const ASTRecordLayout &DerivedLayout = getContext().getASTRecordLayout(RD);
2197 Offsets[0] = llvm::ConstantInt::get(CGM.
IntTy, -VBPtrOffset.
getQuantity());
2200 for (
const auto &I : ObjectWithVPtr->
vbases()) {
2201 const CXXRecordDecl *VBase = I.getType()->getAsCXXRecordDecl();
2203 assert(!Offset.isNegative());
2208 CompleteVBPtrOffset +=
2210 Offset -= CompleteVBPtrOffset;
2212 unsigned VBIndex = Context.getVBTableIndex(ObjectWithVPtr, VBase);
2213 assert(Offsets[VBIndex] ==
nullptr &&
"The same vbindex seen twice?");
2214 Offsets[VBIndex] = llvm::ConstantInt::get(CGM.
IntTy, Offset.getQuantity());
2217 assert(Offsets.size() ==
2218 cast<llvm::ArrayType>(GV->getValueType())->getNumElements());
2219 llvm::ArrayType *VBTableType =
2220 llvm::ArrayType::get(CGM.
IntTy, Offsets.size());
2221 llvm::Constant *
Init = llvm::ConstantArray::get(VBTableType, Offsets);
2222 GV->setInitializer(
Init);
2224 if (RD->
hasAttr<DLLImportAttr>())
2225 GV->setLinkage(llvm::GlobalVariable::AvailableExternallyLinkage);
2228llvm::Value *MicrosoftCXXABI::performThisAdjustment(
CodeGenFunction &CGF,
2232 return This.emitRawPointer(CGF);
2238 V =
This.emitRawPointer(CGF);
2248 CGF.
Builder.CreateNeg(VtorDisp));
2261 llvm::Value *VBaseOffset = GetVBaseOffsetFromVBPtr(
2284 return Ret.emitRawPointer(CGF);
2288 llvm::Value *
V =
Ret.emitRawPointer(CGF);
2293 llvm::Value *VBaseOffset =
2312bool MicrosoftCXXABI::requiresArrayCookie(
const CXXNewExpr *
expr) {
2315 return expr->getAllocatedType().isDestructedType();
2326llvm::Value *MicrosoftCXXABI::readArrayCookieImpl(
CodeGenFunction &CGF,
2335 llvm::Value *numElements,
2338 assert(requiresArrayCookie(
expr));
2341 CharUnits cookieSize = getArrayCookieSizeImpl(elementType);
2356 llvm::FunctionCallee Dtor,
2357 llvm::Constant *Addr) {
2362 llvm::FunctionType *TLRegDtorTy = llvm::FunctionType::get(
2363 CGF.
IntTy, DtorStub->getType(),
false);
2366 TLRegDtorTy,
"__tlregdtor", llvm::AttributeList(),
true);
2367 if (llvm::Function *TLRegDtorFn =
2368 dyn_cast<llvm::Function>(TLRegDtor.getCallee()))
2369 TLRegDtorFn->setDoesNotThrow();
2375 llvm::FunctionCallee Dtor,
2376 llvm::Constant *Addr) {
2391void MicrosoftCXXABI::EmitThreadLocalInitFuncs(
2395 if (CXXThreadLocalInits.empty())
2400 ?
"/include:___dyn_tls_init@12"
2401 :
"/include:__dyn_tls_init");
2406 auto AddToXDU = [&CGM](llvm::Function *InitFunc) {
2407 llvm::GlobalVariable *InitFuncPtr =
new llvm::GlobalVariable(
2408 CGM.
getModule(), InitFunc->getType(),
true,
2409 llvm::GlobalVariable::InternalLinkage, InitFunc,
2410 Twine(InitFunc->getName(),
"$initializer$"));
2411 InitFuncPtr->setSection(
".CRT$XDU");
2418 std::vector<llvm::Function *> NonComdatInits;
2419 for (
size_t I = 0, E = CXXThreadLocalInitVars.size(); I != E; ++I) {
2420 llvm::GlobalVariable *GV = cast<llvm::GlobalVariable>(
2422 llvm::Function *F = CXXThreadLocalInits[I];
2425 if (llvm::Comdat *
C = GV->getComdat())
2426 AddToXDU(F)->setComdat(
C);
2428 NonComdatInits.push_back(F);
2431 if (!NonComdatInits.empty()) {
2432 llvm::FunctionType *FTy =
2433 llvm::FunctionType::get(CGM.
VoidTy,
false);
2449 llvm::Constant *TlsGuardConstant =
2451 llvm::GlobalValue *TlsGuard = cast<llvm::GlobalValue>(TlsGuardConstant);
2453 TlsGuard->setThreadLocal(
true);
2461 llvm::FunctionType *FTy =
2462 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.
getLLVMContext()), {},
2465 FTy,
"__dyn_tls_on_demand_init",
2467 llvm::AttributeList::FunctionIndex,
2468 llvm::Attribute::NoUnwind),
2473 llvm::BasicBlock *DynInitBB,
2474 llvm::BasicBlock *ContinueBB) {
2475 llvm::LoadInst *TlsGuardValue =
2477 llvm::Value *CmpResult =
2479 CGF.
Builder.CreateCondBr(CmpResult, DynInitBB, ContinueBB);
2483 llvm::GlobalValue *TlsGuard,
2484 llvm::BasicBlock *ContinueBB) {
2486 llvm::Function *InitializerFunction =
2488 llvm::CallInst *CallVal = CGF.
Builder.CreateCall(InitializerFunction);
2489 CallVal->setCallingConv(InitializerFunction->getCallingConv());
2491 CGF.
Builder.CreateBr(ContinueBB);
2495 llvm::BasicBlock *DynInitBB =
2497 llvm::BasicBlock *ContinueBB =
2503 CGF.
Builder.SetInsertPoint(DynInitBB);
2505 CGF.
Builder.SetInsertPoint(ContinueBB);
2524 Address Addr(
V, RealVarTy, Alignment);
2528 AlignmentSource::Decl)
2534 StringRef VarName(
"_Init_thread_epoch");
2536 if (
auto *GV = CGM.
getModule().getNamedGlobal(VarName))
2538 auto *GV =
new llvm::GlobalVariable(
2540 false, llvm::GlobalVariable::ExternalLinkage,
2542 nullptr, llvm::GlobalVariable::GeneralDynamicTLSModel);
2548 llvm::FunctionType *FTy =
2549 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.
getLLVMContext()),
2550 CGM.
IntTy->getPointerTo(),
false);
2552 FTy,
"_Init_thread_header",
2554 llvm::AttributeList::FunctionIndex,
2555 llvm::Attribute::NoUnwind),
2560 llvm::FunctionType *FTy =
2561 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.
getLLVMContext()),
2562 CGM.
IntTy->getPointerTo(),
false);
2564 FTy,
"_Init_thread_footer",
2566 llvm::AttributeList::FunctionIndex,
2567 llvm::Attribute::NoUnwind),
2572 llvm::FunctionType *FTy =
2573 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.
getLLVMContext()),
2574 CGM.
IntTy->getPointerTo(),
false);
2576 FTy,
"_Init_thread_abort",
2578 llvm::AttributeList::FunctionIndex,
2579 llvm::Attribute::NoUnwind),
2587 ResetGuardBit(
Address Guard,
unsigned GuardNum)
2588 : Guard(Guard), GuardNum(GuardNum) {}
2594 llvm::LoadInst *LI = Builder.CreateLoad(Guard);
2595 llvm::ConstantInt *Mask =
2596 llvm::ConstantInt::get(CGF.
IntTy, ~(1ULL << GuardNum));
2597 Builder.CreateStore(Builder.CreateAnd(LI, Mask), Guard);
2603 CallInitThreadAbort(
RawAddress Guard) : Guard(Guard.getPointer()) {}
2613 llvm::GlobalVariable *GV,
2617 assert(GV->hasWeakLinkage() || GV->hasLinkOnceLinkage());
2619 llvm::Function *F = CGF.
CurFn;
2620 F->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage);
2621 F->setComdat(CGM.
getModule().getOrInsertComdat(F->getName()));
2627 bool ThreadsafeStatic = getContext().getLangOpts().ThreadsafeStatics;
2631 bool HasPerVariableGuard = ThreadsafeStatic && !ThreadlocalStatic;
2634 llvm::IntegerType *GuardTy = CGF.
Int32Ty;
2635 llvm::ConstantInt *
Zero = llvm::ConstantInt::get(GuardTy, 0);
2639 GuardInfo *GI =
nullptr;
2640 if (ThreadlocalStatic)
2642 else if (!ThreadsafeStatic)
2645 llvm::GlobalVariable *GuardVar = GI ? GI->Guard :
nullptr;
2650 GuardNum = getContext().getStaticLocalNumber(&D);
2651 assert(GuardNum > 0);
2653 }
else if (HasPerVariableGuard) {
2657 GuardNum = GI->BitIndex++;
2660 if (!HasPerVariableGuard && GuardNum >= 32) {
2662 ErrorUnsupportedABI(CGF,
"more than 32 guarded initializations");
2671 llvm::raw_svector_ostream Out(GuardName);
2672 if (HasPerVariableGuard)
2673 getMangleContext().mangleThreadSafeStaticGuardVariable(&D, GuardNum,
2676 getMangleContext().mangleStaticGuardVariable(&D, Out);
2682 new llvm::GlobalVariable(CGM.
getModule(), GuardTy,
false,
2683 GV->getLinkage(), Zero, GuardName.str());
2684 GuardVar->setVisibility(GV->getVisibility());
2685 GuardVar->setDLLStorageClass(GV->getDLLStorageClass());
2686 GuardVar->setAlignment(GuardAlign.
getAsAlign());
2687 if (GuardVar->isWeakForLinker())
2688 GuardVar->setComdat(
2689 CGM.
getModule().getOrInsertComdat(GuardVar->getName()));
2692 if (GI && !HasPerVariableGuard)
2693 GI->Guard = GuardVar;
2698 assert(GuardVar->getLinkage() == GV->getLinkage() &&
2699 "static local from the same function had different linkage");
2701 if (!HasPerVariableGuard) {
2709 llvm::ConstantInt *Bit = llvm::ConstantInt::get(GuardTy, 1ULL << GuardNum);
2710 llvm::LoadInst *LI = Builder.CreateLoad(GuardAddr);
2711 llvm::Value *NeedsInit =
2712 Builder.CreateICmpEQ(Builder.CreateAnd(LI, Bit), Zero);
2716 CodeGenFunction::GuardKind::VariableGuard, &D);
2721 Builder.CreateStore(Builder.CreateOr(LI, Bit), GuardAddr);
2725 Builder.CreateBr(EndBlock);
2743 llvm::LoadInst *FirstGuardLoad = Builder.CreateLoad(GuardAddr);
2744 FirstGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered);
2745 llvm::LoadInst *InitThreadEpoch =
2747 llvm::Value *IsUninitialized =
2748 Builder.CreateICmpSGT(FirstGuardLoad, InitThreadEpoch);
2752 CodeGenFunction::GuardKind::VariableGuard, &D);
2758 GuardAddr.getPointer());
2759 llvm::LoadInst *SecondGuardLoad = Builder.CreateLoad(GuardAddr);
2760 SecondGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered);
2761 llvm::Value *ShouldDoInit =
2762 Builder.CreateICmpEQ(SecondGuardLoad, getAllOnesInt());
2764 Builder.CreateCondBr(ShouldDoInit, InitBlock, EndBlock);
2772 GuardAddr.getPointer());
2773 Builder.CreateBr(EndBlock);
2802 fields.push_back(CGM.
IntTy);
2806 fields.push_back(CGM.
IntTy);
2808 fields.push_back(CGM.
IntTy);
2810 fields.push_back(CGM.
IntTy);
2812 if (fields.size() == 1)
2817void MicrosoftCXXABI::
2820 assert(fields.empty());
2825 fields.push_back(llvm::Constant::getNullValue(CGM.
VoidPtrTy));
2828 fields.push_back(getZeroInt());
2830 fields.push_back(getAllOnesInt());
2835 fields.push_back(getZeroInt());
2837 fields.push_back(getZeroInt());
2839 fields.push_back(getAllOnesInt());
2845 GetNullMemberPointerFields(MPT, fields);
2846 if (fields.size() == 1)
2848 llvm::Constant *Res = llvm::ConstantStruct::getAnon(fields);
2849 assert(Res->getType() == ConvertMemberPointerType(MPT));
2854MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField,
2855 bool IsMemberFunction,
2858 unsigned VBTableIndex) {
2867 fields.push_back(FirstField);
2870 fields.push_back(llvm::ConstantInt::get(
2876 Offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();
2882 fields.push_back(llvm::ConstantInt::get(CGM.
IntTy, VBTableIndex));
2884 return llvm::ConstantStruct::getAnon(fields);
2893llvm::Constant *MicrosoftCXXABI::EmitMemberDataPointer(
const CXXRecordDecl *RD,
2896 MSInheritanceModel::Virtual)
2897 offset -= getContext().getOffsetOfBaseWithVBPtr(RD);
2898 llvm::Constant *FirstField =
2900 return EmitFullMemberPointer(FirstField,
false, RD,
2904llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(
const APValue &MP,
2909 return EmitNullMemberPointer(DstTy);
2915 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD)) {
2916 C = EmitMemberFunctionPointer(MD);
2923 const FieldDecl *FD = dyn_cast<FieldDecl>(MPD);
2925 FD = cast<FieldDecl>(*cast<IndirectFieldDecl>(MPD)->chain_begin());
2928 C = EmitMemberDataPointer(RD, FieldOffset);
2931 if (!MemberPointerPath.empty()) {
2932 const CXXRecordDecl *SrcRD = cast<CXXRecordDecl>(MPD->getDeclContext());
2944 if (DerivedMember) {
2952 if (BS.getType()->getAsCXXRecordDecl()->getCanonicalDecl() ==
2953 Base->getCanonicalDecl())
2954 DerivedToBasePath.push_back(&BS);
2957 assert(DerivedToBasePath.size() == MemberPointerPath.size());
2959 CastKind CK = DerivedMember ? CK_DerivedToBaseMemberPointer
2960 : CK_BaseToDerivedMemberPointer;
2961 C = EmitMemberPointerConversion(SrcTy, DstTy, CK, DerivedToBasePath.begin(),
2962 DerivedToBasePath.end(),
C);
2968MicrosoftCXXABI::EmitMemberFunctionPointer(
const CXXMethodDecl *MD) {
2969 assert(MD->
isInstance() &&
"Member function must not be static!");
2975 unsigned VBTableIndex = 0;
2976 llvm::Constant *FirstField;
2981 if (Types.isFuncTypeConvertible(FPT)) {
2983 Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
2993 FirstField = EmitVirtualMemPtrThunk(MD, ML);
2997 VBTableIndex = VTableContext.getVBTableIndex(RD, ML.
VBase) * 4;
3000 if (VBTableIndex == 0 &&
3002 MSInheritanceModel::Virtual)
3003 NonVirtualBaseAdjustment -= getContext().getOffsetOfBaseWithVBPtr(RD);
3006 return EmitFullMemberPointer(FirstField,
true, RD,
3007 NonVirtualBaseAdjustment, VBTableIndex);
3022 llvm::ICmpInst::Predicate
Eq;
3023 llvm::Instruction::BinaryOps
And,
Or;
3025 Eq = llvm::ICmpInst::ICMP_NE;
3026 And = llvm::Instruction::Or;
3027 Or = llvm::Instruction::And;
3029 Eq = llvm::ICmpInst::ICMP_EQ;
3030 And = llvm::Instruction::And;
3031 Or = llvm::Instruction::Or;
3040 return Builder.CreateICmp(
Eq, L, R);
3043 llvm::Value *L0 = Builder.CreateExtractValue(L, 0,
"lhs.0");
3044 llvm::Value *R0 = Builder.CreateExtractValue(R, 0,
"rhs.0");
3045 llvm::Value *Cmp0 = Builder.CreateICmp(
Eq, L0, R0,
"memptr.cmp.first");
3048 llvm::Value *Res =
nullptr;
3049 llvm::StructType *LType = cast<llvm::StructType>(L->getType());
3050 for (
unsigned I = 1, E = LType->getNumElements(); I != E; ++I) {
3051 llvm::Value *LF = Builder.CreateExtractValue(L, I);
3052 llvm::Value *RF = Builder.CreateExtractValue(R, I);
3053 llvm::Value *Cmp = Builder.CreateICmp(
Eq, LF, RF,
"memptr.cmp.rest");
3055 Res = Builder.CreateBinOp(
And, Res, Cmp);
3063 llvm::Value *
Zero = llvm::Constant::getNullValue(L0->getType());
3064 llvm::Value *IsZero = Builder.CreateICmp(
Eq, L0, Zero,
"memptr.cmp.iszero");
3065 Res = Builder.CreateBinOp(
Or, Res, IsZero);
3070 return Builder.CreateBinOp(
And, Res, Cmp0,
"memptr.cmp");
3075 llvm::Value *MemPtr,
3081 fields.push_back(llvm::Constant::getNullValue(CGM.
VoidPtrTy));
3083 GetNullMemberPointerFields(MPT, fields);
3084 assert(!fields.empty());
3085 llvm::Value *FirstField = MemPtr;
3086 if (MemPtr->getType()->isStructTy())
3087 FirstField = Builder.CreateExtractValue(MemPtr, 0);
3088 llvm::Value *Res = Builder.CreateICmpNE(FirstField, fields[0],
"memptr.cmp0");
3096 for (
int I = 1, E = fields.size(); I < E; ++I) {
3097 llvm::Value *
Field = Builder.CreateExtractValue(MemPtr, I);
3098 llvm::Value *Next = Builder.CreateICmpNE(Field, fields[I],
"memptr.cmp");
3099 Res = Builder.CreateOr(Res, Next,
"memptr.tobool");
3105 llvm::Constant *Val) {
3108 llvm::Constant *FirstField = Val->getType()->isStructTy() ?
3109 Val->getAggregateElement(0
U) : Val;
3110 return FirstField->isNullValue();
3115 if (isZeroInitializable(MPT) && Val->isNullValue())
3121 GetNullMemberPointerFields(MPT, Fields);
3122 if (Fields.size() == 1) {
3123 assert(Val->getType()->isIntegerTy());
3124 return Val == Fields[0];
3128 for (I = 0, E = Fields.size(); I != E; ++I) {
3129 if (Val->getAggregateElement(I) != Fields[I])
3138 llvm::Value *VBPtrOffset,
3139 llvm::Value *VBTableOffset,
3140 llvm::Value **VBPtrOut) {
3143 llvm::Value *VBPtr = Builder.CreateInBoundsGEP(
3144 CGM.
Int8Ty,
This.emitRawPointer(CGF), VBPtrOffset,
"vbptr");
3149 if (
auto CI = dyn_cast<llvm::ConstantInt>(VBPtrOffset)) {
3150 VBPtrAlign =
This.getAlignment().alignmentAtOffset(
3156 llvm::Value *VBTable = Builder.CreateAlignedLoad(
3157 CGM.
Int32Ty->getPointerTo(0), VBPtr, VBPtrAlign,
"vbtable");
3160 llvm::Value *VBTableIndex = Builder.CreateAShr(
3161 VBTableOffset, llvm::ConstantInt::get(VBTableOffset->getType(), 2),
3165 llvm::Value *VBaseOffs =
3166 Builder.CreateInBoundsGEP(CGM.
Int32Ty, VBTable, VBTableIndex);
3167 return Builder.CreateAlignedLoad(CGM.
Int32Ty, VBaseOffs,
3173llvm::Value *MicrosoftCXXABI::AdjustVirtualBase(
3175 Address Base, llvm::Value *VBTableOffset, llvm::Value *VBPtrOffset) {
3178 llvm::BasicBlock *OriginalBB =
nullptr;
3179 llvm::BasicBlock *SkipAdjustBB =
nullptr;
3180 llvm::BasicBlock *VBaseAdjustBB =
nullptr;
3187 OriginalBB = Builder.GetInsertBlock();
3190 llvm::Value *IsVirtual =
3191 Builder.CreateICmpNE(VBTableOffset, getZeroInt(),
3193 Builder.CreateCondBr(IsVirtual, VBaseAdjustBB, SkipAdjustBB);
3205 "member pointer representation requires a "
3206 "complete class type for %0 to perform this expression");
3209 offs = getContext().getASTRecordLayout(RD).getVBPtrOffset();
3212 llvm::Value *VBPtr =
nullptr;
3213 llvm::Value *VBaseOffs =
3214 GetVBaseOffsetFromVBPtr(CGF,
Base, VBPtrOffset, VBTableOffset, &VBPtr);
3215 llvm::Value *AdjustedBase =
3216 Builder.CreateInBoundsGEP(CGM.
Int8Ty, VBPtr, VBaseOffs);
3219 if (VBaseAdjustBB) {
3220 Builder.CreateBr(SkipAdjustBB);
3222 llvm::PHINode *Phi = Builder.CreatePHI(CGM.
Int8PtrTy, 2,
"memptr.base");
3223 Phi->addIncoming(
Base.emitRawPointer(CGF), OriginalBB);
3224 Phi->addIncoming(AdjustedBase, VBaseAdjustBB);
3227 return AdjustedBase;
3230llvm::Value *MicrosoftCXXABI::EmitMemberDataPointerAddress(
3240 llvm::Value *FieldOffset = MemPtr;
3241 llvm::Value *VirtualBaseAdjustmentOffset =
nullptr;
3242 llvm::Value *VBPtrOffset =
nullptr;
3243 if (MemPtr->getType()->isStructTy()) {
3246 FieldOffset = Builder.CreateExtractValue(MemPtr, I++);
3248 VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
3250 VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
3254 if (VirtualBaseAdjustmentOffset) {
3255 Addr = AdjustVirtualBase(CGF, E, RD,
Base, VirtualBaseAdjustmentOffset,
3258 Addr =
Base.emitRawPointer(CGF);
3262 return Builder.CreateInBoundsGEP(CGF.
Int8Ty, Addr, FieldOffset,
3270 assert(E->
getCastKind() == CK_DerivedToBaseMemberPointer ||
3271 E->
getCastKind() == CK_BaseToDerivedMemberPointer ||
3275 if (isa<llvm::Constant>(Src))
3276 return EmitMemberPointerConversion(E, cast<llvm::Constant>(Src));
3286 bool IsReinterpret = E->
getCastKind() == CK_ReinterpretMemberPointer;
3287 if (IsReinterpret && IsFunc)
3292 if (IsReinterpret &&
3299 llvm::Value *
IsNotNull = EmitMemberPointerIsNotNull(CGF, Src, SrcTy);
3300 llvm::Constant *DstNull = EmitNullMemberPointer(DstTy);
3304 if (IsReinterpret) {
3307 assert(Src->getType() == DstNull->getType());
3308 return Builder.CreateSelect(
IsNotNull, Src, DstNull);
3311 llvm::BasicBlock *OriginalBB = Builder.GetInsertBlock();
3314 Builder.CreateCondBr(
IsNotNull, ConvertBB, ContinueBB);
3317 llvm::Value *Dst = EmitNonNullMemberPointerConversion(
3321 Builder.CreateBr(ContinueBB);
3325 llvm::PHINode *Phi = Builder.CreatePHI(DstNull->getType(), 2,
"memptr.converted");
3326 Phi->addIncoming(DstNull, OriginalBB);
3327 Phi->addIncoming(Dst, ConvertBB);
3331llvm::Value *MicrosoftCXXABI::EmitNonNullMemberPointerConversion(
3341 bool IsConstant = isa<llvm::Constant>(Src);
3344 llvm::Value *FirstField = Src;
3345 llvm::Value *NonVirtualBaseAdjustment = getZeroInt();
3346 llvm::Value *VirtualBaseAdjustmentOffset = getZeroInt();
3347 llvm::Value *VBPtrOffset = getZeroInt();
3351 FirstField = Builder.CreateExtractValue(Src, I++);
3353 NonVirtualBaseAdjustment = Builder.CreateExtractValue(Src, I++);
3355 VBPtrOffset = Builder.CreateExtractValue(Src, I++);
3357 VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(Src, I++);
3360 bool IsDerivedToBase = (CK == CK_DerivedToBaseMemberPointer);
3366 llvm::Value *&NVAdjustField = IsFunc ? NonVirtualBaseAdjustment : FirstField;
3373 llvm::Value *SrcVBIndexEqZero =
3374 Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt());
3375 if (SrcInheritance == MSInheritanceModel::Virtual) {
3376 if (int64_t SrcOffsetToFirstVBase =
3377 getContext().getOffsetOfBaseWithVBPtr(SrcRD).getQuantity()) {
3378 llvm::Value *UndoSrcAdjustment = Builder.CreateSelect(
3380 llvm::ConstantInt::get(CGM.
IntTy, SrcOffsetToFirstVBase),
3382 NVAdjustField = Builder.CreateNSWAdd(NVAdjustField, UndoSrcAdjustment);
3393 llvm::Constant *BaseClassOffset = llvm::ConstantInt::get(
3398 llvm::Value *NVDisp;
3399 if (IsDerivedToBase)
3400 NVDisp = Builder.CreateNSWSub(NVAdjustField, BaseClassOffset,
"adj");
3402 NVDisp = Builder.CreateNSWAdd(NVAdjustField, BaseClassOffset,
"adj");
3404 NVAdjustField = Builder.CreateSelect(SrcVBIndexEqZero, NVDisp, getZeroInt());
3408 llvm::Value *DstVBIndexEqZero = SrcVBIndexEqZero;
3411 if (llvm::GlobalVariable *VDispMap =
3412 getAddrOfVirtualDisplacementMap(SrcRD, DstRD)) {
3413 llvm::Value *VBIndex = Builder.CreateExactUDiv(
3414 VirtualBaseAdjustmentOffset, llvm::ConstantInt::get(CGM.
IntTy, 4));
3416 llvm::Constant *Mapping = VDispMap->getInitializer();
3417 VirtualBaseAdjustmentOffset =
3418 Mapping->getAggregateElement(cast<llvm::Constant>(VBIndex));
3420 llvm::Value *Idxs[] = {getZeroInt(), VBIndex};
3421 VirtualBaseAdjustmentOffset = Builder.CreateAlignedLoad(
3422 CGM.
IntTy, Builder.CreateInBoundsGEP(VDispMap->getValueType(),
3428 Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt());
3435 llvm::Value *DstVBPtrOffset = llvm::ConstantInt::get(
3437 getContext().getASTRecordLayout(DstRD).getVBPtrOffset().getQuantity());
3439 Builder.CreateSelect(DstVBIndexEqZero, getZeroInt(), DstVBPtrOffset);
3445 if (DstInheritance == MSInheritanceModel::Virtual) {
3446 if (int64_t DstOffsetToFirstVBase =
3447 getContext().getOffsetOfBaseWithVBPtr(DstRD).getQuantity()) {
3448 llvm::Value *DoDstAdjustment = Builder.CreateSelect(
3450 llvm::ConstantInt::get(CGM.
IntTy, DstOffsetToFirstVBase),
3452 NVAdjustField = Builder.CreateNSWSub(NVAdjustField, DoDstAdjustment);
3461 Dst = llvm::UndefValue::get(ConvertMemberPointerType(DstTy));
3463 Dst = Builder.CreateInsertValue(Dst, FirstField, Idx++);
3465 Dst = Builder.CreateInsertValue(Dst, NonVirtualBaseAdjustment, Idx++);
3467 Dst = Builder.CreateInsertValue(Dst, VBPtrOffset, Idx++);
3469 Dst = Builder.CreateInsertValue(Dst, VirtualBaseAdjustmentOffset, Idx++);
3475MicrosoftCXXABI::EmitMemberPointerConversion(
const CastExpr *E,
3476 llvm::Constant *Src) {
3483 return EmitMemberPointerConversion(SrcTy, DstTy, CK, E->
path_begin(),
3487llvm::Constant *MicrosoftCXXABI::EmitMemberPointerConversion(
3491 assert(CK == CK_DerivedToBaseMemberPointer ||
3492 CK == CK_BaseToDerivedMemberPointer ||
3493 CK == CK_ReinterpretMemberPointer);
3496 if (MemberPointerConstantIsNull(SrcTy, Src))
3497 return EmitNullMemberPointer(DstTy);
3502 if (CK == CK_ReinterpretMemberPointer)
3506 auto *Dst = cast<llvm::Constant>(EmitNonNullMemberPointerConversion(
3507 SrcTy, DstTy, CK, PathBegin, PathEnd, Src, Builder));
3512CGCallee MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer(
3514 llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr,
3526 llvm::Value *FunctionPointer = MemPtr;
3527 llvm::Value *NonVirtualBaseAdjustment =
nullptr;
3528 llvm::Value *VirtualBaseAdjustmentOffset =
nullptr;
3529 llvm::Value *VBPtrOffset =
nullptr;
3530 if (MemPtr->getType()->isStructTy()) {
3533 FunctionPointer = Builder.CreateExtractValue(MemPtr, I++);
3535 NonVirtualBaseAdjustment = Builder.CreateExtractValue(MemPtr, I++);
3537 VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++);
3539 VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++);
3542 if (VirtualBaseAdjustmentOffset) {
3543 ThisPtrForCall = AdjustVirtualBase(CGF, E, RD, This,
3544 VirtualBaseAdjustmentOffset, VBPtrOffset);
3546 ThisPtrForCall =
This.emitRawPointer(CGF);
3549 if (NonVirtualBaseAdjustment)
3550 ThisPtrForCall = Builder.CreateInBoundsGEP(CGF.
Int8Ty, ThisPtrForCall,
3551 NonVirtualBaseAdjustment);
3558 return new MicrosoftCXXABI(CGM);
3592 StringRef MangledName(
"??_7type_info@@6B@");
3593 if (
auto VTable = CGM.
getModule().getNamedGlobal(MangledName))
3597 llvm::GlobalVariable::ExternalLinkage,
3598 nullptr, MangledName);
3611 IsPrivateOnPath = 1 | 8,
3615 HasHierarchyDescriptor = 64
3621 MSRTTIClass *getFirstChild() {
return this + 1; }
3622 static MSRTTIClass *getNextChild(MSRTTIClass *Child) {
3623 return Child + 1 + Child->NumBases;
3627 uint32_t Flags, NumBases, OffsetInVBase;
3631uint32_t MSRTTIClass::initialize(
const MSRTTIClass *
Parent,
3633 Flags = HasHierarchyDescriptor;
3635 VirtualRoot =
nullptr;
3639 Flags |= IsPrivate | IsPrivateOnPath;
3645 if (
Parent->Flags & IsPrivateOnPath)
3646 Flags |= IsPrivateOnPath;
3647 VirtualRoot =
Parent->VirtualRoot;
3648 OffsetInVBase =
Parent->OffsetInVBase + RD->getASTContext()
3649 .getASTRecordLayout(
Parent->RD).getBaseClassOffset(RD).getQuantity();
3653 MSRTTIClass *Child = getFirstChild();
3655 NumBases += Child->initialize(
this, &
Base) + 1;
3656 Child = getNextChild(Child);
3661static llvm::GlobalValue::LinkageTypes getLinkageForRTTI(
QualType Ty) {
3663 case Linkage::Invalid:
3664 llvm_unreachable(
"Linkage hasn't been computed!");
3667 case Linkage::Internal:
3668 case Linkage::UniqueExternal:
3669 return llvm::GlobalValue::InternalLinkage;
3671 case Linkage::VisibleNone:
3672 case Linkage::Module:
3673 case Linkage::External:
3674 return llvm::GlobalValue::LinkOnceODRLinkage;
3676 llvm_unreachable(
"Invalid linkage!");
3682struct MSRTTIBuilder {
3684 HasBranchingHierarchy = 1,
3685 HasVirtualBranchingHierarchy = 2,
3686 HasAmbiguousBases = 4
3689 MSRTTIBuilder(MicrosoftCXXABI &ABI,
const CXXRecordDecl *RD)
3690 : CGM(ABI.CGM), Context(CGM.getContext()),
3691 VMContext(CGM.getLLVMContext()),
Module(CGM.getModule()), RD(RD),
3692 Linkage(getLinkageForRTTI(CGM.getContext().getTagDeclType(RD))),
3695 llvm::GlobalVariable *getBaseClassDescriptor(
const MSRTTIClass &Classes);
3696 llvm::GlobalVariable *
3698 llvm::GlobalVariable *getClassHierarchyDescriptor();
3699 llvm::GlobalVariable *getCompleteObjectLocator(
const VPtrInfo &Info);
3703 llvm::LLVMContext &VMContext;
3706 llvm::GlobalVariable::LinkageTypes
Linkage;
3707 MicrosoftCXXABI &ABI;
3716 Classes.push_back(MSRTTIClass(RD));
3727 for (MSRTTIClass *
Class = &Classes.front();
Class <= &Classes.back();) {
3728 if ((
Class->Flags & MSRTTIClass::IsVirtual) &&
3729 !VirtualBases.insert(
Class->RD).second) {
3733 if (!UniqueBases.insert(
Class->RD).second)
3734 AmbiguousBases.insert(
Class->RD);
3737 if (AmbiguousBases.empty())
3739 for (MSRTTIClass &
Class : Classes)
3740 if (AmbiguousBases.count(
Class.RD))
3741 Class.Flags |= MSRTTIClass::IsAmbiguous;
3744llvm::GlobalVariable *MSRTTIBuilder::getClassHierarchyDescriptor() {
3747 llvm::raw_svector_ostream Out(MangledName);
3748 ABI.getMangleContext().mangleCXXRTTIClassHierarchyDescriptor(RD, Out);
3752 if (
auto CHD =
Module.getNamedGlobal(MangledName))
3758 Classes.front().initialize(
nullptr,
nullptr);
3761 for (
const MSRTTIClass &Class : Classes) {
3762 if (
Class.RD->getNumBases() > 1)
3763 Flags |= HasBranchingHierarchy;
3766 if (
Class.Flags & MSRTTIClass::IsAmbiguous)
3767 Flags |= HasAmbiguousBases;
3769 if ((Flags & HasBranchingHierarchy) && RD->getNumVBases() != 0)
3770 Flags |= HasVirtualBranchingHierarchy;
3773 llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.
IntTy, 0),
3774 llvm::ConstantInt::get(CGM.
IntTy, 0)};
3777 auto Type = ABI.getClassHierarchyDescriptorType();
3781 if (CHD->isWeakForLinker())
3782 CHD->setComdat(CGM.
getModule().getOrInsertComdat(CHD->getName()));
3784 auto *Bases = getBaseClassArray(Classes);
3787 llvm::Constant *Fields[] = {
3788 llvm::ConstantInt::get(CGM.
IntTy, 0),
3789 llvm::ConstantInt::get(CGM.
IntTy, Flags),
3790 llvm::ConstantInt::get(CGM.
IntTy, Classes.size()),
3791 ABI.getImageRelativeConstant(llvm::ConstantExpr::getInBoundsGetElementPtr(
3792 Bases->getValueType(), Bases,
3795 CHD->setInitializer(llvm::ConstantStruct::get(
Type, Fields));
3799llvm::GlobalVariable *
3803 llvm::raw_svector_ostream Out(MangledName);
3804 ABI.getMangleContext().mangleCXXRTTIBaseClassArray(RD, Out);
3812 llvm::Type *PtrType = ABI.getImageRelativeType(
3813 ABI.getBaseClassDescriptorType()->getPointerTo());
3814 auto *ArrType = llvm::ArrayType::get(PtrType, Classes.size() + 1);
3816 new llvm::GlobalVariable(
Module, ArrType,
3818 nullptr, MangledName);
3819 if (BCA->isWeakForLinker())
3820 BCA->setComdat(CGM.
getModule().getOrInsertComdat(BCA->getName()));
3824 for (MSRTTIClass &Class : Classes)
3825 BaseClassArrayData.push_back(
3826 ABI.getImageRelativeConstant(getBaseClassDescriptor(Class)));
3827 BaseClassArrayData.push_back(llvm::Constant::getNullValue(PtrType));
3828 BCA->setInitializer(llvm::ConstantArray::get(ArrType, BaseClassArrayData));
3832llvm::GlobalVariable *
3833MSRTTIBuilder::getBaseClassDescriptor(
const MSRTTIClass &Class) {
3836 uint32_t OffsetInVBTable = 0;
3837 int32_t VBPtrOffset = -1;
3838 if (
Class.VirtualRoot) {
3846 llvm::raw_svector_ostream Out(MangledName);
3847 ABI.getMangleContext().mangleCXXRTTIBaseClassDescriptor(
3848 Class.RD,
Class.OffsetInVBase, VBPtrOffset, OffsetInVBTable,
3853 if (
auto BCD =
Module.getNamedGlobal(MangledName))
3857 auto Type = ABI.getBaseClassDescriptorType();
3860 nullptr, MangledName);
3861 if (BCD->isWeakForLinker())
3862 BCD->setComdat(CGM.
getModule().getOrInsertComdat(BCD->getName()));
3865 llvm::Constant *Fields[] = {
3866 ABI.getImageRelativeConstant(
3868 llvm::ConstantInt::get(CGM.
IntTy,
Class.NumBases),
3869 llvm::ConstantInt::get(CGM.
IntTy,
Class.OffsetInVBase),
3870 llvm::ConstantInt::get(CGM.
IntTy, VBPtrOffset),
3871 llvm::ConstantInt::get(CGM.
IntTy, OffsetInVBTable),
3872 llvm::ConstantInt::get(CGM.
IntTy,
Class.Flags),
3873 ABI.getImageRelativeConstant(
3874 MSRTTIBuilder(ABI,
Class.RD).getClassHierarchyDescriptor()),
3876 BCD->setInitializer(llvm::ConstantStruct::get(
Type, Fields));
3880llvm::GlobalVariable *
3881MSRTTIBuilder::getCompleteObjectLocator(
const VPtrInfo &Info) {
3884 llvm::raw_svector_ostream Out(MangledName);
3885 ABI.getMangleContext().mangleCXXRTTICompleteObjectLocator(RD, Info.
MangledPath, Out);
3889 if (
auto COL =
Module.getNamedGlobal(MangledName))
3894 int VFPtrOffset = 0;
3900 ->second.hasVtorDisp())
3904 llvm::StructType *
Type = ABI.getCompleteObjectLocatorType();
3906 nullptr, MangledName);
3909 llvm::Constant *Fields[] = {
3910 llvm::ConstantInt::get(CGM.
IntTy, ABI.isImageRelative()),
3911 llvm::ConstantInt::get(CGM.
IntTy, OffsetToTop),
3912 llvm::ConstantInt::get(CGM.
IntTy, VFPtrOffset),
3913 ABI.getImageRelativeConstant(
3915 ABI.getImageRelativeConstant(getClassHierarchyDescriptor()),
3916 ABI.getImageRelativeConstant(COL),
3919 if (!ABI.isImageRelative())
3920 FieldsRef = FieldsRef.drop_back();
3921 COL->setInitializer(llvm::ConstantStruct::get(
Type, FieldsRef));
3922 if (COL->isWeakForLinker())
3923 COL->setComdat(CGM.
getModule().getOrInsertComdat(COL->getName()));
3928 bool &IsConst,
bool &IsVolatile,
3929 bool &IsUnaligned) {
3939 IsUnaligned =
false;
3941 if (!PointeeType.
isNull()) {
3962MicrosoftCXXABI::getAddrOfCXXCatchHandlerType(
QualType Type,
3967 bool IsConst, IsVolatile, IsUnaligned;
3991llvm::Constant *MicrosoftCXXABI::getAddrOfRTTIDescriptor(
QualType Type) {
3994 llvm::raw_svector_ostream Out(MangledName);
3995 getMangleContext().mangleCXXRTTI(
Type, Out);
3999 if (llvm::GlobalVariable *GV = CGM.
getModule().getNamedGlobal(MangledName))
4008 llvm::raw_svector_ostream Out(TypeInfoString);
4009 getMangleContext().mangleCXXRTTIName(
Type, Out);
4013 llvm::Constant *Fields[] = {
4015 llvm::ConstantPointerNull::get(CGM.
Int8PtrTy),
4016 llvm::ConstantDataArray::getString(CGM.
getLLVMContext(), TypeInfoString)};
4017 llvm::StructType *TypeDescriptorType =
4018 getTypeDescriptorType(TypeInfoString);
4019 auto *Var =
new llvm::GlobalVariable(
4020 CGM.
getModule(), TypeDescriptorType,
false,
4021 getLinkageForRTTI(
Type),
4022 llvm::ConstantStruct::get(TypeDescriptorType, Fields),
4024 if (Var->isWeakForLinker())
4025 Var->setComdat(CGM.
getModule().getOrInsertComdat(Var->getName()));
4030llvm::GlobalVariable *
4031MicrosoftCXXABI::getMSCompleteObjectLocator(
const CXXRecordDecl *RD,
4033 return MSRTTIBuilder(*
this, RD).getCompleteObjectLocator(Info);
4036void MicrosoftCXXABI::emitCXXStructor(
GlobalDecl GD) {
4037 if (
auto *ctor = dyn_cast<CXXConstructorDecl>(GD.
getDecl())) {
4039 llvm::Function *Fn =
4045 auto *dtor = cast<CXXDestructorDecl>(GD.
getDecl());
4051 dtor->getParent()->getNumVBases() == 0)
4062 if (Fn->isWeakForLinker())
4063 Fn->setComdat(CGM.
getModule().getOrInsertComdat(Fn->getName()));
4073 llvm::raw_svector_ostream Out(ThunkName);
4074 getMangleContext().mangleName(
GlobalDecl(CD, CT), Out);
4077 if (llvm::GlobalValue *GV = CGM.
getModule().getNamedValue(ThunkName))
4078 return cast<llvm::Function>(GV);
4084 QualType RecordTy = getContext().getRecordType(RD);
4085 llvm::Function *ThunkFn = llvm::Function::Create(
4086 ThunkTy, getLinkageForRTTI(RecordTy), ThunkName.str(), &CGM.
getModule());
4087 ThunkFn->setCallingConv(
static_cast<llvm::CallingConv::ID
>(
4089 if (ThunkFn->isWeakForLinker())
4090 ThunkFn->setComdat(CGM.
getModule().getOrInsertComdat(ThunkFn->getName()));
4101 buildThisParam(CGF, FunctionArgs);
4107 &getContext().Idents.get(
"src"),
4108 getContext().getLValueReferenceType(RecordTy,
4110 ImplicitParamKind::Other);
4112 FunctionArgs.push_back(&SrcParam);
4119 &getContext().Idents.get(
"is_most_derived"),
4120 getContext().IntTy, ImplicitParamKind::Other);
4123 FunctionArgs.push_back(&IsMostDerived);
4131 setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
4132 llvm::Value *
This = getThisValue(CGF);
4134 llvm::Value *SrcVal =
4151 assert(PD->hasDefaultArg() &&
"ctor closure lacks default args");
4152 ArgVec.push_back(PD->getDefaultArg());
4155 CodeGenFunction::RunCleanupsScope Cleanups(CGF);
4161 AddedStructorArgCounts ExtraArgs =
4166 llvm::Constant *CalleePtr =
4171 Args, CD,
Ctor_Complete, ExtraArgs.Prefix, ExtraArgs.Suffix);
4174 Cleanups.ForceCleanup();
4183llvm::Constant *MicrosoftCXXABI::getCatchableType(
QualType T,
4185 int32_t VBPtrOffset,
4197 uint32_t
Size = getContext().getTypeSizeInChars(
T).getQuantity();
4200 llvm::raw_svector_ostream Out(MangledName);
4201 getMangleContext().mangleCXXCatchableType(
T, CD, CT, Size, NVOffset,
4202 VBPtrOffset, VBIndex, Out);
4204 if (llvm::GlobalVariable *GV = CGM.
getModule().getNamedGlobal(MangledName))
4205 return getImageRelativeConstant(GV);
4209 llvm::Constant *TD = getImageRelativeConstant(getAddrOfRTTIDescriptor(
T));
4213 llvm::Constant *CopyCtor;
4220 CopyCtor = llvm::Constant::getNullValue(CGM.
Int8PtrTy);
4222 CopyCtor = getImageRelativeConstant(CopyCtor);
4224 bool IsScalar = !RD;
4225 bool HasVirtualBases =
false;
4226 bool IsStdBadAlloc =
false;
4241 if (HasVirtualBases)
4246 llvm::Constant *Fields[] = {
4247 llvm::ConstantInt::get(CGM.
IntTy, Flags),
4249 llvm::ConstantInt::get(CGM.
IntTy, NVOffset),
4250 llvm::ConstantInt::get(CGM.
IntTy, VBPtrOffset),
4251 llvm::ConstantInt::get(CGM.
IntTy, VBIndex),
4252 llvm::ConstantInt::get(CGM.
IntTy, Size),
4255 llvm::StructType *CTType = getCatchableTypeType();
4256 auto *GV =
new llvm::GlobalVariable(
4257 CGM.
getModule(), CTType,
true, getLinkageForRTTI(
T),
4258 llvm::ConstantStruct::get(CTType, Fields), MangledName);
4259 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4260 GV->setSection(
".xdata");
4261 if (GV->isWeakForLinker())
4262 GV->setComdat(CGM.
getModule().getOrInsertComdat(GV->getName()));
4263 return getImageRelativeConstant(GV);
4266llvm::GlobalVariable *MicrosoftCXXABI::getCatchableTypeArray(
QualType T) {
4270 llvm::GlobalVariable *&CTA = CatchableTypeArrays[
T];
4295 if (MostDerivedClass) {
4302 Classes.front().initialize(
nullptr,
nullptr);
4304 for (
const MSRTTIClass &Class : Classes) {
4307 (MSRTTIClass::IsPrivateOnPath | MSRTTIClass::IsAmbiguous))
4310 uint32_t OffsetInVBTable = 0;
4311 int32_t VBPtrOffset = -1;
4312 if (
Class.VirtualRoot) {
4323 CatchableTypes.insert(getCatchableType(RTTITy,
Class.OffsetInVBase,
4324 VBPtrOffset, OffsetInVBTable));
4332 CatchableTypes.insert(getCatchableType(
T));
4345 CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy));
4356 CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy));
4358 uint32_t NumEntries = CatchableTypes.size();
4359 llvm::Type *CTType =
4360 getImageRelativeType(getCatchableTypeType()->getPointerTo());
4361 llvm::ArrayType *AT = llvm::ArrayType::get(CTType, NumEntries);
4362 llvm::StructType *CTAType = getCatchableTypeArrayType(NumEntries);
4363 llvm::Constant *Fields[] = {
4364 llvm::ConstantInt::get(CGM.
IntTy, NumEntries),
4365 llvm::ConstantArray::get(
4367 CatchableTypes.end()))
4371 llvm::raw_svector_ostream Out(MangledName);
4372 getMangleContext().mangleCXXCatchableTypeArray(
T, NumEntries, Out);
4374 CTA =
new llvm::GlobalVariable(
4375 CGM.
getModule(), CTAType,
true, getLinkageForRTTI(
T),
4376 llvm::ConstantStruct::get(CTAType, Fields), MangledName);
4377 CTA->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4378 CTA->setSection(
".xdata");
4379 if (CTA->isWeakForLinker())
4380 CTA->setComdat(CGM.
getModule().getOrInsertComdat(CTA->getName()));
4384llvm::GlobalVariable *MicrosoftCXXABI::getThrowInfo(
QualType T) {
4385 bool IsConst, IsVolatile, IsUnaligned;
4390 llvm::GlobalVariable *CTA = getCatchableTypeArray(
T);
4395 uint32_t NumEntries =
4396 cast<llvm::ConstantInt>(CTA->getInitializer()->getAggregateElement(0
U))
4397 ->getLimitedValue();
4401 llvm::raw_svector_ostream Out(MangledName);
4402 getMangleContext().mangleCXXThrowInfo(
T, IsConst, IsVolatile, IsUnaligned,
4408 if (llvm::GlobalVariable *GV = CGM.
getModule().getNamedGlobal(MangledName))
4424 llvm::Constant *CleanupFn = llvm::Constant::getNullValue(CGM.
Int8PtrTy);
4427 if (!DtorD->isTrivial())
4430 llvm::Constant *ForwardCompat =
4431 getImageRelativeConstant(llvm::Constant::getNullValue(CGM.
Int8PtrTy));
4432 llvm::Constant *PointerToCatchableTypes = getImageRelativeConstant(CTA);
4433 llvm::StructType *TIType = getThrowInfoType();
4434 llvm::Constant *Fields[] = {
4435 llvm::ConstantInt::get(CGM.
IntTy, Flags),
4436 getImageRelativeConstant(CleanupFn),
4438 PointerToCatchableTypes
4440 auto *GV =
new llvm::GlobalVariable(
4441 CGM.
getModule(), TIType,
true, getLinkageForRTTI(
T),
4442 llvm::ConstantStruct::get(TIType, Fields), MangledName.str());
4443 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4444 GV->setSection(
".xdata");
4445 if (GV->isWeakForLinker())
4446 GV->setComdat(CGM.
getModule().getOrInsertComdat(GV->getName()));
4452 assert(SubExpr &&
"SubExpr cannot be null");
4462 llvm::GlobalVariable *TI = getThrowInfo(ThrowType);
4469std::pair<llvm::Value *, const CXXRecordDecl *>
4472 std::tie(This, std::ignore, RD) =
4477bool MicrosoftCXXABI::isPermittedToBeHomogeneousAggregate(
4509 if (
const CXXRecordDecl *FRD = B.getType()->getAsCXXRecordDecl()) {
4510 if (!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.
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Represents a delete expression for memory deallocation and destructor calls, e.g.
FunctionDecl * getOperatorDelete() const
bool isGlobalDelete() const
Represents a C++ destructor within a class.
Represents a call to a member function that may be written either with member call syntax (e....
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
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]).
const Expr * getSubExpr() const
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CastKind getCastKind() const
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 llvm::Value * performReturnAdjustment(CodeGenFunction &CGF, Address Ret, const ReturnAdjustment &RA)=0
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 llvm::Type * ConvertMemberPointerType(const MemberPointerType *MPT)
Find the LLVM type used to represent the given member pointer type.
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 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.
virtual llvm::Value * EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType, Address This, DeleteOrMemberCallExpr E)=0
Emit the ABI-specific virtual destructor call.
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 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 bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy)=0
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.
virtual llvm::Value * performThisAdjustment(CodeGenFunction &CGF, Address This, const ThisAdjustment &TA)=0
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.
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...
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, bool IsMustTail, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type,...
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.
llvm::Function * createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr)
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.
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::Value * GetVTablePtr(Address This, llvm::Type *VTableTy, const CXXRecordDecl *VTableClass)
GetVTablePtr - Return the Value of the vtable pointer member pointed to by This.
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.
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.
const ABIInfo & getABIInfo() const
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
const CGFunctionInfo & arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD)
Arrange a thunk that takes 'this' as the first parameter followed by varargs.
llvm::Type * ConvertTypeForMem(QualType T, bool ForBitField=false)
ConvertTypeForMem - Convert type T into a llvm::Type.
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()
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.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Represents a prototype with parameter type info, e.g.
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.
TLSKind getTLSKind() const
bool isNoDestroy(const ASTContext &) const
Is destruction of this variable entirely suppressed? If so, the variable need not have a usable destr...
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
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.
bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
bool This(InterpState &S, CodePtr OpPC)
bool Zero(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
@ Ctor_Base
Base object ctor.
@ Ctor_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::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.
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::@189 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.
struct clang::ThisAdjustment::VirtualAdjustment::@191 Microsoft
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...