1210008Srdivacky//===--- MicrosoftCXXABI.cpp - Emit LLVM Code from ASTs for a Module ------===// 2210008Srdivacky// 3210008Srdivacky// The LLVM Compiler Infrastructure 4210008Srdivacky// 5210008Srdivacky// This file is distributed under the University of Illinois Open Source 6210008Srdivacky// License. See LICENSE.TXT for details. 7210008Srdivacky// 8210008Srdivacky//===----------------------------------------------------------------------===// 9210008Srdivacky// 10221345Sdim// This provides C++ code generation targeting the Microsoft Visual C++ ABI. 11210008Srdivacky// The class in this file generates structures that follow the Microsoft 12210008Srdivacky// Visual C++ ABI, which is actually not very well documented at all outside 13210008Srdivacky// of Microsoft. 14210008Srdivacky// 15210008Srdivacky//===----------------------------------------------------------------------===// 16210008Srdivacky 17210008Srdivacky#include "CGCXXABI.h" 18296417Sdim#include "CGCleanup.h" 19276479Sdim#include "CGVTables.h" 20210008Srdivacky#include "CodeGenModule.h" 21288943Sdim#include "CodeGenTypes.h" 22288943Sdim#include "TargetInfo.h" 23210008Srdivacky#include "clang/AST/Decl.h" 24210008Srdivacky#include "clang/AST/DeclCXX.h" 25288943Sdim#include "clang/AST/StmtCXX.h" 26261991Sdim#include "clang/AST/VTableBuilder.h" 27276479Sdim#include "llvm/ADT/StringExtras.h" 28261991Sdim#include "llvm/ADT/StringSet.h" 29276479Sdim#include "llvm/IR/CallSite.h" 30288943Sdim#include "llvm/IR/Intrinsics.h" 31210008Srdivacky 32210008Srdivackyusing namespace clang; 33210008Srdivackyusing namespace CodeGen; 34210008Srdivacky 35210008Srdivackynamespace { 36210008Srdivacky 37276479Sdim/// Holds all the vbtable globals for a given class. 38276479Sdimstruct VBTableGlobals { 39276479Sdim const VPtrInfoVector *VBTables; 40276479Sdim SmallVector<llvm::GlobalVariable *, 2> Globals; 41276479Sdim}; 42276479Sdim 43212904Sdimclass MicrosoftCXXABI : public CGCXXABI { 44210008Srdivackypublic: 45276479Sdim MicrosoftCXXABI(CodeGenModule &CGM) 46276479Sdim : CGCXXABI(CGM), BaseClassDescriptorType(nullptr), 47276479Sdim ClassHierarchyDescriptorType(nullptr), 48288943Sdim CompleteObjectLocatorType(nullptr), CatchableTypeType(nullptr), 49296417Sdim ThrowInfoType(nullptr) {} 50210008Srdivacky 51276479Sdim bool HasThisReturn(GlobalDecl GD) const override; 52280031Sdim bool hasMostDerivedReturn(GlobalDecl GD) const override; 53261991Sdim 54276479Sdim bool classifyReturnType(CGFunctionInfo &FI) const override; 55251662Sdim 56276479Sdim RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override; 57251662Sdim 58276479Sdim bool isSRetParameterAfterThis() const override { return true; } 59276479Sdim 60296417Sdim bool isThisCompleteObject(GlobalDecl GD) const override { 61296417Sdim // The Microsoft ABI doesn't use separate complete-object vs. 62296417Sdim // base-object variants of constructors, but it does of destructors. 63296417Sdim if (isa<CXXDestructorDecl>(GD.getDecl())) { 64296417Sdim switch (GD.getDtorType()) { 65296417Sdim case Dtor_Complete: 66296417Sdim case Dtor_Deleting: 67296417Sdim return true; 68296417Sdim 69296417Sdim case Dtor_Base: 70296417Sdim return false; 71296417Sdim 72296417Sdim case Dtor_Comdat: llvm_unreachable("emitting dtor comdat as function?"); 73296417Sdim } 74296417Sdim llvm_unreachable("bad dtor kind"); 75296417Sdim } 76296417Sdim 77296417Sdim // No other kinds. 78296417Sdim return false; 79296417Sdim } 80296417Sdim 81280031Sdim size_t getSrcArgforCopyCtor(const CXXConstructorDecl *CD, 82280031Sdim FunctionArgList &Args) const override { 83280031Sdim assert(Args.size() >= 2 && 84280031Sdim "expected the arglist to have at least two args!"); 85280031Sdim // The 'most_derived' parameter goes second if the ctor is variadic and 86280031Sdim // has v-bases. 87280031Sdim if (CD->getParent()->getNumVBases() > 0 && 88280031Sdim CD->getType()->castAs<FunctionProtoType>()->isVariadic()) 89280031Sdim return 2; 90280031Sdim return 1; 91280031Sdim } 92280031Sdim 93296417Sdim std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD) override { 94296417Sdim std::vector<CharUnits> VBPtrOffsets; 95296417Sdim const ASTContext &Context = getContext(); 96296417Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 97296417Sdim 98296417Sdim const VBTableGlobals &VBGlobals = enumerateVBTables(RD); 99296417Sdim for (const VPtrInfo *VBT : *VBGlobals.VBTables) { 100296417Sdim const ASTRecordLayout &SubobjectLayout = 101296417Sdim Context.getASTRecordLayout(VBT->BaseWithVPtr); 102296417Sdim CharUnits Offs = VBT->NonVirtualOffset; 103296417Sdim Offs += SubobjectLayout.getVBPtrOffset(); 104296417Sdim if (VBT->getVBaseWithVPtr()) 105296417Sdim Offs += Layout.getVBaseClassOffset(VBT->getVBaseWithVPtr()); 106296417Sdim VBPtrOffsets.push_back(Offs); 107296417Sdim } 108296417Sdim llvm::array_pod_sort(VBPtrOffsets.begin(), VBPtrOffsets.end()); 109296417Sdim return VBPtrOffsets; 110296417Sdim } 111296417Sdim 112276479Sdim StringRef GetPureVirtualCallName() override { return "_purecall"; } 113276479Sdim StringRef GetDeletedVirtualCallName() override { return "_purecall"; } 114239462Sdim 115280031Sdim void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, 116296417Sdim Address Ptr, QualType ElementType, 117280031Sdim const CXXDestructorDecl *Dtor) override; 118243830Sdim 119280031Sdim void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override; 120288943Sdim void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override; 121280031Sdim 122288943Sdim void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override; 123288943Sdim 124276479Sdim llvm::GlobalVariable *getMSCompleteObjectLocator(const CXXRecordDecl *RD, 125276479Sdim const VPtrInfo *Info); 126261991Sdim 127276479Sdim llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override; 128296417Sdim CatchTypeInfo 129288943Sdim getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType) override; 130276479Sdim 131296417Sdim /// MSVC needs an extra flag to indicate a catchall. 132296417Sdim CatchTypeInfo getCatchAllTypeInfo() override { 133296417Sdim return CatchTypeInfo{nullptr, 0x40}; 134296417Sdim } 135296417Sdim 136276479Sdim bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy) override; 137276479Sdim void EmitBadTypeidCall(CodeGenFunction &CGF) override; 138276479Sdim llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy, 139296417Sdim Address ThisPtr, 140276479Sdim llvm::Type *StdTypeInfoPtrTy) override; 141276479Sdim 142276479Sdim bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr, 143276479Sdim QualType SrcRecordTy) override; 144276479Sdim 145296417Sdim llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value, 146276479Sdim QualType SrcRecordTy, QualType DestTy, 147276479Sdim QualType DestRecordTy, 148276479Sdim llvm::BasicBlock *CastEnd) override; 149276479Sdim 150296417Sdim llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value, 151276479Sdim QualType SrcRecordTy, 152276479Sdim QualType DestTy) override; 153276479Sdim 154276479Sdim bool EmitBadCastCall(CodeGenFunction &CGF) override; 155296417Sdim bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const override { 156296417Sdim return false; 157296417Sdim } 158276479Sdim 159276479Sdim llvm::Value * 160296417Sdim GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This, 161276479Sdim const CXXRecordDecl *ClassDecl, 162276479Sdim const CXXRecordDecl *BaseClassDecl) override; 163276479Sdim 164276479Sdim llvm::BasicBlock * 165276479Sdim EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, 166276479Sdim const CXXRecordDecl *RD) override; 167249423Sdim 168261991Sdim void initializeHiddenVirtualInheritanceMembers(CodeGenFunction &CGF, 169276479Sdim const CXXRecordDecl *RD) override; 170261991Sdim 171276479Sdim void EmitCXXConstructors(const CXXConstructorDecl *D) override; 172261991Sdim 173261991Sdim // Background on MSVC destructors 174261991Sdim // ============================== 175261991Sdim // 176261991Sdim // Both Itanium and MSVC ABIs have destructor variants. The variant names 177261991Sdim // roughly correspond in the following way: 178261991Sdim // Itanium Microsoft 179261991Sdim // Base -> no name, just ~Class 180261991Sdim // Complete -> vbase destructor 181261991Sdim // Deleting -> scalar deleting destructor 182261991Sdim // vector deleting destructor 183261991Sdim // 184261991Sdim // The base and complete destructors are the same as in Itanium, although the 185261991Sdim // complete destructor does not accept a VTT parameter when there are virtual 186261991Sdim // bases. A separate mechanism involving vtordisps is used to ensure that 187261991Sdim // virtual methods of destroyed subobjects are not called. 188261991Sdim // 189261991Sdim // The deleting destructors accept an i32 bitfield as a second parameter. Bit 190261991Sdim // 1 indicates if the memory should be deleted. Bit 2 indicates if the this 191261991Sdim // pointer points to an array. The scalar deleting destructor assumes that 192261991Sdim // bit 2 is zero, and therefore does not contain a loop. 193261991Sdim // 194261991Sdim // For virtual destructors, only one entry is reserved in the vftable, and it 195261991Sdim // always points to the vector deleting destructor. The vector deleting 196261991Sdim // destructor is the most general, so it can be used to destroy objects in 197261991Sdim // place, delete single heap objects, or delete arrays. 198261991Sdim // 199261991Sdim // A TU defining a non-inline destructor is only guaranteed to emit a base 200261991Sdim // destructor, and all of the other variants are emitted on an as-needed basis 201261991Sdim // in COMDATs. Because a non-base destructor can be emitted in a TU that 202261991Sdim // lacks a definition for the destructor, non-base destructors must always 203261991Sdim // delegate to or alias the base destructor. 204261991Sdim 205280031Sdim void buildStructorSignature(const CXXMethodDecl *MD, StructorType T, 206280031Sdim SmallVectorImpl<CanQualType> &ArgTys) override; 207212904Sdim 208261991Sdim /// Non-base dtors should be emitted as delegating thunks in this ABI. 209261991Sdim bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor, 210276479Sdim CXXDtorType DT) const override { 211261991Sdim return DT != Dtor_Base; 212261991Sdim } 213261991Sdim 214276479Sdim void EmitCXXDestructors(const CXXDestructorDecl *D) override; 215261991Sdim 216276479Sdim const CXXRecordDecl * 217276479Sdim getThisArgumentTypeForMethod(const CXXMethodDecl *MD) override { 218261991Sdim MD = MD->getCanonicalDecl(); 219261991Sdim if (MD->isVirtual() && !isa<CXXDestructorDecl>(MD)) { 220261991Sdim MicrosoftVTableContext::MethodVFTableLocation ML = 221261991Sdim CGM.getMicrosoftVTableContext().getMethodVFTableLocation(MD); 222261991Sdim // The vbases might be ordered differently in the final overrider object 223261991Sdim // and the complete object, so the "this" argument may sometimes point to 224261991Sdim // memory that has no particular type (e.g. past the complete object). 225261991Sdim // In this case, we just use a generic pointer type. 226261991Sdim // FIXME: might want to have a more precise type in the non-virtual 227261991Sdim // multiple inheritance case. 228261991Sdim if (ML.VBase || !ML.VFPtrOffset.isZero()) 229276479Sdim return nullptr; 230261991Sdim } 231261991Sdim return MD->getParent(); 232261991Sdim } 233261991Sdim 234296417Sdim Address 235276479Sdim adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD, 236296417Sdim Address This, 237276479Sdim bool VirtualCall) override; 238261991Sdim 239276479Sdim void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, 240276479Sdim FunctionArgList &Params) override; 241212904Sdim 242261991Sdim llvm::Value *adjustThisParameterInVirtualFunctionPrologue( 243276479Sdim CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) override; 244261991Sdim 245276479Sdim void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override; 246218893Sdim 247276479Sdim unsigned addImplicitConstructorArgs(CodeGenFunction &CGF, 248276479Sdim const CXXConstructorDecl *D, 249276479Sdim CXXCtorType Type, bool ForVirtualBase, 250276479Sdim bool Delegating, 251276479Sdim CallArgList &Args) override; 252249423Sdim 253276479Sdim void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD, 254276479Sdim CXXDtorType Type, bool ForVirtualBase, 255296417Sdim bool Delegating, Address This) override; 256249423Sdim 257288943Sdim void emitVTableBitSetEntries(VPtrInfo *Info, const CXXRecordDecl *RD, 258288943Sdim llvm::GlobalVariable *VTable); 259288943Sdim 260276479Sdim void emitVTableDefinitions(CodeGenVTables &CGVT, 261276479Sdim const CXXRecordDecl *RD) override; 262276479Sdim 263296417Sdim bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF, 264296417Sdim CodeGenFunction::VPtr Vptr) override; 265296417Sdim 266296417Sdim /// Don't initialize vptrs if dynamic class 267296417Sdim /// is marked with with the 'novtable' attribute. 268296417Sdim bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override { 269296417Sdim return !VTableClass->hasAttr<MSNoVTableAttr>(); 270296417Sdim } 271296417Sdim 272296417Sdim llvm::Constant * 273296417Sdim getVTableAddressPoint(BaseSubobject Base, 274296417Sdim const CXXRecordDecl *VTableClass) override; 275296417Sdim 276261991Sdim llvm::Value *getVTableAddressPointInStructor( 277261991Sdim CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, 278296417Sdim BaseSubobject Base, const CXXRecordDecl *NearestVBase) override; 279261991Sdim 280261991Sdim llvm::Constant * 281261991Sdim getVTableAddressPointForConstExpr(BaseSubobject Base, 282276479Sdim const CXXRecordDecl *VTableClass) override; 283261991Sdim 284261991Sdim llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD, 285276479Sdim CharUnits VPtrOffset) override; 286261991Sdim 287261991Sdim llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, 288296417Sdim Address This, llvm::Type *Ty, 289288943Sdim SourceLocation Loc) override; 290261991Sdim 291280031Sdim llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF, 292280031Sdim const CXXDestructorDecl *Dtor, 293280031Sdim CXXDtorType DtorType, 294296417Sdim Address This, 295280031Sdim const CXXMemberCallExpr *CE) override; 296261991Sdim 297261991Sdim void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF, GlobalDecl GD, 298276479Sdim CallArgList &CallArgs) override { 299261991Sdim assert(GD.getDtorType() == Dtor_Deleting && 300261991Sdim "Only deleting destructor thunks are available in this ABI"); 301261991Sdim CallArgs.add(RValue::get(getStructorImplicitParamValue(CGF)), 302288943Sdim getContext().IntTy); 303261991Sdim } 304261991Sdim 305276479Sdim void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override; 306261991Sdim 307276479Sdim llvm::GlobalVariable * 308276479Sdim getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD, 309276479Sdim llvm::GlobalVariable::LinkageTypes Linkage); 310276479Sdim 311288943Sdim llvm::GlobalVariable * 312288943Sdim getAddrOfVirtualDisplacementMap(const CXXRecordDecl *SrcRD, 313288943Sdim const CXXRecordDecl *DstRD) { 314288943Sdim SmallString<256> OutName; 315288943Sdim llvm::raw_svector_ostream Out(OutName); 316288943Sdim getMangleContext().mangleCXXVirtualDisplacementMap(SrcRD, DstRD, Out); 317288943Sdim StringRef MangledName = OutName.str(); 318288943Sdim 319288943Sdim if (auto *VDispMap = CGM.getModule().getNamedGlobal(MangledName)) 320288943Sdim return VDispMap; 321288943Sdim 322288943Sdim MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext(); 323288943Sdim unsigned NumEntries = 1 + SrcRD->getNumVBases(); 324288943Sdim SmallVector<llvm::Constant *, 4> Map(NumEntries, 325288943Sdim llvm::UndefValue::get(CGM.IntTy)); 326288943Sdim Map[0] = llvm::ConstantInt::get(CGM.IntTy, 0); 327288943Sdim bool AnyDifferent = false; 328288943Sdim for (const auto &I : SrcRD->vbases()) { 329288943Sdim const CXXRecordDecl *VBase = I.getType()->getAsCXXRecordDecl(); 330288943Sdim if (!DstRD->isVirtuallyDerivedFrom(VBase)) 331288943Sdim continue; 332288943Sdim 333288943Sdim unsigned SrcVBIndex = VTContext.getVBTableIndex(SrcRD, VBase); 334288943Sdim unsigned DstVBIndex = VTContext.getVBTableIndex(DstRD, VBase); 335288943Sdim Map[SrcVBIndex] = llvm::ConstantInt::get(CGM.IntTy, DstVBIndex * 4); 336288943Sdim AnyDifferent |= SrcVBIndex != DstVBIndex; 337288943Sdim } 338288943Sdim // This map would be useless, don't use it. 339288943Sdim if (!AnyDifferent) 340288943Sdim return nullptr; 341288943Sdim 342288943Sdim llvm::ArrayType *VDispMapTy = llvm::ArrayType::get(CGM.IntTy, Map.size()); 343288943Sdim llvm::Constant *Init = llvm::ConstantArray::get(VDispMapTy, Map); 344288943Sdim llvm::GlobalValue::LinkageTypes Linkage = 345288943Sdim SrcRD->isExternallyVisible() && DstRD->isExternallyVisible() 346288943Sdim ? llvm::GlobalValue::LinkOnceODRLinkage 347288943Sdim : llvm::GlobalValue::InternalLinkage; 348288943Sdim auto *VDispMap = new llvm::GlobalVariable( 349288943Sdim CGM.getModule(), VDispMapTy, /*Constant=*/true, Linkage, 350288943Sdim /*Initializer=*/Init, MangledName); 351288943Sdim return VDispMap; 352288943Sdim } 353288943Sdim 354276479Sdim void emitVBTableDefinition(const VPtrInfo &VBT, const CXXRecordDecl *RD, 355276479Sdim llvm::GlobalVariable *GV) const; 356276479Sdim 357276479Sdim void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, 358276479Sdim GlobalDecl GD, bool ReturnAdjustment) override { 359276479Sdim // Never dllimport/dllexport thunks. 360276479Sdim Thunk->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); 361276479Sdim 362276479Sdim GVALinkage Linkage = 363276479Sdim getContext().GetGVALinkageForFunction(cast<FunctionDecl>(GD.getDecl())); 364276479Sdim 365276479Sdim if (Linkage == GVA_Internal) 366276479Sdim Thunk->setLinkage(llvm::GlobalValue::InternalLinkage); 367276479Sdim else if (ReturnAdjustment) 368276479Sdim Thunk->setLinkage(llvm::GlobalValue::WeakODRLinkage); 369276479Sdim else 370276479Sdim Thunk->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage); 371261991Sdim } 372261991Sdim 373296417Sdim llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This, 374276479Sdim const ThisAdjustment &TA) override; 375261991Sdim 376296417Sdim llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret, 377276479Sdim const ReturnAdjustment &RA) override; 378261991Sdim 379280031Sdim void EmitThreadLocalInitFuncs( 380296417Sdim CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals, 381280031Sdim ArrayRef<llvm::Function *> CXXThreadLocalInits, 382296417Sdim ArrayRef<const VarDecl *> CXXThreadLocalInitVars) override; 383280031Sdim 384280031Sdim bool usesThreadWrapperFunction() const override { return false; } 385280031Sdim LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD, 386280031Sdim QualType LValType) override; 387280031Sdim 388239462Sdim void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, 389239462Sdim llvm::GlobalVariable *DeclPtr, 390276479Sdim bool PerformInit) override; 391280031Sdim void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D, 392280031Sdim llvm::Constant *Dtor, llvm::Constant *Addr) override; 393239462Sdim 394218893Sdim // ==== Notes on array cookies ========= 395218893Sdim // 396218893Sdim // MSVC seems to only use cookies when the class has a destructor; a 397218893Sdim // two-argument usual array deallocation function isn't sufficient. 398218893Sdim // 399218893Sdim // For example, this code prints "100" and "1": 400218893Sdim // struct A { 401218893Sdim // char x; 402218893Sdim // void *operator new[](size_t sz) { 403218893Sdim // printf("%u\n", sz); 404218893Sdim // return malloc(sz); 405218893Sdim // } 406218893Sdim // void operator delete[](void *p, size_t sz) { 407218893Sdim // printf("%u\n", sz); 408218893Sdim // free(p); 409218893Sdim // } 410218893Sdim // }; 411218893Sdim // int main() { 412218893Sdim // A *p = new A[100]; 413218893Sdim // delete[] p; 414218893Sdim // } 415218893Sdim // Whereas it prints "104" and "104" if you give A a destructor. 416239462Sdim 417276479Sdim bool requiresArrayCookie(const CXXDeleteExpr *expr, 418276479Sdim QualType elementType) override; 419276479Sdim bool requiresArrayCookie(const CXXNewExpr *expr) override; 420276479Sdim CharUnits getArrayCookieSizeImpl(QualType type) override; 421296417Sdim Address InitializeArrayCookie(CodeGenFunction &CGF, 422296417Sdim Address NewPtr, 423296417Sdim llvm::Value *NumElements, 424296417Sdim const CXXNewExpr *expr, 425296417Sdim QualType ElementType) override; 426239462Sdim llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, 427296417Sdim Address allocPtr, 428276479Sdim CharUnits cookieSize) override; 429249423Sdim 430276479Sdim friend struct MSRTTIBuilder; 431276479Sdim 432276479Sdim bool isImageRelative() const { 433276479Sdim return CGM.getTarget().getPointerWidth(/*AddressSpace=*/0) == 64; 434276479Sdim } 435276479Sdim 436276479Sdim // 5 routines for constructing the llvm types for MS RTTI structs. 437276479Sdim llvm::StructType *getTypeDescriptorType(StringRef TypeInfoString) { 438276479Sdim llvm::SmallString<32> TDTypeName("rtti.TypeDescriptor"); 439276479Sdim TDTypeName += llvm::utostr(TypeInfoString.size()); 440276479Sdim llvm::StructType *&TypeDescriptorType = 441276479Sdim TypeDescriptorTypeMap[TypeInfoString.size()]; 442276479Sdim if (TypeDescriptorType) 443276479Sdim return TypeDescriptorType; 444276479Sdim llvm::Type *FieldTypes[] = { 445276479Sdim CGM.Int8PtrPtrTy, 446276479Sdim CGM.Int8PtrTy, 447276479Sdim llvm::ArrayType::get(CGM.Int8Ty, TypeInfoString.size() + 1)}; 448276479Sdim TypeDescriptorType = 449276479Sdim llvm::StructType::create(CGM.getLLVMContext(), FieldTypes, TDTypeName); 450276479Sdim return TypeDescriptorType; 451276479Sdim } 452276479Sdim 453276479Sdim llvm::Type *getImageRelativeType(llvm::Type *PtrType) { 454276479Sdim if (!isImageRelative()) 455276479Sdim return PtrType; 456276479Sdim return CGM.IntTy; 457276479Sdim } 458276479Sdim 459276479Sdim llvm::StructType *getBaseClassDescriptorType() { 460276479Sdim if (BaseClassDescriptorType) 461276479Sdim return BaseClassDescriptorType; 462276479Sdim llvm::Type *FieldTypes[] = { 463276479Sdim getImageRelativeType(CGM.Int8PtrTy), 464276479Sdim CGM.IntTy, 465276479Sdim CGM.IntTy, 466276479Sdim CGM.IntTy, 467276479Sdim CGM.IntTy, 468276479Sdim CGM.IntTy, 469276479Sdim getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()), 470276479Sdim }; 471276479Sdim BaseClassDescriptorType = llvm::StructType::create( 472276479Sdim CGM.getLLVMContext(), FieldTypes, "rtti.BaseClassDescriptor"); 473276479Sdim return BaseClassDescriptorType; 474276479Sdim } 475276479Sdim 476276479Sdim llvm::StructType *getClassHierarchyDescriptorType() { 477276479Sdim if (ClassHierarchyDescriptorType) 478276479Sdim return ClassHierarchyDescriptorType; 479276479Sdim // Forward-declare RTTIClassHierarchyDescriptor to break a cycle. 480276479Sdim ClassHierarchyDescriptorType = llvm::StructType::create( 481276479Sdim CGM.getLLVMContext(), "rtti.ClassHierarchyDescriptor"); 482276479Sdim llvm::Type *FieldTypes[] = { 483276479Sdim CGM.IntTy, 484276479Sdim CGM.IntTy, 485276479Sdim CGM.IntTy, 486276479Sdim getImageRelativeType( 487276479Sdim getBaseClassDescriptorType()->getPointerTo()->getPointerTo()), 488276479Sdim }; 489276479Sdim ClassHierarchyDescriptorType->setBody(FieldTypes); 490276479Sdim return ClassHierarchyDescriptorType; 491276479Sdim } 492276479Sdim 493276479Sdim llvm::StructType *getCompleteObjectLocatorType() { 494276479Sdim if (CompleteObjectLocatorType) 495276479Sdim return CompleteObjectLocatorType; 496276479Sdim CompleteObjectLocatorType = llvm::StructType::create( 497276479Sdim CGM.getLLVMContext(), "rtti.CompleteObjectLocator"); 498276479Sdim llvm::Type *FieldTypes[] = { 499276479Sdim CGM.IntTy, 500276479Sdim CGM.IntTy, 501276479Sdim CGM.IntTy, 502276479Sdim getImageRelativeType(CGM.Int8PtrTy), 503276479Sdim getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()), 504276479Sdim getImageRelativeType(CompleteObjectLocatorType), 505276479Sdim }; 506276479Sdim llvm::ArrayRef<llvm::Type *> FieldTypesRef(FieldTypes); 507276479Sdim if (!isImageRelative()) 508276479Sdim FieldTypesRef = FieldTypesRef.drop_back(); 509276479Sdim CompleteObjectLocatorType->setBody(FieldTypesRef); 510276479Sdim return CompleteObjectLocatorType; 511276479Sdim } 512276479Sdim 513276479Sdim llvm::GlobalVariable *getImageBase() { 514276479Sdim StringRef Name = "__ImageBase"; 515276479Sdim if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name)) 516276479Sdim return GV; 517276479Sdim 518276479Sdim return new llvm::GlobalVariable(CGM.getModule(), CGM.Int8Ty, 519276479Sdim /*isConstant=*/true, 520276479Sdim llvm::GlobalValue::ExternalLinkage, 521276479Sdim /*Initializer=*/nullptr, Name); 522276479Sdim } 523276479Sdim 524276479Sdim llvm::Constant *getImageRelativeConstant(llvm::Constant *PtrVal) { 525276479Sdim if (!isImageRelative()) 526276479Sdim return PtrVal; 527276479Sdim 528288943Sdim if (PtrVal->isNullValue()) 529288943Sdim return llvm::Constant::getNullValue(CGM.IntTy); 530288943Sdim 531276479Sdim llvm::Constant *ImageBaseAsInt = 532276479Sdim llvm::ConstantExpr::getPtrToInt(getImageBase(), CGM.IntPtrTy); 533276479Sdim llvm::Constant *PtrValAsInt = 534276479Sdim llvm::ConstantExpr::getPtrToInt(PtrVal, CGM.IntPtrTy); 535276479Sdim llvm::Constant *Diff = 536276479Sdim llvm::ConstantExpr::getSub(PtrValAsInt, ImageBaseAsInt, 537276479Sdim /*HasNUW=*/true, /*HasNSW=*/true); 538276479Sdim return llvm::ConstantExpr::getTrunc(Diff, CGM.IntTy); 539276479Sdim } 540276479Sdim 541249423Sdimprivate: 542261991Sdim MicrosoftMangleContext &getMangleContext() { 543261991Sdim return cast<MicrosoftMangleContext>(CodeGen::CGCXXABI::getMangleContext()); 544261991Sdim } 545261991Sdim 546251662Sdim llvm::Constant *getZeroInt() { 547251662Sdim return llvm::ConstantInt::get(CGM.IntTy, 0); 548249423Sdim } 549249423Sdim 550251662Sdim llvm::Constant *getAllOnesInt() { 551251662Sdim return llvm::Constant::getAllOnesValue(CGM.IntTy); 552249423Sdim } 553249423Sdim 554276479Sdim CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD); 555276479Sdim 556251662Sdim void 557251662Sdim GetNullMemberPointerFields(const MemberPointerType *MPT, 558251662Sdim llvm::SmallVectorImpl<llvm::Constant *> &fields); 559251662Sdim 560261991Sdim /// \brief Shared code for virtual base adjustment. Returns the offset from 561261991Sdim /// the vbptr to the virtual base. Optionally returns the address of the 562261991Sdim /// vbptr itself. 563261991Sdim llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF, 564296417Sdim Address Base, 565261991Sdim llvm::Value *VBPtrOffset, 566261991Sdim llvm::Value *VBTableOffset, 567276479Sdim llvm::Value **VBPtr = nullptr); 568261991Sdim 569261991Sdim llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF, 570296417Sdim Address Base, 571261991Sdim int32_t VBPtrOffset, 572261991Sdim int32_t VBTableOffset, 573276479Sdim llvm::Value **VBPtr = nullptr) { 574280031Sdim assert(VBTableOffset % 4 == 0 && "should be byte offset into table of i32s"); 575261991Sdim llvm::Value *VBPOffset = llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset), 576261991Sdim *VBTOffset = llvm::ConstantInt::get(CGM.IntTy, VBTableOffset); 577261991Sdim return GetVBaseOffsetFromVBPtr(CGF, Base, VBPOffset, VBTOffset, VBPtr); 578261991Sdim } 579261991Sdim 580296417Sdim std::pair<Address, llvm::Value *> 581296417Sdim performBaseAdjustment(CodeGenFunction &CGF, Address Value, 582288943Sdim QualType SrcRecordTy); 583288943Sdim 584261991Sdim /// \brief Performs a full virtual base adjustment. Used to dereference 585261991Sdim /// pointers to members of virtual bases. 586276479Sdim llvm::Value *AdjustVirtualBase(CodeGenFunction &CGF, const Expr *E, 587296417Sdim const CXXRecordDecl *RD, Address Base, 588251662Sdim llvm::Value *VirtualBaseAdjustmentOffset, 589251662Sdim llvm::Value *VBPtrOffset /* optional */); 590251662Sdim 591251662Sdim /// \brief Emits a full member pointer with the fields common to data and 592251662Sdim /// function member pointers. 593251662Sdim llvm::Constant *EmitFullMemberPointer(llvm::Constant *FirstField, 594251662Sdim bool IsMemberFunction, 595261991Sdim const CXXRecordDecl *RD, 596288943Sdim CharUnits NonVirtualBaseAdjustment, 597288943Sdim unsigned VBTableIndex); 598251662Sdim 599261991Sdim bool MemberPointerConstantIsNull(const MemberPointerType *MPT, 600261991Sdim llvm::Constant *MP); 601261991Sdim 602261991Sdim /// \brief - Initialize all vbptrs of 'this' with RD as the complete type. 603261991Sdim void EmitVBPtrStores(CodeGenFunction &CGF, const CXXRecordDecl *RD); 604261991Sdim 605261991Sdim /// \brief Caching wrapper around VBTableBuilder::enumerateVBTables(). 606276479Sdim const VBTableGlobals &enumerateVBTables(const CXXRecordDecl *RD); 607261991Sdim 608261991Sdim /// \brief Generate a thunk for calling a virtual member function MD. 609276479Sdim llvm::Function *EmitVirtualMemPtrThunk( 610276479Sdim const CXXMethodDecl *MD, 611276479Sdim const MicrosoftVTableContext::MethodVFTableLocation &ML); 612261991Sdim 613249423Sdimpublic: 614276479Sdim llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override; 615251662Sdim 616276479Sdim bool isZeroInitializable(const MemberPointerType *MPT) override; 617251662Sdim 618280031Sdim bool isMemberPointerConvertible(const MemberPointerType *MPT) const override { 619280031Sdim const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 620280031Sdim return RD->hasAttr<MSInheritanceAttr>(); 621280031Sdim } 622280031Sdim 623276479Sdim llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override; 624249423Sdim 625276479Sdim llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT, 626276479Sdim CharUnits offset) override; 627288943Sdim llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override; 628276479Sdim llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override; 629249423Sdim 630276479Sdim llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF, 631276479Sdim llvm::Value *L, 632276479Sdim llvm::Value *R, 633276479Sdim const MemberPointerType *MPT, 634276479Sdim bool Inequality) override; 635251662Sdim 636276479Sdim llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF, 637276479Sdim llvm::Value *MemPtr, 638276479Sdim const MemberPointerType *MPT) override; 639249423Sdim 640276479Sdim llvm::Value * 641276479Sdim EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E, 642296417Sdim Address Base, llvm::Value *MemPtr, 643276479Sdim const MemberPointerType *MPT) override; 644249423Sdim 645288943Sdim llvm::Value *EmitNonNullMemberPointerConversion( 646288943Sdim const MemberPointerType *SrcTy, const MemberPointerType *DstTy, 647288943Sdim CastKind CK, CastExpr::path_const_iterator PathBegin, 648288943Sdim CastExpr::path_const_iterator PathEnd, llvm::Value *Src, 649288943Sdim CGBuilderTy &Builder); 650288943Sdim 651276479Sdim llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF, 652276479Sdim const CastExpr *E, 653276479Sdim llvm::Value *Src) override; 654261991Sdim 655276479Sdim llvm::Constant *EmitMemberPointerConversion(const CastExpr *E, 656276479Sdim llvm::Constant *Src) override; 657261991Sdim 658288943Sdim llvm::Constant *EmitMemberPointerConversion( 659288943Sdim const MemberPointerType *SrcTy, const MemberPointerType *DstTy, 660288943Sdim CastKind CK, CastExpr::path_const_iterator PathBegin, 661288943Sdim CastExpr::path_const_iterator PathEnd, llvm::Constant *Src); 662288943Sdim 663276479Sdim llvm::Value * 664276479Sdim EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E, 665296417Sdim Address This, llvm::Value *&ThisPtrForCall, 666296417Sdim llvm::Value *MemPtr, 667276479Sdim const MemberPointerType *MPT) override; 668251662Sdim 669280031Sdim void emitCXXStructor(const CXXMethodDecl *MD, StructorType Type) override; 670280031Sdim 671288943Sdim llvm::StructType *getCatchableTypeType() { 672288943Sdim if (CatchableTypeType) 673288943Sdim return CatchableTypeType; 674288943Sdim llvm::Type *FieldTypes[] = { 675288943Sdim CGM.IntTy, // Flags 676288943Sdim getImageRelativeType(CGM.Int8PtrTy), // TypeDescriptor 677288943Sdim CGM.IntTy, // NonVirtualAdjustment 678288943Sdim CGM.IntTy, // OffsetToVBPtr 679288943Sdim CGM.IntTy, // VBTableIndex 680288943Sdim CGM.IntTy, // Size 681288943Sdim getImageRelativeType(CGM.Int8PtrTy) // CopyCtor 682288943Sdim }; 683288943Sdim CatchableTypeType = llvm::StructType::create( 684288943Sdim CGM.getLLVMContext(), FieldTypes, "eh.CatchableType"); 685288943Sdim return CatchableTypeType; 686288943Sdim } 687288943Sdim 688288943Sdim llvm::StructType *getCatchableTypeArrayType(uint32_t NumEntries) { 689288943Sdim llvm::StructType *&CatchableTypeArrayType = 690288943Sdim CatchableTypeArrayTypeMap[NumEntries]; 691288943Sdim if (CatchableTypeArrayType) 692288943Sdim return CatchableTypeArrayType; 693288943Sdim 694288943Sdim llvm::SmallString<23> CTATypeName("eh.CatchableTypeArray."); 695288943Sdim CTATypeName += llvm::utostr(NumEntries); 696288943Sdim llvm::Type *CTType = 697288943Sdim getImageRelativeType(getCatchableTypeType()->getPointerTo()); 698288943Sdim llvm::Type *FieldTypes[] = { 699288943Sdim CGM.IntTy, // NumEntries 700288943Sdim llvm::ArrayType::get(CTType, NumEntries) // CatchableTypes 701288943Sdim }; 702288943Sdim CatchableTypeArrayType = 703288943Sdim llvm::StructType::create(CGM.getLLVMContext(), FieldTypes, CTATypeName); 704288943Sdim return CatchableTypeArrayType; 705288943Sdim } 706288943Sdim 707288943Sdim llvm::StructType *getThrowInfoType() { 708288943Sdim if (ThrowInfoType) 709288943Sdim return ThrowInfoType; 710288943Sdim llvm::Type *FieldTypes[] = { 711288943Sdim CGM.IntTy, // Flags 712288943Sdim getImageRelativeType(CGM.Int8PtrTy), // CleanupFn 713288943Sdim getImageRelativeType(CGM.Int8PtrTy), // ForwardCompat 714288943Sdim getImageRelativeType(CGM.Int8PtrTy) // CatchableTypeArray 715288943Sdim }; 716288943Sdim ThrowInfoType = llvm::StructType::create(CGM.getLLVMContext(), FieldTypes, 717288943Sdim "eh.ThrowInfo"); 718288943Sdim return ThrowInfoType; 719288943Sdim } 720288943Sdim 721288943Sdim llvm::Constant *getThrowFn() { 722288943Sdim // _CxxThrowException is passed an exception object and a ThrowInfo object 723288943Sdim // which describes the exception. 724288943Sdim llvm::Type *Args[] = {CGM.Int8PtrTy, getThrowInfoType()->getPointerTo()}; 725288943Sdim llvm::FunctionType *FTy = 726288943Sdim llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false); 727288943Sdim auto *Fn = cast<llvm::Function>( 728288943Sdim CGM.CreateRuntimeFunction(FTy, "_CxxThrowException")); 729288943Sdim // _CxxThrowException is stdcall on 32-bit x86 platforms. 730288943Sdim if (CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) 731288943Sdim Fn->setCallingConv(llvm::CallingConv::X86_StdCall); 732288943Sdim return Fn; 733288943Sdim } 734288943Sdim 735288943Sdim llvm::Function *getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD, 736288943Sdim CXXCtorType CT); 737288943Sdim 738288943Sdim llvm::Constant *getCatchableType(QualType T, 739288943Sdim uint32_t NVOffset = 0, 740288943Sdim int32_t VBPtrOffset = -1, 741288943Sdim uint32_t VBIndex = 0); 742288943Sdim 743288943Sdim llvm::GlobalVariable *getCatchableTypeArray(QualType T); 744288943Sdim 745288943Sdim llvm::GlobalVariable *getThrowInfo(QualType T) override; 746288943Sdim 747261991Sdimprivate: 748261991Sdim typedef std::pair<const CXXRecordDecl *, CharUnits> VFTableIdTy; 749276479Sdim typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalVariable *> VTablesMapTy; 750276479Sdim typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalValue *> VFTablesMapTy; 751261991Sdim /// \brief All the vftables that have been referenced. 752261991Sdim VFTablesMapTy VFTablesMap; 753276479Sdim VTablesMapTy VTablesMap; 754261991Sdim 755261991Sdim /// \brief This set holds the record decls we've deferred vtable emission for. 756261991Sdim llvm::SmallPtrSet<const CXXRecordDecl *, 4> DeferredVFTables; 757261991Sdim 758261991Sdim 759261991Sdim /// \brief All the vbtables which have been referenced. 760276479Sdim llvm::DenseMap<const CXXRecordDecl *, VBTableGlobals> VBTablesMap; 761261991Sdim 762261991Sdim /// Info on the global variable used to guard initialization of static locals. 763261991Sdim /// The BitIndex field is only used for externally invisible declarations. 764261991Sdim struct GuardInfo { 765276479Sdim GuardInfo() : Guard(nullptr), BitIndex(0) {} 766261991Sdim llvm::GlobalVariable *Guard; 767261991Sdim unsigned BitIndex; 768261991Sdim }; 769261991Sdim 770261991Sdim /// Map from DeclContext to the current guard variable. We assume that the 771261991Sdim /// AST is visited in source code order. 772261991Sdim llvm::DenseMap<const DeclContext *, GuardInfo> GuardVariableMap; 773288943Sdim llvm::DenseMap<const DeclContext *, GuardInfo> ThreadLocalGuardVariableMap; 774288943Sdim llvm::DenseMap<const DeclContext *, unsigned> ThreadSafeGuardNumMap; 775276479Sdim 776276479Sdim llvm::DenseMap<size_t, llvm::StructType *> TypeDescriptorTypeMap; 777276479Sdim llvm::StructType *BaseClassDescriptorType; 778276479Sdim llvm::StructType *ClassHierarchyDescriptorType; 779276479Sdim llvm::StructType *CompleteObjectLocatorType; 780288943Sdim 781288943Sdim llvm::DenseMap<QualType, llvm::GlobalVariable *> CatchableTypeArrays; 782288943Sdim 783288943Sdim llvm::StructType *CatchableTypeType; 784288943Sdim llvm::DenseMap<uint32_t, llvm::StructType *> CatchableTypeArrayTypeMap; 785288943Sdim llvm::StructType *ThrowInfoType; 786210008Srdivacky}; 787210008Srdivacky 788210008Srdivacky} 789210008Srdivacky 790276479SdimCGCXXABI::RecordArgABI 791276479SdimMicrosoftCXXABI::getRecordArgABI(const CXXRecordDecl *RD) const { 792276479Sdim switch (CGM.getTarget().getTriple().getArch()) { 793276479Sdim default: 794276479Sdim // FIXME: Implement for other architectures. 795276479Sdim return RAA_Default; 796276479Sdim 797276479Sdim case llvm::Triple::x86: 798276479Sdim // All record arguments are passed in memory on x86. Decide whether to 799276479Sdim // construct the object directly in argument memory, or to construct the 800276479Sdim // argument elsewhere and copy the bytes during the call. 801276479Sdim 802276479Sdim // If C++ prohibits us from making a copy, construct the arguments directly 803276479Sdim // into argument memory. 804276479Sdim if (!canCopyArgument(RD)) 805276479Sdim return RAA_DirectInMemory; 806276479Sdim 807276479Sdim // Otherwise, construct the argument into a temporary and copy the bytes 808276479Sdim // into the outgoing argument memory. 809276479Sdim return RAA_Default; 810276479Sdim 811276479Sdim case llvm::Triple::x86_64: 812276479Sdim // Win64 passes objects with non-trivial copy ctors indirectly. 813276479Sdim if (RD->hasNonTrivialCopyConstructor()) 814276479Sdim return RAA_Indirect; 815276479Sdim 816280031Sdim // If an object has a destructor, we'd really like to pass it indirectly 817280031Sdim // because it allows us to elide copies. Unfortunately, MSVC makes that 818280031Sdim // impossible for small types, which it will pass in a single register or 819280031Sdim // stack slot. Most objects with dtors are large-ish, so handle that early. 820280031Sdim // We can't call out all large objects as being indirect because there are 821280031Sdim // multiple x64 calling conventions and the C++ ABI code shouldn't dictate 822280031Sdim // how we pass large POD types. 823280031Sdim if (RD->hasNonTrivialDestructor() && 824280031Sdim getContext().getTypeSize(RD->getTypeForDecl()) > 64) 825276479Sdim return RAA_Indirect; 826276479Sdim 827276479Sdim // We have a trivial copy constructor or no copy constructors, but we have 828276479Sdim // to make sure it isn't deleted. 829276479Sdim bool CopyDeleted = false; 830276479Sdim for (const CXXConstructorDecl *CD : RD->ctors()) { 831276479Sdim if (CD->isCopyConstructor()) { 832276479Sdim assert(CD->isTrivial()); 833276479Sdim // We had at least one undeleted trivial copy ctor. Return directly. 834276479Sdim if (!CD->isDeleted()) 835276479Sdim return RAA_Default; 836276479Sdim CopyDeleted = true; 837276479Sdim } 838276479Sdim } 839276479Sdim 840276479Sdim // The trivial copy constructor was deleted. Return indirectly. 841276479Sdim if (CopyDeleted) 842276479Sdim return RAA_Indirect; 843276479Sdim 844276479Sdim // There were no copy ctors. Return in RAX. 845276479Sdim return RAA_Default; 846276479Sdim } 847276479Sdim 848276479Sdim llvm_unreachable("invalid enum"); 849276479Sdim} 850276479Sdim 851280031Sdimvoid MicrosoftCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF, 852280031Sdim const CXXDeleteExpr *DE, 853296417Sdim Address Ptr, 854280031Sdim QualType ElementType, 855280031Sdim const CXXDestructorDecl *Dtor) { 856280031Sdim // FIXME: Provide a source location here even though there's no 857280031Sdim // CXXMemberCallExpr for dtor call. 858280031Sdim bool UseGlobalDelete = DE->isGlobalDelete(); 859280031Sdim CXXDtorType DtorType = UseGlobalDelete ? Dtor_Complete : Dtor_Deleting; 860280031Sdim llvm::Value *MDThis = 861280031Sdim EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, /*CE=*/nullptr); 862280031Sdim if (UseGlobalDelete) 863280031Sdim CGF.EmitDeleteCall(DE->getOperatorDelete(), MDThis, ElementType); 864243830Sdim} 865243830Sdim 866280031Sdimvoid MicrosoftCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) { 867288943Sdim llvm::Value *Args[] = { 868288943Sdim llvm::ConstantPointerNull::get(CGM.Int8PtrTy), 869288943Sdim llvm::ConstantPointerNull::get(getThrowInfoType()->getPointerTo())}; 870288943Sdim auto *Fn = getThrowFn(); 871280031Sdim if (isNoReturn) 872280031Sdim CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, Args); 873280031Sdim else 874280031Sdim CGF.EmitRuntimeCallOrInvoke(Fn, Args); 875280031Sdim} 876280031Sdim 877288943Sdimnamespace { 878296417Sdimstruct CatchRetScope final : EHScopeStack::Cleanup { 879296417Sdim llvm::CatchPadInst *CPI; 880296417Sdim 881296417Sdim CatchRetScope(llvm::CatchPadInst *CPI) : CPI(CPI) {} 882296417Sdim 883288943Sdim void Emit(CodeGenFunction &CGF, Flags flags) override { 884296417Sdim llvm::BasicBlock *BB = CGF.createBasicBlock("catchret.dest"); 885296417Sdim CGF.Builder.CreateCatchRet(CPI, BB); 886296417Sdim CGF.EmitBlock(BB); 887288943Sdim } 888288943Sdim}; 889243830Sdim} 890243830Sdim 891288943Sdimvoid MicrosoftCXXABI::emitBeginCatch(CodeGenFunction &CGF, 892288943Sdim const CXXCatchStmt *S) { 893288943Sdim // In the MS ABI, the runtime handles the copy, and the catch handler is 894288943Sdim // responsible for destruction. 895288943Sdim VarDecl *CatchParam = S->getExceptionDecl(); 896296417Sdim llvm::BasicBlock *CatchPadBB = CGF.Builder.GetInsertBlock(); 897296417Sdim llvm::CatchPadInst *CPI = 898296417Sdim cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHI()); 899296417Sdim CGF.CurrentFuncletPad = CPI; 900288943Sdim 901288943Sdim // If this is a catch-all or the catch parameter is unnamed, we don't need to 902288943Sdim // emit an alloca to the object. 903288943Sdim if (!CatchParam || !CatchParam->getDeclName()) { 904296417Sdim CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI); 905288943Sdim return; 906288943Sdim } 907288943Sdim 908288943Sdim CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam); 909296417Sdim CPI->setArgOperand(2, var.getObjectAddress(CGF).getPointer()); 910296417Sdim CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI); 911288943Sdim CGF.EmitAutoVarCleanups(var); 912288943Sdim} 913288943Sdim 914296417Sdim/// We need to perform a generic polymorphic operation (like a typeid 915296417Sdim/// or a cast), which requires an object with a vfptr. Adjust the 916296417Sdim/// address to point to an object with a vfptr. 917296417Sdimstd::pair<Address, llvm::Value *> 918296417SdimMicrosoftCXXABI::performBaseAdjustment(CodeGenFunction &CGF, Address Value, 919288943Sdim QualType SrcRecordTy) { 920276479Sdim Value = CGF.Builder.CreateBitCast(Value, CGF.Int8PtrTy); 921276479Sdim const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl(); 922288943Sdim const ASTContext &Context = getContext(); 923276479Sdim 924296417Sdim // If the class itself has a vfptr, great. This check implicitly 925296417Sdim // covers non-virtual base subobjects: a class with its own virtual 926296417Sdim // functions would be a candidate to be a primary base. 927288943Sdim if (Context.getASTRecordLayout(SrcDecl).hasExtendableVFPtr()) 928276479Sdim return std::make_pair(Value, llvm::ConstantInt::get(CGF.Int32Ty, 0)); 929276479Sdim 930296417Sdim // Okay, one of the vbases must have a vfptr, or else this isn't 931296417Sdim // actually a polymorphic class. 932296417Sdim const CXXRecordDecl *PolymorphicBase = nullptr; 933296417Sdim for (auto &Base : SrcDecl->vbases()) { 934296417Sdim const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); 935296417Sdim if (Context.getASTRecordLayout(BaseDecl).hasExtendableVFPtr()) { 936296417Sdim PolymorphicBase = BaseDecl; 937296417Sdim break; 938296417Sdim } 939296417Sdim } 940296417Sdim assert(PolymorphicBase && "polymorphic class has no apparent vfptr?"); 941296417Sdim 942296417Sdim llvm::Value *Offset = 943296417Sdim GetVirtualBaseClassOffset(CGF, Value, SrcDecl, PolymorphicBase); 944296417Sdim llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP(Value.getPointer(), Offset); 945276479Sdim Offset = CGF.Builder.CreateTrunc(Offset, CGF.Int32Ty); 946296417Sdim CharUnits VBaseAlign = 947296417Sdim CGF.CGM.getVBaseAlignment(Value.getAlignment(), SrcDecl, PolymorphicBase); 948296417Sdim return std::make_pair(Address(Ptr, VBaseAlign), Offset); 949261991Sdim} 950261991Sdim 951276479Sdimbool MicrosoftCXXABI::shouldTypeidBeNullChecked(bool IsDeref, 952276479Sdim QualType SrcRecordTy) { 953276479Sdim const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl(); 954276479Sdim return IsDeref && 955288943Sdim !getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr(); 956276479Sdim} 957276479Sdim 958276479Sdimstatic llvm::CallSite emitRTtypeidCall(CodeGenFunction &CGF, 959276479Sdim llvm::Value *Argument) { 960276479Sdim llvm::Type *ArgTypes[] = {CGF.Int8PtrTy}; 961276479Sdim llvm::FunctionType *FTy = 962276479Sdim llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false); 963276479Sdim llvm::Value *Args[] = {Argument}; 964276479Sdim llvm::Constant *Fn = CGF.CGM.CreateRuntimeFunction(FTy, "__RTtypeid"); 965276479Sdim return CGF.EmitRuntimeCallOrInvoke(Fn, Args); 966276479Sdim} 967276479Sdim 968276479Sdimvoid MicrosoftCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) { 969276479Sdim llvm::CallSite Call = 970276479Sdim emitRTtypeidCall(CGF, llvm::Constant::getNullValue(CGM.VoidPtrTy)); 971276479Sdim Call.setDoesNotReturn(); 972276479Sdim CGF.Builder.CreateUnreachable(); 973276479Sdim} 974276479Sdim 975276479Sdimllvm::Value *MicrosoftCXXABI::EmitTypeid(CodeGenFunction &CGF, 976276479Sdim QualType SrcRecordTy, 977296417Sdim Address ThisPtr, 978276479Sdim llvm::Type *StdTypeInfoPtrTy) { 979276479Sdim llvm::Value *Offset; 980276479Sdim std::tie(ThisPtr, Offset) = performBaseAdjustment(CGF, ThisPtr, SrcRecordTy); 981296417Sdim auto Typeid = emitRTtypeidCall(CGF, ThisPtr.getPointer()).getInstruction(); 982296417Sdim return CGF.Builder.CreateBitCast(Typeid, StdTypeInfoPtrTy); 983276479Sdim} 984276479Sdim 985276479Sdimbool MicrosoftCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr, 986276479Sdim QualType SrcRecordTy) { 987276479Sdim const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl(); 988276479Sdim return SrcIsPtr && 989288943Sdim !getContext().getASTRecordLayout(SrcDecl).hasExtendableVFPtr(); 990276479Sdim} 991276479Sdim 992276479Sdimllvm::Value *MicrosoftCXXABI::EmitDynamicCastCall( 993296417Sdim CodeGenFunction &CGF, Address This, QualType SrcRecordTy, 994276479Sdim QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) { 995276479Sdim llvm::Type *DestLTy = CGF.ConvertType(DestTy); 996276479Sdim 997276479Sdim llvm::Value *SrcRTTI = 998276479Sdim CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType()); 999276479Sdim llvm::Value *DestRTTI = 1000276479Sdim CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType()); 1001276479Sdim 1002276479Sdim llvm::Value *Offset; 1003296417Sdim std::tie(This, Offset) = performBaseAdjustment(CGF, This, SrcRecordTy); 1004296417Sdim llvm::Value *ThisPtr = This.getPointer(); 1005276479Sdim 1006276479Sdim // PVOID __RTDynamicCast( 1007276479Sdim // PVOID inptr, 1008276479Sdim // LONG VfDelta, 1009276479Sdim // PVOID SrcType, 1010276479Sdim // PVOID TargetType, 1011276479Sdim // BOOL isReference) 1012276479Sdim llvm::Type *ArgTypes[] = {CGF.Int8PtrTy, CGF.Int32Ty, CGF.Int8PtrTy, 1013276479Sdim CGF.Int8PtrTy, CGF.Int32Ty}; 1014276479Sdim llvm::Constant *Function = CGF.CGM.CreateRuntimeFunction( 1015276479Sdim llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false), 1016276479Sdim "__RTDynamicCast"); 1017276479Sdim llvm::Value *Args[] = { 1018296417Sdim ThisPtr, Offset, SrcRTTI, DestRTTI, 1019276479Sdim llvm::ConstantInt::get(CGF.Int32Ty, DestTy->isReferenceType())}; 1020296417Sdim ThisPtr = CGF.EmitRuntimeCallOrInvoke(Function, Args).getInstruction(); 1021296417Sdim return CGF.Builder.CreateBitCast(ThisPtr, DestLTy); 1022276479Sdim} 1023276479Sdim 1024261991Sdimllvm::Value * 1025296417SdimMicrosoftCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value, 1026276479Sdim QualType SrcRecordTy, 1027276479Sdim QualType DestTy) { 1028276479Sdim llvm::Value *Offset; 1029276479Sdim std::tie(Value, Offset) = performBaseAdjustment(CGF, Value, SrcRecordTy); 1030276479Sdim 1031276479Sdim // PVOID __RTCastToVoid( 1032276479Sdim // PVOID inptr) 1033276479Sdim llvm::Type *ArgTypes[] = {CGF.Int8PtrTy}; 1034276479Sdim llvm::Constant *Function = CGF.CGM.CreateRuntimeFunction( 1035276479Sdim llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false), 1036276479Sdim "__RTCastToVoid"); 1037296417Sdim llvm::Value *Args[] = {Value.getPointer()}; 1038276479Sdim return CGF.EmitRuntimeCall(Function, Args); 1039276479Sdim} 1040276479Sdim 1041276479Sdimbool MicrosoftCXXABI::EmitBadCastCall(CodeGenFunction &CGF) { 1042276479Sdim return false; 1043276479Sdim} 1044276479Sdim 1045280031Sdimllvm::Value *MicrosoftCXXABI::GetVirtualBaseClassOffset( 1046296417Sdim CodeGenFunction &CGF, Address This, const CXXRecordDecl *ClassDecl, 1047280031Sdim const CXXRecordDecl *BaseClassDecl) { 1048288943Sdim const ASTContext &Context = getContext(); 1049276479Sdim int64_t VBPtrChars = 1050288943Sdim Context.getASTRecordLayout(ClassDecl).getVBPtrOffset().getQuantity(); 1051261991Sdim llvm::Value *VBPtrOffset = llvm::ConstantInt::get(CGM.PtrDiffTy, VBPtrChars); 1052288943Sdim CharUnits IntSize = Context.getTypeSizeInChars(Context.IntTy); 1053261991Sdim CharUnits VBTableChars = 1054261991Sdim IntSize * 1055261991Sdim CGM.getMicrosoftVTableContext().getVBTableIndex(ClassDecl, BaseClassDecl); 1056261991Sdim llvm::Value *VBTableOffset = 1057280031Sdim llvm::ConstantInt::get(CGM.IntTy, VBTableChars.getQuantity()); 1058261991Sdim 1059261991Sdim llvm::Value *VBPtrToNewBase = 1060280031Sdim GetVBaseOffsetFromVBPtr(CGF, This, VBPtrOffset, VBTableOffset); 1061261991Sdim VBPtrToNewBase = 1062280031Sdim CGF.Builder.CreateSExtOrBitCast(VBPtrToNewBase, CGM.PtrDiffTy); 1063261991Sdim return CGF.Builder.CreateNSWAdd(VBPtrOffset, VBPtrToNewBase); 1064261991Sdim} 1065261991Sdim 1066261991Sdimbool MicrosoftCXXABI::HasThisReturn(GlobalDecl GD) const { 1067261991Sdim return isa<CXXConstructorDecl>(GD.getDecl()); 1068261991Sdim} 1069261991Sdim 1070280031Sdimstatic bool isDeletingDtor(GlobalDecl GD) { 1071280031Sdim return isa<CXXDestructorDecl>(GD.getDecl()) && 1072280031Sdim GD.getDtorType() == Dtor_Deleting; 1073280031Sdim} 1074280031Sdim 1075280031Sdimbool MicrosoftCXXABI::hasMostDerivedReturn(GlobalDecl GD) const { 1076280031Sdim return isDeletingDtor(GD); 1077280031Sdim} 1078280031Sdim 1079276479Sdimbool MicrosoftCXXABI::classifyReturnType(CGFunctionInfo &FI) const { 1080276479Sdim const CXXRecordDecl *RD = FI.getReturnType()->getAsCXXRecordDecl(); 1081276479Sdim if (!RD) 1082276479Sdim return false; 1083249423Sdim 1084296417Sdim CharUnits Align = CGM.getContext().getTypeAlignInChars(FI.getReturnType()); 1085276479Sdim if (FI.isInstanceMethod()) { 1086276479Sdim // If it's an instance method, aggregates are always returned indirectly via 1087276479Sdim // the second parameter. 1088296417Sdim FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false); 1089276479Sdim FI.getReturnInfo().setSRetAfterThis(FI.isInstanceMethod()); 1090276479Sdim return true; 1091276479Sdim } else if (!RD->isPOD()) { 1092276479Sdim // If it's a free function, non-POD types are returned indirectly. 1093296417Sdim FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false); 1094276479Sdim return true; 1095276479Sdim } 1096276479Sdim 1097276479Sdim // Otherwise, use the C ABI rules. 1098276479Sdim return false; 1099276479Sdim} 1100276479Sdim 1101261991Sdimllvm::BasicBlock * 1102261991SdimMicrosoftCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, 1103261991Sdim const CXXRecordDecl *RD) { 1104249423Sdim llvm::Value *IsMostDerivedClass = getStructorImplicitParamValue(CGF); 1105249423Sdim assert(IsMostDerivedClass && 1106249423Sdim "ctor for a class with virtual bases must have an implicit parameter"); 1107261991Sdim llvm::Value *IsCompleteObject = 1108261991Sdim CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object"); 1109249423Sdim 1110249423Sdim llvm::BasicBlock *CallVbaseCtorsBB = CGF.createBasicBlock("ctor.init_vbases"); 1111249423Sdim llvm::BasicBlock *SkipVbaseCtorsBB = CGF.createBasicBlock("ctor.skip_vbases"); 1112249423Sdim CGF.Builder.CreateCondBr(IsCompleteObject, 1113249423Sdim CallVbaseCtorsBB, SkipVbaseCtorsBB); 1114249423Sdim 1115249423Sdim CGF.EmitBlock(CallVbaseCtorsBB); 1116249423Sdim 1117261991Sdim // Fill in the vbtable pointers here. 1118261991Sdim EmitVBPtrStores(CGF, RD); 1119261991Sdim 1120249423Sdim // CGF will put the base ctor calls in this basic block for us later. 1121249423Sdim 1122249423Sdim return SkipVbaseCtorsBB; 1123249423Sdim} 1124249423Sdim 1125261991Sdimvoid MicrosoftCXXABI::initializeHiddenVirtualInheritanceMembers( 1126261991Sdim CodeGenFunction &CGF, const CXXRecordDecl *RD) { 1127261991Sdim // In most cases, an override for a vbase virtual method can adjust 1128261991Sdim // the "this" parameter by applying a constant offset. 1129261991Sdim // However, this is not enough while a constructor or a destructor of some 1130261991Sdim // class X is being executed if all the following conditions are met: 1131261991Sdim // - X has virtual bases, (1) 1132261991Sdim // - X overrides a virtual method M of a vbase Y, (2) 1133261991Sdim // - X itself is a vbase of the most derived class. 1134261991Sdim // 1135261991Sdim // If (1) and (2) are true, the vtorDisp for vbase Y is a hidden member of X 1136261991Sdim // which holds the extra amount of "this" adjustment we must do when we use 1137261991Sdim // the X vftables (i.e. during X ctor or dtor). 1138261991Sdim // Outside the ctors and dtors, the values of vtorDisps are zero. 1139261991Sdim 1140261991Sdim const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD); 1141261991Sdim typedef ASTRecordLayout::VBaseOffsetsMapTy VBOffsets; 1142261991Sdim const VBOffsets &VBaseMap = Layout.getVBaseOffsetsMap(); 1143261991Sdim CGBuilderTy &Builder = CGF.Builder; 1144261991Sdim 1145296417Sdim unsigned AS = getThisAddress(CGF).getAddressSpace(); 1146276479Sdim llvm::Value *Int8This = nullptr; // Initialize lazily. 1147261991Sdim 1148261991Sdim for (VBOffsets::const_iterator I = VBaseMap.begin(), E = VBaseMap.end(); 1149261991Sdim I != E; ++I) { 1150261991Sdim if (!I->second.hasVtorDisp()) 1151261991Sdim continue; 1152261991Sdim 1153261991Sdim llvm::Value *VBaseOffset = 1154296417Sdim GetVirtualBaseClassOffset(CGF, getThisAddress(CGF), RD, I->first); 1155261991Sdim // FIXME: it doesn't look right that we SExt in GetVirtualBaseClassOffset() 1156261991Sdim // just to Trunc back immediately. 1157261991Sdim VBaseOffset = Builder.CreateTruncOrBitCast(VBaseOffset, CGF.Int32Ty); 1158261991Sdim uint64_t ConstantVBaseOffset = 1159261991Sdim Layout.getVBaseClassOffset(I->first).getQuantity(); 1160261991Sdim 1161261991Sdim // vtorDisp_for_vbase = vbptr[vbase_idx] - offsetof(RD, vbase). 1162261991Sdim llvm::Value *VtorDispValue = Builder.CreateSub( 1163261991Sdim VBaseOffset, llvm::ConstantInt::get(CGM.Int32Ty, ConstantVBaseOffset), 1164261991Sdim "vtordisp.value"); 1165261991Sdim 1166261991Sdim if (!Int8This) 1167261991Sdim Int8This = Builder.CreateBitCast(getThisValue(CGF), 1168261991Sdim CGF.Int8Ty->getPointerTo(AS)); 1169261991Sdim llvm::Value *VtorDispPtr = Builder.CreateInBoundsGEP(Int8This, VBaseOffset); 1170261991Sdim // vtorDisp is always the 32-bits before the vbase in the class layout. 1171261991Sdim VtorDispPtr = Builder.CreateConstGEP1_32(VtorDispPtr, -4); 1172261991Sdim VtorDispPtr = Builder.CreateBitCast( 1173261991Sdim VtorDispPtr, CGF.Int32Ty->getPointerTo(AS), "vtordisp.ptr"); 1174261991Sdim 1175296417Sdim Builder.CreateAlignedStore(VtorDispValue, VtorDispPtr, 1176296417Sdim CharUnits::fromQuantity(4)); 1177261991Sdim } 1178261991Sdim} 1179261991Sdim 1180288943Sdimstatic bool hasDefaultCXXMethodCC(ASTContext &Context, 1181288943Sdim const CXXMethodDecl *MD) { 1182288943Sdim CallingConv ExpectedCallingConv = Context.getDefaultCallingConvention( 1183288943Sdim /*IsVariadic=*/false, /*IsCXXMethod=*/true); 1184288943Sdim CallingConv ActualCallingConv = 1185288943Sdim MD->getType()->getAs<FunctionProtoType>()->getCallConv(); 1186288943Sdim return ExpectedCallingConv == ActualCallingConv; 1187288943Sdim} 1188288943Sdim 1189261991Sdimvoid MicrosoftCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) { 1190261991Sdim // There's only one constructor type in this ABI. 1191261991Sdim CGM.EmitGlobal(GlobalDecl(D, Ctor_Complete)); 1192288943Sdim 1193288943Sdim // Exported default constructors either have a simple call-site where they use 1194288943Sdim // the typical calling convention and have a single 'this' pointer for an 1195288943Sdim // argument -or- they get a wrapper function which appropriately thunks to the 1196288943Sdim // real default constructor. This thunk is the default constructor closure. 1197288943Sdim if (D->hasAttr<DLLExportAttr>() && D->isDefaultConstructor()) 1198288943Sdim if (!hasDefaultCXXMethodCC(getContext(), D) || D->getNumParams() != 0) { 1199288943Sdim llvm::Function *Fn = getAddrOfCXXCtorClosure(D, Ctor_DefaultClosure); 1200288943Sdim Fn->setLinkage(llvm::GlobalValue::WeakODRLinkage); 1201288943Sdim Fn->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 1202288943Sdim } 1203261991Sdim} 1204261991Sdim 1205261991Sdimvoid MicrosoftCXXABI::EmitVBPtrStores(CodeGenFunction &CGF, 1206261991Sdim const CXXRecordDecl *RD) { 1207296417Sdim Address This = getThisAddress(CGF); 1208296417Sdim This = CGF.Builder.CreateElementBitCast(This, CGM.Int8Ty, "this.int8"); 1209288943Sdim const ASTContext &Context = getContext(); 1210288943Sdim const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD); 1211261991Sdim 1212276479Sdim const VBTableGlobals &VBGlobals = enumerateVBTables(RD); 1213276479Sdim for (unsigned I = 0, E = VBGlobals.VBTables->size(); I != E; ++I) { 1214276479Sdim const VPtrInfo *VBT = (*VBGlobals.VBTables)[I]; 1215276479Sdim llvm::GlobalVariable *GV = VBGlobals.Globals[I]; 1216261991Sdim const ASTRecordLayout &SubobjectLayout = 1217288943Sdim Context.getASTRecordLayout(VBT->BaseWithVPtr); 1218276479Sdim CharUnits Offs = VBT->NonVirtualOffset; 1219276479Sdim Offs += SubobjectLayout.getVBPtrOffset(); 1220276479Sdim if (VBT->getVBaseWithVPtr()) 1221276479Sdim Offs += Layout.getVBaseClassOffset(VBT->getVBaseWithVPtr()); 1222296417Sdim Address VBPtr = CGF.Builder.CreateConstInBoundsByteGEP(This, Offs); 1223288943Sdim llvm::Value *GVPtr = 1224288943Sdim CGF.Builder.CreateConstInBoundsGEP2_32(GV->getValueType(), GV, 0, 0); 1225296417Sdim VBPtr = CGF.Builder.CreateElementBitCast(VBPtr, GVPtr->getType(), 1226276479Sdim "vbptr." + VBT->ReusingBase->getName()); 1227280031Sdim CGF.Builder.CreateStore(GVPtr, VBPtr); 1228261991Sdim } 1229261991Sdim} 1230261991Sdim 1231280031Sdimvoid 1232280031SdimMicrosoftCXXABI::buildStructorSignature(const CXXMethodDecl *MD, StructorType T, 1233249423Sdim SmallVectorImpl<CanQualType> &ArgTys) { 1234249423Sdim // TODO: 'for base' flag 1235280031Sdim if (T == StructorType::Deleting) { 1236261991Sdim // The scalar deleting destructor takes an implicit int parameter. 1237288943Sdim ArgTys.push_back(getContext().IntTy); 1238249423Sdim } 1239280031Sdim auto *CD = dyn_cast<CXXConstructorDecl>(MD); 1240280031Sdim if (!CD) 1241280031Sdim return; 1242280031Sdim 1243280031Sdim // All parameters are already in place except is_most_derived, which goes 1244280031Sdim // after 'this' if it's variadic and last if it's not. 1245280031Sdim 1246280031Sdim const CXXRecordDecl *Class = CD->getParent(); 1247280031Sdim const FunctionProtoType *FPT = CD->getType()->castAs<FunctionProtoType>(); 1248280031Sdim if (Class->getNumVBases()) { 1249280031Sdim if (FPT->isVariadic()) 1250288943Sdim ArgTys.insert(ArgTys.begin() + 1, getContext().IntTy); 1251280031Sdim else 1252288943Sdim ArgTys.push_back(getContext().IntTy); 1253280031Sdim } 1254249423Sdim} 1255249423Sdim 1256261991Sdimvoid MicrosoftCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) { 1257261991Sdim // The TU defining a dtor is only guaranteed to emit a base destructor. All 1258261991Sdim // other destructor variants are delegating thunks. 1259261991Sdim CGM.EmitGlobal(GlobalDecl(D, Dtor_Base)); 1260261991Sdim} 1261261991Sdim 1262276479SdimCharUnits 1263276479SdimMicrosoftCXXABI::getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) { 1264261991Sdim GD = GD.getCanonicalDecl(); 1265261991Sdim const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); 1266261991Sdim 1267261991Sdim GlobalDecl LookupGD = GD; 1268261991Sdim if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) { 1269276479Sdim // Complete destructors take a pointer to the complete object as a 1270276479Sdim // parameter, thus don't need this adjustment. 1271276479Sdim if (GD.getDtorType() == Dtor_Complete) 1272276479Sdim return CharUnits(); 1273276479Sdim 1274276479Sdim // There's no Dtor_Base in vftable but it shares the this adjustment with 1275276479Sdim // the deleting one, so look it up instead. 1276276479Sdim LookupGD = GlobalDecl(DD, Dtor_Deleting); 1277276479Sdim } 1278276479Sdim 1279276479Sdim MicrosoftVTableContext::MethodVFTableLocation ML = 1280276479Sdim CGM.getMicrosoftVTableContext().getMethodVFTableLocation(LookupGD); 1281276479Sdim CharUnits Adjustment = ML.VFPtrOffset; 1282276479Sdim 1283276479Sdim // Normal virtual instance methods need to adjust from the vfptr that first 1284276479Sdim // defined the virtual method to the virtual base subobject, but destructors 1285276479Sdim // do not. The vector deleting destructor thunk applies this adjustment for 1286276479Sdim // us if necessary. 1287276479Sdim if (isa<CXXDestructorDecl>(MD)) 1288276479Sdim Adjustment = CharUnits::Zero(); 1289276479Sdim 1290276479Sdim if (ML.VBase) { 1291276479Sdim const ASTRecordLayout &DerivedLayout = 1292288943Sdim getContext().getASTRecordLayout(MD->getParent()); 1293276479Sdim Adjustment += DerivedLayout.getVBaseClassOffset(ML.VBase); 1294276479Sdim } 1295276479Sdim 1296276479Sdim return Adjustment; 1297276479Sdim} 1298276479Sdim 1299296417SdimAddress MicrosoftCXXABI::adjustThisArgumentForVirtualFunctionCall( 1300296417Sdim CodeGenFunction &CGF, GlobalDecl GD, Address This, 1301296417Sdim bool VirtualCall) { 1302276479Sdim if (!VirtualCall) { 1303276479Sdim // If the call of a virtual function is not virtual, we just have to 1304276479Sdim // compensate for the adjustment the virtual function does in its prologue. 1305276479Sdim CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD); 1306276479Sdim if (Adjustment.isZero()) 1307276479Sdim return This; 1308276479Sdim 1309296417Sdim This = CGF.Builder.CreateElementBitCast(This, CGF.Int8Ty); 1310276479Sdim assert(Adjustment.isPositive()); 1311296417Sdim return CGF.Builder.CreateConstByteGEP(This, Adjustment); 1312276479Sdim } 1313276479Sdim 1314276479Sdim GD = GD.getCanonicalDecl(); 1315276479Sdim const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); 1316276479Sdim 1317276479Sdim GlobalDecl LookupGD = GD; 1318276479Sdim if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) { 1319261991Sdim // Complete dtors take a pointer to the complete object, 1320261991Sdim // thus don't need adjustment. 1321261991Sdim if (GD.getDtorType() == Dtor_Complete) 1322261991Sdim return This; 1323261991Sdim 1324261991Sdim // There's only Dtor_Deleting in vftable but it shares the this adjustment 1325261991Sdim // with the base one, so look up the deleting one instead. 1326261991Sdim LookupGD = GlobalDecl(DD, Dtor_Deleting); 1327261991Sdim } 1328261991Sdim MicrosoftVTableContext::MethodVFTableLocation ML = 1329261991Sdim CGM.getMicrosoftVTableContext().getMethodVFTableLocation(LookupGD); 1330261991Sdim 1331261991Sdim CharUnits StaticOffset = ML.VFPtrOffset; 1332261991Sdim 1333276479Sdim // Base destructors expect 'this' to point to the beginning of the base 1334276479Sdim // subobject, not the first vfptr that happens to contain the virtual dtor. 1335276479Sdim // However, we still need to apply the virtual base adjustment. 1336276479Sdim if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base) 1337276479Sdim StaticOffset = CharUnits::Zero(); 1338261991Sdim 1339296417Sdim Address Result = This; 1340276479Sdim if (ML.VBase) { 1341296417Sdim Result = CGF.Builder.CreateElementBitCast(Result, CGF.Int8Ty); 1342296417Sdim 1343296417Sdim const CXXRecordDecl *Derived = MD->getParent(); 1344296417Sdim const CXXRecordDecl *VBase = ML.VBase; 1345276479Sdim llvm::Value *VBaseOffset = 1346296417Sdim GetVirtualBaseClassOffset(CGF, Result, Derived, VBase); 1347296417Sdim llvm::Value *VBasePtr = 1348296417Sdim CGF.Builder.CreateInBoundsGEP(Result.getPointer(), VBaseOffset); 1349296417Sdim CharUnits VBaseAlign = 1350296417Sdim CGF.CGM.getVBaseAlignment(Result.getAlignment(), Derived, VBase); 1351296417Sdim Result = Address(VBasePtr, VBaseAlign); 1352261991Sdim } 1353261991Sdim if (!StaticOffset.isZero()) { 1354261991Sdim assert(StaticOffset.isPositive()); 1355296417Sdim Result = CGF.Builder.CreateElementBitCast(Result, CGF.Int8Ty); 1356261991Sdim if (ML.VBase) { 1357261991Sdim // Non-virtual adjustment might result in a pointer outside the allocated 1358261991Sdim // object, e.g. if the final overrider class is laid out after the virtual 1359261991Sdim // base that declares a method in the most derived class. 1360261991Sdim // FIXME: Update the code that emits this adjustment in thunks prologues. 1361296417Sdim Result = CGF.Builder.CreateConstByteGEP(Result, StaticOffset); 1362261991Sdim } else { 1363296417Sdim Result = CGF.Builder.CreateConstInBoundsByteGEP(Result, StaticOffset); 1364261991Sdim } 1365261991Sdim } 1366296417Sdim return Result; 1367261991Sdim} 1368261991Sdim 1369276479Sdimvoid MicrosoftCXXABI::addImplicitStructorParams(CodeGenFunction &CGF, 1370276479Sdim QualType &ResTy, 1371276479Sdim FunctionArgList &Params) { 1372249423Sdim ASTContext &Context = getContext(); 1373249423Sdim const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl()); 1374276479Sdim assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)); 1375249423Sdim if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) { 1376249423Sdim ImplicitParamDecl *IsMostDerived 1377276479Sdim = ImplicitParamDecl::Create(Context, nullptr, 1378249423Sdim CGF.CurGD.getDecl()->getLocation(), 1379249423Sdim &Context.Idents.get("is_most_derived"), 1380249423Sdim Context.IntTy); 1381276479Sdim // The 'most_derived' parameter goes second if the ctor is variadic and last 1382276479Sdim // if it's not. Dtors can't be variadic. 1383276479Sdim const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>(); 1384276479Sdim if (FPT->isVariadic()) 1385276479Sdim Params.insert(Params.begin() + 1, IsMostDerived); 1386276479Sdim else 1387276479Sdim Params.push_back(IsMostDerived); 1388249423Sdim getStructorImplicitParamDecl(CGF) = IsMostDerived; 1389280031Sdim } else if (isDeletingDtor(CGF.CurGD)) { 1390249423Sdim ImplicitParamDecl *ShouldDelete 1391276479Sdim = ImplicitParamDecl::Create(Context, nullptr, 1392249423Sdim CGF.CurGD.getDecl()->getLocation(), 1393249423Sdim &Context.Idents.get("should_call_delete"), 1394261991Sdim Context.IntTy); 1395249423Sdim Params.push_back(ShouldDelete); 1396249423Sdim getStructorImplicitParamDecl(CGF) = ShouldDelete; 1397249423Sdim } 1398243830Sdim} 1399243830Sdim 1400261991Sdimllvm::Value *MicrosoftCXXABI::adjustThisParameterInVirtualFunctionPrologue( 1401261991Sdim CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) { 1402261991Sdim // In this ABI, every virtual function takes a pointer to one of the 1403261991Sdim // subobjects that first defines it as the 'this' parameter, rather than a 1404276479Sdim // pointer to the final overrider subobject. Thus, we need to adjust it back 1405261991Sdim // to the final overrider subobject before use. 1406261991Sdim // See comments in the MicrosoftVFTableContext implementation for the details. 1407276479Sdim CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD); 1408261991Sdim if (Adjustment.isZero()) 1409261991Sdim return This; 1410261991Sdim 1411261991Sdim unsigned AS = cast<llvm::PointerType>(This->getType())->getAddressSpace(); 1412261991Sdim llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS), 1413261991Sdim *thisTy = This->getType(); 1414261991Sdim 1415261991Sdim This = CGF.Builder.CreateBitCast(This, charPtrTy); 1416261991Sdim assert(Adjustment.isPositive()); 1417288943Sdim This = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, This, 1418288943Sdim -Adjustment.getQuantity()); 1419261991Sdim return CGF.Builder.CreateBitCast(This, thisTy); 1420261991Sdim} 1421261991Sdim 1422243830Sdimvoid MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) { 1423243830Sdim EmitThisParam(CGF); 1424261991Sdim 1425261991Sdim /// If this is a function that the ABI specifies returns 'this', initialize 1426261991Sdim /// the return slot to 'this' at the start of the function. 1427261991Sdim /// 1428261991Sdim /// Unlike the setting of return types, this is done within the ABI 1429261991Sdim /// implementation instead of by clients of CGCXXABI because: 1430261991Sdim /// 1) getThisValue is currently protected 1431261991Sdim /// 2) in theory, an ABI could implement 'this' returns some other way; 1432261991Sdim /// HasThisReturn only specifies a contract, not the implementation 1433261991Sdim if (HasThisReturn(CGF.CurGD)) 1434243830Sdim CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue); 1435280031Sdim else if (hasMostDerivedReturn(CGF.CurGD)) 1436280031Sdim CGF.Builder.CreateStore(CGF.EmitCastToVoidPtr(getThisValue(CGF)), 1437280031Sdim CGF.ReturnValue); 1438249423Sdim 1439249423Sdim const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl()); 1440249423Sdim if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) { 1441249423Sdim assert(getStructorImplicitParamDecl(CGF) && 1442249423Sdim "no implicit parameter for a constructor with virtual bases?"); 1443249423Sdim getStructorImplicitParamValue(CGF) 1444249423Sdim = CGF.Builder.CreateLoad( 1445249423Sdim CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), 1446249423Sdim "is_most_derived"); 1447249423Sdim } 1448249423Sdim 1449280031Sdim if (isDeletingDtor(CGF.CurGD)) { 1450249423Sdim assert(getStructorImplicitParamDecl(CGF) && 1451249423Sdim "no implicit parameter for a deleting destructor?"); 1452249423Sdim getStructorImplicitParamValue(CGF) 1453249423Sdim = CGF.Builder.CreateLoad( 1454249423Sdim CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), 1455249423Sdim "should_call_delete"); 1456249423Sdim } 1457243830Sdim} 1458243830Sdim 1459276479Sdimunsigned MicrosoftCXXABI::addImplicitConstructorArgs( 1460276479Sdim CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type, 1461276479Sdim bool ForVirtualBase, bool Delegating, CallArgList &Args) { 1462249423Sdim assert(Type == Ctor_Complete || Type == Ctor_Base); 1463249423Sdim 1464276479Sdim // Check if we need a 'most_derived' parameter. 1465276479Sdim if (!D->getParent()->getNumVBases()) 1466276479Sdim return 0; 1467276479Sdim 1468276479Sdim // Add the 'most_derived' argument second if we are variadic or last if not. 1469276479Sdim const FunctionProtoType *FPT = D->getType()->castAs<FunctionProtoType>(); 1470276479Sdim llvm::Value *MostDerivedArg = 1471276479Sdim llvm::ConstantInt::get(CGM.Int32Ty, Type == Ctor_Complete); 1472276479Sdim RValue RV = RValue::get(MostDerivedArg); 1473276479Sdim if (MostDerivedArg) { 1474276479Sdim if (FPT->isVariadic()) 1475276479Sdim Args.insert(Args.begin() + 1, 1476276479Sdim CallArg(RV, getContext().IntTy, /*needscopy=*/false)); 1477276479Sdim else 1478276479Sdim Args.add(RV, getContext().IntTy); 1479249423Sdim } 1480249423Sdim 1481276479Sdim return 1; // Added one arg. 1482276479Sdim} 1483276479Sdim 1484276479Sdimvoid MicrosoftCXXABI::EmitDestructorCall(CodeGenFunction &CGF, 1485276479Sdim const CXXDestructorDecl *DD, 1486276479Sdim CXXDtorType Type, bool ForVirtualBase, 1487296417Sdim bool Delegating, Address This) { 1488280031Sdim llvm::Value *Callee = CGM.getAddrOfCXXStructor(DD, getFromDtorType(Type)); 1489276479Sdim 1490276479Sdim if (DD->isVirtual()) { 1491276479Sdim assert(Type != CXXDtorType::Dtor_Deleting && 1492276479Sdim "The deleting destructor should only be called via a virtual call"); 1493276479Sdim This = adjustThisArgumentForVirtualFunctionCall(CGF, GlobalDecl(DD, Type), 1494276479Sdim This, false); 1495276479Sdim } 1496276479Sdim 1497296417Sdim CGF.EmitCXXStructorCall(DD, Callee, ReturnValueSlot(), This.getPointer(), 1498280031Sdim /*ImplicitParam=*/nullptr, 1499280031Sdim /*ImplicitParamTy=*/QualType(), nullptr, 1500280031Sdim getFromDtorType(Type)); 1501249423Sdim} 1502249423Sdim 1503288943Sdimvoid MicrosoftCXXABI::emitVTableBitSetEntries(VPtrInfo *Info, 1504288943Sdim const CXXRecordDecl *RD, 1505288943Sdim llvm::GlobalVariable *VTable) { 1506288943Sdim if (!getContext().getLangOpts().Sanitize.has(SanitizerKind::CFIVCall) && 1507288943Sdim !getContext().getLangOpts().Sanitize.has(SanitizerKind::CFINVCall) && 1508288943Sdim !getContext().getLangOpts().Sanitize.has(SanitizerKind::CFIDerivedCast) && 1509288943Sdim !getContext().getLangOpts().Sanitize.has(SanitizerKind::CFIUnrelatedCast)) 1510288943Sdim return; 1511288943Sdim 1512288943Sdim llvm::NamedMDNode *BitsetsMD = 1513288943Sdim CGM.getModule().getOrInsertNamedMetadata("llvm.bitsets"); 1514288943Sdim 1515288943Sdim // The location of the first virtual function pointer in the virtual table, 1516288943Sdim // aka the "address point" on Itanium. This is at offset 0 if RTTI is 1517288943Sdim // disabled, or sizeof(void*) if RTTI is enabled. 1518288943Sdim CharUnits AddressPoint = 1519288943Sdim getContext().getLangOpts().RTTIData 1520288943Sdim ? getContext().toCharUnitsFromBits( 1521288943Sdim getContext().getTargetInfo().getPointerWidth(0)) 1522288943Sdim : CharUnits::Zero(); 1523288943Sdim 1524288943Sdim if (Info->PathToBaseWithVPtr.empty()) { 1525288943Sdim if (!CGM.IsCFIBlacklistedRecord(RD)) 1526296417Sdim CGM.CreateVTableBitSetEntry(BitsetsMD, VTable, AddressPoint, RD); 1527288943Sdim return; 1528288943Sdim } 1529288943Sdim 1530288943Sdim // Add a bitset entry for the least derived base belonging to this vftable. 1531288943Sdim if (!CGM.IsCFIBlacklistedRecord(Info->PathToBaseWithVPtr.back())) 1532296417Sdim CGM.CreateVTableBitSetEntry(BitsetsMD, VTable, AddressPoint, 1533296417Sdim Info->PathToBaseWithVPtr.back()); 1534288943Sdim 1535288943Sdim // Add a bitset entry for each derived class that is laid out at the same 1536288943Sdim // offset as the least derived base. 1537288943Sdim for (unsigned I = Info->PathToBaseWithVPtr.size() - 1; I != 0; --I) { 1538288943Sdim const CXXRecordDecl *DerivedRD = Info->PathToBaseWithVPtr[I - 1]; 1539288943Sdim const CXXRecordDecl *BaseRD = Info->PathToBaseWithVPtr[I]; 1540288943Sdim 1541288943Sdim const ASTRecordLayout &Layout = 1542288943Sdim getContext().getASTRecordLayout(DerivedRD); 1543288943Sdim CharUnits Offset; 1544288943Sdim auto VBI = Layout.getVBaseOffsetsMap().find(BaseRD); 1545288943Sdim if (VBI == Layout.getVBaseOffsetsMap().end()) 1546288943Sdim Offset = Layout.getBaseClassOffset(BaseRD); 1547288943Sdim else 1548288943Sdim Offset = VBI->second.VBaseOffset; 1549288943Sdim if (!Offset.isZero()) 1550288943Sdim return; 1551288943Sdim if (!CGM.IsCFIBlacklistedRecord(DerivedRD)) 1552296417Sdim CGM.CreateVTableBitSetEntry(BitsetsMD, VTable, AddressPoint, DerivedRD); 1553288943Sdim } 1554288943Sdim 1555288943Sdim // Finally do the same for the most derived class. 1556288943Sdim if (Info->FullOffsetInMDC.isZero() && !CGM.IsCFIBlacklistedRecord(RD)) 1557296417Sdim CGM.CreateVTableBitSetEntry(BitsetsMD, VTable, AddressPoint, RD); 1558288943Sdim} 1559288943Sdim 1560261991Sdimvoid MicrosoftCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT, 1561261991Sdim const CXXRecordDecl *RD) { 1562261991Sdim MicrosoftVTableContext &VFTContext = CGM.getMicrosoftVTableContext(); 1563280031Sdim const VPtrInfoVector &VFPtrs = VFTContext.getVFPtrOffsets(RD); 1564261991Sdim 1565276479Sdim for (VPtrInfo *Info : VFPtrs) { 1566276479Sdim llvm::GlobalVariable *VTable = getAddrOfVTable(RD, Info->FullOffsetInMDC); 1567261991Sdim if (VTable->hasInitializer()) 1568261991Sdim continue; 1569261991Sdim 1570280031Sdim llvm::Constant *RTTI = getContext().getLangOpts().RTTIData 1571280031Sdim ? getMSCompleteObjectLocator(RD, Info) 1572280031Sdim : nullptr; 1573276479Sdim 1574261991Sdim const VTableLayout &VTLayout = 1575276479Sdim VFTContext.getVFTableLayout(RD, Info->FullOffsetInMDC); 1576261991Sdim llvm::Constant *Init = CGVT.CreateVTableInitializer( 1577261991Sdim RD, VTLayout.vtable_component_begin(), 1578261991Sdim VTLayout.getNumVTableComponents(), VTLayout.vtable_thunk_begin(), 1579276479Sdim VTLayout.getNumVTableThunks(), RTTI); 1580276479Sdim 1581261991Sdim VTable->setInitializer(Init); 1582288943Sdim 1583288943Sdim emitVTableBitSetEntries(Info, RD, VTable); 1584261991Sdim } 1585261991Sdim} 1586261991Sdim 1587296417Sdimbool MicrosoftCXXABI::isVirtualOffsetNeededForVTableField( 1588296417Sdim CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr) { 1589296417Sdim return Vptr.NearestVBase != nullptr; 1590296417Sdim} 1591296417Sdim 1592261991Sdimllvm::Value *MicrosoftCXXABI::getVTableAddressPointInStructor( 1593261991Sdim CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base, 1594296417Sdim const CXXRecordDecl *NearestVBase) { 1595296417Sdim llvm::Constant *VTableAddressPoint = getVTableAddressPoint(Base, VTableClass); 1596261991Sdim if (!VTableAddressPoint) { 1597261991Sdim assert(Base.getBase()->getNumVBases() && 1598288943Sdim !getContext().getASTRecordLayout(Base.getBase()).hasOwnVFPtr()); 1599261991Sdim } 1600261991Sdim return VTableAddressPoint; 1601261991Sdim} 1602261991Sdim 1603261991Sdimstatic void mangleVFTableName(MicrosoftMangleContext &MangleContext, 1604276479Sdim const CXXRecordDecl *RD, const VPtrInfo *VFPtr, 1605261991Sdim SmallString<256> &Name) { 1606261991Sdim llvm::raw_svector_ostream Out(Name); 1607276479Sdim MangleContext.mangleCXXVFTable(RD, VFPtr->MangledPath, Out); 1608261991Sdim} 1609261991Sdim 1610296417Sdimllvm::Constant * 1611296417SdimMicrosoftCXXABI::getVTableAddressPoint(BaseSubobject Base, 1612296417Sdim const CXXRecordDecl *VTableClass) { 1613296417Sdim (void)getAddrOfVTable(VTableClass, Base.getBaseOffset()); 1614296417Sdim VFTableIdTy ID(VTableClass, Base.getBaseOffset()); 1615296417Sdim return VFTablesMap[ID]; 1616296417Sdim} 1617296417Sdim 1618261991Sdimllvm::Constant *MicrosoftCXXABI::getVTableAddressPointForConstExpr( 1619261991Sdim BaseSubobject Base, const CXXRecordDecl *VTableClass) { 1620296417Sdim llvm::Constant *VFTable = getVTableAddressPoint(Base, VTableClass); 1621276479Sdim assert(VFTable && "Couldn't find a vftable for the given base?"); 1622276479Sdim return VFTable; 1623261991Sdim} 1624261991Sdim 1625261991Sdimllvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(const CXXRecordDecl *RD, 1626261991Sdim CharUnits VPtrOffset) { 1627261991Sdim // getAddrOfVTable may return 0 if asked to get an address of a vtable which 1628261991Sdim // shouldn't be used in the given record type. We want to cache this result in 1629261991Sdim // VFTablesMap, thus a simple zero check is not sufficient. 1630296417Sdim 1631261991Sdim VFTableIdTy ID(RD, VPtrOffset); 1632276479Sdim VTablesMapTy::iterator I; 1633261991Sdim bool Inserted; 1634276479Sdim std::tie(I, Inserted) = VTablesMap.insert(std::make_pair(ID, nullptr)); 1635261991Sdim if (!Inserted) 1636261991Sdim return I->second; 1637261991Sdim 1638261991Sdim llvm::GlobalVariable *&VTable = I->second; 1639261991Sdim 1640261991Sdim MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext(); 1641276479Sdim const VPtrInfoVector &VFPtrs = VTContext.getVFPtrOffsets(RD); 1642261991Sdim 1643280031Sdim if (DeferredVFTables.insert(RD).second) { 1644261991Sdim // We haven't processed this record type before. 1645261991Sdim // Queue up this v-table for possible deferred emission. 1646261991Sdim CGM.addDeferredVTable(RD); 1647261991Sdim 1648261991Sdim#ifndef NDEBUG 1649261991Sdim // Create all the vftables at once in order to make sure each vftable has 1650261991Sdim // a unique mangled name. 1651261991Sdim llvm::StringSet<> ObservedMangledNames; 1652261991Sdim for (size_t J = 0, F = VFPtrs.size(); J != F; ++J) { 1653261991Sdim SmallString<256> Name; 1654261991Sdim mangleVFTableName(getMangleContext(), RD, VFPtrs[J], Name); 1655280031Sdim if (!ObservedMangledNames.insert(Name.str()).second) 1656261991Sdim llvm_unreachable("Already saw this mangling before?"); 1657261991Sdim } 1658261991Sdim#endif 1659261991Sdim } 1660261991Sdim 1661288943Sdim VPtrInfo *const *VFPtrI = 1662288943Sdim std::find_if(VFPtrs.begin(), VFPtrs.end(), [&](VPtrInfo *VPI) { 1663288943Sdim return VPI->FullOffsetInMDC == VPtrOffset; 1664288943Sdim }); 1665288943Sdim if (VFPtrI == VFPtrs.end()) { 1666288943Sdim VFTablesMap[ID] = nullptr; 1667288943Sdim return nullptr; 1668288943Sdim } 1669288943Sdim VPtrInfo *VFPtr = *VFPtrI; 1670261991Sdim 1671288943Sdim SmallString<256> VFTableName; 1672288943Sdim mangleVFTableName(getMangleContext(), RD, VFPtr, VFTableName); 1673261991Sdim 1674288943Sdim llvm::GlobalValue::LinkageTypes VFTableLinkage = CGM.getVTableLinkage(RD); 1675288943Sdim bool VFTableComesFromAnotherTU = 1676288943Sdim llvm::GlobalValue::isAvailableExternallyLinkage(VFTableLinkage) || 1677288943Sdim llvm::GlobalValue::isExternalLinkage(VFTableLinkage); 1678288943Sdim bool VTableAliasIsRequred = 1679288943Sdim !VFTableComesFromAnotherTU && getContext().getLangOpts().RTTIData; 1680276479Sdim 1681288943Sdim if (llvm::GlobalValue *VFTable = 1682288943Sdim CGM.getModule().getNamedGlobal(VFTableName)) { 1683288943Sdim VFTablesMap[ID] = VFTable; 1684296417Sdim VTable = VTableAliasIsRequred 1685296417Sdim ? cast<llvm::GlobalVariable>( 1686296417Sdim cast<llvm::GlobalAlias>(VFTable)->getBaseObject()) 1687296417Sdim : cast<llvm::GlobalVariable>(VFTable); 1688296417Sdim return VTable; 1689288943Sdim } 1690276479Sdim 1691288943Sdim uint64_t NumVTableSlots = 1692288943Sdim VTContext.getVFTableLayout(RD, VFPtr->FullOffsetInMDC) 1693288943Sdim .getNumVTableComponents(); 1694288943Sdim llvm::GlobalValue::LinkageTypes VTableLinkage = 1695288943Sdim VTableAliasIsRequred ? llvm::GlobalValue::PrivateLinkage : VFTableLinkage; 1696276479Sdim 1697288943Sdim StringRef VTableName = VTableAliasIsRequred ? StringRef() : VFTableName.str(); 1698288943Sdim 1699288943Sdim llvm::ArrayType *VTableType = 1700288943Sdim llvm::ArrayType::get(CGM.Int8PtrTy, NumVTableSlots); 1701288943Sdim 1702288943Sdim // Create a backing variable for the contents of VTable. The VTable may 1703288943Sdim // or may not include space for a pointer to RTTI data. 1704288943Sdim llvm::GlobalValue *VFTable; 1705288943Sdim VTable = new llvm::GlobalVariable(CGM.getModule(), VTableType, 1706288943Sdim /*isConstant=*/true, VTableLinkage, 1707288943Sdim /*Initializer=*/nullptr, VTableName); 1708288943Sdim VTable->setUnnamedAddr(true); 1709288943Sdim 1710288943Sdim llvm::Comdat *C = nullptr; 1711288943Sdim if (!VFTableComesFromAnotherTU && 1712288943Sdim (llvm::GlobalValue::isWeakForLinker(VFTableLinkage) || 1713288943Sdim (llvm::GlobalValue::isLocalLinkage(VFTableLinkage) && 1714288943Sdim VTableAliasIsRequred))) 1715288943Sdim C = CGM.getModule().getOrInsertComdat(VFTableName.str()); 1716288943Sdim 1717288943Sdim // Only insert a pointer into the VFTable for RTTI data if we are not 1718288943Sdim // importing it. We never reference the RTTI data directly so there is no 1719288943Sdim // need to make room for it. 1720288943Sdim if (VTableAliasIsRequred) { 1721288943Sdim llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.IntTy, 0), 1722288943Sdim llvm::ConstantInt::get(CGM.IntTy, 1)}; 1723288943Sdim // Create a GEP which points just after the first entry in the VFTable, 1724288943Sdim // this should be the location of the first virtual method. 1725288943Sdim llvm::Constant *VTableGEP = llvm::ConstantExpr::getInBoundsGetElementPtr( 1726288943Sdim VTable->getValueType(), VTable, GEPIndices); 1727288943Sdim if (llvm::GlobalValue::isWeakForLinker(VFTableLinkage)) { 1728288943Sdim VFTableLinkage = llvm::GlobalValue::ExternalLinkage; 1729288943Sdim if (C) 1730288943Sdim C->setSelectionKind(llvm::Comdat::Largest); 1731276479Sdim } 1732296417Sdim VFTable = llvm::GlobalAlias::create(CGM.Int8PtrTy, 1733296417Sdim /*AddressSpace=*/0, VFTableLinkage, 1734296417Sdim VFTableName.str(), VTableGEP, 1735296417Sdim &CGM.getModule()); 1736288943Sdim VFTable->setUnnamedAddr(true); 1737288943Sdim } else { 1738288943Sdim // We don't need a GlobalAlias to be a symbol for the VTable if we won't 1739288943Sdim // be referencing any RTTI data. 1740288943Sdim // The GlobalVariable will end up being an appropriate definition of the 1741288943Sdim // VFTable. 1742288943Sdim VFTable = VTable; 1743261991Sdim } 1744288943Sdim if (C) 1745288943Sdim VTable->setComdat(C); 1746261991Sdim 1747288943Sdim if (RD->hasAttr<DLLImportAttr>()) 1748288943Sdim VFTable->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 1749288943Sdim else if (RD->hasAttr<DLLExportAttr>()) 1750288943Sdim VFTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 1751288943Sdim 1752288943Sdim VFTablesMap[ID] = VFTable; 1753261991Sdim return VTable; 1754261991Sdim} 1755261991Sdim 1756288943Sdim// Compute the identity of the most derived class whose virtual table is located 1757288943Sdim// at the given offset into RD. 1758288943Sdimstatic const CXXRecordDecl *getClassAtVTableLocation(ASTContext &Ctx, 1759288943Sdim const CXXRecordDecl *RD, 1760288943Sdim CharUnits Offset) { 1761288943Sdim if (Offset.isZero()) 1762288943Sdim return RD; 1763288943Sdim 1764288943Sdim const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD); 1765288943Sdim const CXXRecordDecl *MaxBase = nullptr; 1766288943Sdim CharUnits MaxBaseOffset; 1767288943Sdim for (auto &&B : RD->bases()) { 1768288943Sdim const CXXRecordDecl *Base = B.getType()->getAsCXXRecordDecl(); 1769288943Sdim CharUnits BaseOffset = Layout.getBaseClassOffset(Base); 1770288943Sdim if (BaseOffset <= Offset && BaseOffset >= MaxBaseOffset) { 1771288943Sdim MaxBase = Base; 1772288943Sdim MaxBaseOffset = BaseOffset; 1773288943Sdim } 1774288943Sdim } 1775288943Sdim for (auto &&B : RD->vbases()) { 1776288943Sdim const CXXRecordDecl *Base = B.getType()->getAsCXXRecordDecl(); 1777288943Sdim CharUnits BaseOffset = Layout.getVBaseClassOffset(Base); 1778288943Sdim if (BaseOffset <= Offset && BaseOffset >= MaxBaseOffset) { 1779288943Sdim MaxBase = Base; 1780288943Sdim MaxBaseOffset = BaseOffset; 1781288943Sdim } 1782288943Sdim } 1783288943Sdim assert(MaxBase); 1784288943Sdim return getClassAtVTableLocation(Ctx, MaxBase, Offset - MaxBaseOffset); 1785288943Sdim} 1786288943Sdim 1787288943Sdim// Compute the identity of the most derived class whose virtual table is located 1788288943Sdim// at the MethodVFTableLocation ML. 1789288943Sdimstatic const CXXRecordDecl * 1790288943SdimgetClassAtVTableLocation(ASTContext &Ctx, GlobalDecl GD, 1791288943Sdim MicrosoftVTableContext::MethodVFTableLocation &ML) { 1792288943Sdim const CXXRecordDecl *RD = ML.VBase; 1793288943Sdim if (!RD) 1794288943Sdim RD = cast<CXXMethodDecl>(GD.getDecl())->getParent(); 1795288943Sdim 1796288943Sdim return getClassAtVTableLocation(Ctx, RD, ML.VFPtrOffset); 1797288943Sdim} 1798288943Sdim 1799261991Sdimllvm::Value *MicrosoftCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF, 1800261991Sdim GlobalDecl GD, 1801296417Sdim Address This, 1802288943Sdim llvm::Type *Ty, 1803288943Sdim SourceLocation Loc) { 1804261991Sdim GD = GD.getCanonicalDecl(); 1805261991Sdim CGBuilderTy &Builder = CGF.Builder; 1806261991Sdim 1807261991Sdim Ty = Ty->getPointerTo()->getPointerTo(); 1808296417Sdim Address VPtr = 1809276479Sdim adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true); 1810261991Sdim 1811296417Sdim auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl()); 1812296417Sdim llvm::Value *VTable = CGF.GetVTablePtr(VPtr, Ty, MethodDecl->getParent()); 1813296417Sdim 1814261991Sdim MicrosoftVTableContext::MethodVFTableLocation ML = 1815261991Sdim CGM.getMicrosoftVTableContext().getMethodVFTableLocation(GD); 1816288943Sdim if (CGF.SanOpts.has(SanitizerKind::CFIVCall)) 1817288943Sdim CGF.EmitVTablePtrCheck(getClassAtVTableLocation(getContext(), GD, ML), 1818288943Sdim VTable, CodeGenFunction::CFITCK_VCall, Loc); 1819288943Sdim 1820261991Sdim llvm::Value *VFuncPtr = 1821261991Sdim Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn"); 1822296417Sdim return Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign()); 1823261991Sdim} 1824261991Sdim 1825280031Sdimllvm::Value *MicrosoftCXXABI::EmitVirtualDestructorCall( 1826280031Sdim CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType, 1827296417Sdim Address This, const CXXMemberCallExpr *CE) { 1828280031Sdim assert(CE == nullptr || CE->arg_begin() == CE->arg_end()); 1829249423Sdim assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete); 1830249423Sdim 1831249423Sdim // We have only one destructor in the vftable but can get both behaviors 1832261991Sdim // by passing an implicit int parameter. 1833261991Sdim GlobalDecl GD(Dtor, Dtor_Deleting); 1834280031Sdim const CGFunctionInfo *FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration( 1835280031Sdim Dtor, StructorType::Deleting); 1836249423Sdim llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo); 1837288943Sdim llvm::Value *Callee = getVirtualFunctionPointer( 1838288943Sdim CGF, GD, This, Ty, CE ? CE->getLocStart() : SourceLocation()); 1839249423Sdim 1840288943Sdim ASTContext &Context = getContext(); 1841280031Sdim llvm::Value *ImplicitParam = llvm::ConstantInt::get( 1842280031Sdim llvm::IntegerType::getInt32Ty(CGF.getLLVMContext()), 1843280031Sdim DtorType == Dtor_Deleting); 1844249423Sdim 1845276479Sdim This = adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true); 1846296417Sdim RValue RV = CGF.EmitCXXStructorCall(Dtor, Callee, ReturnValueSlot(), 1847296417Sdim This.getPointer(), 1848280031Sdim ImplicitParam, Context.IntTy, CE, 1849280031Sdim StructorType::Deleting); 1850280031Sdim return RV.getScalarVal(); 1851249423Sdim} 1852249423Sdim 1853276479Sdimconst VBTableGlobals & 1854276479SdimMicrosoftCXXABI::enumerateVBTables(const CXXRecordDecl *RD) { 1855261991Sdim // At this layer, we can key the cache off of a single class, which is much 1856276479Sdim // easier than caching each vbtable individually. 1857276479Sdim llvm::DenseMap<const CXXRecordDecl*, VBTableGlobals>::iterator Entry; 1858276479Sdim bool Added; 1859276479Sdim std::tie(Entry, Added) = 1860276479Sdim VBTablesMap.insert(std::make_pair(RD, VBTableGlobals())); 1861276479Sdim VBTableGlobals &VBGlobals = Entry->second; 1862276479Sdim if (!Added) 1863276479Sdim return VBGlobals; 1864261991Sdim 1865276479Sdim MicrosoftVTableContext &Context = CGM.getMicrosoftVTableContext(); 1866276479Sdim VBGlobals.VBTables = &Context.enumerateVBTables(RD); 1867261991Sdim 1868276479Sdim // Cache the globals for all vbtables so we don't have to recompute the 1869276479Sdim // mangled names. 1870276479Sdim llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD); 1871276479Sdim for (VPtrInfoVector::const_iterator I = VBGlobals.VBTables->begin(), 1872276479Sdim E = VBGlobals.VBTables->end(); 1873276479Sdim I != E; ++I) { 1874276479Sdim VBGlobals.Globals.push_back(getAddrOfVBTable(**I, RD, Linkage)); 1875276479Sdim } 1876276479Sdim 1877276479Sdim return VBGlobals; 1878261991Sdim} 1879261991Sdim 1880276479Sdimllvm::Function *MicrosoftCXXABI::EmitVirtualMemPtrThunk( 1881276479Sdim const CXXMethodDecl *MD, 1882276479Sdim const MicrosoftVTableContext::MethodVFTableLocation &ML) { 1883280031Sdim assert(!isa<CXXConstructorDecl>(MD) && !isa<CXXDestructorDecl>(MD) && 1884280031Sdim "can't form pointers to ctors or virtual dtors"); 1885280031Sdim 1886276479Sdim // Calculate the mangled name. 1887276479Sdim SmallString<256> ThunkName; 1888276479Sdim llvm::raw_svector_ostream Out(ThunkName); 1889276479Sdim getMangleContext().mangleVirtualMemPtrThunk(MD, Out); 1890276479Sdim 1891261991Sdim // If the thunk has been generated previously, just return it. 1892261991Sdim if (llvm::GlobalValue *GV = CGM.getModule().getNamedValue(ThunkName)) 1893261991Sdim return cast<llvm::Function>(GV); 1894261991Sdim 1895261991Sdim // Create the llvm::Function. 1896280031Sdim const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeMSMemberPointerThunk(MD); 1897261991Sdim llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo); 1898261991Sdim llvm::Function *ThunkFn = 1899261991Sdim llvm::Function::Create(ThunkTy, llvm::Function::ExternalLinkage, 1900261991Sdim ThunkName.str(), &CGM.getModule()); 1901261991Sdim assert(ThunkFn->getName() == ThunkName && "name was uniqued!"); 1902261991Sdim 1903261991Sdim ThunkFn->setLinkage(MD->isExternallyVisible() 1904261991Sdim ? llvm::GlobalValue::LinkOnceODRLinkage 1905261991Sdim : llvm::GlobalValue::InternalLinkage); 1906288943Sdim if (MD->isExternallyVisible()) 1907288943Sdim ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName())); 1908261991Sdim 1909261991Sdim CGM.SetLLVMFunctionAttributes(MD, FnInfo, ThunkFn); 1910261991Sdim CGM.SetLLVMFunctionAttributesForDefinition(MD, ThunkFn); 1911261991Sdim 1912280031Sdim // Add the "thunk" attribute so that LLVM knows that the return type is 1913280031Sdim // meaningless. These thunks can be used to call functions with differing 1914280031Sdim // return types, and the caller is required to cast the prototype 1915280031Sdim // appropriately to extract the correct value. 1916280031Sdim ThunkFn->addFnAttr("thunk"); 1917280031Sdim 1918280031Sdim // These thunks can be compared, so they are not unnamed. 1919280031Sdim ThunkFn->setUnnamedAddr(false); 1920280031Sdim 1921261991Sdim // Start codegen. 1922261991Sdim CodeGenFunction CGF(CGM); 1923280031Sdim CGF.CurGD = GlobalDecl(MD); 1924280031Sdim CGF.CurFuncIsThunk = true; 1925261991Sdim 1926280031Sdim // Build FunctionArgs, but only include the implicit 'this' parameter 1927280031Sdim // declaration. 1928280031Sdim FunctionArgList FunctionArgs; 1929280031Sdim buildThisParam(CGF, FunctionArgs); 1930280031Sdim 1931280031Sdim // Start defining the function. 1932280031Sdim CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo, 1933280031Sdim FunctionArgs, MD->getLocation(), SourceLocation()); 1934280031Sdim EmitThisParam(CGF); 1935280031Sdim 1936276479Sdim // Load the vfptr and then callee from the vftable. The callee should have 1937276479Sdim // adjusted 'this' so that the vfptr is at offset zero. 1938280031Sdim llvm::Value *VTable = CGF.GetVTablePtr( 1939296417Sdim getThisAddress(CGF), ThunkTy->getPointerTo()->getPointerTo(), MD->getParent()); 1940296417Sdim 1941276479Sdim llvm::Value *VFuncPtr = 1942276479Sdim CGF.Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn"); 1943296417Sdim llvm::Value *Callee = 1944296417Sdim CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign()); 1945261991Sdim 1946280031Sdim CGF.EmitMustTailThunk(MD, getThisValue(CGF), Callee); 1947261991Sdim 1948261991Sdim return ThunkFn; 1949261991Sdim} 1950261991Sdim 1951261991Sdimvoid MicrosoftCXXABI::emitVirtualInheritanceTables(const CXXRecordDecl *RD) { 1952276479Sdim const VBTableGlobals &VBGlobals = enumerateVBTables(RD); 1953276479Sdim for (unsigned I = 0, E = VBGlobals.VBTables->size(); I != E; ++I) { 1954276479Sdim const VPtrInfo *VBT = (*VBGlobals.VBTables)[I]; 1955276479Sdim llvm::GlobalVariable *GV = VBGlobals.Globals[I]; 1956288943Sdim if (GV->isDeclaration()) 1957288943Sdim emitVBTableDefinition(*VBT, RD, GV); 1958276479Sdim } 1959276479Sdim} 1960261991Sdim 1961276479Sdimllvm::GlobalVariable * 1962276479SdimMicrosoftCXXABI::getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD, 1963276479Sdim llvm::GlobalVariable::LinkageTypes Linkage) { 1964276479Sdim SmallString<256> OutName; 1965276479Sdim llvm::raw_svector_ostream Out(OutName); 1966276479Sdim getMangleContext().mangleCXXVBTable(RD, VBT.MangledPath, Out); 1967276479Sdim StringRef Name = OutName.str(); 1968276479Sdim 1969276479Sdim llvm::ArrayType *VBTableType = 1970276479Sdim llvm::ArrayType::get(CGM.IntTy, 1 + VBT.ReusingBase->getNumVBases()); 1971276479Sdim 1972276479Sdim assert(!CGM.getModule().getNamedGlobal(Name) && 1973276479Sdim "vbtable with this name already exists: mangling bug?"); 1974276479Sdim llvm::GlobalVariable *GV = 1975276479Sdim CGM.CreateOrReplaceCXXRuntimeVariable(Name, VBTableType, Linkage); 1976276479Sdim GV->setUnnamedAddr(true); 1977276479Sdim 1978276479Sdim if (RD->hasAttr<DLLImportAttr>()) 1979276479Sdim GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); 1980276479Sdim else if (RD->hasAttr<DLLExportAttr>()) 1981276479Sdim GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); 1982276479Sdim 1983288943Sdim if (!GV->hasExternalLinkage()) 1984288943Sdim emitVBTableDefinition(VBT, RD, GV); 1985288943Sdim 1986276479Sdim return GV; 1987276479Sdim} 1988276479Sdim 1989276479Sdimvoid MicrosoftCXXABI::emitVBTableDefinition(const VPtrInfo &VBT, 1990276479Sdim const CXXRecordDecl *RD, 1991276479Sdim llvm::GlobalVariable *GV) const { 1992276479Sdim const CXXRecordDecl *ReusingBase = VBT.ReusingBase; 1993276479Sdim 1994276479Sdim assert(RD->getNumVBases() && ReusingBase->getNumVBases() && 1995276479Sdim "should only emit vbtables for classes with vbtables"); 1996276479Sdim 1997276479Sdim const ASTRecordLayout &BaseLayout = 1998288943Sdim getContext().getASTRecordLayout(VBT.BaseWithVPtr); 1999288943Sdim const ASTRecordLayout &DerivedLayout = getContext().getASTRecordLayout(RD); 2000276479Sdim 2001276479Sdim SmallVector<llvm::Constant *, 4> Offsets(1 + ReusingBase->getNumVBases(), 2002276479Sdim nullptr); 2003276479Sdim 2004276479Sdim // The offset from ReusingBase's vbptr to itself always leads. 2005276479Sdim CharUnits VBPtrOffset = BaseLayout.getVBPtrOffset(); 2006276479Sdim Offsets[0] = llvm::ConstantInt::get(CGM.IntTy, -VBPtrOffset.getQuantity()); 2007276479Sdim 2008276479Sdim MicrosoftVTableContext &Context = CGM.getMicrosoftVTableContext(); 2009276479Sdim for (const auto &I : ReusingBase->vbases()) { 2010276479Sdim const CXXRecordDecl *VBase = I.getType()->getAsCXXRecordDecl(); 2011276479Sdim CharUnits Offset = DerivedLayout.getVBaseClassOffset(VBase); 2012276479Sdim assert(!Offset.isNegative()); 2013276479Sdim 2014276479Sdim // Make it relative to the subobject vbptr. 2015276479Sdim CharUnits CompleteVBPtrOffset = VBT.NonVirtualOffset + VBPtrOffset; 2016276479Sdim if (VBT.getVBaseWithVPtr()) 2017276479Sdim CompleteVBPtrOffset += 2018276479Sdim DerivedLayout.getVBaseClassOffset(VBT.getVBaseWithVPtr()); 2019276479Sdim Offset -= CompleteVBPtrOffset; 2020276479Sdim 2021276479Sdim unsigned VBIndex = Context.getVBTableIndex(ReusingBase, VBase); 2022276479Sdim assert(Offsets[VBIndex] == nullptr && "The same vbindex seen twice?"); 2023276479Sdim Offsets[VBIndex] = llvm::ConstantInt::get(CGM.IntTy, Offset.getQuantity()); 2024261991Sdim } 2025276479Sdim 2026276479Sdim assert(Offsets.size() == 2027276479Sdim cast<llvm::ArrayType>(cast<llvm::PointerType>(GV->getType()) 2028276479Sdim ->getElementType())->getNumElements()); 2029276479Sdim llvm::ArrayType *VBTableType = 2030276479Sdim llvm::ArrayType::get(CGM.IntTy, Offsets.size()); 2031276479Sdim llvm::Constant *Init = llvm::ConstantArray::get(VBTableType, Offsets); 2032276479Sdim GV->setInitializer(Init); 2033261991Sdim} 2034261991Sdim 2035261991Sdimllvm::Value *MicrosoftCXXABI::performThisAdjustment(CodeGenFunction &CGF, 2036296417Sdim Address This, 2037261991Sdim const ThisAdjustment &TA) { 2038261991Sdim if (TA.isEmpty()) 2039296417Sdim return This.getPointer(); 2040261991Sdim 2041296417Sdim This = CGF.Builder.CreateElementBitCast(This, CGF.Int8Ty); 2042261991Sdim 2043296417Sdim llvm::Value *V; 2044296417Sdim if (TA.Virtual.isEmpty()) { 2045296417Sdim V = This.getPointer(); 2046296417Sdim } else { 2047261991Sdim assert(TA.Virtual.Microsoft.VtordispOffset < 0); 2048261991Sdim // Adjust the this argument based on the vtordisp value. 2049296417Sdim Address VtorDispPtr = 2050296417Sdim CGF.Builder.CreateConstInBoundsByteGEP(This, 2051296417Sdim CharUnits::fromQuantity(TA.Virtual.Microsoft.VtordispOffset)); 2052296417Sdim VtorDispPtr = CGF.Builder.CreateElementBitCast(VtorDispPtr, CGF.Int32Ty); 2053261991Sdim llvm::Value *VtorDisp = CGF.Builder.CreateLoad(VtorDispPtr, "vtordisp"); 2054296417Sdim V = CGF.Builder.CreateGEP(This.getPointer(), 2055296417Sdim CGF.Builder.CreateNeg(VtorDisp)); 2056261991Sdim 2057296417Sdim // Unfortunately, having applied the vtordisp means that we no 2058296417Sdim // longer really have a known alignment for the vbptr step. 2059296417Sdim // We'll assume the vbptr is pointer-aligned. 2060296417Sdim 2061261991Sdim if (TA.Virtual.Microsoft.VBPtrOffset) { 2062261991Sdim // If the final overrider is defined in a virtual base other than the one 2063261991Sdim // that holds the vfptr, we have to use a vtordispex thunk which looks up 2064261991Sdim // the vbtable of the derived class. 2065261991Sdim assert(TA.Virtual.Microsoft.VBPtrOffset > 0); 2066261991Sdim assert(TA.Virtual.Microsoft.VBOffsetOffset >= 0); 2067261991Sdim llvm::Value *VBPtr; 2068261991Sdim llvm::Value *VBaseOffset = 2069296417Sdim GetVBaseOffsetFromVBPtr(CGF, Address(V, CGF.getPointerAlign()), 2070296417Sdim -TA.Virtual.Microsoft.VBPtrOffset, 2071261991Sdim TA.Virtual.Microsoft.VBOffsetOffset, &VBPtr); 2072261991Sdim V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset); 2073261991Sdim } 2074261991Sdim } 2075261991Sdim 2076261991Sdim if (TA.NonVirtual) { 2077261991Sdim // Non-virtual adjustment might result in a pointer outside the allocated 2078261991Sdim // object, e.g. if the final overrider class is laid out after the virtual 2079261991Sdim // base that declares a method in the most derived class. 2080261991Sdim V = CGF.Builder.CreateConstGEP1_32(V, TA.NonVirtual); 2081261991Sdim } 2082261991Sdim 2083261991Sdim // Don't need to bitcast back, the call CodeGen will handle this. 2084261991Sdim return V; 2085261991Sdim} 2086261991Sdim 2087261991Sdimllvm::Value * 2088296417SdimMicrosoftCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret, 2089261991Sdim const ReturnAdjustment &RA) { 2090261991Sdim if (RA.isEmpty()) 2091296417Sdim return Ret.getPointer(); 2092261991Sdim 2093296417Sdim auto OrigTy = Ret.getType(); 2094296417Sdim Ret = CGF.Builder.CreateElementBitCast(Ret, CGF.Int8Ty); 2095261991Sdim 2096296417Sdim llvm::Value *V = Ret.getPointer(); 2097261991Sdim if (RA.Virtual.Microsoft.VBIndex) { 2098261991Sdim assert(RA.Virtual.Microsoft.VBIndex > 0); 2099296417Sdim int32_t IntSize = CGF.getIntSize().getQuantity(); 2100261991Sdim llvm::Value *VBPtr; 2101261991Sdim llvm::Value *VBaseOffset = 2102296417Sdim GetVBaseOffsetFromVBPtr(CGF, Ret, RA.Virtual.Microsoft.VBPtrOffset, 2103261991Sdim IntSize * RA.Virtual.Microsoft.VBIndex, &VBPtr); 2104261991Sdim V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset); 2105261991Sdim } 2106261991Sdim 2107261991Sdim if (RA.NonVirtual) 2108288943Sdim V = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, V, RA.NonVirtual); 2109261991Sdim 2110261991Sdim // Cast back to the original type. 2111296417Sdim return CGF.Builder.CreateBitCast(V, OrigTy); 2112261991Sdim} 2113261991Sdim 2114239462Sdimbool MicrosoftCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr, 2115239462Sdim QualType elementType) { 2116239462Sdim // Microsoft seems to completely ignore the possibility of a 2117239462Sdim // two-argument usual deallocation function. 2118239462Sdim return elementType.isDestructedType(); 2119239462Sdim} 2120239462Sdim 2121239462Sdimbool MicrosoftCXXABI::requiresArrayCookie(const CXXNewExpr *expr) { 2122239462Sdim // Microsoft seems to completely ignore the possibility of a 2123239462Sdim // two-argument usual deallocation function. 2124239462Sdim return expr->getAllocatedType().isDestructedType(); 2125239462Sdim} 2126239462Sdim 2127239462SdimCharUnits MicrosoftCXXABI::getArrayCookieSizeImpl(QualType type) { 2128239462Sdim // The array cookie is always a size_t; we then pad that out to the 2129239462Sdim // alignment of the element type. 2130239462Sdim ASTContext &Ctx = getContext(); 2131239462Sdim return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()), 2132239462Sdim Ctx.getTypeAlignInChars(type)); 2133239462Sdim} 2134239462Sdim 2135239462Sdimllvm::Value *MicrosoftCXXABI::readArrayCookieImpl(CodeGenFunction &CGF, 2136296417Sdim Address allocPtr, 2137239462Sdim CharUnits cookieSize) { 2138296417Sdim Address numElementsPtr = 2139296417Sdim CGF.Builder.CreateElementBitCast(allocPtr, CGF.SizeTy); 2140239462Sdim return CGF.Builder.CreateLoad(numElementsPtr); 2141239462Sdim} 2142239462Sdim 2143296417SdimAddress MicrosoftCXXABI::InitializeArrayCookie(CodeGenFunction &CGF, 2144296417Sdim Address newPtr, 2145296417Sdim llvm::Value *numElements, 2146296417Sdim const CXXNewExpr *expr, 2147296417Sdim QualType elementType) { 2148239462Sdim assert(requiresArrayCookie(expr)); 2149239462Sdim 2150239462Sdim // The size of the cookie. 2151239462Sdim CharUnits cookieSize = getArrayCookieSizeImpl(elementType); 2152239462Sdim 2153239462Sdim // Compute an offset to the cookie. 2154296417Sdim Address cookiePtr = newPtr; 2155239462Sdim 2156239462Sdim // Write the number of elements into the appropriate slot. 2157296417Sdim Address numElementsPtr 2158296417Sdim = CGF.Builder.CreateElementBitCast(cookiePtr, CGF.SizeTy); 2159239462Sdim CGF.Builder.CreateStore(numElements, numElementsPtr); 2160239462Sdim 2161239462Sdim // Finally, compute a pointer to the actual data buffer by skipping 2162239462Sdim // over the cookie completely. 2163296417Sdim return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize); 2164239462Sdim} 2165239462Sdim 2166280031Sdimstatic void emitGlobalDtorWithTLRegDtor(CodeGenFunction &CGF, const VarDecl &VD, 2167280031Sdim llvm::Constant *Dtor, 2168280031Sdim llvm::Constant *Addr) { 2169280031Sdim // Create a function which calls the destructor. 2170280031Sdim llvm::Constant *DtorStub = CGF.createAtExitStub(VD, Dtor, Addr); 2171280031Sdim 2172280031Sdim // extern "C" int __tlregdtor(void (*f)(void)); 2173280031Sdim llvm::FunctionType *TLRegDtorTy = llvm::FunctionType::get( 2174280031Sdim CGF.IntTy, DtorStub->getType(), /*IsVarArg=*/false); 2175280031Sdim 2176280031Sdim llvm::Constant *TLRegDtor = 2177280031Sdim CGF.CGM.CreateRuntimeFunction(TLRegDtorTy, "__tlregdtor"); 2178280031Sdim if (llvm::Function *TLRegDtorFn = dyn_cast<llvm::Function>(TLRegDtor)) 2179280031Sdim TLRegDtorFn->setDoesNotThrow(); 2180280031Sdim 2181280031Sdim CGF.EmitNounwindRuntimeCall(TLRegDtor, DtorStub); 2182280031Sdim} 2183280031Sdim 2184280031Sdimvoid MicrosoftCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D, 2185280031Sdim llvm::Constant *Dtor, 2186280031Sdim llvm::Constant *Addr) { 2187280031Sdim if (D.getTLSKind()) 2188280031Sdim return emitGlobalDtorWithTLRegDtor(CGF, D, Dtor, Addr); 2189280031Sdim 2190280031Sdim // The default behavior is to use atexit. 2191280031Sdim CGF.registerGlobalDtorWithAtExit(D, Dtor, Addr); 2192280031Sdim} 2193280031Sdim 2194280031Sdimvoid MicrosoftCXXABI::EmitThreadLocalInitFuncs( 2195296417Sdim CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals, 2196280031Sdim ArrayRef<llvm::Function *> CXXThreadLocalInits, 2197296417Sdim ArrayRef<const VarDecl *> CXXThreadLocalInitVars) { 2198280031Sdim // This will create a GV in the .CRT$XDU section. It will point to our 2199280031Sdim // initialization function. The CRT will call all of these function 2200280031Sdim // pointers at start-up time and, eventually, at thread-creation time. 2201280031Sdim auto AddToXDU = [&CGM](llvm::Function *InitFunc) { 2202280031Sdim llvm::GlobalVariable *InitFuncPtr = new llvm::GlobalVariable( 2203280031Sdim CGM.getModule(), InitFunc->getType(), /*IsConstant=*/true, 2204280031Sdim llvm::GlobalVariable::InternalLinkage, InitFunc, 2205280031Sdim Twine(InitFunc->getName(), "$initializer$")); 2206280031Sdim InitFuncPtr->setSection(".CRT$XDU"); 2207280031Sdim // This variable has discardable linkage, we have to add it to @llvm.used to 2208280031Sdim // ensure it won't get discarded. 2209280031Sdim CGM.addUsedGlobal(InitFuncPtr); 2210280031Sdim return InitFuncPtr; 2211280031Sdim }; 2212280031Sdim 2213280031Sdim std::vector<llvm::Function *> NonComdatInits; 2214280031Sdim for (size_t I = 0, E = CXXThreadLocalInitVars.size(); I != E; ++I) { 2215296417Sdim llvm::GlobalVariable *GV = cast<llvm::GlobalVariable>( 2216296417Sdim CGM.GetGlobalValue(CGM.getMangledName(CXXThreadLocalInitVars[I]))); 2217280031Sdim llvm::Function *F = CXXThreadLocalInits[I]; 2218280031Sdim 2219280031Sdim // If the GV is already in a comdat group, then we have to join it. 2220288943Sdim if (llvm::Comdat *C = GV->getComdat()) 2221280031Sdim AddToXDU(F)->setComdat(C); 2222288943Sdim else 2223280031Sdim NonComdatInits.push_back(F); 2224280031Sdim } 2225280031Sdim 2226280031Sdim if (!NonComdatInits.empty()) { 2227280031Sdim llvm::FunctionType *FTy = 2228280031Sdim llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); 2229280031Sdim llvm::Function *InitFunc = CGM.CreateGlobalInitOrDestructFunction( 2230296417Sdim FTy, "__tls_init", CGM.getTypes().arrangeNullaryFunction(), 2231296417Sdim SourceLocation(), /*TLS=*/true); 2232280031Sdim CodeGenFunction(CGM).GenerateCXXGlobalInitFunc(InitFunc, NonComdatInits); 2233280031Sdim 2234280031Sdim AddToXDU(InitFunc); 2235280031Sdim } 2236280031Sdim} 2237280031Sdim 2238280031SdimLValue MicrosoftCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, 2239280031Sdim const VarDecl *VD, 2240280031Sdim QualType LValType) { 2241280031Sdim CGF.CGM.ErrorUnsupported(VD, "thread wrappers"); 2242280031Sdim return LValue(); 2243280031Sdim} 2244280031Sdim 2245296417Sdimstatic ConstantAddress getInitThreadEpochPtr(CodeGenModule &CGM) { 2246288943Sdim StringRef VarName("_Init_thread_epoch"); 2247296417Sdim CharUnits Align = CGM.getIntAlign(); 2248288943Sdim if (auto *GV = CGM.getModule().getNamedGlobal(VarName)) 2249296417Sdim return ConstantAddress(GV, Align); 2250288943Sdim auto *GV = new llvm::GlobalVariable( 2251288943Sdim CGM.getModule(), CGM.IntTy, 2252288943Sdim /*Constant=*/false, llvm::GlobalVariable::ExternalLinkage, 2253288943Sdim /*Initializer=*/nullptr, VarName, 2254288943Sdim /*InsertBefore=*/nullptr, llvm::GlobalVariable::GeneralDynamicTLSModel); 2255296417Sdim GV->setAlignment(Align.getQuantity()); 2256296417Sdim return ConstantAddress(GV, Align); 2257288943Sdim} 2258288943Sdim 2259288943Sdimstatic llvm::Constant *getInitThreadHeaderFn(CodeGenModule &CGM) { 2260288943Sdim llvm::FunctionType *FTy = 2261288943Sdim llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()), 2262288943Sdim CGM.IntTy->getPointerTo(), /*isVarArg=*/false); 2263288943Sdim return CGM.CreateRuntimeFunction( 2264288943Sdim FTy, "_Init_thread_header", 2265288943Sdim llvm::AttributeSet::get(CGM.getLLVMContext(), 2266288943Sdim llvm::AttributeSet::FunctionIndex, 2267288943Sdim llvm::Attribute::NoUnwind)); 2268288943Sdim} 2269288943Sdim 2270288943Sdimstatic llvm::Constant *getInitThreadFooterFn(CodeGenModule &CGM) { 2271288943Sdim llvm::FunctionType *FTy = 2272288943Sdim llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()), 2273288943Sdim CGM.IntTy->getPointerTo(), /*isVarArg=*/false); 2274288943Sdim return CGM.CreateRuntimeFunction( 2275288943Sdim FTy, "_Init_thread_footer", 2276288943Sdim llvm::AttributeSet::get(CGM.getLLVMContext(), 2277288943Sdim llvm::AttributeSet::FunctionIndex, 2278288943Sdim llvm::Attribute::NoUnwind)); 2279288943Sdim} 2280288943Sdim 2281288943Sdimstatic llvm::Constant *getInitThreadAbortFn(CodeGenModule &CGM) { 2282288943Sdim llvm::FunctionType *FTy = 2283288943Sdim llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()), 2284288943Sdim CGM.IntTy->getPointerTo(), /*isVarArg=*/false); 2285288943Sdim return CGM.CreateRuntimeFunction( 2286288943Sdim FTy, "_Init_thread_abort", 2287288943Sdim llvm::AttributeSet::get(CGM.getLLVMContext(), 2288288943Sdim llvm::AttributeSet::FunctionIndex, 2289288943Sdim llvm::Attribute::NoUnwind)); 2290288943Sdim} 2291288943Sdim 2292288943Sdimnamespace { 2293296417Sdimstruct ResetGuardBit final : EHScopeStack::Cleanup { 2294296417Sdim Address Guard; 2295288943Sdim unsigned GuardNum; 2296296417Sdim ResetGuardBit(Address Guard, unsigned GuardNum) 2297288943Sdim : Guard(Guard), GuardNum(GuardNum) {} 2298288943Sdim 2299288943Sdim void Emit(CodeGenFunction &CGF, Flags flags) override { 2300288943Sdim // Reset the bit in the mask so that the static variable may be 2301288943Sdim // reinitialized. 2302288943Sdim CGBuilderTy &Builder = CGF.Builder; 2303288943Sdim llvm::LoadInst *LI = Builder.CreateLoad(Guard); 2304288943Sdim llvm::ConstantInt *Mask = 2305288943Sdim llvm::ConstantInt::get(CGF.IntTy, ~(1U << GuardNum)); 2306288943Sdim Builder.CreateStore(Builder.CreateAnd(LI, Mask), Guard); 2307288943Sdim } 2308288943Sdim}; 2309288943Sdim 2310296417Sdimstruct CallInitThreadAbort final : EHScopeStack::Cleanup { 2311296417Sdim llvm::Value *Guard; 2312296417Sdim CallInitThreadAbort(Address Guard) : Guard(Guard.getPointer()) {} 2313288943Sdim 2314288943Sdim void Emit(CodeGenFunction &CGF, Flags flags) override { 2315288943Sdim // Calling _Init_thread_abort will reset the guard's state. 2316288943Sdim CGF.EmitNounwindRuntimeCall(getInitThreadAbortFn(CGF.CGM), Guard); 2317288943Sdim } 2318288943Sdim}; 2319288943Sdim} 2320288943Sdim 2321239462Sdimvoid MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, 2322261991Sdim llvm::GlobalVariable *GV, 2323239462Sdim bool PerformInit) { 2324276479Sdim // MSVC only uses guards for static locals. 2325276479Sdim if (!D.isStaticLocal()) { 2326276479Sdim assert(GV->hasWeakLinkage() || GV->hasLinkOnceLinkage()); 2327276479Sdim // GlobalOpt is allowed to discard the initializer, so use linkonce_odr. 2328288943Sdim llvm::Function *F = CGF.CurFn; 2329288943Sdim F->setLinkage(llvm::GlobalValue::LinkOnceODRLinkage); 2330288943Sdim F->setComdat(CGM.getModule().getOrInsertComdat(F->getName())); 2331276479Sdim CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit); 2332276479Sdim return; 2333276479Sdim } 2334276479Sdim 2335288943Sdim bool ThreadlocalStatic = D.getTLSKind(); 2336288943Sdim bool ThreadsafeStatic = getContext().getLangOpts().ThreadsafeStatics; 2337239462Sdim 2338288943Sdim // Thread-safe static variables which aren't thread-specific have a 2339288943Sdim // per-variable guard. 2340288943Sdim bool HasPerVariableGuard = ThreadsafeStatic && !ThreadlocalStatic; 2341251662Sdim 2342261991Sdim CGBuilderTy &Builder = CGF.Builder; 2343261991Sdim llvm::IntegerType *GuardTy = CGF.Int32Ty; 2344261991Sdim llvm::ConstantInt *Zero = llvm::ConstantInt::get(GuardTy, 0); 2345296417Sdim CharUnits GuardAlign = CharUnits::fromQuantity(4); 2346261991Sdim 2347261991Sdim // Get the guard variable for this function if we have one already. 2348288943Sdim GuardInfo *GI = nullptr; 2349288943Sdim if (ThreadlocalStatic) 2350288943Sdim GI = &ThreadLocalGuardVariableMap[D.getDeclContext()]; 2351288943Sdim else if (!ThreadsafeStatic) 2352288943Sdim GI = &GuardVariableMap[D.getDeclContext()]; 2353261991Sdim 2354288943Sdim llvm::GlobalVariable *GuardVar = GI ? GI->Guard : nullptr; 2355288943Sdim unsigned GuardNum; 2356288943Sdim if (D.isExternallyVisible()) { 2357261991Sdim // Externally visible variables have to be numbered in Sema to properly 2358261991Sdim // handle unreachable VarDecls. 2359288943Sdim GuardNum = getContext().getStaticLocalNumber(&D); 2360288943Sdim assert(GuardNum > 0); 2361288943Sdim GuardNum--; 2362288943Sdim } else if (HasPerVariableGuard) { 2363288943Sdim GuardNum = ThreadSafeGuardNumMap[D.getDeclContext()]++; 2364261991Sdim } else { 2365261991Sdim // Non-externally visible variables are numbered here in CodeGen. 2366288943Sdim GuardNum = GI->BitIndex++; 2367261991Sdim } 2368261991Sdim 2369288943Sdim if (!HasPerVariableGuard && GuardNum >= 32) { 2370261991Sdim if (D.isExternallyVisible()) 2371261991Sdim ErrorUnsupportedABI(CGF, "more than 32 guarded initializations"); 2372288943Sdim GuardNum %= 32; 2373288943Sdim GuardVar = nullptr; 2374261991Sdim } 2375261991Sdim 2376288943Sdim if (!GuardVar) { 2377261991Sdim // Mangle the name for the guard. 2378261991Sdim SmallString<256> GuardName; 2379261991Sdim { 2380261991Sdim llvm::raw_svector_ostream Out(GuardName); 2381288943Sdim if (HasPerVariableGuard) 2382288943Sdim getMangleContext().mangleThreadSafeStaticGuardVariable(&D, GuardNum, 2383288943Sdim Out); 2384288943Sdim else 2385288943Sdim getMangleContext().mangleStaticGuardVariable(&D, Out); 2386261991Sdim } 2387261991Sdim 2388276479Sdim // Create the guard variable with a zero-initializer. Just absorb linkage, 2389276479Sdim // visibility and dll storage class from the guarded variable. 2390288943Sdim GuardVar = 2391288943Sdim new llvm::GlobalVariable(CGM.getModule(), GuardTy, /*isConstant=*/false, 2392276479Sdim GV->getLinkage(), Zero, GuardName.str()); 2393288943Sdim GuardVar->setVisibility(GV->getVisibility()); 2394288943Sdim GuardVar->setDLLStorageClass(GV->getDLLStorageClass()); 2395296417Sdim GuardVar->setAlignment(GuardAlign.getQuantity()); 2396288943Sdim if (GuardVar->isWeakForLinker()) 2397288943Sdim GuardVar->setComdat( 2398288943Sdim CGM.getModule().getOrInsertComdat(GuardVar->getName())); 2399288943Sdim if (D.getTLSKind()) 2400288943Sdim GuardVar->setThreadLocal(true); 2401288943Sdim if (GI && !HasPerVariableGuard) 2402288943Sdim GI->Guard = GuardVar; 2403261991Sdim } 2404261991Sdim 2405296417Sdim ConstantAddress GuardAddr(GuardVar, GuardAlign); 2406296417Sdim 2407288943Sdim assert(GuardVar->getLinkage() == GV->getLinkage() && 2408288943Sdim "static local from the same function had different linkage"); 2409261991Sdim 2410288943Sdim if (!HasPerVariableGuard) { 2411288943Sdim // Pseudo code for the test: 2412288943Sdim // if (!(GuardVar & MyGuardBit)) { 2413288943Sdim // GuardVar |= MyGuardBit; 2414288943Sdim // ... initialize the object ...; 2415288943Sdim // } 2416261991Sdim 2417288943Sdim // Test our bit from the guard variable. 2418288943Sdim llvm::ConstantInt *Bit = llvm::ConstantInt::get(GuardTy, 1U << GuardNum); 2419296417Sdim llvm::LoadInst *LI = Builder.CreateLoad(GuardAddr); 2420288943Sdim llvm::Value *IsInitialized = 2421288943Sdim Builder.CreateICmpNE(Builder.CreateAnd(LI, Bit), Zero); 2422288943Sdim llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init"); 2423288943Sdim llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end"); 2424288943Sdim Builder.CreateCondBr(IsInitialized, EndBlock, InitBlock); 2425261991Sdim 2426288943Sdim // Set our bit in the guard variable and emit the initializer and add a global 2427288943Sdim // destructor if appropriate. 2428288943Sdim CGF.EmitBlock(InitBlock); 2429296417Sdim Builder.CreateStore(Builder.CreateOr(LI, Bit), GuardAddr); 2430296417Sdim CGF.EHStack.pushCleanup<ResetGuardBit>(EHCleanup, GuardAddr, GuardNum); 2431288943Sdim CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit); 2432288943Sdim CGF.PopCleanupBlock(); 2433288943Sdim Builder.CreateBr(EndBlock); 2434288943Sdim 2435288943Sdim // Continue. 2436288943Sdim CGF.EmitBlock(EndBlock); 2437288943Sdim } else { 2438288943Sdim // Pseudo code for the test: 2439288943Sdim // if (TSS > _Init_thread_epoch) { 2440288943Sdim // _Init_thread_header(&TSS); 2441288943Sdim // if (TSS == -1) { 2442288943Sdim // ... initialize the object ...; 2443288943Sdim // _Init_thread_footer(&TSS); 2444288943Sdim // } 2445288943Sdim // } 2446288943Sdim // 2447288943Sdim // The algorithm is almost identical to what can be found in the appendix 2448288943Sdim // found in N2325. 2449288943Sdim 2450288943Sdim // This BasicBLock determines whether or not we have any work to do. 2451296417Sdim llvm::LoadInst *FirstGuardLoad = Builder.CreateLoad(GuardAddr); 2452288943Sdim FirstGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered); 2453288943Sdim llvm::LoadInst *InitThreadEpoch = 2454288943Sdim Builder.CreateLoad(getInitThreadEpochPtr(CGM)); 2455288943Sdim llvm::Value *IsUninitialized = 2456288943Sdim Builder.CreateICmpSGT(FirstGuardLoad, InitThreadEpoch); 2457288943Sdim llvm::BasicBlock *AttemptInitBlock = CGF.createBasicBlock("init.attempt"); 2458288943Sdim llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end"); 2459288943Sdim Builder.CreateCondBr(IsUninitialized, AttemptInitBlock, EndBlock); 2460288943Sdim 2461288943Sdim // This BasicBlock attempts to determine whether or not this thread is 2462288943Sdim // responsible for doing the initialization. 2463288943Sdim CGF.EmitBlock(AttemptInitBlock); 2464296417Sdim CGF.EmitNounwindRuntimeCall(getInitThreadHeaderFn(CGM), 2465296417Sdim GuardAddr.getPointer()); 2466296417Sdim llvm::LoadInst *SecondGuardLoad = Builder.CreateLoad(GuardAddr); 2467288943Sdim SecondGuardLoad->setOrdering(llvm::AtomicOrdering::Unordered); 2468288943Sdim llvm::Value *ShouldDoInit = 2469288943Sdim Builder.CreateICmpEQ(SecondGuardLoad, getAllOnesInt()); 2470288943Sdim llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init"); 2471288943Sdim Builder.CreateCondBr(ShouldDoInit, InitBlock, EndBlock); 2472288943Sdim 2473288943Sdim // Ok, we ended up getting selected as the initializing thread. 2474288943Sdim CGF.EmitBlock(InitBlock); 2475296417Sdim CGF.EHStack.pushCleanup<CallInitThreadAbort>(EHCleanup, GuardAddr); 2476288943Sdim CGF.EmitCXXGlobalVarDeclInit(D, GV, PerformInit); 2477288943Sdim CGF.PopCleanupBlock(); 2478296417Sdim CGF.EmitNounwindRuntimeCall(getInitThreadFooterFn(CGM), 2479296417Sdim GuardAddr.getPointer()); 2480288943Sdim Builder.CreateBr(EndBlock); 2481288943Sdim 2482288943Sdim CGF.EmitBlock(EndBlock); 2483288943Sdim } 2484239462Sdim} 2485239462Sdim 2486251662Sdimbool MicrosoftCXXABI::isZeroInitializable(const MemberPointerType *MPT) { 2487251662Sdim // Null-ness for function memptrs only depends on the first field, which is 2488251662Sdim // the function pointer. The rest don't matter, so we can zero initialize. 2489251662Sdim if (MPT->isMemberFunctionPointer()) 2490251662Sdim return true; 2491251662Sdim 2492251662Sdim // The virtual base adjustment field is always -1 for null, so if we have one 2493251662Sdim // we can't zero initialize. The field offset is sometimes also -1 if 0 is a 2494251662Sdim // valid field offset. 2495276479Sdim const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 2496276479Sdim MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); 2497276479Sdim return (!MSInheritanceAttr::hasVBTableOffsetField(Inheritance) && 2498276479Sdim RD->nullFieldOffsetIsZero()); 2499239462Sdim} 2500239462Sdim 2501251662Sdimllvm::Type * 2502251662SdimMicrosoftCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) { 2503276479Sdim const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 2504276479Sdim MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); 2505251662Sdim llvm::SmallVector<llvm::Type *, 4> fields; 2506251662Sdim if (MPT->isMemberFunctionPointer()) 2507251662Sdim fields.push_back(CGM.VoidPtrTy); // FunctionPointerOrVirtualThunk 2508251662Sdim else 2509251662Sdim fields.push_back(CGM.IntTy); // FieldOffset 2510251662Sdim 2511276479Sdim if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(), 2512276479Sdim Inheritance)) 2513251662Sdim fields.push_back(CGM.IntTy); 2514276479Sdim if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) 2515251662Sdim fields.push_back(CGM.IntTy); 2516276479Sdim if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance)) 2517251662Sdim fields.push_back(CGM.IntTy); // VirtualBaseAdjustmentOffset 2518251662Sdim 2519251662Sdim if (fields.size() == 1) 2520251662Sdim return fields[0]; 2521251662Sdim return llvm::StructType::get(CGM.getLLVMContext(), fields); 2522251662Sdim} 2523251662Sdim 2524251662Sdimvoid MicrosoftCXXABI:: 2525251662SdimGetNullMemberPointerFields(const MemberPointerType *MPT, 2526251662Sdim llvm::SmallVectorImpl<llvm::Constant *> &fields) { 2527251662Sdim assert(fields.empty()); 2528276479Sdim const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 2529276479Sdim MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); 2530251662Sdim if (MPT->isMemberFunctionPointer()) { 2531251662Sdim // FunctionPointerOrVirtualThunk 2532251662Sdim fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy)); 2533251662Sdim } else { 2534276479Sdim if (RD->nullFieldOffsetIsZero()) 2535251662Sdim fields.push_back(getZeroInt()); // FieldOffset 2536251662Sdim else 2537251662Sdim fields.push_back(getAllOnesInt()); // FieldOffset 2538249423Sdim } 2539251662Sdim 2540276479Sdim if (MSInheritanceAttr::hasNVOffsetField(MPT->isMemberFunctionPointer(), 2541276479Sdim Inheritance)) 2542251662Sdim fields.push_back(getZeroInt()); 2543276479Sdim if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) 2544251662Sdim fields.push_back(getZeroInt()); 2545276479Sdim if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance)) 2546251662Sdim fields.push_back(getAllOnesInt()); 2547249423Sdim} 2548249423Sdim 2549249423Sdimllvm::Constant * 2550249423SdimMicrosoftCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) { 2551251662Sdim llvm::SmallVector<llvm::Constant *, 4> fields; 2552251662Sdim GetNullMemberPointerFields(MPT, fields); 2553251662Sdim if (fields.size() == 1) 2554251662Sdim return fields[0]; 2555251662Sdim llvm::Constant *Res = llvm::ConstantStruct::getAnon(fields); 2556251662Sdim assert(Res->getType() == ConvertMemberPointerType(MPT)); 2557251662Sdim return Res; 2558249423Sdim} 2559249423Sdim 2560249423Sdimllvm::Constant * 2561251662SdimMicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField, 2562251662Sdim bool IsMemberFunction, 2563261991Sdim const CXXRecordDecl *RD, 2564288943Sdim CharUnits NonVirtualBaseAdjustment, 2565288943Sdim unsigned VBTableIndex) { 2566276479Sdim MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); 2567251662Sdim 2568251662Sdim // Single inheritance class member pointer are represented as scalars instead 2569251662Sdim // of aggregates. 2570276479Sdim if (MSInheritanceAttr::hasOnlyOneField(IsMemberFunction, Inheritance)) 2571251662Sdim return FirstField; 2572251662Sdim 2573251662Sdim llvm::SmallVector<llvm::Constant *, 4> fields; 2574251662Sdim fields.push_back(FirstField); 2575251662Sdim 2576276479Sdim if (MSInheritanceAttr::hasNVOffsetField(IsMemberFunction, Inheritance)) 2577261991Sdim fields.push_back(llvm::ConstantInt::get( 2578261991Sdim CGM.IntTy, NonVirtualBaseAdjustment.getQuantity())); 2579251662Sdim 2580276479Sdim if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) { 2581261991Sdim CharUnits Offs = CharUnits::Zero(); 2582288943Sdim if (VBTableIndex) 2583276479Sdim Offs = getContext().getASTRecordLayout(RD).getVBPtrOffset(); 2584261991Sdim fields.push_back(llvm::ConstantInt::get(CGM.IntTy, Offs.getQuantity())); 2585251662Sdim } 2586251662Sdim 2587251662Sdim // The rest of the fields are adjusted by conversions to a more derived class. 2588276479Sdim if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance)) 2589288943Sdim fields.push_back(llvm::ConstantInt::get(CGM.IntTy, VBTableIndex)); 2590251662Sdim 2591251662Sdim return llvm::ConstantStruct::getAnon(fields); 2592251662Sdim} 2593251662Sdim 2594251662Sdimllvm::Constant * 2595249423SdimMicrosoftCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT, 2596249423Sdim CharUnits offset) { 2597276479Sdim const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 2598288943Sdim if (RD->getMSInheritanceModel() == 2599288943Sdim MSInheritanceAttr::Keyword_virtual_inheritance) 2600288943Sdim offset -= getContext().getOffsetOfBaseWithVBPtr(RD); 2601251662Sdim llvm::Constant *FirstField = 2602251662Sdim llvm::ConstantInt::get(CGM.IntTy, offset.getQuantity()); 2603261991Sdim return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/false, RD, 2604288943Sdim CharUnits::Zero(), /*VBTableIndex=*/0); 2605249423Sdim} 2606249423Sdim 2607261991Sdimllvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const APValue &MP, 2608261991Sdim QualType MPType) { 2609288943Sdim const MemberPointerType *DstTy = MPType->castAs<MemberPointerType>(); 2610261991Sdim const ValueDecl *MPD = MP.getMemberPointerDecl(); 2611261991Sdim if (!MPD) 2612288943Sdim return EmitNullMemberPointer(DstTy); 2613261991Sdim 2614288943Sdim ASTContext &Ctx = getContext(); 2615288943Sdim ArrayRef<const CXXRecordDecl *> MemberPointerPath = MP.getMemberPointerPath(); 2616261991Sdim 2617288943Sdim llvm::Constant *C; 2618288943Sdim if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD)) { 2619288943Sdim C = EmitMemberFunctionPointer(MD); 2620288943Sdim } else { 2621288943Sdim CharUnits FieldOffset = Ctx.toCharUnitsFromBits(Ctx.getFieldOffset(MPD)); 2622288943Sdim C = EmitMemberDataPointer(DstTy, FieldOffset); 2623288943Sdim } 2624261991Sdim 2625288943Sdim if (!MemberPointerPath.empty()) { 2626288943Sdim const CXXRecordDecl *SrcRD = cast<CXXRecordDecl>(MPD->getDeclContext()); 2627288943Sdim const Type *SrcRecTy = Ctx.getTypeDeclType(SrcRD).getTypePtr(); 2628288943Sdim const MemberPointerType *SrcTy = 2629288943Sdim Ctx.getMemberPointerType(DstTy->getPointeeType(), SrcRecTy) 2630288943Sdim ->castAs<MemberPointerType>(); 2631261991Sdim 2632288943Sdim bool DerivedMember = MP.isMemberPointerToDerivedMember(); 2633288943Sdim SmallVector<const CXXBaseSpecifier *, 4> DerivedToBasePath; 2634288943Sdim const CXXRecordDecl *PrevRD = SrcRD; 2635288943Sdim for (const CXXRecordDecl *PathElem : MemberPointerPath) { 2636288943Sdim const CXXRecordDecl *Base = nullptr; 2637288943Sdim const CXXRecordDecl *Derived = nullptr; 2638288943Sdim if (DerivedMember) { 2639288943Sdim Base = PathElem; 2640288943Sdim Derived = PrevRD; 2641288943Sdim } else { 2642288943Sdim Base = PrevRD; 2643288943Sdim Derived = PathElem; 2644288943Sdim } 2645288943Sdim for (const CXXBaseSpecifier &BS : Derived->bases()) 2646288943Sdim if (BS.getType()->getAsCXXRecordDecl()->getCanonicalDecl() == 2647288943Sdim Base->getCanonicalDecl()) 2648288943Sdim DerivedToBasePath.push_back(&BS); 2649288943Sdim PrevRD = PathElem; 2650288943Sdim } 2651288943Sdim assert(DerivedToBasePath.size() == MemberPointerPath.size()); 2652288943Sdim 2653288943Sdim CastKind CK = DerivedMember ? CK_DerivedToBaseMemberPointer 2654288943Sdim : CK_BaseToDerivedMemberPointer; 2655288943Sdim C = EmitMemberPointerConversion(SrcTy, DstTy, CK, DerivedToBasePath.begin(), 2656288943Sdim DerivedToBasePath.end(), C); 2657288943Sdim } 2658288943Sdim return C; 2659261991Sdim} 2660261991Sdim 2661251662Sdimllvm::Constant * 2662288943SdimMicrosoftCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) { 2663251662Sdim assert(MD->isInstance() && "Member function must not be static!"); 2664288943Sdim 2665251662Sdim MD = MD->getCanonicalDecl(); 2666288943Sdim CharUnits NonVirtualBaseAdjustment = CharUnits::Zero(); 2667288943Sdim const CXXRecordDecl *RD = MD->getParent()->getMostRecentDecl(); 2668251662Sdim CodeGenTypes &Types = CGM.getTypes(); 2669251662Sdim 2670288943Sdim unsigned VBTableIndex = 0; 2671251662Sdim llvm::Constant *FirstField; 2672280031Sdim const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>(); 2673261991Sdim if (!MD->isVirtual()) { 2674251662Sdim llvm::Type *Ty; 2675251662Sdim // Check whether the function has a computable LLVM signature. 2676251662Sdim if (Types.isFuncTypeConvertible(FPT)) { 2677251662Sdim // The function has a computable LLVM signature; use the correct type. 2678251662Sdim Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD)); 2679251662Sdim } else { 2680251662Sdim // Use an arbitrary non-function type to tell GetAddrOfFunction that the 2681251662Sdim // function type is incomplete. 2682251662Sdim Ty = CGM.PtrDiffTy; 2683251662Sdim } 2684251662Sdim FirstField = CGM.GetAddrOfFunction(MD, Ty); 2685261991Sdim } else { 2686288943Sdim auto &VTableContext = CGM.getMicrosoftVTableContext(); 2687261991Sdim MicrosoftVTableContext::MethodVFTableLocation ML = 2688288943Sdim VTableContext.getMethodVFTableLocation(MD); 2689288943Sdim FirstField = EmitVirtualMemPtrThunk(MD, ML); 2690288943Sdim // Include the vfptr adjustment if the method is in a non-primary vftable. 2691288943Sdim NonVirtualBaseAdjustment += ML.VFPtrOffset; 2692288943Sdim if (ML.VBase) 2693288943Sdim VBTableIndex = VTableContext.getVBTableIndex(RD, ML.VBase) * 4; 2694251662Sdim } 2695251662Sdim 2696288943Sdim if (VBTableIndex == 0 && 2697288943Sdim RD->getMSInheritanceModel() == 2698288943Sdim MSInheritanceAttr::Keyword_virtual_inheritance) 2699288943Sdim NonVirtualBaseAdjustment -= getContext().getOffsetOfBaseWithVBPtr(RD); 2700288943Sdim 2701251662Sdim // The rest of the fields are common with data member pointers. 2702288943Sdim FirstField = llvm::ConstantExpr::getBitCast(FirstField, CGM.VoidPtrTy); 2703261991Sdim return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/true, RD, 2704288943Sdim NonVirtualBaseAdjustment, VBTableIndex); 2705251662Sdim} 2706251662Sdim 2707251662Sdim/// Member pointers are the same if they're either bitwise identical *or* both 2708251662Sdim/// null. Null-ness for function members is determined by the first field, 2709251662Sdim/// while for data member pointers we must compare all fields. 2710249423Sdimllvm::Value * 2711251662SdimMicrosoftCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF, 2712251662Sdim llvm::Value *L, 2713251662Sdim llvm::Value *R, 2714251662Sdim const MemberPointerType *MPT, 2715251662Sdim bool Inequality) { 2716251662Sdim CGBuilderTy &Builder = CGF.Builder; 2717251662Sdim 2718251662Sdim // Handle != comparisons by switching the sense of all boolean operations. 2719251662Sdim llvm::ICmpInst::Predicate Eq; 2720251662Sdim llvm::Instruction::BinaryOps And, Or; 2721251662Sdim if (Inequality) { 2722251662Sdim Eq = llvm::ICmpInst::ICMP_NE; 2723251662Sdim And = llvm::Instruction::Or; 2724251662Sdim Or = llvm::Instruction::And; 2725251662Sdim } else { 2726251662Sdim Eq = llvm::ICmpInst::ICMP_EQ; 2727251662Sdim And = llvm::Instruction::And; 2728251662Sdim Or = llvm::Instruction::Or; 2729251662Sdim } 2730251662Sdim 2731251662Sdim // If this is a single field member pointer (single inheritance), this is a 2732251662Sdim // single icmp. 2733276479Sdim const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 2734276479Sdim MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); 2735276479Sdim if (MSInheritanceAttr::hasOnlyOneField(MPT->isMemberFunctionPointer(), 2736276479Sdim Inheritance)) 2737251662Sdim return Builder.CreateICmp(Eq, L, R); 2738251662Sdim 2739251662Sdim // Compare the first field. 2740251662Sdim llvm::Value *L0 = Builder.CreateExtractValue(L, 0, "lhs.0"); 2741251662Sdim llvm::Value *R0 = Builder.CreateExtractValue(R, 0, "rhs.0"); 2742251662Sdim llvm::Value *Cmp0 = Builder.CreateICmp(Eq, L0, R0, "memptr.cmp.first"); 2743251662Sdim 2744251662Sdim // Compare everything other than the first field. 2745276479Sdim llvm::Value *Res = nullptr; 2746251662Sdim llvm::StructType *LType = cast<llvm::StructType>(L->getType()); 2747251662Sdim for (unsigned I = 1, E = LType->getNumElements(); I != E; ++I) { 2748251662Sdim llvm::Value *LF = Builder.CreateExtractValue(L, I); 2749251662Sdim llvm::Value *RF = Builder.CreateExtractValue(R, I); 2750251662Sdim llvm::Value *Cmp = Builder.CreateICmp(Eq, LF, RF, "memptr.cmp.rest"); 2751251662Sdim if (Res) 2752251662Sdim Res = Builder.CreateBinOp(And, Res, Cmp); 2753251662Sdim else 2754251662Sdim Res = Cmp; 2755251662Sdim } 2756251662Sdim 2757251662Sdim // Check if the first field is 0 if this is a function pointer. 2758251662Sdim if (MPT->isMemberFunctionPointer()) { 2759251662Sdim // (l1 == r1 && ...) || l0 == 0 2760251662Sdim llvm::Value *Zero = llvm::Constant::getNullValue(L0->getType()); 2761251662Sdim llvm::Value *IsZero = Builder.CreateICmp(Eq, L0, Zero, "memptr.cmp.iszero"); 2762251662Sdim Res = Builder.CreateBinOp(Or, Res, IsZero); 2763251662Sdim } 2764251662Sdim 2765251662Sdim // Combine the comparison of the first field, which must always be true for 2766251662Sdim // this comparison to succeeed. 2767251662Sdim return Builder.CreateBinOp(And, Res, Cmp0, "memptr.cmp"); 2768251662Sdim} 2769251662Sdim 2770251662Sdimllvm::Value * 2771249423SdimMicrosoftCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF, 2772249423Sdim llvm::Value *MemPtr, 2773249423Sdim const MemberPointerType *MPT) { 2774249423Sdim CGBuilderTy &Builder = CGF.Builder; 2775251662Sdim llvm::SmallVector<llvm::Constant *, 4> fields; 2776251662Sdim // We only need one field for member functions. 2777251662Sdim if (MPT->isMemberFunctionPointer()) 2778251662Sdim fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy)); 2779251662Sdim else 2780251662Sdim GetNullMemberPointerFields(MPT, fields); 2781251662Sdim assert(!fields.empty()); 2782251662Sdim llvm::Value *FirstField = MemPtr; 2783251662Sdim if (MemPtr->getType()->isStructTy()) 2784251662Sdim FirstField = Builder.CreateExtractValue(MemPtr, 0); 2785251662Sdim llvm::Value *Res = Builder.CreateICmpNE(FirstField, fields[0], "memptr.cmp0"); 2786249423Sdim 2787251662Sdim // For function member pointers, we only need to test the function pointer 2788251662Sdim // field. The other fields if any can be garbage. 2789251662Sdim if (MPT->isMemberFunctionPointer()) 2790251662Sdim return Res; 2791251662Sdim 2792251662Sdim // Otherwise, emit a series of compares and combine the results. 2793251662Sdim for (int I = 1, E = fields.size(); I < E; ++I) { 2794251662Sdim llvm::Value *Field = Builder.CreateExtractValue(MemPtr, I); 2795251662Sdim llvm::Value *Next = Builder.CreateICmpNE(Field, fields[I], "memptr.cmp"); 2796276479Sdim Res = Builder.CreateOr(Res, Next, "memptr.tobool"); 2797249423Sdim } 2798251662Sdim return Res; 2799251662Sdim} 2800249423Sdim 2801261991Sdimbool MicrosoftCXXABI::MemberPointerConstantIsNull(const MemberPointerType *MPT, 2802261991Sdim llvm::Constant *Val) { 2803261991Sdim // Function pointers are null if the pointer in the first field is null. 2804261991Sdim if (MPT->isMemberFunctionPointer()) { 2805261991Sdim llvm::Constant *FirstField = Val->getType()->isStructTy() ? 2806261991Sdim Val->getAggregateElement(0U) : Val; 2807261991Sdim return FirstField->isNullValue(); 2808261991Sdim } 2809261991Sdim 2810261991Sdim // If it's not a function pointer and it's zero initializable, we can easily 2811261991Sdim // check zero. 2812261991Sdim if (isZeroInitializable(MPT) && Val->isNullValue()) 2813261991Sdim return true; 2814261991Sdim 2815261991Sdim // Otherwise, break down all the fields for comparison. Hopefully these 2816261991Sdim // little Constants are reused, while a big null struct might not be. 2817261991Sdim llvm::SmallVector<llvm::Constant *, 4> Fields; 2818261991Sdim GetNullMemberPointerFields(MPT, Fields); 2819261991Sdim if (Fields.size() == 1) { 2820261991Sdim assert(Val->getType()->isIntegerTy()); 2821261991Sdim return Val == Fields[0]; 2822261991Sdim } 2823261991Sdim 2824261991Sdim unsigned I, E; 2825261991Sdim for (I = 0, E = Fields.size(); I != E; ++I) { 2826261991Sdim if (Val->getAggregateElement(I) != Fields[I]) 2827261991Sdim break; 2828261991Sdim } 2829261991Sdim return I == E; 2830261991Sdim} 2831261991Sdim 2832261991Sdimllvm::Value * 2833261991SdimMicrosoftCXXABI::GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF, 2834296417Sdim Address This, 2835261991Sdim llvm::Value *VBPtrOffset, 2836261991Sdim llvm::Value *VBTableOffset, 2837261991Sdim llvm::Value **VBPtrOut) { 2838261991Sdim CGBuilderTy &Builder = CGF.Builder; 2839261991Sdim // Load the vbtable pointer from the vbptr in the instance. 2840296417Sdim This = Builder.CreateElementBitCast(This, CGM.Int8Ty); 2841261991Sdim llvm::Value *VBPtr = 2842296417Sdim Builder.CreateInBoundsGEP(This.getPointer(), VBPtrOffset, "vbptr"); 2843261991Sdim if (VBPtrOut) *VBPtrOut = VBPtr; 2844280031Sdim VBPtr = Builder.CreateBitCast(VBPtr, 2845296417Sdim CGM.Int32Ty->getPointerTo(0)->getPointerTo(This.getAddressSpace())); 2846261991Sdim 2847296417Sdim CharUnits VBPtrAlign; 2848296417Sdim if (auto CI = dyn_cast<llvm::ConstantInt>(VBPtrOffset)) { 2849296417Sdim VBPtrAlign = This.getAlignment().alignmentAtOffset( 2850296417Sdim CharUnits::fromQuantity(CI->getSExtValue())); 2851296417Sdim } else { 2852296417Sdim VBPtrAlign = CGF.getPointerAlign(); 2853296417Sdim } 2854296417Sdim 2855296417Sdim llvm::Value *VBTable = Builder.CreateAlignedLoad(VBPtr, VBPtrAlign, "vbtable"); 2856296417Sdim 2857280031Sdim // Translate from byte offset to table index. It improves analyzability. 2858280031Sdim llvm::Value *VBTableIndex = Builder.CreateAShr( 2859280031Sdim VBTableOffset, llvm::ConstantInt::get(VBTableOffset->getType(), 2), 2860280031Sdim "vbtindex", /*isExact=*/true); 2861280031Sdim 2862261991Sdim // Load an i32 offset from the vb-table. 2863280031Sdim llvm::Value *VBaseOffs = Builder.CreateInBoundsGEP(VBTable, VBTableIndex); 2864261991Sdim VBaseOffs = Builder.CreateBitCast(VBaseOffs, CGM.Int32Ty->getPointerTo(0)); 2865296417Sdim return Builder.CreateAlignedLoad(VBaseOffs, CharUnits::fromQuantity(4), 2866296417Sdim "vbase_offs"); 2867261991Sdim} 2868261991Sdim 2869251662Sdim// Returns an adjusted base cast to i8*, since we do more address arithmetic on 2870251662Sdim// it. 2871276479Sdimllvm::Value *MicrosoftCXXABI::AdjustVirtualBase( 2872276479Sdim CodeGenFunction &CGF, const Expr *E, const CXXRecordDecl *RD, 2873296417Sdim Address Base, llvm::Value *VBTableOffset, llvm::Value *VBPtrOffset) { 2874251662Sdim CGBuilderTy &Builder = CGF.Builder; 2875296417Sdim Base = Builder.CreateElementBitCast(Base, CGM.Int8Ty); 2876276479Sdim llvm::BasicBlock *OriginalBB = nullptr; 2877276479Sdim llvm::BasicBlock *SkipAdjustBB = nullptr; 2878276479Sdim llvm::BasicBlock *VBaseAdjustBB = nullptr; 2879251662Sdim 2880251662Sdim // In the unspecified inheritance model, there might not be a vbtable at all, 2881251662Sdim // in which case we need to skip the virtual base lookup. If there is a 2882251662Sdim // vbtable, the first entry is a no-op entry that gives back the original 2883251662Sdim // base, so look for a virtual base adjustment offset of zero. 2884251662Sdim if (VBPtrOffset) { 2885251662Sdim OriginalBB = Builder.GetInsertBlock(); 2886251662Sdim VBaseAdjustBB = CGF.createBasicBlock("memptr.vadjust"); 2887251662Sdim SkipAdjustBB = CGF.createBasicBlock("memptr.skip_vadjust"); 2888251662Sdim llvm::Value *IsVirtual = 2889261991Sdim Builder.CreateICmpNE(VBTableOffset, getZeroInt(), 2890251662Sdim "memptr.is_vbase"); 2891251662Sdim Builder.CreateCondBr(IsVirtual, VBaseAdjustBB, SkipAdjustBB); 2892251662Sdim CGF.EmitBlock(VBaseAdjustBB); 2893251662Sdim } 2894251662Sdim 2895251662Sdim // If we weren't given a dynamic vbptr offset, RD should be complete and we'll 2896251662Sdim // know the vbptr offset. 2897251662Sdim if (!VBPtrOffset) { 2898261991Sdim CharUnits offs = CharUnits::Zero(); 2899276479Sdim if (!RD->hasDefinition()) { 2900276479Sdim DiagnosticsEngine &Diags = CGF.CGM.getDiags(); 2901276479Sdim unsigned DiagID = Diags.getCustomDiagID( 2902276479Sdim DiagnosticsEngine::Error, 2903276479Sdim "member pointer representation requires a " 2904276479Sdim "complete class type for %0 to perform this expression"); 2905276479Sdim Diags.Report(E->getExprLoc(), DiagID) << RD << E->getSourceRange(); 2906276479Sdim } else if (RD->getNumVBases()) 2907276479Sdim offs = getContext().getASTRecordLayout(RD).getVBPtrOffset(); 2908251662Sdim VBPtrOffset = llvm::ConstantInt::get(CGM.IntTy, offs.getQuantity()); 2909251662Sdim } 2910276479Sdim llvm::Value *VBPtr = nullptr; 2911251662Sdim llvm::Value *VBaseOffs = 2912261991Sdim GetVBaseOffsetFromVBPtr(CGF, Base, VBPtrOffset, VBTableOffset, &VBPtr); 2913251662Sdim llvm::Value *AdjustedBase = Builder.CreateInBoundsGEP(VBPtr, VBaseOffs); 2914251662Sdim 2915251662Sdim // Merge control flow with the case where we didn't have to adjust. 2916251662Sdim if (VBaseAdjustBB) { 2917251662Sdim Builder.CreateBr(SkipAdjustBB); 2918251662Sdim CGF.EmitBlock(SkipAdjustBB); 2919251662Sdim llvm::PHINode *Phi = Builder.CreatePHI(CGM.Int8PtrTy, 2, "memptr.base"); 2920296417Sdim Phi->addIncoming(Base.getPointer(), OriginalBB); 2921251662Sdim Phi->addIncoming(AdjustedBase, VBaseAdjustBB); 2922251662Sdim return Phi; 2923251662Sdim } 2924251662Sdim return AdjustedBase; 2925249423Sdim} 2926249423Sdim 2927276479Sdimllvm::Value *MicrosoftCXXABI::EmitMemberDataPointerAddress( 2928296417Sdim CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr, 2929276479Sdim const MemberPointerType *MPT) { 2930251662Sdim assert(MPT->isMemberDataPointer()); 2931296417Sdim unsigned AS = Base.getAddressSpace(); 2932249423Sdim llvm::Type *PType = 2933249423Sdim CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS); 2934249423Sdim CGBuilderTy &Builder = CGF.Builder; 2935276479Sdim const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 2936276479Sdim MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); 2937249423Sdim 2938251662Sdim // Extract the fields we need, regardless of model. We'll apply them if we 2939251662Sdim // have them. 2940251662Sdim llvm::Value *FieldOffset = MemPtr; 2941276479Sdim llvm::Value *VirtualBaseAdjustmentOffset = nullptr; 2942276479Sdim llvm::Value *VBPtrOffset = nullptr; 2943251662Sdim if (MemPtr->getType()->isStructTy()) { 2944251662Sdim // We need to extract values. 2945251662Sdim unsigned I = 0; 2946251662Sdim FieldOffset = Builder.CreateExtractValue(MemPtr, I++); 2947276479Sdim if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) 2948251662Sdim VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++); 2949276479Sdim if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance)) 2950251662Sdim VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++); 2951249423Sdim } 2952249423Sdim 2953296417Sdim llvm::Value *Addr; 2954251662Sdim if (VirtualBaseAdjustmentOffset) { 2955296417Sdim Addr = AdjustVirtualBase(CGF, E, RD, Base, VirtualBaseAdjustmentOffset, 2956251662Sdim VBPtrOffset); 2957296417Sdim } else { 2958296417Sdim Addr = Base.getPointer(); 2959249423Sdim } 2960276479Sdim 2961276479Sdim // Cast to char*. 2962296417Sdim Addr = Builder.CreateBitCast(Addr, CGF.Int8Ty->getPointerTo(AS)); 2963276479Sdim 2964276479Sdim // Apply the offset, which we assume is non-null. 2965296417Sdim Addr = Builder.CreateInBoundsGEP(Addr, FieldOffset, "memptr.offset"); 2966249423Sdim 2967249423Sdim // Cast the address to the appropriate pointer type, adopting the address 2968249423Sdim // space of the base pointer. 2969249423Sdim return Builder.CreateBitCast(Addr, PType); 2970249423Sdim} 2971249423Sdim 2972251662Sdimllvm::Value * 2973261991SdimMicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, 2974261991Sdim const CastExpr *E, 2975261991Sdim llvm::Value *Src) { 2976261991Sdim assert(E->getCastKind() == CK_DerivedToBaseMemberPointer || 2977261991Sdim E->getCastKind() == CK_BaseToDerivedMemberPointer || 2978261991Sdim E->getCastKind() == CK_ReinterpretMemberPointer); 2979261991Sdim 2980261991Sdim // Use constant emission if we can. 2981261991Sdim if (isa<llvm::Constant>(Src)) 2982261991Sdim return EmitMemberPointerConversion(E, cast<llvm::Constant>(Src)); 2983261991Sdim 2984261991Sdim // We may be adding or dropping fields from the member pointer, so we need 2985261991Sdim // both types and the inheritance models of both records. 2986261991Sdim const MemberPointerType *SrcTy = 2987261991Sdim E->getSubExpr()->getType()->castAs<MemberPointerType>(); 2988261991Sdim const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>(); 2989261991Sdim bool IsFunc = SrcTy->isMemberFunctionPointer(); 2990261991Sdim 2991261991Sdim // If the classes use the same null representation, reinterpret_cast is a nop. 2992261991Sdim bool IsReinterpret = E->getCastKind() == CK_ReinterpretMemberPointer; 2993276479Sdim if (IsReinterpret && IsFunc) 2994261991Sdim return Src; 2995261991Sdim 2996276479Sdim CXXRecordDecl *SrcRD = SrcTy->getMostRecentCXXRecordDecl(); 2997276479Sdim CXXRecordDecl *DstRD = DstTy->getMostRecentCXXRecordDecl(); 2998276479Sdim if (IsReinterpret && 2999276479Sdim SrcRD->nullFieldOffsetIsZero() == DstRD->nullFieldOffsetIsZero()) 3000276479Sdim return Src; 3001276479Sdim 3002261991Sdim CGBuilderTy &Builder = CGF.Builder; 3003261991Sdim 3004261991Sdim // Branch past the conversion if Src is null. 3005261991Sdim llvm::Value *IsNotNull = EmitMemberPointerIsNotNull(CGF, Src, SrcTy); 3006261991Sdim llvm::Constant *DstNull = EmitNullMemberPointer(DstTy); 3007261991Sdim 3008261991Sdim // C++ 5.2.10p9: The null member pointer value is converted to the null member 3009261991Sdim // pointer value of the destination type. 3010261991Sdim if (IsReinterpret) { 3011261991Sdim // For reinterpret casts, sema ensures that src and dst are both functions 3012261991Sdim // or data and have the same size, which means the LLVM types should match. 3013261991Sdim assert(Src->getType() == DstNull->getType()); 3014261991Sdim return Builder.CreateSelect(IsNotNull, Src, DstNull); 3015261991Sdim } 3016261991Sdim 3017261991Sdim llvm::BasicBlock *OriginalBB = Builder.GetInsertBlock(); 3018261991Sdim llvm::BasicBlock *ConvertBB = CGF.createBasicBlock("memptr.convert"); 3019261991Sdim llvm::BasicBlock *ContinueBB = CGF.createBasicBlock("memptr.converted"); 3020261991Sdim Builder.CreateCondBr(IsNotNull, ConvertBB, ContinueBB); 3021261991Sdim CGF.EmitBlock(ConvertBB); 3022261991Sdim 3023288943Sdim llvm::Value *Dst = EmitNonNullMemberPointerConversion( 3024288943Sdim SrcTy, DstTy, E->getCastKind(), E->path_begin(), E->path_end(), Src, 3025288943Sdim Builder); 3026288943Sdim 3027288943Sdim Builder.CreateBr(ContinueBB); 3028288943Sdim 3029288943Sdim // In the continuation, choose between DstNull and Dst. 3030288943Sdim CGF.EmitBlock(ContinueBB); 3031288943Sdim llvm::PHINode *Phi = Builder.CreatePHI(DstNull->getType(), 2, "memptr.converted"); 3032288943Sdim Phi->addIncoming(DstNull, OriginalBB); 3033288943Sdim Phi->addIncoming(Dst, ConvertBB); 3034288943Sdim return Phi; 3035288943Sdim} 3036288943Sdim 3037288943Sdimllvm::Value *MicrosoftCXXABI::EmitNonNullMemberPointerConversion( 3038288943Sdim const MemberPointerType *SrcTy, const MemberPointerType *DstTy, CastKind CK, 3039288943Sdim CastExpr::path_const_iterator PathBegin, 3040288943Sdim CastExpr::path_const_iterator PathEnd, llvm::Value *Src, 3041288943Sdim CGBuilderTy &Builder) { 3042288943Sdim const CXXRecordDecl *SrcRD = SrcTy->getMostRecentCXXRecordDecl(); 3043288943Sdim const CXXRecordDecl *DstRD = DstTy->getMostRecentCXXRecordDecl(); 3044288943Sdim MSInheritanceAttr::Spelling SrcInheritance = SrcRD->getMSInheritanceModel(); 3045288943Sdim MSInheritanceAttr::Spelling DstInheritance = DstRD->getMSInheritanceModel(); 3046288943Sdim bool IsFunc = SrcTy->isMemberFunctionPointer(); 3047288943Sdim bool IsConstant = isa<llvm::Constant>(Src); 3048288943Sdim 3049261991Sdim // Decompose src. 3050261991Sdim llvm::Value *FirstField = Src; 3051288943Sdim llvm::Value *NonVirtualBaseAdjustment = getZeroInt(); 3052288943Sdim llvm::Value *VirtualBaseAdjustmentOffset = getZeroInt(); 3053288943Sdim llvm::Value *VBPtrOffset = getZeroInt(); 3054276479Sdim if (!MSInheritanceAttr::hasOnlyOneField(IsFunc, SrcInheritance)) { 3055261991Sdim // We need to extract values. 3056261991Sdim unsigned I = 0; 3057261991Sdim FirstField = Builder.CreateExtractValue(Src, I++); 3058276479Sdim if (MSInheritanceAttr::hasNVOffsetField(IsFunc, SrcInheritance)) 3059261991Sdim NonVirtualBaseAdjustment = Builder.CreateExtractValue(Src, I++); 3060276479Sdim if (MSInheritanceAttr::hasVBPtrOffsetField(SrcInheritance)) 3061261991Sdim VBPtrOffset = Builder.CreateExtractValue(Src, I++); 3062276479Sdim if (MSInheritanceAttr::hasVBTableOffsetField(SrcInheritance)) 3063261991Sdim VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(Src, I++); 3064261991Sdim } 3065261991Sdim 3066288943Sdim bool IsDerivedToBase = (CK == CK_DerivedToBaseMemberPointer); 3067288943Sdim const MemberPointerType *DerivedTy = IsDerivedToBase ? SrcTy : DstTy; 3068288943Sdim const CXXRecordDecl *DerivedClass = DerivedTy->getMostRecentCXXRecordDecl(); 3069288943Sdim 3070261991Sdim // For data pointers, we adjust the field offset directly. For functions, we 3071261991Sdim // have a separate field. 3072288943Sdim llvm::Value *&NVAdjustField = IsFunc ? NonVirtualBaseAdjustment : FirstField; 3073288943Sdim 3074288943Sdim // The virtual inheritance model has a quirk: the virtual base table is always 3075288943Sdim // referenced when dereferencing a member pointer even if the member pointer 3076288943Sdim // is non-virtual. This is accounted for by adjusting the non-virtual offset 3077288943Sdim // to point backwards to the top of the MDC from the first VBase. Undo this 3078288943Sdim // adjustment to normalize the member pointer. 3079288943Sdim llvm::Value *SrcVBIndexEqZero = 3080288943Sdim Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt()); 3081288943Sdim if (SrcInheritance == MSInheritanceAttr::Keyword_virtual_inheritance) { 3082288943Sdim if (int64_t SrcOffsetToFirstVBase = 3083288943Sdim getContext().getOffsetOfBaseWithVBPtr(SrcRD).getQuantity()) { 3084288943Sdim llvm::Value *UndoSrcAdjustment = Builder.CreateSelect( 3085288943Sdim SrcVBIndexEqZero, 3086288943Sdim llvm::ConstantInt::get(CGM.IntTy, SrcOffsetToFirstVBase), 3087288943Sdim getZeroInt()); 3088288943Sdim NVAdjustField = Builder.CreateNSWAdd(NVAdjustField, UndoSrcAdjustment); 3089288943Sdim } 3090261991Sdim } 3091261991Sdim 3092288943Sdim // A non-zero vbindex implies that we are dealing with a source member in a 3093288943Sdim // floating virtual base in addition to some non-virtual offset. If the 3094288943Sdim // vbindex is zero, we are dealing with a source that exists in a non-virtual, 3095288943Sdim // fixed, base. The difference between these two cases is that the vbindex + 3096288943Sdim // nvoffset *always* point to the member regardless of what context they are 3097288943Sdim // evaluated in so long as the vbindex is adjusted. A member inside a fixed 3098288943Sdim // base requires explicit nv adjustment. 3099288943Sdim llvm::Constant *BaseClassOffset = llvm::ConstantInt::get( 3100288943Sdim CGM.IntTy, 3101288943Sdim CGM.computeNonVirtualBaseClassOffset(DerivedClass, PathBegin, PathEnd) 3102288943Sdim .getQuantity()); 3103261991Sdim 3104288943Sdim llvm::Value *NVDisp; 3105288943Sdim if (IsDerivedToBase) 3106288943Sdim NVDisp = Builder.CreateNSWSub(NVAdjustField, BaseClassOffset, "adj"); 3107288943Sdim else 3108288943Sdim NVDisp = Builder.CreateNSWAdd(NVAdjustField, BaseClassOffset, "adj"); 3109288943Sdim 3110288943Sdim NVAdjustField = Builder.CreateSelect(SrcVBIndexEqZero, NVDisp, getZeroInt()); 3111288943Sdim 3112288943Sdim // Update the vbindex to an appropriate value in the destination because 3113288943Sdim // SrcRD's vbtable might not be a strict prefix of the one in DstRD. 3114288943Sdim llvm::Value *DstVBIndexEqZero = SrcVBIndexEqZero; 3115288943Sdim if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance) && 3116288943Sdim MSInheritanceAttr::hasVBTableOffsetField(SrcInheritance)) { 3117288943Sdim if (llvm::GlobalVariable *VDispMap = 3118288943Sdim getAddrOfVirtualDisplacementMap(SrcRD, DstRD)) { 3119288943Sdim llvm::Value *VBIndex = Builder.CreateExactUDiv( 3120288943Sdim VirtualBaseAdjustmentOffset, llvm::ConstantInt::get(CGM.IntTy, 4)); 3121288943Sdim if (IsConstant) { 3122288943Sdim llvm::Constant *Mapping = VDispMap->getInitializer(); 3123288943Sdim VirtualBaseAdjustmentOffset = 3124288943Sdim Mapping->getAggregateElement(cast<llvm::Constant>(VBIndex)); 3125288943Sdim } else { 3126288943Sdim llvm::Value *Idxs[] = {getZeroInt(), VBIndex}; 3127288943Sdim VirtualBaseAdjustmentOffset = 3128296417Sdim Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(VDispMap, Idxs), 3129296417Sdim CharUnits::fromQuantity(4)); 3130288943Sdim } 3131288943Sdim 3132288943Sdim DstVBIndexEqZero = 3133288943Sdim Builder.CreateICmpEQ(VirtualBaseAdjustmentOffset, getZeroInt()); 3134288943Sdim } 3135288943Sdim } 3136288943Sdim 3137288943Sdim // Set the VBPtrOffset to zero if the vbindex is zero. Otherwise, initialize 3138288943Sdim // it to the offset of the vbptr. 3139288943Sdim if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance)) { 3140288943Sdim llvm::Value *DstVBPtrOffset = llvm::ConstantInt::get( 3141288943Sdim CGM.IntTy, 3142288943Sdim getContext().getASTRecordLayout(DstRD).getVBPtrOffset().getQuantity()); 3143288943Sdim VBPtrOffset = 3144288943Sdim Builder.CreateSelect(DstVBIndexEqZero, getZeroInt(), DstVBPtrOffset); 3145288943Sdim } 3146288943Sdim 3147288943Sdim // Likewise, apply a similar adjustment so that dereferencing the member 3148288943Sdim // pointer correctly accounts for the distance between the start of the first 3149288943Sdim // virtual base and the top of the MDC. 3150288943Sdim if (DstInheritance == MSInheritanceAttr::Keyword_virtual_inheritance) { 3151288943Sdim if (int64_t DstOffsetToFirstVBase = 3152288943Sdim getContext().getOffsetOfBaseWithVBPtr(DstRD).getQuantity()) { 3153288943Sdim llvm::Value *DoDstAdjustment = Builder.CreateSelect( 3154288943Sdim DstVBIndexEqZero, 3155288943Sdim llvm::ConstantInt::get(CGM.IntTy, DstOffsetToFirstVBase), 3156288943Sdim getZeroInt()); 3157288943Sdim NVAdjustField = Builder.CreateNSWSub(NVAdjustField, DoDstAdjustment); 3158288943Sdim } 3159288943Sdim } 3160288943Sdim 3161261991Sdim // Recompose dst from the null struct and the adjusted fields from src. 3162261991Sdim llvm::Value *Dst; 3163276479Sdim if (MSInheritanceAttr::hasOnlyOneField(IsFunc, DstInheritance)) { 3164261991Sdim Dst = FirstField; 3165261991Sdim } else { 3166288943Sdim Dst = llvm::UndefValue::get(ConvertMemberPointerType(DstTy)); 3167261991Sdim unsigned Idx = 0; 3168261991Sdim Dst = Builder.CreateInsertValue(Dst, FirstField, Idx++); 3169276479Sdim if (MSInheritanceAttr::hasNVOffsetField(IsFunc, DstInheritance)) 3170288943Sdim Dst = Builder.CreateInsertValue(Dst, NonVirtualBaseAdjustment, Idx++); 3171276479Sdim if (MSInheritanceAttr::hasVBPtrOffsetField(DstInheritance)) 3172288943Sdim Dst = Builder.CreateInsertValue(Dst, VBPtrOffset, Idx++); 3173276479Sdim if (MSInheritanceAttr::hasVBTableOffsetField(DstInheritance)) 3174288943Sdim Dst = Builder.CreateInsertValue(Dst, VirtualBaseAdjustmentOffset, Idx++); 3175261991Sdim } 3176288943Sdim return Dst; 3177261991Sdim} 3178261991Sdim 3179261991Sdimllvm::Constant * 3180261991SdimMicrosoftCXXABI::EmitMemberPointerConversion(const CastExpr *E, 3181261991Sdim llvm::Constant *Src) { 3182261991Sdim const MemberPointerType *SrcTy = 3183288943Sdim E->getSubExpr()->getType()->castAs<MemberPointerType>(); 3184261991Sdim const MemberPointerType *DstTy = E->getType()->castAs<MemberPointerType>(); 3185261991Sdim 3186288943Sdim CastKind CK = E->getCastKind(); 3187288943Sdim 3188288943Sdim return EmitMemberPointerConversion(SrcTy, DstTy, CK, E->path_begin(), 3189288943Sdim E->path_end(), Src); 3190288943Sdim} 3191288943Sdim 3192288943Sdimllvm::Constant *MicrosoftCXXABI::EmitMemberPointerConversion( 3193288943Sdim const MemberPointerType *SrcTy, const MemberPointerType *DstTy, CastKind CK, 3194288943Sdim CastExpr::path_const_iterator PathBegin, 3195288943Sdim CastExpr::path_const_iterator PathEnd, llvm::Constant *Src) { 3196288943Sdim assert(CK == CK_DerivedToBaseMemberPointer || 3197288943Sdim CK == CK_BaseToDerivedMemberPointer || 3198288943Sdim CK == CK_ReinterpretMemberPointer); 3199261991Sdim // If src is null, emit a new null for dst. We can't return src because dst 3200261991Sdim // might have a new representation. 3201261991Sdim if (MemberPointerConstantIsNull(SrcTy, Src)) 3202261991Sdim return EmitNullMemberPointer(DstTy); 3203261991Sdim 3204261991Sdim // We don't need to do anything for reinterpret_casts of non-null member 3205261991Sdim // pointers. We should only get here when the two type representations have 3206261991Sdim // the same size. 3207288943Sdim if (CK == CK_ReinterpretMemberPointer) 3208261991Sdim return Src; 3209261991Sdim 3210296417Sdim CGBuilderTy Builder(CGM, CGM.getLLVMContext()); 3211288943Sdim auto *Dst = cast<llvm::Constant>(EmitNonNullMemberPointerConversion( 3212288943Sdim SrcTy, DstTy, CK, PathBegin, PathEnd, Src, Builder)); 3213261991Sdim 3214288943Sdim return Dst; 3215261991Sdim} 3216261991Sdim 3217276479Sdimllvm::Value *MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer( 3218296417Sdim CodeGenFunction &CGF, const Expr *E, Address This, 3219296417Sdim llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr, 3220296417Sdim const MemberPointerType *MPT) { 3221251662Sdim assert(MPT->isMemberFunctionPointer()); 3222251662Sdim const FunctionProtoType *FPT = 3223251662Sdim MPT->getPointeeType()->castAs<FunctionProtoType>(); 3224276479Sdim const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 3225296417Sdim llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType( 3226296417Sdim CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr)); 3227251662Sdim CGBuilderTy &Builder = CGF.Builder; 3228251662Sdim 3229276479Sdim MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); 3230251662Sdim 3231251662Sdim // Extract the fields we need, regardless of model. We'll apply them if we 3232251662Sdim // have them. 3233251662Sdim llvm::Value *FunctionPointer = MemPtr; 3234276479Sdim llvm::Value *NonVirtualBaseAdjustment = nullptr; 3235276479Sdim llvm::Value *VirtualBaseAdjustmentOffset = nullptr; 3236276479Sdim llvm::Value *VBPtrOffset = nullptr; 3237251662Sdim if (MemPtr->getType()->isStructTy()) { 3238251662Sdim // We need to extract values. 3239251662Sdim unsigned I = 0; 3240251662Sdim FunctionPointer = Builder.CreateExtractValue(MemPtr, I++); 3241276479Sdim if (MSInheritanceAttr::hasNVOffsetField(MPT, Inheritance)) 3242251662Sdim NonVirtualBaseAdjustment = Builder.CreateExtractValue(MemPtr, I++); 3243276479Sdim if (MSInheritanceAttr::hasVBPtrOffsetField(Inheritance)) 3244251662Sdim VBPtrOffset = Builder.CreateExtractValue(MemPtr, I++); 3245276479Sdim if (MSInheritanceAttr::hasVBTableOffsetField(Inheritance)) 3246251662Sdim VirtualBaseAdjustmentOffset = Builder.CreateExtractValue(MemPtr, I++); 3247251662Sdim } 3248251662Sdim 3249251662Sdim if (VirtualBaseAdjustmentOffset) { 3250296417Sdim ThisPtrForCall = AdjustVirtualBase(CGF, E, RD, This, 3251296417Sdim VirtualBaseAdjustmentOffset, VBPtrOffset); 3252296417Sdim } else { 3253296417Sdim ThisPtrForCall = This.getPointer(); 3254251662Sdim } 3255251662Sdim 3256251662Sdim if (NonVirtualBaseAdjustment) { 3257251662Sdim // Apply the adjustment and cast back to the original struct type. 3258296417Sdim llvm::Value *Ptr = Builder.CreateBitCast(ThisPtrForCall, CGF.Int8PtrTy); 3259251662Sdim Ptr = Builder.CreateInBoundsGEP(Ptr, NonVirtualBaseAdjustment); 3260296417Sdim ThisPtrForCall = Builder.CreateBitCast(Ptr, ThisPtrForCall->getType(), 3261296417Sdim "this.adjusted"); 3262251662Sdim } 3263251662Sdim 3264251662Sdim return Builder.CreateBitCast(FunctionPointer, FTy->getPointerTo()); 3265251662Sdim} 3266251662Sdim 3267212904SdimCGCXXABI *clang::CodeGen::CreateMicrosoftCXXABI(CodeGenModule &CGM) { 3268210008Srdivacky return new MicrosoftCXXABI(CGM); 3269210008Srdivacky} 3270276479Sdim 3271276479Sdim// MS RTTI Overview: 3272276479Sdim// The run time type information emitted by cl.exe contains 5 distinct types of 3273276479Sdim// structures. Many of them reference each other. 3274276479Sdim// 3275276479Sdim// TypeInfo: Static classes that are returned by typeid. 3276276479Sdim// 3277276479Sdim// CompleteObjectLocator: Referenced by vftables. They contain information 3278276479Sdim// required for dynamic casting, including OffsetFromTop. They also contain 3279276479Sdim// a reference to the TypeInfo for the type and a reference to the 3280276479Sdim// CompleteHierarchyDescriptor for the type. 3281276479Sdim// 3282276479Sdim// ClassHieararchyDescriptor: Contains information about a class hierarchy. 3283276479Sdim// Used during dynamic_cast to walk a class hierarchy. References a base 3284276479Sdim// class array and the size of said array. 3285276479Sdim// 3286276479Sdim// BaseClassArray: Contains a list of classes in a hierarchy. BaseClassArray is 3287276479Sdim// somewhat of a misnomer because the most derived class is also in the list 3288276479Sdim// as well as multiple copies of virtual bases (if they occur multiple times 3289276479Sdim// in the hiearchy.) The BaseClassArray contains one BaseClassDescriptor for 3290276479Sdim// every path in the hierarchy, in pre-order depth first order. Note, we do 3291276479Sdim// not declare a specific llvm type for BaseClassArray, it's merely an array 3292276479Sdim// of BaseClassDescriptor pointers. 3293276479Sdim// 3294276479Sdim// BaseClassDescriptor: Contains information about a class in a class hierarchy. 3295276479Sdim// BaseClassDescriptor is also somewhat of a misnomer for the same reason that 3296276479Sdim// BaseClassArray is. It contains information about a class within a 3297276479Sdim// hierarchy such as: is this base is ambiguous and what is its offset in the 3298276479Sdim// vbtable. The names of the BaseClassDescriptors have all of their fields 3299276479Sdim// mangled into them so they can be aggressively deduplicated by the linker. 3300276479Sdim 3301276479Sdimstatic llvm::GlobalVariable *getTypeInfoVTable(CodeGenModule &CGM) { 3302276479Sdim StringRef MangledName("\01??_7type_info@@6B@"); 3303276479Sdim if (auto VTable = CGM.getModule().getNamedGlobal(MangledName)) 3304276479Sdim return VTable; 3305276479Sdim return new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy, 3306276479Sdim /*Constant=*/true, 3307276479Sdim llvm::GlobalVariable::ExternalLinkage, 3308276479Sdim /*Initializer=*/nullptr, MangledName); 3309276479Sdim} 3310276479Sdim 3311276479Sdimnamespace { 3312276479Sdim 3313276479Sdim/// \brief A Helper struct that stores information about a class in a class 3314276479Sdim/// hierarchy. The information stored in these structs struct is used during 3315276479Sdim/// the generation of ClassHierarchyDescriptors and BaseClassDescriptors. 3316276479Sdim// During RTTI creation, MSRTTIClasses are stored in a contiguous array with 3317276479Sdim// implicit depth first pre-order tree connectivity. getFirstChild and 3318276479Sdim// getNextSibling allow us to walk the tree efficiently. 3319276479Sdimstruct MSRTTIClass { 3320276479Sdim enum { 3321276479Sdim IsPrivateOnPath = 1 | 8, 3322276479Sdim IsAmbiguous = 2, 3323276479Sdim IsPrivate = 4, 3324276479Sdim IsVirtual = 16, 3325276479Sdim HasHierarchyDescriptor = 64 3326276479Sdim }; 3327276479Sdim MSRTTIClass(const CXXRecordDecl *RD) : RD(RD) {} 3328276479Sdim uint32_t initialize(const MSRTTIClass *Parent, 3329276479Sdim const CXXBaseSpecifier *Specifier); 3330276479Sdim 3331276479Sdim MSRTTIClass *getFirstChild() { return this + 1; } 3332276479Sdim static MSRTTIClass *getNextChild(MSRTTIClass *Child) { 3333276479Sdim return Child + 1 + Child->NumBases; 3334276479Sdim } 3335276479Sdim 3336276479Sdim const CXXRecordDecl *RD, *VirtualRoot; 3337276479Sdim uint32_t Flags, NumBases, OffsetInVBase; 3338276479Sdim}; 3339276479Sdim 3340276479Sdim/// \brief Recursively initialize the base class array. 3341276479Sdimuint32_t MSRTTIClass::initialize(const MSRTTIClass *Parent, 3342276479Sdim const CXXBaseSpecifier *Specifier) { 3343276479Sdim Flags = HasHierarchyDescriptor; 3344276479Sdim if (!Parent) { 3345276479Sdim VirtualRoot = nullptr; 3346276479Sdim OffsetInVBase = 0; 3347276479Sdim } else { 3348276479Sdim if (Specifier->getAccessSpecifier() != AS_public) 3349276479Sdim Flags |= IsPrivate | IsPrivateOnPath; 3350276479Sdim if (Specifier->isVirtual()) { 3351276479Sdim Flags |= IsVirtual; 3352276479Sdim VirtualRoot = RD; 3353276479Sdim OffsetInVBase = 0; 3354276479Sdim } else { 3355276479Sdim if (Parent->Flags & IsPrivateOnPath) 3356276479Sdim Flags |= IsPrivateOnPath; 3357276479Sdim VirtualRoot = Parent->VirtualRoot; 3358276479Sdim OffsetInVBase = Parent->OffsetInVBase + RD->getASTContext() 3359276479Sdim .getASTRecordLayout(Parent->RD).getBaseClassOffset(RD).getQuantity(); 3360276479Sdim } 3361276479Sdim } 3362276479Sdim NumBases = 0; 3363276479Sdim MSRTTIClass *Child = getFirstChild(); 3364276479Sdim for (const CXXBaseSpecifier &Base : RD->bases()) { 3365276479Sdim NumBases += Child->initialize(this, &Base) + 1; 3366276479Sdim Child = getNextChild(Child); 3367276479Sdim } 3368276479Sdim return NumBases; 3369276479Sdim} 3370276479Sdim 3371276479Sdimstatic llvm::GlobalValue::LinkageTypes getLinkageForRTTI(QualType Ty) { 3372276479Sdim switch (Ty->getLinkage()) { 3373276479Sdim case NoLinkage: 3374276479Sdim case InternalLinkage: 3375276479Sdim case UniqueExternalLinkage: 3376276479Sdim return llvm::GlobalValue::InternalLinkage; 3377276479Sdim 3378276479Sdim case VisibleNoLinkage: 3379276479Sdim case ExternalLinkage: 3380276479Sdim return llvm::GlobalValue::LinkOnceODRLinkage; 3381276479Sdim } 3382276479Sdim llvm_unreachable("Invalid linkage!"); 3383276479Sdim} 3384276479Sdim 3385276479Sdim/// \brief An ephemeral helper class for building MS RTTI types. It caches some 3386276479Sdim/// calls to the module and information about the most derived class in a 3387276479Sdim/// hierarchy. 3388276479Sdimstruct MSRTTIBuilder { 3389276479Sdim enum { 3390276479Sdim HasBranchingHierarchy = 1, 3391276479Sdim HasVirtualBranchingHierarchy = 2, 3392276479Sdim HasAmbiguousBases = 4 3393276479Sdim }; 3394276479Sdim 3395276479Sdim MSRTTIBuilder(MicrosoftCXXABI &ABI, const CXXRecordDecl *RD) 3396276479Sdim : CGM(ABI.CGM), Context(CGM.getContext()), 3397276479Sdim VMContext(CGM.getLLVMContext()), Module(CGM.getModule()), RD(RD), 3398276479Sdim Linkage(getLinkageForRTTI(CGM.getContext().getTagDeclType(RD))), 3399276479Sdim ABI(ABI) {} 3400276479Sdim 3401276479Sdim llvm::GlobalVariable *getBaseClassDescriptor(const MSRTTIClass &Classes); 3402276479Sdim llvm::GlobalVariable * 3403276479Sdim getBaseClassArray(SmallVectorImpl<MSRTTIClass> &Classes); 3404276479Sdim llvm::GlobalVariable *getClassHierarchyDescriptor(); 3405276479Sdim llvm::GlobalVariable *getCompleteObjectLocator(const VPtrInfo *Info); 3406276479Sdim 3407276479Sdim CodeGenModule &CGM; 3408276479Sdim ASTContext &Context; 3409276479Sdim llvm::LLVMContext &VMContext; 3410276479Sdim llvm::Module &Module; 3411276479Sdim const CXXRecordDecl *RD; 3412276479Sdim llvm::GlobalVariable::LinkageTypes Linkage; 3413276479Sdim MicrosoftCXXABI &ABI; 3414276479Sdim}; 3415276479Sdim 3416276479Sdim} // namespace 3417276479Sdim 3418276479Sdim/// \brief Recursively serializes a class hierarchy in pre-order depth first 3419276479Sdim/// order. 3420276479Sdimstatic void serializeClassHierarchy(SmallVectorImpl<MSRTTIClass> &Classes, 3421276479Sdim const CXXRecordDecl *RD) { 3422276479Sdim Classes.push_back(MSRTTIClass(RD)); 3423276479Sdim for (const CXXBaseSpecifier &Base : RD->bases()) 3424276479Sdim serializeClassHierarchy(Classes, Base.getType()->getAsCXXRecordDecl()); 3425276479Sdim} 3426276479Sdim 3427276479Sdim/// \brief Find ambiguity among base classes. 3428276479Sdimstatic void 3429276479SdimdetectAmbiguousBases(SmallVectorImpl<MSRTTIClass> &Classes) { 3430276479Sdim llvm::SmallPtrSet<const CXXRecordDecl *, 8> VirtualBases; 3431276479Sdim llvm::SmallPtrSet<const CXXRecordDecl *, 8> UniqueBases; 3432276479Sdim llvm::SmallPtrSet<const CXXRecordDecl *, 8> AmbiguousBases; 3433276479Sdim for (MSRTTIClass *Class = &Classes.front(); Class <= &Classes.back();) { 3434276479Sdim if ((Class->Flags & MSRTTIClass::IsVirtual) && 3435280031Sdim !VirtualBases.insert(Class->RD).second) { 3436276479Sdim Class = MSRTTIClass::getNextChild(Class); 3437276479Sdim continue; 3438276479Sdim } 3439280031Sdim if (!UniqueBases.insert(Class->RD).second) 3440276479Sdim AmbiguousBases.insert(Class->RD); 3441276479Sdim Class++; 3442276479Sdim } 3443276479Sdim if (AmbiguousBases.empty()) 3444276479Sdim return; 3445276479Sdim for (MSRTTIClass &Class : Classes) 3446276479Sdim if (AmbiguousBases.count(Class.RD)) 3447276479Sdim Class.Flags |= MSRTTIClass::IsAmbiguous; 3448276479Sdim} 3449276479Sdim 3450276479Sdimllvm::GlobalVariable *MSRTTIBuilder::getClassHierarchyDescriptor() { 3451276479Sdim SmallString<256> MangledName; 3452276479Sdim { 3453276479Sdim llvm::raw_svector_ostream Out(MangledName); 3454276479Sdim ABI.getMangleContext().mangleCXXRTTIClassHierarchyDescriptor(RD, Out); 3455276479Sdim } 3456276479Sdim 3457276479Sdim // Check to see if we've already declared this ClassHierarchyDescriptor. 3458276479Sdim if (auto CHD = Module.getNamedGlobal(MangledName)) 3459276479Sdim return CHD; 3460276479Sdim 3461276479Sdim // Serialize the class hierarchy and initialize the CHD Fields. 3462276479Sdim SmallVector<MSRTTIClass, 8> Classes; 3463276479Sdim serializeClassHierarchy(Classes, RD); 3464276479Sdim Classes.front().initialize(/*Parent=*/nullptr, /*Specifier=*/nullptr); 3465276479Sdim detectAmbiguousBases(Classes); 3466276479Sdim int Flags = 0; 3467276479Sdim for (auto Class : Classes) { 3468276479Sdim if (Class.RD->getNumBases() > 1) 3469276479Sdim Flags |= HasBranchingHierarchy; 3470276479Sdim // Note: cl.exe does not calculate "HasAmbiguousBases" correctly. We 3471276479Sdim // believe the field isn't actually used. 3472276479Sdim if (Class.Flags & MSRTTIClass::IsAmbiguous) 3473276479Sdim Flags |= HasAmbiguousBases; 3474276479Sdim } 3475276479Sdim if ((Flags & HasBranchingHierarchy) && RD->getNumVBases() != 0) 3476276479Sdim Flags |= HasVirtualBranchingHierarchy; 3477276479Sdim // These gep indices are used to get the address of the first element of the 3478276479Sdim // base class array. 3479276479Sdim llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.IntTy, 0), 3480276479Sdim llvm::ConstantInt::get(CGM.IntTy, 0)}; 3481276479Sdim 3482276479Sdim // Forward-declare the class hierarchy descriptor 3483276479Sdim auto Type = ABI.getClassHierarchyDescriptorType(); 3484276479Sdim auto CHD = new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage, 3485276479Sdim /*Initializer=*/nullptr, 3486296417Sdim MangledName); 3487288943Sdim if (CHD->isWeakForLinker()) 3488288943Sdim CHD->setComdat(CGM.getModule().getOrInsertComdat(CHD->getName())); 3489276479Sdim 3490288943Sdim auto *Bases = getBaseClassArray(Classes); 3491288943Sdim 3492276479Sdim // Initialize the base class ClassHierarchyDescriptor. 3493276479Sdim llvm::Constant *Fields[] = { 3494276479Sdim llvm::ConstantInt::get(CGM.IntTy, 0), // Unknown 3495276479Sdim llvm::ConstantInt::get(CGM.IntTy, Flags), 3496276479Sdim llvm::ConstantInt::get(CGM.IntTy, Classes.size()), 3497276479Sdim ABI.getImageRelativeConstant(llvm::ConstantExpr::getInBoundsGetElementPtr( 3498288943Sdim Bases->getValueType(), Bases, 3499276479Sdim llvm::ArrayRef<llvm::Value *>(GEPIndices))), 3500276479Sdim }; 3501276479Sdim CHD->setInitializer(llvm::ConstantStruct::get(Type, Fields)); 3502276479Sdim return CHD; 3503276479Sdim} 3504276479Sdim 3505276479Sdimllvm::GlobalVariable * 3506276479SdimMSRTTIBuilder::getBaseClassArray(SmallVectorImpl<MSRTTIClass> &Classes) { 3507276479Sdim SmallString<256> MangledName; 3508276479Sdim { 3509276479Sdim llvm::raw_svector_ostream Out(MangledName); 3510276479Sdim ABI.getMangleContext().mangleCXXRTTIBaseClassArray(RD, Out); 3511276479Sdim } 3512276479Sdim 3513276479Sdim // Forward-declare the base class array. 3514276479Sdim // cl.exe pads the base class array with 1 (in 32 bit mode) or 4 (in 64 bit 3515276479Sdim // mode) bytes of padding. We provide a pointer sized amount of padding by 3516276479Sdim // adding +1 to Classes.size(). The sections have pointer alignment and are 3517276479Sdim // marked pick-any so it shouldn't matter. 3518276479Sdim llvm::Type *PtrType = ABI.getImageRelativeType( 3519276479Sdim ABI.getBaseClassDescriptorType()->getPointerTo()); 3520276479Sdim auto *ArrType = llvm::ArrayType::get(PtrType, Classes.size() + 1); 3521288943Sdim auto *BCA = 3522288943Sdim new llvm::GlobalVariable(Module, ArrType, 3523288943Sdim /*Constant=*/true, Linkage, 3524296417Sdim /*Initializer=*/nullptr, MangledName); 3525288943Sdim if (BCA->isWeakForLinker()) 3526288943Sdim BCA->setComdat(CGM.getModule().getOrInsertComdat(BCA->getName())); 3527276479Sdim 3528276479Sdim // Initialize the BaseClassArray. 3529276479Sdim SmallVector<llvm::Constant *, 8> BaseClassArrayData; 3530276479Sdim for (MSRTTIClass &Class : Classes) 3531276479Sdim BaseClassArrayData.push_back( 3532276479Sdim ABI.getImageRelativeConstant(getBaseClassDescriptor(Class))); 3533276479Sdim BaseClassArrayData.push_back(llvm::Constant::getNullValue(PtrType)); 3534276479Sdim BCA->setInitializer(llvm::ConstantArray::get(ArrType, BaseClassArrayData)); 3535276479Sdim return BCA; 3536276479Sdim} 3537276479Sdim 3538276479Sdimllvm::GlobalVariable * 3539276479SdimMSRTTIBuilder::getBaseClassDescriptor(const MSRTTIClass &Class) { 3540276479Sdim // Compute the fields for the BaseClassDescriptor. They are computed up front 3541276479Sdim // because they are mangled into the name of the object. 3542276479Sdim uint32_t OffsetInVBTable = 0; 3543276479Sdim int32_t VBPtrOffset = -1; 3544276479Sdim if (Class.VirtualRoot) { 3545276479Sdim auto &VTableContext = CGM.getMicrosoftVTableContext(); 3546276479Sdim OffsetInVBTable = VTableContext.getVBTableIndex(RD, Class.VirtualRoot) * 4; 3547276479Sdim VBPtrOffset = Context.getASTRecordLayout(RD).getVBPtrOffset().getQuantity(); 3548276479Sdim } 3549276479Sdim 3550276479Sdim SmallString<256> MangledName; 3551276479Sdim { 3552276479Sdim llvm::raw_svector_ostream Out(MangledName); 3553276479Sdim ABI.getMangleContext().mangleCXXRTTIBaseClassDescriptor( 3554276479Sdim Class.RD, Class.OffsetInVBase, VBPtrOffset, OffsetInVBTable, 3555276479Sdim Class.Flags, Out); 3556276479Sdim } 3557276479Sdim 3558276479Sdim // Check to see if we've already declared this object. 3559276479Sdim if (auto BCD = Module.getNamedGlobal(MangledName)) 3560276479Sdim return BCD; 3561276479Sdim 3562276479Sdim // Forward-declare the base class descriptor. 3563276479Sdim auto Type = ABI.getBaseClassDescriptorType(); 3564288943Sdim auto BCD = 3565288943Sdim new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage, 3566296417Sdim /*Initializer=*/nullptr, MangledName); 3567288943Sdim if (BCD->isWeakForLinker()) 3568288943Sdim BCD->setComdat(CGM.getModule().getOrInsertComdat(BCD->getName())); 3569276479Sdim 3570276479Sdim // Initialize the BaseClassDescriptor. 3571276479Sdim llvm::Constant *Fields[] = { 3572276479Sdim ABI.getImageRelativeConstant( 3573276479Sdim ABI.getAddrOfRTTIDescriptor(Context.getTypeDeclType(Class.RD))), 3574276479Sdim llvm::ConstantInt::get(CGM.IntTy, Class.NumBases), 3575276479Sdim llvm::ConstantInt::get(CGM.IntTy, Class.OffsetInVBase), 3576276479Sdim llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset), 3577276479Sdim llvm::ConstantInt::get(CGM.IntTy, OffsetInVBTable), 3578276479Sdim llvm::ConstantInt::get(CGM.IntTy, Class.Flags), 3579276479Sdim ABI.getImageRelativeConstant( 3580276479Sdim MSRTTIBuilder(ABI, Class.RD).getClassHierarchyDescriptor()), 3581276479Sdim }; 3582276479Sdim BCD->setInitializer(llvm::ConstantStruct::get(Type, Fields)); 3583276479Sdim return BCD; 3584276479Sdim} 3585276479Sdim 3586276479Sdimllvm::GlobalVariable * 3587276479SdimMSRTTIBuilder::getCompleteObjectLocator(const VPtrInfo *Info) { 3588276479Sdim SmallString<256> MangledName; 3589276479Sdim { 3590276479Sdim llvm::raw_svector_ostream Out(MangledName); 3591276479Sdim ABI.getMangleContext().mangleCXXRTTICompleteObjectLocator(RD, Info->MangledPath, Out); 3592276479Sdim } 3593276479Sdim 3594276479Sdim // Check to see if we've already computed this complete object locator. 3595276479Sdim if (auto COL = Module.getNamedGlobal(MangledName)) 3596276479Sdim return COL; 3597276479Sdim 3598276479Sdim // Compute the fields of the complete object locator. 3599276479Sdim int OffsetToTop = Info->FullOffsetInMDC.getQuantity(); 3600276479Sdim int VFPtrOffset = 0; 3601276479Sdim // The offset includes the vtordisp if one exists. 3602276479Sdim if (const CXXRecordDecl *VBase = Info->getVBaseWithVPtr()) 3603276479Sdim if (Context.getASTRecordLayout(RD) 3604276479Sdim .getVBaseOffsetsMap() 3605276479Sdim .find(VBase) 3606276479Sdim ->second.hasVtorDisp()) 3607276479Sdim VFPtrOffset = Info->NonVirtualOffset.getQuantity() + 4; 3608276479Sdim 3609276479Sdim // Forward-declare the complete object locator. 3610276479Sdim llvm::StructType *Type = ABI.getCompleteObjectLocatorType(); 3611276479Sdim auto COL = new llvm::GlobalVariable(Module, Type, /*Constant=*/true, Linkage, 3612296417Sdim /*Initializer=*/nullptr, MangledName); 3613276479Sdim 3614276479Sdim // Initialize the CompleteObjectLocator. 3615276479Sdim llvm::Constant *Fields[] = { 3616276479Sdim llvm::ConstantInt::get(CGM.IntTy, ABI.isImageRelative()), 3617276479Sdim llvm::ConstantInt::get(CGM.IntTy, OffsetToTop), 3618276479Sdim llvm::ConstantInt::get(CGM.IntTy, VFPtrOffset), 3619276479Sdim ABI.getImageRelativeConstant( 3620276479Sdim CGM.GetAddrOfRTTIDescriptor(Context.getTypeDeclType(RD))), 3621276479Sdim ABI.getImageRelativeConstant(getClassHierarchyDescriptor()), 3622276479Sdim ABI.getImageRelativeConstant(COL), 3623276479Sdim }; 3624276479Sdim llvm::ArrayRef<llvm::Constant *> FieldsRef(Fields); 3625276479Sdim if (!ABI.isImageRelative()) 3626276479Sdim FieldsRef = FieldsRef.drop_back(); 3627276479Sdim COL->setInitializer(llvm::ConstantStruct::get(Type, FieldsRef)); 3628288943Sdim if (COL->isWeakForLinker()) 3629288943Sdim COL->setComdat(CGM.getModule().getOrInsertComdat(COL->getName())); 3630276479Sdim return COL; 3631276479Sdim} 3632276479Sdim 3633288943Sdimstatic QualType decomposeTypeForEH(ASTContext &Context, QualType T, 3634288943Sdim bool &IsConst, bool &IsVolatile) { 3635288943Sdim T = Context.getExceptionObjectType(T); 3636288943Sdim 3637288943Sdim // C++14 [except.handle]p3: 3638288943Sdim // A handler is a match for an exception object of type E if [...] 3639288943Sdim // - the handler is of type cv T or const T& where T is a pointer type and 3640288943Sdim // E is a pointer type that can be converted to T by [...] 3641288943Sdim // - a qualification conversion 3642288943Sdim IsConst = false; 3643288943Sdim IsVolatile = false; 3644288943Sdim QualType PointeeType = T->getPointeeType(); 3645288943Sdim if (!PointeeType.isNull()) { 3646288943Sdim IsConst = PointeeType.isConstQualified(); 3647288943Sdim IsVolatile = PointeeType.isVolatileQualified(); 3648288943Sdim } 3649288943Sdim 3650288943Sdim // Member pointer types like "const int A::*" are represented by having RTTI 3651288943Sdim // for "int A::*" and separately storing the const qualifier. 3652288943Sdim if (const auto *MPTy = T->getAs<MemberPointerType>()) 3653288943Sdim T = Context.getMemberPointerType(PointeeType.getUnqualifiedType(), 3654288943Sdim MPTy->getClass()); 3655288943Sdim 3656288943Sdim // Pointer types like "const int * const *" are represented by having RTTI 3657288943Sdim // for "const int **" and separately storing the const qualifier. 3658288943Sdim if (T->isPointerType()) 3659288943Sdim T = Context.getPointerType(PointeeType.getUnqualifiedType()); 3660288943Sdim 3661288943Sdim return T; 3662288943Sdim} 3663288943Sdim 3664296417SdimCatchTypeInfo 3665288943SdimMicrosoftCXXABI::getAddrOfCXXCatchHandlerType(QualType Type, 3666288943Sdim QualType CatchHandlerType) { 3667288943Sdim // TypeDescriptors for exceptions never have qualified pointer types, 3668288943Sdim // qualifiers are stored seperately in order to support qualification 3669288943Sdim // conversions. 3670288943Sdim bool IsConst, IsVolatile; 3671288943Sdim Type = decomposeTypeForEH(getContext(), Type, IsConst, IsVolatile); 3672288943Sdim 3673288943Sdim bool IsReference = CatchHandlerType->isReferenceType(); 3674288943Sdim 3675288943Sdim uint32_t Flags = 0; 3676288943Sdim if (IsConst) 3677288943Sdim Flags |= 1; 3678288943Sdim if (IsVolatile) 3679288943Sdim Flags |= 2; 3680288943Sdim if (IsReference) 3681288943Sdim Flags |= 8; 3682288943Sdim 3683296417Sdim return CatchTypeInfo{getAddrOfRTTIDescriptor(Type)->stripPointerCasts(), 3684296417Sdim Flags}; 3685288943Sdim} 3686288943Sdim 3687276479Sdim/// \brief Gets a TypeDescriptor. Returns a llvm::Constant * rather than a 3688276479Sdim/// llvm::GlobalVariable * because different type descriptors have different 3689276479Sdim/// types, and need to be abstracted. They are abstracting by casting the 3690276479Sdim/// address to an Int8PtrTy. 3691276479Sdimllvm::Constant *MicrosoftCXXABI::getAddrOfRTTIDescriptor(QualType Type) { 3692288943Sdim SmallString<256> MangledName; 3693276479Sdim { 3694276479Sdim llvm::raw_svector_ostream Out(MangledName); 3695276479Sdim getMangleContext().mangleCXXRTTI(Type, Out); 3696276479Sdim } 3697276479Sdim 3698276479Sdim // Check to see if we've already declared this TypeDescriptor. 3699276479Sdim if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName)) 3700276479Sdim return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy); 3701276479Sdim 3702276479Sdim // Compute the fields for the TypeDescriptor. 3703288943Sdim SmallString<256> TypeInfoString; 3704276479Sdim { 3705276479Sdim llvm::raw_svector_ostream Out(TypeInfoString); 3706276479Sdim getMangleContext().mangleCXXRTTIName(Type, Out); 3707276479Sdim } 3708276479Sdim 3709276479Sdim // Declare and initialize the TypeDescriptor. 3710276479Sdim llvm::Constant *Fields[] = { 3711276479Sdim getTypeInfoVTable(CGM), // VFPtr 3712276479Sdim llvm::ConstantPointerNull::get(CGM.Int8PtrTy), // Runtime data 3713276479Sdim llvm::ConstantDataArray::getString(CGM.getLLVMContext(), TypeInfoString)}; 3714276479Sdim llvm::StructType *TypeDescriptorType = 3715276479Sdim getTypeDescriptorType(TypeInfoString); 3716288943Sdim auto *Var = new llvm::GlobalVariable( 3717288943Sdim CGM.getModule(), TypeDescriptorType, /*Constant=*/false, 3718288943Sdim getLinkageForRTTI(Type), 3719288943Sdim llvm::ConstantStruct::get(TypeDescriptorType, Fields), 3720296417Sdim MangledName); 3721288943Sdim if (Var->isWeakForLinker()) 3722288943Sdim Var->setComdat(CGM.getModule().getOrInsertComdat(Var->getName())); 3723288943Sdim return llvm::ConstantExpr::getBitCast(Var, CGM.Int8PtrTy); 3724276479Sdim} 3725276479Sdim 3726276479Sdim/// \brief Gets or a creates a Microsoft CompleteObjectLocator. 3727276479Sdimllvm::GlobalVariable * 3728276479SdimMicrosoftCXXABI::getMSCompleteObjectLocator(const CXXRecordDecl *RD, 3729276479Sdim const VPtrInfo *Info) { 3730276479Sdim return MSRTTIBuilder(*this, RD).getCompleteObjectLocator(Info); 3731276479Sdim} 3732280031Sdim 3733280031Sdimstatic void emitCXXConstructor(CodeGenModule &CGM, 3734280031Sdim const CXXConstructorDecl *ctor, 3735280031Sdim StructorType ctorType) { 3736280031Sdim // There are no constructor variants, always emit the complete destructor. 3737288943Sdim llvm::Function *Fn = CGM.codegenCXXStructor(ctor, StructorType::Complete); 3738288943Sdim CGM.maybeSetTrivialComdat(*ctor, *Fn); 3739280031Sdim} 3740280031Sdim 3741280031Sdimstatic void emitCXXDestructor(CodeGenModule &CGM, const CXXDestructorDecl *dtor, 3742280031Sdim StructorType dtorType) { 3743280031Sdim // The complete destructor is equivalent to the base destructor for 3744280031Sdim // classes with no virtual bases, so try to emit it as an alias. 3745280031Sdim if (!dtor->getParent()->getNumVBases() && 3746280031Sdim (dtorType == StructorType::Complete || dtorType == StructorType::Base)) { 3747280031Sdim bool ProducedAlias = !CGM.TryEmitDefinitionAsAlias( 3748280031Sdim GlobalDecl(dtor, Dtor_Complete), GlobalDecl(dtor, Dtor_Base), true); 3749280031Sdim if (ProducedAlias) { 3750280031Sdim if (dtorType == StructorType::Complete) 3751280031Sdim return; 3752280031Sdim if (dtor->isVirtual()) 3753280031Sdim CGM.getVTables().EmitThunks(GlobalDecl(dtor, Dtor_Complete)); 3754280031Sdim } 3755280031Sdim } 3756280031Sdim 3757280031Sdim // The base destructor is equivalent to the base destructor of its 3758280031Sdim // base class if there is exactly one non-virtual base class with a 3759280031Sdim // non-trivial destructor, there are no fields with a non-trivial 3760280031Sdim // destructor, and the body of the destructor is trivial. 3761280031Sdim if (dtorType == StructorType::Base && !CGM.TryEmitBaseDestructorAsAlias(dtor)) 3762280031Sdim return; 3763280031Sdim 3764288943Sdim llvm::Function *Fn = CGM.codegenCXXStructor(dtor, dtorType); 3765288943Sdim if (Fn->isWeakForLinker()) 3766288943Sdim Fn->setComdat(CGM.getModule().getOrInsertComdat(Fn->getName())); 3767280031Sdim} 3768280031Sdim 3769280031Sdimvoid MicrosoftCXXABI::emitCXXStructor(const CXXMethodDecl *MD, 3770280031Sdim StructorType Type) { 3771280031Sdim if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) { 3772280031Sdim emitCXXConstructor(CGM, CD, Type); 3773280031Sdim return; 3774280031Sdim } 3775280031Sdim emitCXXDestructor(CGM, cast<CXXDestructorDecl>(MD), Type); 3776280031Sdim} 3777288943Sdim 3778288943Sdimllvm::Function * 3779288943SdimMicrosoftCXXABI::getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD, 3780288943Sdim CXXCtorType CT) { 3781288943Sdim assert(CT == Ctor_CopyingClosure || CT == Ctor_DefaultClosure); 3782288943Sdim 3783288943Sdim // Calculate the mangled name. 3784288943Sdim SmallString<256> ThunkName; 3785288943Sdim llvm::raw_svector_ostream Out(ThunkName); 3786288943Sdim getMangleContext().mangleCXXCtor(CD, CT, Out); 3787288943Sdim 3788288943Sdim // If the thunk has been generated previously, just return it. 3789288943Sdim if (llvm::GlobalValue *GV = CGM.getModule().getNamedValue(ThunkName)) 3790288943Sdim return cast<llvm::Function>(GV); 3791288943Sdim 3792288943Sdim // Create the llvm::Function. 3793288943Sdim const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeMSCtorClosure(CD, CT); 3794288943Sdim llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo); 3795288943Sdim const CXXRecordDecl *RD = CD->getParent(); 3796288943Sdim QualType RecordTy = getContext().getRecordType(RD); 3797288943Sdim llvm::Function *ThunkFn = llvm::Function::Create( 3798288943Sdim ThunkTy, getLinkageForRTTI(RecordTy), ThunkName.str(), &CGM.getModule()); 3799288943Sdim ThunkFn->setCallingConv(static_cast<llvm::CallingConv::ID>( 3800288943Sdim FnInfo.getEffectiveCallingConvention())); 3801288943Sdim if (ThunkFn->isWeakForLinker()) 3802288943Sdim ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName())); 3803288943Sdim bool IsCopy = CT == Ctor_CopyingClosure; 3804288943Sdim 3805288943Sdim // Start codegen. 3806288943Sdim CodeGenFunction CGF(CGM); 3807288943Sdim CGF.CurGD = GlobalDecl(CD, Ctor_Complete); 3808288943Sdim 3809288943Sdim // Build FunctionArgs. 3810288943Sdim FunctionArgList FunctionArgs; 3811288943Sdim 3812288943Sdim // A constructor always starts with a 'this' pointer as its first argument. 3813288943Sdim buildThisParam(CGF, FunctionArgs); 3814288943Sdim 3815288943Sdim // Following the 'this' pointer is a reference to the source object that we 3816288943Sdim // are copying from. 3817288943Sdim ImplicitParamDecl SrcParam( 3818288943Sdim getContext(), nullptr, SourceLocation(), &getContext().Idents.get("src"), 3819288943Sdim getContext().getLValueReferenceType(RecordTy, 3820288943Sdim /*SpelledAsLValue=*/true)); 3821288943Sdim if (IsCopy) 3822288943Sdim FunctionArgs.push_back(&SrcParam); 3823288943Sdim 3824288943Sdim // Constructors for classes which utilize virtual bases have an additional 3825288943Sdim // parameter which indicates whether or not it is being delegated to by a more 3826288943Sdim // derived constructor. 3827288943Sdim ImplicitParamDecl IsMostDerived(getContext(), nullptr, SourceLocation(), 3828288943Sdim &getContext().Idents.get("is_most_derived"), 3829288943Sdim getContext().IntTy); 3830288943Sdim // Only add the parameter to the list if thie class has virtual bases. 3831288943Sdim if (RD->getNumVBases() > 0) 3832288943Sdim FunctionArgs.push_back(&IsMostDerived); 3833288943Sdim 3834288943Sdim // Start defining the function. 3835288943Sdim CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo, 3836288943Sdim FunctionArgs, CD->getLocation(), SourceLocation()); 3837288943Sdim EmitThisParam(CGF); 3838288943Sdim llvm::Value *This = getThisValue(CGF); 3839288943Sdim 3840288943Sdim llvm::Value *SrcVal = 3841288943Sdim IsCopy ? CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&SrcParam), "src") 3842288943Sdim : nullptr; 3843288943Sdim 3844288943Sdim CallArgList Args; 3845288943Sdim 3846288943Sdim // Push the this ptr. 3847288943Sdim Args.add(RValue::get(This), CD->getThisType(getContext())); 3848288943Sdim 3849288943Sdim // Push the src ptr. 3850288943Sdim if (SrcVal) 3851288943Sdim Args.add(RValue::get(SrcVal), SrcParam.getType()); 3852288943Sdim 3853288943Sdim // Add the rest of the default arguments. 3854288943Sdim std::vector<Stmt *> ArgVec; 3855288943Sdim for (unsigned I = IsCopy ? 1 : 0, E = CD->getNumParams(); I != E; ++I) { 3856288943Sdim Stmt *DefaultArg = getContext().getDefaultArgExprForConstructor(CD, I); 3857288943Sdim assert(DefaultArg && "sema forgot to instantiate default args"); 3858288943Sdim ArgVec.push_back(DefaultArg); 3859288943Sdim } 3860288943Sdim 3861288943Sdim CodeGenFunction::RunCleanupsScope Cleanups(CGF); 3862288943Sdim 3863288943Sdim const auto *FPT = CD->getType()->castAs<FunctionProtoType>(); 3864296417Sdim CGF.EmitCallArgs(Args, FPT, llvm::makeArrayRef(ArgVec), CD, IsCopy ? 1 : 0); 3865288943Sdim 3866288943Sdim // Insert any ABI-specific implicit constructor arguments. 3867288943Sdim unsigned ExtraArgs = addImplicitConstructorArgs(CGF, CD, Ctor_Complete, 3868288943Sdim /*ForVirtualBase=*/false, 3869288943Sdim /*Delegating=*/false, Args); 3870288943Sdim 3871288943Sdim // Call the destructor with our arguments. 3872288943Sdim llvm::Value *CalleeFn = CGM.getAddrOfCXXStructor(CD, StructorType::Complete); 3873288943Sdim const CGFunctionInfo &CalleeInfo = CGM.getTypes().arrangeCXXConstructorCall( 3874288943Sdim Args, CD, Ctor_Complete, ExtraArgs); 3875288943Sdim CGF.EmitCall(CalleeInfo, CalleeFn, ReturnValueSlot(), Args, CD); 3876288943Sdim 3877288943Sdim Cleanups.ForceCleanup(); 3878288943Sdim 3879288943Sdim // Emit the ret instruction, remove any temporary instructions created for the 3880288943Sdim // aid of CodeGen. 3881288943Sdim CGF.FinishFunction(SourceLocation()); 3882288943Sdim 3883288943Sdim return ThunkFn; 3884288943Sdim} 3885288943Sdim 3886288943Sdimllvm::Constant *MicrosoftCXXABI::getCatchableType(QualType T, 3887288943Sdim uint32_t NVOffset, 3888288943Sdim int32_t VBPtrOffset, 3889288943Sdim uint32_t VBIndex) { 3890288943Sdim assert(!T->isReferenceType()); 3891288943Sdim 3892288943Sdim CXXRecordDecl *RD = T->getAsCXXRecordDecl(); 3893288943Sdim const CXXConstructorDecl *CD = 3894288943Sdim RD ? CGM.getContext().getCopyConstructorForExceptionObject(RD) : nullptr; 3895288943Sdim CXXCtorType CT = Ctor_Complete; 3896288943Sdim if (CD) 3897288943Sdim if (!hasDefaultCXXMethodCC(getContext(), CD) || CD->getNumParams() != 1) 3898288943Sdim CT = Ctor_CopyingClosure; 3899288943Sdim 3900288943Sdim uint32_t Size = getContext().getTypeSizeInChars(T).getQuantity(); 3901288943Sdim SmallString<256> MangledName; 3902288943Sdim { 3903288943Sdim llvm::raw_svector_ostream Out(MangledName); 3904288943Sdim getMangleContext().mangleCXXCatchableType(T, CD, CT, Size, NVOffset, 3905288943Sdim VBPtrOffset, VBIndex, Out); 3906288943Sdim } 3907288943Sdim if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName)) 3908288943Sdim return getImageRelativeConstant(GV); 3909288943Sdim 3910288943Sdim // The TypeDescriptor is used by the runtime to determine if a catch handler 3911288943Sdim // is appropriate for the exception object. 3912288943Sdim llvm::Constant *TD = getImageRelativeConstant(getAddrOfRTTIDescriptor(T)); 3913288943Sdim 3914288943Sdim // The runtime is responsible for calling the copy constructor if the 3915288943Sdim // exception is caught by value. 3916288943Sdim llvm::Constant *CopyCtor; 3917288943Sdim if (CD) { 3918288943Sdim if (CT == Ctor_CopyingClosure) 3919288943Sdim CopyCtor = getAddrOfCXXCtorClosure(CD, Ctor_CopyingClosure); 3920288943Sdim else 3921288943Sdim CopyCtor = CGM.getAddrOfCXXStructor(CD, StructorType::Complete); 3922288943Sdim 3923288943Sdim CopyCtor = llvm::ConstantExpr::getBitCast(CopyCtor, CGM.Int8PtrTy); 3924288943Sdim } else { 3925288943Sdim CopyCtor = llvm::Constant::getNullValue(CGM.Int8PtrTy); 3926288943Sdim } 3927288943Sdim CopyCtor = getImageRelativeConstant(CopyCtor); 3928288943Sdim 3929288943Sdim bool IsScalar = !RD; 3930288943Sdim bool HasVirtualBases = false; 3931288943Sdim bool IsStdBadAlloc = false; // std::bad_alloc is special for some reason. 3932288943Sdim QualType PointeeType = T; 3933288943Sdim if (T->isPointerType()) 3934288943Sdim PointeeType = T->getPointeeType(); 3935288943Sdim if (const CXXRecordDecl *RD = PointeeType->getAsCXXRecordDecl()) { 3936288943Sdim HasVirtualBases = RD->getNumVBases() > 0; 3937288943Sdim if (IdentifierInfo *II = RD->getIdentifier()) 3938288943Sdim IsStdBadAlloc = II->isStr("bad_alloc") && RD->isInStdNamespace(); 3939288943Sdim } 3940288943Sdim 3941288943Sdim // Encode the relevant CatchableType properties into the Flags bitfield. 3942288943Sdim // FIXME: Figure out how bits 2 or 8 can get set. 3943288943Sdim uint32_t Flags = 0; 3944288943Sdim if (IsScalar) 3945288943Sdim Flags |= 1; 3946288943Sdim if (HasVirtualBases) 3947288943Sdim Flags |= 4; 3948288943Sdim if (IsStdBadAlloc) 3949288943Sdim Flags |= 16; 3950288943Sdim 3951288943Sdim llvm::Constant *Fields[] = { 3952288943Sdim llvm::ConstantInt::get(CGM.IntTy, Flags), // Flags 3953288943Sdim TD, // TypeDescriptor 3954288943Sdim llvm::ConstantInt::get(CGM.IntTy, NVOffset), // NonVirtualAdjustment 3955288943Sdim llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset), // OffsetToVBPtr 3956288943Sdim llvm::ConstantInt::get(CGM.IntTy, VBIndex), // VBTableIndex 3957288943Sdim llvm::ConstantInt::get(CGM.IntTy, Size), // Size 3958288943Sdim CopyCtor // CopyCtor 3959288943Sdim }; 3960288943Sdim llvm::StructType *CTType = getCatchableTypeType(); 3961288943Sdim auto *GV = new llvm::GlobalVariable( 3962288943Sdim CGM.getModule(), CTType, /*Constant=*/true, getLinkageForRTTI(T), 3963296417Sdim llvm::ConstantStruct::get(CTType, Fields), MangledName); 3964288943Sdim GV->setUnnamedAddr(true); 3965288943Sdim GV->setSection(".xdata"); 3966288943Sdim if (GV->isWeakForLinker()) 3967288943Sdim GV->setComdat(CGM.getModule().getOrInsertComdat(GV->getName())); 3968288943Sdim return getImageRelativeConstant(GV); 3969288943Sdim} 3970288943Sdim 3971288943Sdimllvm::GlobalVariable *MicrosoftCXXABI::getCatchableTypeArray(QualType T) { 3972288943Sdim assert(!T->isReferenceType()); 3973288943Sdim 3974288943Sdim // See if we've already generated a CatchableTypeArray for this type before. 3975288943Sdim llvm::GlobalVariable *&CTA = CatchableTypeArrays[T]; 3976288943Sdim if (CTA) 3977288943Sdim return CTA; 3978288943Sdim 3979288943Sdim // Ensure that we don't have duplicate entries in our CatchableTypeArray by 3980288943Sdim // using a SmallSetVector. Duplicates may arise due to virtual bases 3981288943Sdim // occurring more than once in the hierarchy. 3982288943Sdim llvm::SmallSetVector<llvm::Constant *, 2> CatchableTypes; 3983288943Sdim 3984288943Sdim // C++14 [except.handle]p3: 3985288943Sdim // A handler is a match for an exception object of type E if [...] 3986288943Sdim // - the handler is of type cv T or cv T& and T is an unambiguous public 3987288943Sdim // base class of E, or 3988288943Sdim // - the handler is of type cv T or const T& where T is a pointer type and 3989288943Sdim // E is a pointer type that can be converted to T by [...] 3990288943Sdim // - a standard pointer conversion (4.10) not involving conversions to 3991288943Sdim // pointers to private or protected or ambiguous classes 3992288943Sdim const CXXRecordDecl *MostDerivedClass = nullptr; 3993288943Sdim bool IsPointer = T->isPointerType(); 3994288943Sdim if (IsPointer) 3995288943Sdim MostDerivedClass = T->getPointeeType()->getAsCXXRecordDecl(); 3996288943Sdim else 3997288943Sdim MostDerivedClass = T->getAsCXXRecordDecl(); 3998288943Sdim 3999288943Sdim // Collect all the unambiguous public bases of the MostDerivedClass. 4000288943Sdim if (MostDerivedClass) { 4001288943Sdim const ASTContext &Context = getContext(); 4002288943Sdim const ASTRecordLayout &MostDerivedLayout = 4003288943Sdim Context.getASTRecordLayout(MostDerivedClass); 4004288943Sdim MicrosoftVTableContext &VTableContext = CGM.getMicrosoftVTableContext(); 4005288943Sdim SmallVector<MSRTTIClass, 8> Classes; 4006288943Sdim serializeClassHierarchy(Classes, MostDerivedClass); 4007288943Sdim Classes.front().initialize(/*Parent=*/nullptr, /*Specifier=*/nullptr); 4008288943Sdim detectAmbiguousBases(Classes); 4009288943Sdim for (const MSRTTIClass &Class : Classes) { 4010288943Sdim // Skip any ambiguous or private bases. 4011288943Sdim if (Class.Flags & 4012288943Sdim (MSRTTIClass::IsPrivateOnPath | MSRTTIClass::IsAmbiguous)) 4013288943Sdim continue; 4014288943Sdim // Write down how to convert from a derived pointer to a base pointer. 4015288943Sdim uint32_t OffsetInVBTable = 0; 4016288943Sdim int32_t VBPtrOffset = -1; 4017288943Sdim if (Class.VirtualRoot) { 4018288943Sdim OffsetInVBTable = 4019288943Sdim VTableContext.getVBTableIndex(MostDerivedClass, Class.VirtualRoot)*4; 4020288943Sdim VBPtrOffset = MostDerivedLayout.getVBPtrOffset().getQuantity(); 4021288943Sdim } 4022288943Sdim 4023288943Sdim // Turn our record back into a pointer if the exception object is a 4024288943Sdim // pointer. 4025288943Sdim QualType RTTITy = QualType(Class.RD->getTypeForDecl(), 0); 4026288943Sdim if (IsPointer) 4027288943Sdim RTTITy = Context.getPointerType(RTTITy); 4028288943Sdim CatchableTypes.insert(getCatchableType(RTTITy, Class.OffsetInVBase, 4029288943Sdim VBPtrOffset, OffsetInVBTable)); 4030288943Sdim } 4031288943Sdim } 4032288943Sdim 4033288943Sdim // C++14 [except.handle]p3: 4034288943Sdim // A handler is a match for an exception object of type E if 4035288943Sdim // - The handler is of type cv T or cv T& and E and T are the same type 4036288943Sdim // (ignoring the top-level cv-qualifiers) 4037288943Sdim CatchableTypes.insert(getCatchableType(T)); 4038288943Sdim 4039288943Sdim // C++14 [except.handle]p3: 4040288943Sdim // A handler is a match for an exception object of type E if 4041288943Sdim // - the handler is of type cv T or const T& where T is a pointer type and 4042288943Sdim // E is a pointer type that can be converted to T by [...] 4043288943Sdim // - a standard pointer conversion (4.10) not involving conversions to 4044288943Sdim // pointers to private or protected or ambiguous classes 4045288943Sdim // 4046288943Sdim // C++14 [conv.ptr]p2: 4047288943Sdim // A prvalue of type "pointer to cv T," where T is an object type, can be 4048288943Sdim // converted to a prvalue of type "pointer to cv void". 4049288943Sdim if (IsPointer && T->getPointeeType()->isObjectType()) 4050288943Sdim CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy)); 4051288943Sdim 4052288943Sdim // C++14 [except.handle]p3: 4053288943Sdim // A handler is a match for an exception object of type E if [...] 4054288943Sdim // - the handler is of type cv T or const T& where T is a pointer or 4055288943Sdim // pointer to member type and E is std::nullptr_t. 4056288943Sdim // 4057288943Sdim // We cannot possibly list all possible pointer types here, making this 4058288943Sdim // implementation incompatible with the standard. However, MSVC includes an 4059288943Sdim // entry for pointer-to-void in this case. Let's do the same. 4060288943Sdim if (T->isNullPtrType()) 4061288943Sdim CatchableTypes.insert(getCatchableType(getContext().VoidPtrTy)); 4062288943Sdim 4063288943Sdim uint32_t NumEntries = CatchableTypes.size(); 4064288943Sdim llvm::Type *CTType = 4065288943Sdim getImageRelativeType(getCatchableTypeType()->getPointerTo()); 4066288943Sdim llvm::ArrayType *AT = llvm::ArrayType::get(CTType, NumEntries); 4067288943Sdim llvm::StructType *CTAType = getCatchableTypeArrayType(NumEntries); 4068288943Sdim llvm::Constant *Fields[] = { 4069288943Sdim llvm::ConstantInt::get(CGM.IntTy, NumEntries), // NumEntries 4070288943Sdim llvm::ConstantArray::get( 4071288943Sdim AT, llvm::makeArrayRef(CatchableTypes.begin(), 4072288943Sdim CatchableTypes.end())) // CatchableTypes 4073288943Sdim }; 4074288943Sdim SmallString<256> MangledName; 4075288943Sdim { 4076288943Sdim llvm::raw_svector_ostream Out(MangledName); 4077288943Sdim getMangleContext().mangleCXXCatchableTypeArray(T, NumEntries, Out); 4078288943Sdim } 4079288943Sdim CTA = new llvm::GlobalVariable( 4080288943Sdim CGM.getModule(), CTAType, /*Constant=*/true, getLinkageForRTTI(T), 4081296417Sdim llvm::ConstantStruct::get(CTAType, Fields), MangledName); 4082288943Sdim CTA->setUnnamedAddr(true); 4083288943Sdim CTA->setSection(".xdata"); 4084288943Sdim if (CTA->isWeakForLinker()) 4085288943Sdim CTA->setComdat(CGM.getModule().getOrInsertComdat(CTA->getName())); 4086288943Sdim return CTA; 4087288943Sdim} 4088288943Sdim 4089288943Sdimllvm::GlobalVariable *MicrosoftCXXABI::getThrowInfo(QualType T) { 4090288943Sdim bool IsConst, IsVolatile; 4091288943Sdim T = decomposeTypeForEH(getContext(), T, IsConst, IsVolatile); 4092288943Sdim 4093288943Sdim // The CatchableTypeArray enumerates the various (CV-unqualified) types that 4094288943Sdim // the exception object may be caught as. 4095288943Sdim llvm::GlobalVariable *CTA = getCatchableTypeArray(T); 4096288943Sdim // The first field in a CatchableTypeArray is the number of CatchableTypes. 4097288943Sdim // This is used as a component of the mangled name which means that we need to 4098288943Sdim // know what it is in order to see if we have previously generated the 4099288943Sdim // ThrowInfo. 4100288943Sdim uint32_t NumEntries = 4101288943Sdim cast<llvm::ConstantInt>(CTA->getInitializer()->getAggregateElement(0U)) 4102288943Sdim ->getLimitedValue(); 4103288943Sdim 4104288943Sdim SmallString<256> MangledName; 4105288943Sdim { 4106288943Sdim llvm::raw_svector_ostream Out(MangledName); 4107288943Sdim getMangleContext().mangleCXXThrowInfo(T, IsConst, IsVolatile, NumEntries, 4108288943Sdim Out); 4109288943Sdim } 4110288943Sdim 4111288943Sdim // Reuse a previously generated ThrowInfo if we have generated an appropriate 4112288943Sdim // one before. 4113288943Sdim if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName)) 4114288943Sdim return GV; 4115288943Sdim 4116288943Sdim // The RTTI TypeDescriptor uses an unqualified type but catch clauses must 4117288943Sdim // be at least as CV qualified. Encode this requirement into the Flags 4118288943Sdim // bitfield. 4119288943Sdim uint32_t Flags = 0; 4120288943Sdim if (IsConst) 4121288943Sdim Flags |= 1; 4122288943Sdim if (IsVolatile) 4123288943Sdim Flags |= 2; 4124288943Sdim 4125288943Sdim // The cleanup-function (a destructor) must be called when the exception 4126288943Sdim // object's lifetime ends. 4127288943Sdim llvm::Constant *CleanupFn = llvm::Constant::getNullValue(CGM.Int8PtrTy); 4128288943Sdim if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 4129288943Sdim if (CXXDestructorDecl *DtorD = RD->getDestructor()) 4130288943Sdim if (!DtorD->isTrivial()) 4131288943Sdim CleanupFn = llvm::ConstantExpr::getBitCast( 4132288943Sdim CGM.getAddrOfCXXStructor(DtorD, StructorType::Complete), 4133288943Sdim CGM.Int8PtrTy); 4134288943Sdim // This is unused as far as we can tell, initialize it to null. 4135288943Sdim llvm::Constant *ForwardCompat = 4136288943Sdim getImageRelativeConstant(llvm::Constant::getNullValue(CGM.Int8PtrTy)); 4137288943Sdim llvm::Constant *PointerToCatchableTypes = getImageRelativeConstant( 4138288943Sdim llvm::ConstantExpr::getBitCast(CTA, CGM.Int8PtrTy)); 4139288943Sdim llvm::StructType *TIType = getThrowInfoType(); 4140288943Sdim llvm::Constant *Fields[] = { 4141288943Sdim llvm::ConstantInt::get(CGM.IntTy, Flags), // Flags 4142288943Sdim getImageRelativeConstant(CleanupFn), // CleanupFn 4143288943Sdim ForwardCompat, // ForwardCompat 4144288943Sdim PointerToCatchableTypes // CatchableTypeArray 4145288943Sdim }; 4146288943Sdim auto *GV = new llvm::GlobalVariable( 4147288943Sdim CGM.getModule(), TIType, /*Constant=*/true, getLinkageForRTTI(T), 4148288943Sdim llvm::ConstantStruct::get(TIType, Fields), StringRef(MangledName)); 4149288943Sdim GV->setUnnamedAddr(true); 4150288943Sdim GV->setSection(".xdata"); 4151288943Sdim if (GV->isWeakForLinker()) 4152288943Sdim GV->setComdat(CGM.getModule().getOrInsertComdat(GV->getName())); 4153288943Sdim return GV; 4154288943Sdim} 4155288943Sdim 4156288943Sdimvoid MicrosoftCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) { 4157288943Sdim const Expr *SubExpr = E->getSubExpr(); 4158288943Sdim QualType ThrowType = SubExpr->getType(); 4159288943Sdim // The exception object lives on the stack and it's address is passed to the 4160288943Sdim // runtime function. 4161296417Sdim Address AI = CGF.CreateMemTemp(ThrowType); 4162288943Sdim CGF.EmitAnyExprToMem(SubExpr, AI, ThrowType.getQualifiers(), 4163288943Sdim /*IsInit=*/true); 4164288943Sdim 4165288943Sdim // The so-called ThrowInfo is used to describe how the exception object may be 4166288943Sdim // caught. 4167288943Sdim llvm::GlobalVariable *TI = getThrowInfo(ThrowType); 4168288943Sdim 4169288943Sdim // Call into the runtime to throw the exception. 4170296417Sdim llvm::Value *Args[] = { 4171296417Sdim CGF.Builder.CreateBitCast(AI.getPointer(), CGM.Int8PtrTy), 4172296417Sdim TI 4173296417Sdim }; 4174288943Sdim CGF.EmitNoreturnRuntimeCallOrInvoke(getThrowFn(), Args); 4175288943Sdim} 4176