//===--- MicrosoftCXXABI.cpp - Emit LLVM Code from ASTs for a Module ------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This provides C++ code generation targeting the Microsoft Visual C++ ABI.

// The class in this file generates structures that follow the Microsoft

// Visual C++ ABI, which is actually not very well documented at all outside

// of Microsoft.

//

//===----------------------------------------------------------------------===//

#include "CGCXXABI.h"

#include "CGCleanup.h"

#include "CGVTables.h"

#include "CodeGenModule.h"

#include "CodeGenTypes.h"

#include "TargetInfo.h"

#include "clang/AST/Attr.h"

#include "clang/AST/CXXInheritance.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/StmtCXX.h"

#include "clang/AST/VTableBuilder.h"

#include "clang/CodeGen/ConstantInitBuilder.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/ADT/StringSet.h"

#include "llvm/IR/Intrinsics.h"

using namespace clang;

using namespace CodeGen;

namespace {

/// Holds all the vbtable globals for a given class.

struct VBTableGlobals {

  const VPtrInfoVector *VBTables;

  SmallVector<llvm::GlobalVariable *, 2> Globals;

};

class MicrosoftCXXABI : public CGCXXABI {

public:

  MicrosoftCXXABI(CodeGenModule &CGM)

      : CGCXXABI(CGM), BaseClassDescriptorType(nullptr),

        ClassHierarchyDescriptorType(nullptr),

        CompleteObjectLocatorType(nullptr), CatchableTypeType(nullptr),

        ThrowInfoType(nullptr) {

    assert(!(CGM.getLangOpts().isExplicitDefaultVisibilityExportMapping() ||

             CGM.getLangOpts().isAllDefaultVisibilityExportMapping()) &&

           "visibility export mapping option unimplemented in this ABI");

  }

  bool HasThisReturn(GlobalDecl GD) const override;

  bool hasMostDerivedReturn(GlobalDecl GD) const override;

  bool classifyReturnType(CGFunctionInfo &FI) const override;

  RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override;

  bool isSRetParameterAfterThis() const override { return true; }

  bool isThisCompleteObject(GlobalDecl GD) const override {

    // The Microsoft ABI doesn't use separate complete-object vs.

    // base-object variants of constructors, but it does of destructors.

    if (isa<CXXDestructorDecl>(GD.getDecl())) {

      switch (GD.getDtorType()) {

      case Dtor_Complete:

      case Dtor_Deleting:

        return true;

      case Dtor_Base:

        return false;

      case Dtor_Comdat: llvm_unreachable("emitting dtor comdat as function?");

      }

      llvm_unreachable("bad dtor kind");

    }

    // No other kinds.

    return false;

  }

  size_t getSrcArgforCopyCtor(const CXXConstructorDecl *CD,

                              FunctionArgList &Args) const override {

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

           "expected the arglist to have at least two args!");

    // The 'most_derived' parameter goes second if the ctor is variadic and

    // has v-bases.

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

        
CD->getType()->castAs<FunctionProtoType>()->isVariadic()15
)

      return 2;

    return 1;

  }

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

    std::vector<CharUnits> VBPtrOffsets;

    const ASTContext &Context = getContext();

    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);

    const VBTableGlobals &VBGlobals = enumerateVBTables(RD);

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

      const ASTRecordLayout &SubobjectLayout =

          Context.getASTRecordLayout(VBT->IntroducingObject);

      CharUnits Offs = VBT->NonVirtualOffset;

      Offs += SubobjectLayout.getVBPtrOffset();

      if (VBT->getVBaseWithVPtr())

        Offs += Layout.getVBaseClassOffset(VBT->getVBaseWithVPtr());

      VBPtrOffsets.push_back(Offs);

    }

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

    return VBPtrOffsets;

  }

  StringRef GetPureVirtualCallName() override { return "_purecall"; }

  StringRef GetDeletedVirtualCallName() override { return "_purecall"; }

  void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,

                               Address Ptr, QualType ElementType,

                               const CXXDestructorDecl *Dtor) override;

  void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;

  void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;

  void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;

  llvm::GlobalVariable *getMSCompleteObjectLocator(const CXXRecordDecl *RD,

                                                   const VPtrInfo &Info);

  llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override;

  CatchTypeInfo

  getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType) override;

  /// MSVC needs an extra flag to indicate a catchall.

  CatchTypeInfo getCatchAllTypeInfo() override {

    // For -EHa catch(...) must handle HW exception

    // Adjective = HT_IsStdDotDot (0x40), only catch C++ exceptions

    if (getContext().getLangOpts().EHAsynch)

      return CatchTypeInfo{nullptr, 0};

    else

      return CatchTypeInfo{nullptr, 0x40};

  }

  bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy) override;

  void EmitBadTypeidCall(CodeGenFunction &CGF) override;

  llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,

                          Address ThisPtr,

                          llvm::Type *StdTypeInfoPtrTy) override;

  bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,

                                          QualType SrcRecordTy) override;

  llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,

                                   QualType SrcRecordTy, QualType DestTy,

                                   QualType DestRecordTy,

                                   llvm::BasicBlock *CastEnd) override;

  llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,

                                     QualType SrcRecordTy,

                                     QualType DestTy) override;

  bool EmitBadCastCall(CodeGenFunction &CGF) override;

  bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const override {

    return false;

  }

  llvm::Value *

  GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,

                            const CXXRecordDecl *ClassDecl,

                            const CXXRecordDecl *BaseClassDecl) override;

  llvm::BasicBlock *

  EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,

                                const CXXRecordDecl *RD) override;

  llvm::BasicBlock *

  EmitDtorCompleteObjectHandler(CodeGenFunction &CGF);

  void initializeHiddenVirtualInheritanceMembers(CodeGenFunction &CGF,

                                              const CXXRecordDecl *RD) override;

  void EmitCXXConstructors(const CXXConstructorDecl *D) override;

  // Background on MSVC destructors

  // ==============================

  //

  // Both Itanium and MSVC ABIs have destructor variants.  The variant names

  // roughly correspond in the following way:

  //   Itanium       Microsoft

  //   Base       -> no name, just ~Class

  //   Complete   -> vbase destructor

  //   Deleting   -> scalar deleting destructor

  //                 vector deleting destructor

  //

  // The base and complete destructors are the same as in Itanium, although the

  // complete destructor does not accept a VTT parameter when there are virtual

  // bases.  A separate mechanism involving vtordisps is used to ensure that

  // virtual methods of destroyed subobjects are not called.

  //

  // The deleting destructors accept an i32 bitfield as a second parameter.  Bit

  // 1 indicates if the memory should be deleted.  Bit 2 indicates if the this

  // pointer points to an array.  The scalar deleting destructor assumes that

  // bit 2 is zero, and therefore does not contain a loop.

  //

  // For virtual destructors, only one entry is reserved in the vftable, and it

  // always points to the vector deleting destructor.  The vector deleting

  // destructor is the most general, so it can be used to destroy objects in

  // place, delete single heap objects, or delete arrays.

  //

  // A TU defining a non-inline destructor is only guaranteed to emit a base

  // destructor, and all of the other variants are emitted on an as-needed basis

  // in COMDATs.  Because a non-base destructor can be emitted in a TU that

  // lacks a definition for the destructor, non-base destructors must always

  // delegate to or alias the base destructor.

  AddedStructorArgCounts

  buildStructorSignature(GlobalDecl GD,

                         SmallVectorImpl<CanQualType> &ArgTys) override;

  /// Non-base dtors should be emitted as delegating thunks in this ABI.

  bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,

                              CXXDtorType DT) const override {

    return DT != Dtor_Base;

  }

  void setCXXDestructorDLLStorage(llvm::GlobalValue *GV,

                                  const CXXDestructorDecl *Dtor,

                                  CXXDtorType DT) const override;

  llvm::GlobalValue::LinkageTypes

  getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor,

                          CXXDtorType DT) const override;

  void EmitCXXDestructors(const CXXDestructorDecl *D) override;

  const CXXRecordDecl *

  getThisArgumentTypeForMethod(const CXXMethodDecl *MD) override {

    if (MD->isVirtual() && 
!isa<CXXDestructorDecl>(MD)3.23k
) {

      MethodVFTableLocation ML =

          CGM.getMicrosoftVTableContext().getMethodVFTableLocation(MD);

      // The vbases might be ordered differently in the final overrider object

      // and the complete object, so the "this" argument may sometimes point to

      // memory that has no particular type (e.g. past the complete object).

      // In this case, we just use a generic pointer type.

      // FIXME: might want to have a more precise type in the non-virtual

      // multiple inheritance case.

      if (ML.VBase || 
!ML.VFPtrOffset.isZero()2.06k
)

        return nullptr;

    }

    return MD->getParent();

  }

  Address

  adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD,

                                           Address This,

                                           bool VirtualCall) override;

  void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,

                                 FunctionArgList &Params) override;

  void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;

  AddedStructorArgs getImplicitConstructorArgs(CodeGenFunction &CGF,

                                               const CXXConstructorDecl *D,

                                               CXXCtorType Type,

                                               bool ForVirtualBase,

                                               bool Delegating) override;

  llvm::Value *getCXXDestructorImplicitParam(CodeGenFunction &CGF,

                                             const CXXDestructorDecl *DD,

                                             CXXDtorType Type,

                                             bool ForVirtualBase,

                                             bool Delegating) override;

  void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,

                          CXXDtorType Type, bool ForVirtualBase,

                          bool Delegating, Address This,

                          QualType ThisTy) override;

  void emitVTableTypeMetadata(const VPtrInfo &Info, const CXXRecordDecl *RD,

                              llvm::GlobalVariable *VTable);

  void emitVTableDefinitions(CodeGenVTables &CGVT,

                             const CXXRecordDecl *RD) override;

  bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,

                                           CodeGenFunction::VPtr Vptr) override;

  /// Don't initialize vptrs if dynamic class

  /// is marked with with the 'novtable' attribute.

  bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override {

    return !VTableClass->hasAttr<MSNoVTableAttr>();

  }

  llvm::Constant *

  getVTableAddressPoint(BaseSubobject Base,

                        const CXXRecordDecl *VTableClass) override;

  llvm::Value *getVTableAddressPointInStructor(

      CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,

      BaseSubobject Base, const CXXRecordDecl *NearestVBase) override;

  llvm::Constant *

  getVTableAddressPointForConstExpr(BaseSubobject Base,

                                    const CXXRecordDecl *VTableClass) override;

  llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,

                                        CharUnits VPtrOffset) override;

  CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,

                                     Address This, llvm::Type *Ty,

                                     SourceLocation Loc) override;

  llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,

                                         const CXXDestructorDecl *Dtor,

                                         CXXDtorType DtorType, Address This,

                                         DeleteOrMemberCallExpr E) override;

  void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF, GlobalDecl GD,

                                        CallArgList &CallArgs) override {

    assert(GD.getDtorType() == Dtor_Deleting &&

           "Only deleting destructor thunks are available in this ABI");

    CallArgs.add(RValue::get(getStructorImplicitParamValue(CGF)),

                 getContext().IntTy);

  }

  void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override;

  llvm::GlobalVariable *

  getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD,

                   llvm::GlobalVariable::LinkageTypes Linkage);

  llvm::GlobalVariable *

  getAddrOfVirtualDisplacementMap(const CXXRecordDecl *SrcRD,

                                  const CXXRecordDecl *DstRD) {

    SmallString<256> OutName;

    llvm::raw_svector_ostream Out(OutName);

    getMangleContext().mangleCXXVirtualDisplacementMap(SrcRD, DstRD, Out);

    StringRef MangledName = OutName.str();

    if (auto *VDispMap = CGM.getModule().getNamedGlobal(MangledName))

      return VDispMap;

    MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext();

    unsigned NumEntries = 1 + SrcRD->getNumVBases();

    SmallVector<llvm::Constant *, 4> Map(NumEntries,

                                         llvm::UndefValue::get(CGM.IntTy));

    Map[0] = llvm::ConstantInt::get(CGM.IntTy, 0);

    bool AnyDifferent = false;

    for (const auto &I : SrcRD->vbases()) {

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

      if (!DstRD->isVirtuallyDerivedFrom(VBase))

        continue;

      unsigned SrcVBIndex = VTContext.getVBTableIndex(SrcRD, VBase);

      unsigned DstVBIndex = VTContext.getVBTableIndex(DstRD, VBase);

      Map[SrcVBIndex] = llvm::ConstantInt::get(CGM.IntTy, DstVBIndex * 4);

      AnyDifferent |= SrcVBIndex != DstVBIndex;

    }

    // This map would be useless, don't use it.

    if (!AnyDifferent)

      return nullptr;

    llvm::ArrayType *VDispMapTy = llvm::ArrayType::get(CGM.IntTy, Map.size());

    llvm::Constant *Init = llvm::ConstantArray::get(VDispMapTy, Map);

    llvm::GlobalValue::LinkageTypes Linkage =

        SrcRD->isExternallyVisible() && DstRD->isExternallyVisible()

            ? llvm::GlobalValue::LinkOnceODRLinkage

            : llvm::GlobalValue::InternalLinkage;

    auto *VDispMap = new llvm::GlobalVariable(

        CGM.getModule(), VDispMapTy, /*isConstant=*/true, Linkage,

        /*Initializer=*/Init, MangledName);

    return VDispMap;

  }

  void emitVBTableDefinition(const VPtrInfo &VBT, const CXXRecordDecl *RD,

                             llvm::GlobalVariable *GV) const;

  void setThunkLinkage(llvm::Function *Thunk, bool ForVTable,

                       GlobalDecl GD, bool ReturnAdjustment) override {

    GVALinkage Linkage =

        getContext().GetGVALinkageForFunction(cast<FunctionDecl>(GD.getDecl()));

    if (Linkage == GVA_Internal)

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

    else if (ReturnAdjustment)

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

    else

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

  }

  bool exportThunk() override { return false; }

  llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,

                                     const ThisAdjustment &TA) override;

  llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,

                                       const ReturnAdjustment &RA) override;

  void EmitThreadLocalInitFuncs(

      CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,

      ArrayRef<llvm::Function *> CXXThreadLocalInits,

      ArrayRef<const VarDecl *> CXXThreadLocalInitVars) override;

  bool usesThreadWrapperFunction(const VarDecl *VD) const override {

    return getContext().getLangOpts().isCompatibleWithMSVC(

               LangOptions::MSVC2019_5) &&

           
(12
!isEmittedWithConstantInitializer(VD)12
 || 
mayNeedDestruction(VD)2
);

  }

  LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,

                                      QualType LValType) override;

  void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,

                       llvm::GlobalVariable *DeclPtr,

                       bool PerformInit) override;

  void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,

                          llvm::FunctionCallee Dtor,

                          llvm::Constant *Addr) override;

  // ==== Notes on array cookies =========

  //

  // MSVC seems to only use cookies when the class has a destructor; a

  // two-argument usual array deallocation function isn't sufficient.

  //

  // For example, this code prints "100" and "1":

  //   struct A {

  //     char x;

  //     void *operator new[](size_t sz) {

  //       printf("%u\n", sz);

  //       return malloc(sz);

  //     }

  //     void operator delete[](void *p, size_t sz) {

  //       printf("%u\n", sz);

  //       free(p);

  //     }

  //   };

  //   int main() {

  //     A *p = new A[100];

  //     delete[] p;

  //   }

  // Whereas it prints "104" and "104" if you give A a destructor.

  bool requiresArrayCookie(const CXXDeleteExpr *expr,

                           QualType elementType) override;

  bool requiresArrayCookie(const CXXNewExpr *expr) override;

  CharUnits getArrayCookieSizeImpl(QualType type) override;

  Address InitializeArrayCookie(CodeGenFunction &CGF,

                                Address NewPtr,

                                llvm::Value *NumElements,

                                const CXXNewExpr *expr,

                                QualType ElementType) override;

  llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,

                                   Address allocPtr,

                                   CharUnits cookieSize) override;

  friend struct MSRTTIBuilder;

  bool isImageRelative() const {

    return CGM.getTarget().getPointerWidth(/*AddrSpace=*/0) == 64;

  }

  // 5 routines for constructing the llvm types for MS RTTI structs.

  llvm::StructType *getTypeDescriptorType(StringRef TypeInfoString) {

    llvm::SmallString<32> TDTypeName("rtti.TypeDescriptor");

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

    llvm::StructType *&TypeDescriptorType =

        TypeDescriptorTypeMap[TypeInfoString.size()];

    if (TypeDescriptorType)

      return TypeDescriptorType;

    llvm::Type *FieldTypes[] = {

        CGM.Int8PtrPtrTy,

        CGM.Int8PtrTy,

        llvm::ArrayType::get(CGM.Int8Ty, TypeInfoString.size() + 1)};

    TypeDescriptorType =

        llvm::StructType::create(CGM.getLLVMContext(), FieldTypes, TDTypeName);

    return TypeDescriptorType;

  }

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

    if (!isImageRelative())

      return PtrType;

    return CGM.IntTy;

  }

  llvm::StructType *getBaseClassDescriptorType() {

    if (BaseClassDescriptorType)

      return BaseClassDescriptorType;

    llvm::Type *FieldTypes[] = {

        getImageRelativeType(CGM.Int8PtrTy),

        CGM.IntTy,

        CGM.IntTy,

        CGM.IntTy,

        CGM.IntTy,

        CGM.IntTy,

        getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()),

    };

    BaseClassDescriptorType = llvm::StructType::create(

        CGM.getLLVMContext(), FieldTypes, "rtti.BaseClassDescriptor");

    return BaseClassDescriptorType;

  }

  llvm::StructType *getClassHierarchyDescriptorType() {

    if (ClassHierarchyDescriptorType)

      return ClassHierarchyDescriptorType;

    // Forward-declare RTTIClassHierarchyDescriptor to break a cycle.

    ClassHierarchyDescriptorType = llvm::StructType::create(

        CGM.getLLVMContext(), "rtti.ClassHierarchyDescriptor");

    llvm::Type *FieldTypes[] = {

        CGM.IntTy,

        CGM.IntTy,

        CGM.IntTy,

        getImageRelativeType(

            getBaseClassDescriptorType()->getPointerTo()->getPointerTo()),

    };

    ClassHierarchyDescriptorType->setBody(FieldTypes);

    return ClassHierarchyDescriptorType;

  }

  llvm::StructType *getCompleteObjectLocatorType() {

    if (CompleteObjectLocatorType)

      return CompleteObjectLocatorType;

    CompleteObjectLocatorType = llvm::StructType::create(

        CGM.getLLVMContext(), "rtti.CompleteObjectLocator");

    llvm::Type *FieldTypes[] = {

        CGM.IntTy,

        CGM.IntTy,

        CGM.IntTy,

        getImageRelativeType(CGM.Int8PtrTy),

        getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()),

        getImageRelativeType(CompleteObjectLocatorType),

    };

    llvm::ArrayRef<llvm::Type *> FieldTypesRef(FieldTypes);

    if (!isImageRelative())

      FieldTypesRef = FieldTypesRef.drop_back();

    CompleteObjectLocatorType->setBody(FieldTypesRef);

    return CompleteObjectLocatorType;

  }

  llvm::GlobalVariable *getImageBase() {

    StringRef Name = "__ImageBase";

    if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name))

      return GV;

    auto *GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8Ty,

                                        /*isConstant=*/true,

                                        llvm::GlobalValue::ExternalLinkage,

                                        /*Initializer=*/nullptr, Name);

    CGM.setDSOLocal(GV);

    return GV;

  }

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

    if (!isImageRelative())

      return PtrVal;

    if (PtrVal->isNullValue())

      return llvm::Constant::getNullValue(CGM.IntTy);

    llvm::Constant *ImageBaseAsInt =

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

    llvm::Constant *PtrValAsInt =

        llvm::ConstantExpr::getPtrToInt(PtrVal, CGM.IntPtrTy);

    llvm::Constant *Diff =

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

                                   /*HasNUW=*/true, /*HasNSW=*/true);

    return llvm::ConstantExpr::getTrunc(Diff, CGM.IntTy);

  }

private:

  MicrosoftMangleContext &getMangleContext() {

    return cast<MicrosoftMangleContext>(CodeGen::CGCXXABI::getMangleContext());

  }

  llvm::Constant *getZeroInt() {

    return llvm::ConstantInt::get(CGM.IntTy, 0);

  }

  llvm::Constant *getAllOnesInt() {

    return  llvm::Constant::getAllOnesValue(CGM.IntTy);

  }

  CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) override;

  void

  GetNullMemberPointerFields(const MemberPointerType *MPT,

                             llvm::SmallVectorImpl<llvm::Constant *> &fields);

  /// Shared code for virtual base adjustment.  Returns the offset from

  /// the vbptr to the virtual base.  Optionally returns the address of the

  /// vbptr itself.

  llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,

                                       Address Base,

                                       llvm::Value *VBPtrOffset,

                                       llvm::Value *VBTableOffset,

                                       llvm::Value **VBPtr = nullptr);

  llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF,

                                       Address Base,

                                       int32_t VBPtrOffset,

                                       int32_t VBTableOffset,

                                       llvm::Value **VBPtr = nullptr) {

    assert(VBTableOffset % 4 == 0 && "should be byte offset into table of i32s");

    llvm::Value *VBPOffset = llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset),

                *VBTOffset = llvm::ConstantInt::get(CGM.IntTy, VBTableOffset);

    return GetVBaseOffsetFromVBPtr(CGF, Base, VBPOffset, VBTOffset, VBPtr);

  }

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

  performBaseAdjustment(CodeGenFunction &CGF, Address Value,

                        QualType SrcRecordTy);

  /// Performs a full virtual base adjustment.  Used to dereference

  /// pointers to members of virtual bases.

  llvm::Value *AdjustVirtualBase(CodeGenFunction &CGF, const Expr *E,

                                 const CXXRecordDecl *RD, Address Base,

                                 llvm::Value *VirtualBaseAdjustmentOffset,

                                 llvm::Value *VBPtrOffset /* optional */);

  /// Emits a full member pointer with the fields common to data and

  /// function member pointers.

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

                                        bool IsMemberFunction,

                                        const CXXRecordDecl *RD,

                                        CharUnits NonVirtualBaseAdjustment,

                                        unsigned VBTableIndex);

  bool MemberPointerConstantIsNull(const MemberPointerType *MPT,

                                   llvm::Constant *MP);

  /// - Initialize all vbptrs of 'this' with RD as the complete type.

  void EmitVBPtrStores(CodeGenFunction &CGF, const CXXRecordDecl *RD);

  /// Caching wrapper around VBTableBuilder::enumerateVBTables().

  const VBTableGlobals &enumerateVBTables(const CXXRecordDecl *RD);

  /// Generate a thunk for calling a virtual member function MD.

  llvm::Function *EmitVirtualMemPtrThunk(const CXXMethodDecl *MD,

                                         const MethodVFTableLocation &ML);

  llvm::Constant *EmitMemberDataPointer(const CXXRecordDecl *RD,

                                        CharUnits offset);

public:

  llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;

  bool isZeroInitializable(const MemberPointerType *MPT) override;

  bool isMemberPointerConvertible(const MemberPointerType *MPT) const override {

    const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();

    return RD->hasAttr<MSInheritanceAttr>();

  }

  llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override;

  llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,

                                        CharUnits offset) override;

  llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override;

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

  llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,

                                           llvm::Value *L,

                                           llvm::Value *R,

                                           const MemberPointerType *MPT,

                                           bool Inequality) override;

  llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,

                                          llvm::Value *MemPtr,

                                          const MemberPointerType *MPT) override;

  llvm::Value *

  EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,

                               Address Base, llvm::Value *MemPtr,

                               const MemberPointerType *MPT) override;

  llvm::Value *EmitNonNullMemberPointerConversion(

      const MemberPointerType *SrcTy, const MemberPointerType *DstTy,

      CastKind CK, CastExpr::path_const_iterator PathBegin,

      CastExpr::path_const_iterator PathEnd, llvm::Value *Src,

      CGBuilderTy &Builder);

  llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,

                                           const CastExpr *E,

                                           llvm::Value *Src) override;

  llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,

                                              llvm::Constant *Src) override;

  llvm::Constant *EmitMemberPointerConversion(

      const MemberPointerType *SrcTy, const MemberPointerType *DstTy,

      CastKind CK, CastExpr::path_const_iterator PathBegin,

      CastExpr::path_const_iterator PathEnd, llvm::Constant *Src);

  CGCallee

  EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E,

                                  Address This, llvm::Value *&ThisPtrForCall,

                                  llvm::Value *MemPtr,

                                  const MemberPointerType *MPT) override;

  void emitCXXStructor(GlobalDecl GD) override;

  llvm::StructType *getCatchableTypeType() {

    if (CatchableTypeType)

      return CatchableTypeType;

    llvm::Type *FieldTypes[] = {

        CGM.IntTy,                           // Flags

        getImageRelativeType(CGM.Int8PtrTy), // TypeDescriptor

        CGM.IntTy,                           // NonVirtualAdjustment

        CGM.IntTy,                           // OffsetToVBPtr

        CGM.IntTy,                           // VBTableIndex

        CGM.IntTy,                           // Size

        getImageRelativeType(CGM.Int8PtrTy)  // CopyCtor

    };

    CatchableTypeType = llvm::StructType::create(

        CGM.getLLVMContext(), FieldTypes, "eh.CatchableType");

    return CatchableTypeType;

  }

  llvm::StructType *getCatchableTypeArrayType(uint32_t NumEntries) {

    llvm::StructType *&CatchableTypeArrayType =

        CatchableTypeArrayTypeMap[NumEntries];

    if (CatchableTypeArrayType)

      return CatchableTypeArrayType;

    llvm::SmallString<23> CTATypeName("eh.CatchableTypeArray.");

    CTATypeName += llvm::utostr(NumEntries);

    llvm::Type *CTType =

        getImageRelativeType(getCatchableTypeType()->getPointerTo());

    llvm::Type *FieldTypes[] = {

        CGM.IntTy,                               // NumEntries

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

    };

    CatchableTypeArrayType =

        llvm::StructType::create(CGM.getLLVMContext(), FieldTypes, CTATypeName);

    return CatchableTypeArrayType;

  }

  llvm::StructType *getThrowInfoType() {

    if (ThrowInfoType)

      return ThrowInfoType;

    llvm::Type *FieldTypes[] = {

        CGM.IntTy,                           // Flags

        getImageRelativeType(CGM.Int8PtrTy), // CleanupFn

        getImageRelativeType(CGM.Int8PtrTy), // ForwardCompat

        getImageRelativeType(CGM.Int8PtrTy)  // CatchableTypeArray

    };

    ThrowInfoType = llvm::StructType::create(CGM.getLLVMContext(), FieldTypes,

                                             "eh.ThrowInfo");

    return ThrowInfoType;

  }

  llvm::FunctionCallee getThrowFn() {

    // _CxxThrowException is passed an exception object and a ThrowInfo object

    // which describes the exception.

    llvm::Type *Args[] = {CGM.Int8PtrTy, getThrowInfoType()->getPointerTo()};

    llvm::FunctionType *FTy =

        llvm::FunctionType::get(CGM.VoidTy, Args, /*isVarArg=*/false);

    llvm::FunctionCallee Throw =

        CGM.CreateRuntimeFunction(FTy, "_CxxThrowException");

    // _CxxThrowException is stdcall on 32-bit x86 platforms.

    if (CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) {

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

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

    }

    return Throw;

  }

  llvm::Function *getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD,

                                          CXXCtorType CT);

  llvm::Constant *getCatchableType(QualType T,

                                   uint32_t NVOffset = 0,

                                   int32_t VBPtrOffset = -1,

                                   uint32_t VBIndex = 0);

  llvm::GlobalVariable *getCatchableTypeArray(QualType T);

  llvm::GlobalVariable *getThrowInfo(QualType T) override;

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

  LoadVTablePtr(CodeGenFunction &CGF, Address This,

                const CXXRecordDecl *RD) override;

  virtual bool

  isPermittedToBeHomogeneousAggregate(const CXXRecordDecl *RD) const override;

private:

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

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

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

  /// All the vftables that have been referenced.

  VFTablesMapTy VFTablesMap;

  VTablesMapTy VTablesMap;

  /// This set holds the record decls we've deferred vtable emission for.

  llvm::SmallPtrSet<const CXXRecordDecl *, 4> DeferredVFTables;

  /// All the vbtables which have been referenced.

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

  /// Info on the global variable used to guard initialization of static locals.

  /// The BitIndex field is only used for externally invisible declarations.

  struct GuardInfo {

    GuardInfo() : Guard(nullptr), BitIndex(0) {}

    llvm::GlobalVariable *Guard;

    unsigned BitIndex;

  };

  /// Map from DeclContext to the current guard variable.  We assume that the

  /// AST is visited in source code order.

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

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

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

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

  llvm::StructType *BaseClassDescriptorType;

  llvm::StructType *ClassHierarchyDescriptorType;

  llvm::StructType *CompleteObjectLocatorType;

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

  llvm::StructType *CatchableTypeType;

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

  llvm::StructType *ThrowInfoType;

};

}

CGCXXABI::RecordArgABI

MicrosoftCXXABI::getRecordArgABI(const CXXRecordDecl *RD) const {

  // Use the default C calling convention rules for things that can be passed in

  // registers, i.e. non-trivially copyable records or records marked with

  // [[trivial_abi]].

  if (RD->canPassInRegisters())

    return RAA_Default;

  switch (CGM.getTarget().getTriple().getArch()) {

  default:

    // FIXME: Implement for other architectures.

    return RAA_Indirect;

  case llvm::Triple::thumb:

    // Pass things indirectly for now because it is simple.

    // FIXME: This is incompatible with MSVC for arguments with a dtor and no

    // copy ctor.

    return RAA_Indirect;

  case llvm::Triple::x86: {

    // If the argument has *required* alignment greater than four bytes, pass

    // it indirectly. Prior to MSVC version 19.14, passing overaligned

    // arguments was not supported and resulted in a compiler error. In 19.14

    // and later versions, such arguments are now passed indirectly.

    TypeInfo Info = getContext().getTypeInfo(RD->getTypeForDecl());

    if (Info.isAlignRequired() && 
Info.Align > 45
)

      return RAA_Indirect;

    // If C++ prohibits us from making a copy, construct the arguments directly

    // into argument memory.

    return RAA_DirectInMemory;

  }

  case llvm::Triple::x86_64:

  case llvm::Triple::aarch64:

    return RAA_Indirect;

  }

  llvm_unreachable("invalid enum");

}

void MicrosoftCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,

                                              const CXXDeleteExpr *DE,

                                              Address Ptr,

                                              QualType ElementType,

                                              const CXXDestructorDecl *Dtor) {

  // FIXME: Provide a source location here even though there's no

  // CXXMemberCallExpr for dtor call.

  bool UseGlobalDelete = DE->isGlobalDelete();

  CXXDtorType DtorType = UseGlobalDelete ? 
Dtor_Complete2
 : 
Dtor_Deleting43
;

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

  if (UseGlobalDelete)

    CGF.EmitDeleteCall(DE->getOperatorDelete(), MDThis, ElementType);

}

void MicrosoftCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {

  llvm::Value *Args[] = {

      llvm::ConstantPointerNull::get(CGM.Int8PtrTy),

      llvm::ConstantPointerNull::get(getThrowInfoType()->getPointerTo())};

  llvm::FunctionCallee Fn = getThrowFn();

  if (isNoReturn)

    CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, Args);

  else

    CGF.EmitRuntimeCallOrInvoke(Fn, Args);

}

void MicrosoftCXXABI::emitBeginCatch(CodeGenFunction &CGF,

                                     const CXXCatchStmt *S) {

  // In the MS ABI, the runtime handles the copy, and the catch handler is

  // responsible for destruction.

  VarDecl *CatchParam = S->getExceptionDecl();

  llvm::BasicBlock *CatchPadBB = CGF.Builder.GetInsertBlock();

  llvm::CatchPadInst *CPI =

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

  CGF.CurrentFuncletPad = CPI;

  // If this is a catch-all or the catch parameter is unnamed, we don't need to

  // emit an alloca to the object.

  if (!CatchParam || 
!CatchParam->getDeclName()15
) {

    CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI);

    return;

  }

  CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);

  CPI->setArgOperand(2, var.getObjectAddress(CGF).getPointer());

  CGF.EHStack.pushCleanup<CatchRetScope>(NormalCleanup, CPI);

  CGF.EmitAutoVarCleanups(var);

}

/// We need to perform a generic polymorphic operation (like a typeid

/// or a cast), which requires an object with a vfptr.  Adjust the

/// address to point to an object with a vfptr.

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

MicrosoftCXXABI::performBaseAdjustment(CodeGenFunction &CGF, Address Value,

                                       QualType SrcRecordTy) {

  Value = CGF.Builder.CreateElementBitCast(Value, CGF.Int8Ty);

  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();

  const ASTContext &Context = getContext();

  // If the class itself has a vfptr, great.  This check implicitly

  // covers non-virtual base subobjects: a class with its own virtual

  // functions would be a candidate to be a primary base.

  if (Context.getASTRecordLayout(SrcDecl).hasExtendableVFPtr())

    return std::make_tuple(Value, llvm::ConstantInt::get(CGF.Int32Ty, 0),

                           SrcDecl);

  // Okay, one of the vbases must have a vfptr, or else this isn't

  // actually a polymorphic class.

  const CXXRecordDecl *PolymorphicBase = nullptr;

  for (auto &Base : SrcDecl->vbases()) {

    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();

    if (Context.getASTRecordLayout(BaseDecl).hasExtendableVFPtr()) {

      PolymorphicBase = BaseDecl;

      break;

    }

  }

  assert(PolymorphicBase && "polymorphic class has no apparent vfptr?");

  llvm::Value *Offset =

    GetVirtualBaseClassOffset(CGF, Value, SrcDecl, PolymorphicBase);

  llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP(

      Value.getElementType(), Value.getPointer(), Offset);

  CharUnits VBaseAlign =

    CGF.CGM.getVBaseAlignment(Value.getAlignment(), SrcDecl, PolymorphicBase);

  return std::make_tuple(Address(Ptr, CGF.Int8Ty, VBaseAlign), Offset,

                         PolymorphicBase);

}

bool MicrosoftCXXABI::shouldTypeidBeNullChecked(bool IsDeref,

                                                QualType SrcRecordTy) {

  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();

  return IsDeref &&

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

}

static llvm::CallBase *emitRTtypeidCall(CodeGenFunction &CGF,

                                        llvm::Value *Argument) {

  llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};

  llvm::FunctionType *FTy =

      llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false);

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

  llvm::FunctionCallee Fn = CGF.CGM.CreateRuntimeFunction(FTy, "__RTtypeid");

  return CGF.EmitRuntimeCallOrInvoke(Fn, Args);

}

void MicrosoftCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {

  llvm::CallBase *Call =

      emitRTtypeidCall(CGF, llvm::Constant::getNullValue(CGM.VoidPtrTy));

  Call->setDoesNotReturn();

  CGF.Builder.CreateUnreachable();

}

llvm::Value *MicrosoftCXXABI::EmitTypeid(CodeGenFunction &CGF,

                                         QualType SrcRecordTy,

                                         Address ThisPtr,

                                         llvm::Type *StdTypeInfoPtrTy) {

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

      performBaseAdjustment(CGF, ThisPtr, SrcRecordTy);

  llvm::CallBase *Typeid = emitRTtypeidCall(CGF, ThisPtr.getPointer());

  return CGF.Builder.CreateBitCast(Typeid, StdTypeInfoPtrTy);

}

bool MicrosoftCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,

                                                         QualType SrcRecordTy) {

  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();

  return SrcIsPtr &&

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

}

llvm::Value *MicrosoftCXXABI::EmitDynamicCastCall(

    CodeGenFunction &CGF, Address This, QualType SrcRecordTy,

    QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) {

  llvm::Type *DestLTy = CGF.ConvertType(DestTy);

  llvm::Value *SrcRTTI =

      CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());

  llvm::Value *DestRTTI =

      CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());

  llvm::Value *Offset;

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

      performBaseAdjustment(CGF, This, SrcRecordTy);

  llvm::Value *ThisPtr = This.getPointer();

  Offset = CGF.Builder.CreateTrunc(Offset, CGF.Int32Ty);

  // PVOID __RTDynamicCast(

  //   PVOID inptr,

  //   LONG VfDelta,

  //   PVOID SrcType,

  //   PVOID TargetType,

  //   BOOL isReference)

  llvm::Type *ArgTypes[] = {CGF.Int8PtrTy, CGF.Int32Ty, CGF.Int8PtrTy,

                            CGF.Int8PtrTy, CGF.Int32Ty};

  llvm::FunctionCallee Function = CGF.CGM.CreateRuntimeFunction(

      llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),

      "__RTDynamicCast");

  llvm::Value *Args[] = {

      ThisPtr, Offset, SrcRTTI, DestRTTI,

      llvm::ConstantInt::get(CGF.Int32Ty, DestTy->isReferenceType())};

  ThisPtr = CGF.EmitRuntimeCallOrInvoke(Function, Args);

  return CGF.Builder.CreateBitCast(ThisPtr, DestLTy);

}

llvm::Value *

MicrosoftCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,

                                       QualType SrcRecordTy,

                                       QualType DestTy) {

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

      performBaseAdjustment(CGF, Value, SrcRecordTy);

  // PVOID __RTCastToVoid(

  //   PVOID inptr)

  llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};

  llvm::FunctionCallee Function = CGF.CGM.CreateRuntimeFunction(

      llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),

      "__RTCastToVoid");

  llvm::Value *Args[] = {Value.getPointer()};

  return CGF.EmitRuntimeCall(Function, Args);

}

bool MicrosoftCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {

  return false;

}

llvm::Value *MicrosoftCXXABI::GetVirtualBaseClassOffset(

    CodeGenFunction &CGF, Address This, const CXXRecordDecl *ClassDecl,

    const CXXRecordDecl *BaseClassDecl) {

  const ASTContext &Context = getContext();

  int64_t VBPtrChars =

      Context.getASTRecordLayout(ClassDecl).getVBPtrOffset().getQuantity();

  llvm::Value *VBPtrOffset = llvm::ConstantInt::get(CGM.PtrDiffTy, VBPtrChars);

  CharUnits IntSize = Context.getTypeSizeInChars(Context.IntTy);

  CharUnits VBTableChars =

      IntSize *

      CGM.getMicrosoftVTableContext().getVBTableIndex(ClassDecl, BaseClassDecl);

  llvm::Value *VBTableOffset =

      llvm::ConstantInt::get(CGM.IntTy, VBTableChars.getQuantity());