contrib/llvm/tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

   1 //===------- ItaniumCXXABI.cpp - Emit LLVM Code from ASTs for a Module ----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This provides C++ code generation targeting the Itanium C++ ABI.  The class
  11 // in this file generates structures that follow the Itanium C++ ABI, which is
  12 // documented at:
  13 //  http://www.codesourcery.com/public/cxx-abi/abi.html
  14 //  http://www.codesourcery.com/public/cxx-abi/abi-eh.html
  15 //
  16 // It also supports the closely-related ARM ABI, documented at:
  17 // http://infocenter.arm.com/help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf
  18 //
  19 //===----------------------------------------------------------------------===//
  20
  21 #include "CGCXXABI.h"
  22 #include "CGCleanup.h"
  23 #include "CGRecordLayout.h"
  24 #include "CGVTables.h"
  25 #include "CodeGenFunction.h"
  26 #include "CodeGenModule.h"
  27 #include "TargetInfo.h"
  28 #include "clang/AST/Mangle.h"
  29 #include "clang/AST/Type.h"
  30 #include "clang/AST/StmtCXX.h"
  31 #include "llvm/IR/CallSite.h"
  32 #include "llvm/IR/DataLayout.h"
  33 #include "llvm/IR/Instructions.h"
  34 #include "llvm/IR/Intrinsics.h"
  35 #include "llvm/IR/Value.h"
  36
  37 using namespace clang;
  38 using namespace CodeGen;
  39
  40 namespace {
  41 class ItaniumCXXABI : public CodeGen::CGCXXABI {
  42   /// VTables - All the vtables which have been defined.
  43   llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> VTables;
  44
  45 protected:
  46   bool UseARMMethodPtrABI;
  47   bool UseARMGuardVarABI;
  48
  49   ItaniumMangleContext &getMangleContext() {
  50     return cast<ItaniumMangleContext>(CodeGen::CGCXXABI::getMangleContext());
  51   }
  52
  53 public:
  54   ItaniumCXXABI(CodeGen::CodeGenModule &CGM,
  55                 bool UseARMMethodPtrABI = false,
  56                 bool UseARMGuardVarABI = false) :
  57     CGCXXABI(CGM), UseARMMethodPtrABI(UseARMMethodPtrABI),
  58     UseARMGuardVarABI(UseARMGuardVarABI) { }
  59
  60   bool classifyReturnType(CGFunctionInfo &FI) const override;
  61
  62   RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override {
  63     // Structures with either a non-trivial destructor or a non-trivial
  64     // copy constructor are always indirect.
  65     // FIXME: Use canCopyArgument() when it is fixed to handle lazily declared
  66     // special members.
  67     if (RD->hasNonTrivialDestructor() || RD->hasNonTrivialCopyConstructor())
  68       return RAA_Indirect;
  69     return RAA_Default;
  70   }
  71
  72   bool isThisCompleteObject(GlobalDecl GD) const override {
  73     // The Itanium ABI has separate complete-object vs.  base-object
  74     // variants of both constructors and destructors.
  75     if (isa<CXXDestructorDecl>(GD.getDecl())) {
  76       switch (GD.getDtorType()) {
  77       case Dtor_Complete:
  78       case Dtor_Deleting:
  79         return true;
  80
  81       case Dtor_Base:
  82         return false;
  83
  84       case Dtor_Comdat:
  85         llvm_unreachable("emitting dtor comdat as function?");
  86       }
  87       llvm_unreachable("bad dtor kind");
  88     }
  89     if (isa<CXXConstructorDecl>(GD.getDecl())) {
  90       switch (GD.getCtorType()) {
  91       case Ctor_Complete:
  92         return true;
  93
  94       case Ctor_Base:
  95         return false;
  96
  97       case Ctor_CopyingClosure:
  98       case Ctor_DefaultClosure:
  99         llvm_unreachable("closure ctors in Itanium ABI?");
 100
 101       case Ctor_Comdat:
 102         llvm_unreachable("emitting ctor comdat as function?");
 103       }
 104       llvm_unreachable("bad dtor kind");
 105     }
 106
 107     // No other kinds.
 108     return false;
 109   }
 110
 111   bool isZeroInitializable(const MemberPointerType *MPT) override;
 112
 113   llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;
 114
 115   llvm::Value *
 116     EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
 117                                     const Expr *E,
 118                                     Address This,
 119                                     llvm::Value *&ThisPtrForCall,
 120                                     llvm::Value *MemFnPtr,
 121                                     const MemberPointerType *MPT) override;
 122
 123   llvm::Value *
 124     EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
 125                                  Address Base,
 126                                  llvm::Value *MemPtr,
 127                                  const MemberPointerType *MPT) override;
 128
 129   llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
 130                                            const CastExpr *E,
 131                                            llvm::Value *Src) override;
 132   llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
 133                                               llvm::Constant *Src) override;
 134
 135   llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override;
 136
 137   llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override;
 138   llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
 139                                         CharUnits offset) override;
 140   llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override;
 141   llvm::Constant *BuildMemberPointer(const CXXMethodDecl *MD,
 142                                      CharUnits ThisAdjustment);
 143
 144   llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
 145                                            llvm::Value *L, llvm::Value *R,
 146                                            const MemberPointerType *MPT,
 147                                            bool Inequality) override;
 148
 149   llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
 150                                          llvm::Value *Addr,
 151                                          const MemberPointerType *MPT) override;
 152
 153   void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
 154                                Address Ptr, QualType ElementType,
 155                                const CXXDestructorDecl *Dtor) override;
 156
 157   CharUnits getAlignmentOfExnObject() {
 158     unsigned Align = CGM.getContext().getTargetInfo().getExnObjectAlignment();
 159     return CGM.getContext().toCharUnitsFromBits(Align);
 160   }
 161
 162   void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
 163   void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
 164
 165   void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
 166
 167   llvm::CallInst *
 168   emitTerminateForUnexpectedException(CodeGenFunction &CGF,
 169                                       llvm::Value *Exn) override;
 170
 171   void EmitFundamentalRTTIDescriptor(QualType Type);
 172   void EmitFundamentalRTTIDescriptors();
 173   llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override;
 174   CatchTypeInfo
 175   getAddrOfCXXCatchHandlerType(QualType Ty,
 176                                QualType CatchHandlerType) override {
 177     return CatchTypeInfo{getAddrOfRTTIDescriptor(Ty), 0};
 178   }
 179
 180   bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy) override;
 181   void EmitBadTypeidCall(CodeGenFunction &CGF) override;
 182   llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
 183                           Address ThisPtr,
 184                           llvm::Type *StdTypeInfoPtrTy) override;
 185
 186   bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
 187                                           QualType SrcRecordTy) override;
 188
 189   llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
 190                                    QualType SrcRecordTy, QualType DestTy,
 191                                    QualType DestRecordTy,
 192                                    llvm::BasicBlock *CastEnd) override;
 193
 194   llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
 195                                      QualType SrcRecordTy,
 196                                      QualType DestTy) override;
 197
 198   bool EmitBadCastCall(CodeGenFunction &CGF) override;
 199
 200   llvm::Value *
 201     GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
 202                               const CXXRecordDecl *ClassDecl,
 203                               const CXXRecordDecl *BaseClassDecl) override;
 204
 205   void EmitCXXConstructors(const CXXConstructorDecl *D) override;
 206
 207   void buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
 208                               SmallVectorImpl<CanQualType> &ArgTys) override;
 209
 210   bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
 211                               CXXDtorType DT) const override {
 212     // Itanium does not emit any destructor variant as an inline thunk.
 213     // Delegating may occur as an optimization, but all variants are either
 214     // emitted with external linkage or as linkonce if they are inline and used.
 215     return false;
 216   }
 217
 218   void EmitCXXDestructors(const CXXDestructorDecl *D) override;
 219
 220   void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
 221                                  FunctionArgList &Params) override;
 222
 223   void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
 224
 225   unsigned addImplicitConstructorArgs(CodeGenFunction &CGF,
 226                                       const CXXConstructorDecl *D,
 227                                       CXXCtorType Type, bool ForVirtualBase,
 228                                       bool Delegating,
 229                                       CallArgList &Args) override;
 230
 231   void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
 232                           CXXDtorType Type, bool ForVirtualBase,
 233                           bool Delegating, Address This) override;
 234
 235   void emitVTableDefinitions(CodeGenVTables &CGVT,
 236                              const CXXRecordDecl *RD) override;
 237
 238   bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
 239                                            CodeGenFunction::VPtr Vptr) override;
 240
 241   bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override {
 242     return true;
 243   }
 244
 245   llvm::Constant *
 246   getVTableAddressPoint(BaseSubobject Base,
 247                         const CXXRecordDecl *VTableClass) override;
 248
 249   llvm::Value *getVTableAddressPointInStructor(
 250       CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
 251       BaseSubobject Base, const CXXRecordDecl *NearestVBase) override;
 252
 253   llvm::Value *getVTableAddressPointInStructorWithVTT(
 254       CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
 255       BaseSubobject Base, const CXXRecordDecl *NearestVBase);
 256
 257   llvm::Constant *
 258   getVTableAddressPointForConstExpr(BaseSubobject Base,
 259                                     const CXXRecordDecl *VTableClass) override;
 260
 261   llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
 262                                         CharUnits VPtrOffset) override;
 263
 264   llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
 265                                          Address This, llvm::Type *Ty,
 266                                          SourceLocation Loc) override;
 267
 268   llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
 269                                          const CXXDestructorDecl *Dtor,
 270                                          CXXDtorType DtorType,
 271                                          Address This,
 272                                          const CXXMemberCallExpr *CE) override;
 273
 274   void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override;
 275
 276   bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const override;
 277
 278   void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, GlobalDecl GD,
 279                        bool ReturnAdjustment) override {
 280     // Allow inlining of thunks by emitting them with available_externally
 281     // linkage together with vtables when needed.
 282     if (ForVTable && !Thunk->hasLocalLinkage())
 283       Thunk->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
 284   }
 285
 286   llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
 287                                      const ThisAdjustment &TA) override;
 288
 289   llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
 290                                        const ReturnAdjustment &RA) override;
 291
 292   size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
 293                               FunctionArgList &Args) const override {
 294     assert(!Args.empty() && "expected the arglist to not be empty!");
 295     return Args.size() - 1;
 296   }
 297
 298   StringRef GetPureVirtualCallName() override { return "__cxa_pure_virtual"; }
 299   StringRef GetDeletedVirtualCallName() override
 300     { return "__cxa_deleted_virtual"; }
 301
 302   CharUnits getArrayCookieSizeImpl(QualType elementType) override;
 303   Address InitializeArrayCookie(CodeGenFunction &CGF,
 304                                 Address NewPtr,
 305                                 llvm::Value *NumElements,
 306                                 const CXXNewExpr *expr,
 307                                 QualType ElementType) override;
 308   llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
 309                                    Address allocPtr,
 310                                    CharUnits cookieSize) override;
 311
 312   void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
 313                        llvm::GlobalVariable *DeclPtr,
 314                        bool PerformInit) override;
 315   void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
 316                           llvm::Constant *dtor, llvm::Constant *addr) override;
 317
 318   llvm::Function *getOrCreateThreadLocalWrapper(const VarDecl *VD,
 319                                                 llvm::Value *Val);
 320   void EmitThreadLocalInitFuncs(
 321       CodeGenModule &CGM,
 322       ArrayRef<const VarDecl *> CXXThreadLocals,
 323       ArrayRef<llvm::Function *> CXXThreadLocalInits,
 324       ArrayRef<const VarDecl *> CXXThreadLocalInitVars) override;
 325
 326   bool usesThreadWrapperFunction() const override { return true; }
 327   LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF, const VarDecl *VD,
 328                                       QualType LValType) override;
 329
 330   bool NeedsVTTParameter(GlobalDecl GD) override;
 331
 332   /**************************** RTTI Uniqueness ******************************/
 333
 334 protected:
 335   /// Returns true if the ABI requires RTTI type_info objects to be unique
 336   /// across a program.
 337   virtual bool shouldRTTIBeUnique() const { return true; }
 338
 339 public:
 340   /// What sort of unique-RTTI behavior should we use?
 341   enum RTTIUniquenessKind {
 342     /// We are guaranteeing, or need to guarantee, that the RTTI string
 343     /// is unique.
 344     RUK_Unique,
 345
 346     /// We are not guaranteeing uniqueness for the RTTI string, so we
 347     /// can demote to hidden visibility but must use string comparisons.
 348     RUK_NonUniqueHidden,
 349
 350     /// We are not guaranteeing uniqueness for the RTTI string, so we
 351     /// have to use string comparisons, but we also have to emit it with
 352     /// non-hidden visibility.
 353     RUK_NonUniqueVisible
 354   };
 355
 356   /// Return the required visibility status for the given type and linkage in
 357   /// the current ABI.
 358   RTTIUniquenessKind
 359   classifyRTTIUniqueness(QualType CanTy,
 360                          llvm::GlobalValue::LinkageTypes Linkage) const;
 361   friend class ItaniumRTTIBuilder;
 362
 363   void emitCXXStructor(const CXXMethodDecl *MD, StructorType Type) override;
 364
 365  private:
 366    bool hasAnyUsedVirtualInlineFunction(const CXXRecordDecl *RD) const {
 367     const auto &VtableLayout =
 368         CGM.getItaniumVTableContext().getVTableLayout(RD);
 369
 370     for (const auto &VtableComponent : VtableLayout.vtable_components()) {
 371       if (!VtableComponent.isUsedFunctionPointerKind())
 372         continue;
 373
 374       const CXXMethodDecl *Method = VtableComponent.getFunctionDecl();
 375       if (Method->getCanonicalDecl()->isInlined())
 376         return true;
 377     }
 378     return false;
 379   }
 380
 381   bool isVTableHidden(const CXXRecordDecl *RD) const {
 382     const auto &VtableLayout =
 383             CGM.getItaniumVTableContext().getVTableLayout(RD);
 384
 385     for (const auto &VtableComponent : VtableLayout.vtable_components()) {
 386       if (VtableComponent.isRTTIKind()) {
 387         const CXXRecordDecl *RTTIDecl = VtableComponent.getRTTIDecl();
 388         if (RTTIDecl->getVisibility() == Visibility::HiddenVisibility)
 389           return true;
 390       } else if (VtableComponent.isUsedFunctionPointerKind()) {
 391         const CXXMethodDecl *Method = VtableComponent.getFunctionDecl();
 392         if (Method->getVisibility() == Visibility::HiddenVisibility &&
 393             !Method->isDefined())
 394           return true;
 395       }
 396     }
 397     return false;
 398   }
 399 };
 400
 401 class ARMCXXABI : public ItaniumCXXABI {
 402 public:
 403   ARMCXXABI(CodeGen::CodeGenModule &CGM) :
 404     ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
 405                   /* UseARMGuardVarABI = */ true) {}
 406
 407   bool HasThisReturn(GlobalDecl GD) const override {
 408     return (isa<CXXConstructorDecl>(GD.getDecl()) || (
 409               isa<CXXDestructorDecl>(GD.getDecl()) &&
 410               GD.getDtorType() != Dtor_Deleting));
 411   }
 412
 413   void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV,
 414                            QualType ResTy) override;
 415
 416   CharUnits getArrayCookieSizeImpl(QualType elementType) override;
 417   Address InitializeArrayCookie(CodeGenFunction &CGF,
 418                                 Address NewPtr,
 419                                 llvm::Value *NumElements,
 420                                 const CXXNewExpr *expr,
 421                                 QualType ElementType) override;
 422   llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, Address allocPtr,
 423                                    CharUnits cookieSize) override;
 424 };
 425
 426 class iOS64CXXABI : public ARMCXXABI {
 427 public:
 428   iOS64CXXABI(CodeGen::CodeGenModule &CGM) : ARMCXXABI(CGM) {}
 429
 430   // ARM64 libraries are prepared for non-unique RTTI.
 431   bool shouldRTTIBeUnique() const override { return false; }
 432 };
 433
 434 class WebAssemblyCXXABI final : public ItaniumCXXABI {
 435 public:
 436   explicit WebAssemblyCXXABI(CodeGen::CodeGenModule &CGM)
 437       : ItaniumCXXABI(CGM, /*UseARMMethodPtrABI=*/true,
 438                       /*UseARMGuardVarABI=*/true) {}
 439
 440 private:
 441   bool HasThisReturn(GlobalDecl GD) const override {
 442     return isa<CXXConstructorDecl>(GD.getDecl()) ||
 443            (isa<CXXDestructorDecl>(GD.getDecl()) &&
 444             GD.getDtorType() != Dtor_Deleting);
 445   }
 446   bool canCallMismatchedFunctionType() const override { return false; }
 447 };
 448 }
 449
 450 CodeGen::CGCXXABI *CodeGen::CreateItaniumCXXABI(CodeGenModule &CGM) {
 451   switch (CGM.getTarget().getCXXABI().getKind()) {
 452   // For IR-generation purposes, there's no significant difference
 453   // between the ARM and iOS ABIs.
 454   case TargetCXXABI::GenericARM:
 455   case TargetCXXABI::iOS:
 456   case TargetCXXABI::WatchOS:
 457     return new ARMCXXABI(CGM);
 458
 459   case TargetCXXABI::iOS64:
 460     return new iOS64CXXABI(CGM);
 461
 462   // Note that AArch64 uses the generic ItaniumCXXABI class since it doesn't
 463   // include the other 32-bit ARM oddities: constructor/destructor return values
 464   // and array cookies.
 465   case TargetCXXABI::GenericAArch64:
 466     return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
 467                              /* UseARMGuardVarABI = */ true);
 468
 469   case TargetCXXABI::GenericMIPS:
 470     return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true);
 471
 472   case TargetCXXABI::WebAssembly:
 473     return new WebAssemblyCXXABI(CGM);
 474
 475   case TargetCXXABI::GenericItanium:
 476     if (CGM.getContext().getTargetInfo().getTriple().getArch()
 477         == llvm::Triple::le32) {
 478       // For PNaCl, use ARM-style method pointers so that PNaCl code
 479       // does not assume anything about the alignment of function
 480       // pointers.
 481       return new ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true,
 482                                /* UseARMGuardVarABI = */ false);
 483     }
 484     return new ItaniumCXXABI(CGM);
 485
 486   case TargetCXXABI::Microsoft:
 487     llvm_unreachable("Microsoft ABI is not Itanium-based");
 488   }
 489   llvm_unreachable("bad ABI kind");
 490 }
 491
 492 llvm::Type *
 493 ItaniumCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
 494   if (MPT->isMemberDataPointer())
 495     return CGM.PtrDiffTy;
 496   return llvm::StructType::get(CGM.PtrDiffTy, CGM.PtrDiffTy, nullptr);
 497 }
 498
 499 /// In the Itanium and ARM ABIs, method pointers have the form:
 500 ///   struct { ptrdiff_t ptr; ptrdiff_t adj; } memptr;
 501 ///
 502 /// In the Itanium ABI:
 503 ///  - method pointers are virtual if (memptr.ptr & 1) is nonzero
 504 ///  - the this-adjustment is (memptr.adj)
 505 ///  - the virtual offset is (memptr.ptr - 1)
 506 ///
 507 /// In the ARM ABI:
 508 ///  - method pointers are virtual if (memptr.adj & 1) is nonzero
 509 ///  - the this-adjustment is (memptr.adj >> 1)
 510 ///  - the virtual offset is (memptr.ptr)
 511 /// ARM uses 'adj' for the virtual flag because Thumb functions
 512 /// may be only single-byte aligned.
 513 ///
 514 /// If the member is virtual, the adjusted 'this' pointer points
 515 /// to a vtable pointer from which the virtual offset is applied.
 516 ///
 517 /// If the member is non-virtual, memptr.ptr is the address of
 518 /// the function to call.
 519 llvm::Value *ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(
 520     CodeGenFunction &CGF, const Expr *E, Address ThisAddr,
 521     llvm::Value *&ThisPtrForCall,
 522     llvm::Value *MemFnPtr, const MemberPointerType *MPT) {
 523   CGBuilderTy &Builder = CGF.Builder;
 524
 525   const FunctionProtoType *FPT =
 526     MPT->getPointeeType()->getAs<FunctionProtoType>();
 527   const CXXRecordDecl *RD =
 528     cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
 529
 530   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
 531       CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
 532
 533   llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);
 534
 535   llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual");
 536   llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
 537   llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
 538
 539   // Extract memptr.adj, which is in the second field.
 540   llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1, "memptr.adj");
 541
 542   // Compute the true adjustment.
 543   llvm::Value *Adj = RawAdj;
 544   if (UseARMMethodPtrABI)
 545     Adj = Builder.CreateAShr(Adj, ptrdiff_1, "memptr.adj.shifted");
 546
 547   // Apply the adjustment and cast back to the original struct type
 548   // for consistency.
 549   llvm::Value *This = ThisAddr.getPointer();
 550   llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
 551   Ptr = Builder.CreateInBoundsGEP(Ptr, Adj);
 552   This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
 553   ThisPtrForCall = This;
 554
 555   // Load the function pointer.
 556   llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0, "memptr.ptr");
 557
 558   // If the LSB in the function pointer is 1, the function pointer points to
 559   // a virtual function.
 560   llvm::Value *IsVirtual;
 561   if (UseARMMethodPtrABI)
 562     IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1);
 563   else
 564     IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1);
 565   IsVirtual = Builder.CreateIsNotNull(IsVirtual, "memptr.isvirtual");
 566   Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
 567
 568   // In the virtual path, the adjustment left 'This' pointing to the
 569   // vtable of the correct base subobject.  The "function pointer" is an
 570   // offset within the vtable (+1 for the virtual flag on non-ARM).
 571   CGF.EmitBlock(FnVirtual);
 572
 573   // Cast the adjusted this to a pointer to vtable pointer and load.
 574   llvm::Type *VTableTy = Builder.getInt8PtrTy();
 575   CharUnits VTablePtrAlign =
 576     CGF.CGM.getDynamicOffsetAlignment(ThisAddr.getAlignment(), RD,
 577                                       CGF.getPointerAlign());
 578   llvm::Value *VTable =
 579     CGF.GetVTablePtr(Address(This, VTablePtrAlign), VTableTy, RD);
 580
 581   // Apply the offset.
 582   llvm::Value *VTableOffset = FnAsInt;
 583   if (!UseARMMethodPtrABI)
 584     VTableOffset = Builder.CreateSub(VTableOffset, ptrdiff_1);
 585   VTable = Builder.CreateGEP(VTable, VTableOffset);
 586
 587   // Load the virtual function to call.
 588   VTable = Builder.CreateBitCast(VTable, FTy->getPointerTo()->getPointerTo());
 589   llvm::Value *VirtualFn =
 590     Builder.CreateAlignedLoad(VTable, CGF.getPointerAlign(),
 591                               "memptr.virtualfn");
 592   CGF.EmitBranch(FnEnd);
 593
 594   // In the non-virtual path, the function pointer is actually a
 595   // function pointer.
 596   CGF.EmitBlock(FnNonVirtual);
 597   llvm::Value *NonVirtualFn =
 598     Builder.CreateIntToPtr(FnAsInt, FTy->getPointerTo(), "memptr.nonvirtualfn");
 599
 600   // We're done.
 601   CGF.EmitBlock(FnEnd);
 602   llvm::PHINode *Callee = Builder.CreatePHI(FTy->getPointerTo(), 2);
 603   Callee->addIncoming(VirtualFn, FnVirtual);
 604   Callee->addIncoming(NonVirtualFn, FnNonVirtual);
 605   return Callee;
 606 }
 607
 608 /// Compute an l-value by applying the given pointer-to-member to a
 609 /// base object.
 610 llvm::Value *ItaniumCXXABI::EmitMemberDataPointerAddress(
 611     CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr,
 612     const MemberPointerType *MPT) {
 613   assert(MemPtr->getType() == CGM.PtrDiffTy);
 614
 615   CGBuilderTy &Builder = CGF.Builder;
 616
 617   // Cast to char*.
 618   Base = Builder.CreateElementBitCast(Base, CGF.Int8Ty);
 619
 620   // Apply the offset, which we assume is non-null.
 621   llvm::Value *Addr =
 622     Builder.CreateInBoundsGEP(Base.getPointer(), MemPtr, "memptr.offset");
 623
 624   // Cast the address to the appropriate pointer type, adopting the
 625   // address space of the base pointer.
 626   llvm::Type *PType = CGF.ConvertTypeForMem(MPT->getPointeeType())
 627                             ->getPointerTo(Base.getAddressSpace());
 628   return Builder.CreateBitCast(Addr, PType);
 629 }
 630
 631 /// Perform a bitcast, derived-to-base, or base-to-derived member pointer
 632 /// conversion.
 633 ///
 634 /// Bitcast conversions are always a no-op under Itanium.
 635 ///
 636 /// Obligatory offset/adjustment diagram:
 637 ///         <-- offset -->          <-- adjustment -->
 638 ///   |--------------------------|----------------------|--------------------|
 639 ///   ^Derived address point     ^Base address point    ^Member address point
 640 ///
 641 /// So when converting a base member pointer to a derived member pointer,
 642 /// we add the offset to the adjustment because the address point has
 643 /// decreased;  and conversely, when converting a derived MP to a base MP
 644 /// we subtract the offset from the adjustment because the address point
 645 /// has increased.
 646 ///
 647 /// The standard forbids (at compile time) conversion to and from
 648 /// virtual bases, which is why we don't have to consider them here.
 649 ///
 650 /// The standard forbids (at run time) casting a derived MP to a base
 651 /// MP when the derived MP does not point to a member of the base.
 652 /// This is why -1 is a reasonable choice for null data member
 653 /// pointers.
 654 llvm::Value *
 655 ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
 656                                            const CastExpr *E,
 657                                            llvm::Value *src) {
 658   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
 659          E->getCastKind() == CK_BaseToDerivedMemberPointer ||
 660          E->getCastKind() == CK_ReinterpretMemberPointer);
 661
 662   // Under Itanium, reinterprets don't require any additional processing.
 663   if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
 664
 665   // Use constant emission if we can.
 666   if (isa<llvm::Constant>(src))
 667     return EmitMemberPointerConversion(E, cast<llvm::Constant>(src));
 668
 669   llvm::Constant *adj = getMemberPointerAdjustment(E);
 670   if (!adj) return src;
 671
 672   CGBuilderTy &Builder = CGF.Builder;
 673   bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
 674
 675   const MemberPointerType *destTy =
 676     E->getType()->castAs<MemberPointerType>();
 677
 678   // For member data pointers, this is just a matter of adding the
 679   // offset if the source is non-null.
 680   if (destTy->isMemberDataPointer()) {
 681     llvm::Value *dst;
 682     if (isDerivedToBase)
 683       dst = Builder.CreateNSWSub(src, adj, "adj");
 684     else
 685       dst = Builder.CreateNSWAdd(src, adj, "adj");
 686
 687     // Null check.
 688     llvm::Value *null = llvm::Constant::getAllOnesValue(src->getType());
 689     llvm::Value *isNull = Builder.CreateICmpEQ(src, null, "memptr.isnull");
 690     return Builder.CreateSelect(isNull, src, dst);
 691   }
 692
 693   // The this-adjustment is left-shifted by 1 on ARM.
 694   if (UseARMMethodPtrABI) {
 695     uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
 696     offset <<= 1;
 697     adj = llvm::ConstantInt::get(adj->getType(), offset);
 698   }
 699
 700   llvm::Value *srcAdj = Builder.CreateExtractValue(src, 1, "src.adj");
 701   llvm::Value *dstAdj;
 702   if (isDerivedToBase)
 703     dstAdj = Builder.CreateNSWSub(srcAdj, adj, "adj");
 704   else
 705     dstAdj = Builder.CreateNSWAdd(srcAdj, adj, "adj");
 706
 707   return Builder.CreateInsertValue(src, dstAdj, 1);
 708 }
 709
 710 llvm::Constant *
 711 ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
 712                                            llvm::Constant *src) {
 713   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
 714          E->getCastKind() == CK_BaseToDerivedMemberPointer ||
 715          E->getCastKind() == CK_ReinterpretMemberPointer);
 716
 717   // Under Itanium, reinterprets don't require any additional processing.
 718   if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
 719
 720   // If the adjustment is trivial, we don't need to do anything.
 721   llvm::Constant *adj = getMemberPointerAdjustment(E);
 722   if (!adj) return src;
 723
 724   bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
 725
 726   const MemberPointerType *destTy =
 727     E->getType()->castAs<MemberPointerType>();
 728
 729   // For member data pointers, this is just a matter of adding the
 730   // offset if the source is non-null.
 731   if (destTy->isMemberDataPointer()) {
 732     // null maps to null.
 733     if (src->isAllOnesValue()) return src;
 734
 735     if (isDerivedToBase)
 736       return llvm::ConstantExpr::getNSWSub(src, adj);
 737     else
 738       return llvm::ConstantExpr::getNSWAdd(src, adj);
 739   }
 740
 741   // The this-adjustment is left-shifted by 1 on ARM.
 742   if (UseARMMethodPtrABI) {
 743     uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
 744     offset <<= 1;
 745     adj = llvm::ConstantInt::get(adj->getType(), offset);
 746   }
 747
 748   llvm::Constant *srcAdj = llvm::ConstantExpr::getExtractValue(src, 1);
 749   llvm::Constant *dstAdj;
 750   if (isDerivedToBase)
 751     dstAdj = llvm::ConstantExpr::getNSWSub(srcAdj, adj);
 752   else
 753     dstAdj = llvm::ConstantExpr::getNSWAdd(srcAdj, adj);
 754
 755   return llvm::ConstantExpr::getInsertValue(src, dstAdj, 1);
 756 }
 757
 758 llvm::Constant *
 759 ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
 760   // Itanium C++ ABI 2.3:
 761   //   A NULL pointer is represented as -1.
 762   if (MPT->isMemberDataPointer())
 763     return llvm::ConstantInt::get(CGM.PtrDiffTy, -1ULL, /*isSigned=*/true);
 764
 765   llvm::Constant *Zero = llvm::ConstantInt::get(CGM.PtrDiffTy, 0);
 766   llvm::Constant *Values[2] = { Zero, Zero };
 767   return llvm::ConstantStruct::getAnon(Values);
 768 }
 769
 770 llvm::Constant *
 771 ItaniumCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
 772                                      CharUnits offset) {
 773   // Itanium C++ ABI 2.3:
 774   //   A pointer to data member is an offset from the base address of
 775   //   the class object containing it, represented as a ptrdiff_t
 776   return llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity());
 777 }
 778
 779 llvm::Constant *
 780 ItaniumCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
 781   return BuildMemberPointer(MD, CharUnits::Zero());
 782 }
 783
 784 llvm::Constant *ItaniumCXXABI::BuildMemberPointer(const CXXMethodDecl *MD,
 785                                                   CharUnits ThisAdjustment) {
 786   assert(MD->isInstance() && "Member function must not be static!");
 787   MD = MD->getCanonicalDecl();
 788
 789   CodeGenTypes &Types = CGM.getTypes();
 790
 791   // Get the function pointer (or index if this is a virtual function).
 792   llvm::Constant *MemPtr[2];
 793   if (MD->isVirtual()) {
 794     uint64_t Index = CGM.getItaniumVTableContext().getMethodVTableIndex(MD);
 795
 796     const ASTContext &Context = getContext();
 797     CharUnits PointerWidth =
 798       Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
 799     uint64_t VTableOffset = (Index * PointerWidth.getQuantity());
 800
 801     if (UseARMMethodPtrABI) {
 802       // ARM C++ ABI 3.2.1:
 803       //   This ABI specifies that adj contains twice the this
 804       //   adjustment, plus 1 if the member function is virtual. The
 805       //   least significant bit of adj then makes exactly the same
 806       //   discrimination as the least significant bit of ptr does for
 807       //   Itanium.
 808       MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset);
 809       MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
 810                                          2 * ThisAdjustment.getQuantity() + 1);
 811     } else {
 812       // Itanium C++ ABI 2.3:
 813       //   For a virtual function, [the pointer field] is 1 plus the
 814       //   virtual table offset (in bytes) of the function,
 815       //   represented as a ptrdiff_t.
 816       MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset + 1);
 817       MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
 818                                          ThisAdjustment.getQuantity());
 819     }
 820   } else {
 821     const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
 822     llvm::Type *Ty;
 823     // Check whether the function has a computable LLVM signature.
 824     if (Types.isFuncTypeConvertible(FPT)) {
 825       // The function has a computable LLVM signature; use the correct type.
 826       Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
 827     } else {
 828       // Use an arbitrary non-function type to tell GetAddrOfFunction that the
 829       // function type is incomplete.
 830       Ty = CGM.PtrDiffTy;
 831     }
 832     llvm::Constant *addr = CGM.GetAddrOfFunction(MD, Ty);
 833
 834     MemPtr[0] = llvm::ConstantExpr::getPtrToInt(addr, CGM.PtrDiffTy);
 835     MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
 836                                        (UseARMMethodPtrABI ? 2 : 1) *
 837                                        ThisAdjustment.getQuantity());
 838   }
 839
 840   return llvm::ConstantStruct::getAnon(MemPtr);
 841 }
 842
 843 llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const APValue &MP,
 844                                                  QualType MPType) {
 845   const MemberPointerType *MPT = MPType->castAs<MemberPointerType>();
 846   const ValueDecl *MPD = MP.getMemberPointerDecl();
 847   if (!MPD)
 848     return EmitNullMemberPointer(MPT);
 849
 850   CharUnits ThisAdjustment = getMemberPointerPathAdjustment(MP);
 851
 852   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD))
 853     return BuildMemberPointer(MD, ThisAdjustment);
 854
 855   CharUnits FieldOffset =
 856     getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD));
 857   return EmitMemberDataPointer(MPT, ThisAdjustment + FieldOffset);
 858 }
 859
 860 /// The comparison algorithm is pretty easy: the member pointers are
 861 /// the same if they're either bitwise identical *or* both null.
 862 ///
 863 /// ARM is different here only because null-ness is more complicated.
 864 llvm::Value *
 865 ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
 866                                            llvm::Value *L,
 867                                            llvm::Value *R,
 868                                            const MemberPointerType *MPT,
 869                                            bool Inequality) {
 870   CGBuilderTy &Builder = CGF.Builder;
 871
 872   llvm::ICmpInst::Predicate Eq;
 873   llvm::Instruction::BinaryOps And, Or;
 874   if (Inequality) {
 875     Eq = llvm::ICmpInst::ICMP_NE;
 876     And = llvm::Instruction::Or;
 877     Or = llvm::Instruction::And;
 878   } else {
 879     Eq = llvm::ICmpInst::ICMP_EQ;
 880     And = llvm::Instruction::And;
 881     Or = llvm::Instruction::Or;
 882   }
 883
 884   // Member data pointers are easy because there's a unique null
 885   // value, so it just comes down to bitwise equality.
 886   if (MPT->isMemberDataPointer())
 887     return Builder.CreateICmp(Eq, L, R);
 888
 889   // For member function pointers, the tautologies are more complex.
 890   // The Itanium tautology is:
 891   //   (L == R) <==> (L.ptr == R.ptr && (L.ptr == 0 || L.adj == R.adj))
 892   // The ARM tautology is:
 893   //   (L == R) <==> (L.ptr == R.ptr &&
 894   //                  (L.adj == R.adj ||
 895   //                   (L.ptr == 0 && ((L.adj|R.adj) & 1) == 0)))
 896   // The inequality tautologies have exactly the same structure, except
 897   // applying De Morgan's laws.
 898
 899   llvm::Value *LPtr = Builder.CreateExtractValue(L, 0, "lhs.memptr.ptr");
 900   llvm::Value *RPtr = Builder.CreateExtractValue(R, 0, "rhs.memptr.ptr");
 901
 902   // This condition tests whether L.ptr == R.ptr.  This must always be
 903   // true for equality to hold.
 904   llvm::Value *PtrEq = Builder.CreateICmp(Eq, LPtr, RPtr, "cmp.ptr");
 905
 906   // This condition, together with the assumption that L.ptr == R.ptr,
 907   // tests whether the pointers are both null.  ARM imposes an extra
 908   // condition.
 909   llvm::Value *Zero = llvm::Constant::getNullValue(LPtr->getType());
 910   llvm::Value *EqZero = Builder.CreateICmp(Eq, LPtr, Zero, "cmp.ptr.null");
 911
 912   // This condition tests whether L.adj == R.adj.  If this isn't
 913   // true, the pointers are unequal unless they're both null.
 914   llvm::Value *LAdj = Builder.CreateExtractValue(L, 1, "lhs.memptr.adj");
 915   llvm::Value *RAdj = Builder.CreateExtractValue(R, 1, "rhs.memptr.adj");
 916   llvm::Value *AdjEq = Builder.CreateICmp(Eq, LAdj, RAdj, "cmp.adj");
 917
 918   // Null member function pointers on ARM clear the low bit of Adj,
 919   // so the zero condition has to check that neither low bit is set.
 920   if (UseARMMethodPtrABI) {
 921     llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1);
 922
 923     // Compute (l.adj | r.adj) & 1 and test it against zero.
 924     llvm::Value *OrAdj = Builder.CreateOr(LAdj, RAdj, "or.adj");
 925     llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One);
 926     llvm::Value *OrAdjAnd1EqZero = Builder.CreateICmp(Eq, OrAdjAnd1, Zero,
 927                                                       "cmp.or.adj");
 928     EqZero = Builder.CreateBinOp(And, EqZero, OrAdjAnd1EqZero);
 929   }
 930
 931   // Tie together all our conditions.
 932   llvm::Value *Result = Builder.CreateBinOp(Or, EqZero, AdjEq);
 933   Result = Builder.CreateBinOp(And, PtrEq, Result,
 934                                Inequality ? "memptr.ne" : "memptr.eq");
 935   return Result;
 936 }
 937
 938 llvm::Value *
 939 ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
 940                                           llvm::Value *MemPtr,
 941                                           const MemberPointerType *MPT) {
 942   CGBuilderTy &Builder = CGF.Builder;
 943
 944   /// For member data pointers, this is just a check against -1.
 945   if (MPT->isMemberDataPointer()) {
 946     assert(MemPtr->getType() == CGM.PtrDiffTy);
 947     llvm::Value *NegativeOne =
 948       llvm::Constant::getAllOnesValue(MemPtr->getType());
 949     return Builder.CreateICmpNE(MemPtr, NegativeOne, "memptr.tobool");
 950   }
 951
 952   // In Itanium, a member function pointer is not null if 'ptr' is not null.
 953   llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0, "memptr.ptr");
 954
 955   llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0);
 956   llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero, "memptr.tobool");
 957
 958   // On ARM, a member function pointer is also non-null if the low bit of 'adj'
 959   // (the virtual bit) is set.
 960   if (UseARMMethodPtrABI) {
 961     llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);
 962     llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1, "memptr.adj");
 963     llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit");
 964     llvm::Value *IsVirtual = Builder.CreateICmpNE(VirtualBit, Zero,
 965                                                   "memptr.isvirtual");
 966     Result = Builder.CreateOr(Result, IsVirtual);
 967   }
 968
 969   return Result;
 970 }
 971
 972 bool ItaniumCXXABI::classifyReturnType(CGFunctionInfo &FI) const {
 973   const CXXRecordDecl *RD = FI.getReturnType()->getAsCXXRecordDecl();
 974   if (!RD)
 975     return false;
 976
 977   // Return indirectly if we have a non-trivial copy ctor or non-trivial dtor.
 978   // FIXME: Use canCopyArgument() when it is fixed to handle lazily declared
 979   // special members.
 980   if (RD->hasNonTrivialDestructor() || RD->hasNonTrivialCopyConstructor()) {
 981     auto Align = CGM.getContext().getTypeAlignInChars(FI.getReturnType());
 982     FI.getReturnInfo() = ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
 983     return true;
 984   }
 985   return false;
 986 }
 987
 988 /// The Itanium ABI requires non-zero initialization only for data
 989 /// member pointers, for which '0' is a valid offset.
 990 bool ItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
 991   return MPT->isMemberFunctionPointer();
 992 }
 993
 994 /// The Itanium ABI always places an offset to the complete object
 995 /// at entry -2 in the vtable.
 996 void ItaniumCXXABI::emitVirtualObjectDelete(CodeGenFunction &CGF,
 997                                             const CXXDeleteExpr *DE,
 998                                             Address Ptr,
 999                                             QualType ElementType,
1000                                             const CXXDestructorDecl *Dtor) {
1001   bool UseGlobalDelete = DE->isGlobalDelete();
1002   if (UseGlobalDelete) {
1003     // Derive the complete-object pointer, which is what we need
1004     // to pass to the deallocation function.
1005
1006     // Grab the vtable pointer as an intptr_t*.
1007     auto *ClassDecl =
1008         cast<CXXRecordDecl>(ElementType->getAs<RecordType>()->getDecl());
1009     llvm::Value *VTable =
1010         CGF.GetVTablePtr(Ptr, CGF.IntPtrTy->getPointerTo(), ClassDecl);
1011
1012     // Track back to entry -2 and pull out the offset there.
1013     llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
1014         VTable, -2, "complete-offset.ptr");
1015     llvm::Value *Offset =
1016       CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1017
1018     // Apply the offset.
1019     llvm::Value *CompletePtr =
1020       CGF.Builder.CreateBitCast(Ptr.getPointer(), CGF.Int8PtrTy);
1021     CompletePtr = CGF.Builder.CreateInBoundsGEP(CompletePtr, Offset);
1022
1023     // If we're supposed to call the global delete, make sure we do so
1024     // even if the destructor throws.
1025     CGF.pushCallObjectDeleteCleanup(DE->getOperatorDelete(), CompletePtr,
1026                                     ElementType);
1027   }
1028
1029   // FIXME: Provide a source location here even though there's no
1030   // CXXMemberCallExpr for dtor call.
1031   CXXDtorType DtorType = UseGlobalDelete ? Dtor_Complete : Dtor_Deleting;
1032   EmitVirtualDestructorCall(CGF, Dtor, DtorType, Ptr, /*CE=*/nullptr);
1033
1034   if (UseGlobalDelete)
1035     CGF.PopCleanupBlock();
1036 }
1037
1038 void ItaniumCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
1039   // void __cxa_rethrow();
1040
1041   llvm::FunctionType *FTy =
1042     llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
1043
1044   llvm::Constant *Fn = CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow");
1045
1046   if (isNoReturn)
1047     CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, None);
1048   else
1049     CGF.EmitRuntimeCallOrInvoke(Fn);
1050 }
1051
1052 static llvm::Constant *getAllocateExceptionFn(CodeGenModule &CGM) {
1053   // void *__cxa_allocate_exception(size_t thrown_size);
1054
1055   llvm::FunctionType *FTy =
1056     llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*IsVarArgs=*/false);
1057
1058   return CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception");
1059 }
1060
1061 static llvm::Constant *getThrowFn(CodeGenModule &CGM) {
1062   // void __cxa_throw(void *thrown_exception, std::type_info *tinfo,
1063   //                  void (*dest) (void *));
1064
1065   llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy };
1066   llvm::FunctionType *FTy =
1067     llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false);
1068
1069   return CGM.CreateRuntimeFunction(FTy, "__cxa_throw");
1070 }
1071
1072 void ItaniumCXXABI::emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) {
1073   QualType ThrowType = E->getSubExpr()->getType();
1074   // Now allocate the exception object.
1075   llvm::Type *SizeTy = CGF.ConvertType(getContext().getSizeType());
1076   uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity();
1077
1078   llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(CGM);
1079   llvm::CallInst *ExceptionPtr = CGF.EmitNounwindRuntimeCall(
1080       AllocExceptionFn, llvm::ConstantInt::get(SizeTy, TypeSize), "exception");
1081
1082   CharUnits ExnAlign = getAlignmentOfExnObject();
1083   CGF.EmitAnyExprToExn(E->getSubExpr(), Address(ExceptionPtr, ExnAlign));
1084
1085   // Now throw the exception.
1086   llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType,
1087                                                          /*ForEH=*/true);
1088
1089   // The address of the destructor.  If the exception type has a
1090   // trivial destructor (or isn't a record), we just pass null.
1091   llvm::Constant *Dtor = nullptr;
1092   if (const RecordType *RecordTy = ThrowType->getAs<RecordType>()) {
1093     CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
1094     if (!Record->hasTrivialDestructor()) {
1095       CXXDestructorDecl *DtorD = Record->getDestructor();
1096       Dtor = CGM.getAddrOfCXXStructor(DtorD, StructorType::Complete);
1097       Dtor = llvm::ConstantExpr::getBitCast(Dtor, CGM.Int8PtrTy);
1098     }
1099   }
1100   if (!Dtor) Dtor = llvm::Constant::getNullValue(CGM.Int8PtrTy);
1101
1102   llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor };
1103   CGF.EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args);
1104 }
1105
1106 static llvm::Constant *getItaniumDynamicCastFn(CodeGenFunction &CGF) {
1107   // void *__dynamic_cast(const void *sub,
1108   //                      const abi::__class_type_info *src,
1109   //                      const abi::__class_type_info *dst,
1110   //                      std::ptrdiff_t src2dst_offset);
1111
1112   llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
1113   llvm::Type *PtrDiffTy =
1114     CGF.ConvertType(CGF.getContext().getPointerDiffType());
1115
1116   llvm::Type *Args[4] = { Int8PtrTy, Int8PtrTy, Int8PtrTy, PtrDiffTy };
1117
1118   llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
1119
1120   // Mark the function as nounwind readonly.
1121   llvm::Attribute::AttrKind FuncAttrs[] = { llvm::Attribute::NoUnwind,
1122                                             llvm::Attribute::ReadOnly };
1123   llvm::AttributeSet Attrs = llvm::AttributeSet::get(
1124       CGF.getLLVMContext(), llvm::AttributeSet::FunctionIndex, FuncAttrs);
1125
1126   return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast", Attrs);
1127 }
1128
1129 static llvm::Constant *getBadCastFn(CodeGenFunction &CGF) {
1130   // void __cxa_bad_cast();
1131   llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1132   return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast");
1133 }
1134
1135 /// \brief Compute the src2dst_offset hint as described in the
1136 /// Itanium C++ ABI [2.9.7]
1137 static CharUnits computeOffsetHint(ASTContext &Context,
1138                                    const CXXRecordDecl *Src,
1139                                    const CXXRecordDecl *Dst) {
1140   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1141                      /*DetectVirtual=*/false);
1142
1143   // If Dst is not derived from Src we can skip the whole computation below and
1144   // return that Src is not a public base of Dst.  Record all inheritance paths.
1145   if (!Dst->isDerivedFrom(Src, Paths))
1146     return CharUnits::fromQuantity(-2ULL);
1147
1148   unsigned NumPublicPaths = 0;
1149   CharUnits Offset;
1150
1151   // Now walk all possible inheritance paths.
1152   for (const CXXBasePath &Path : Paths) {
1153     if (Path.Access != AS_public)  // Ignore non-public inheritance.
1154       continue;
1155
1156     ++NumPublicPaths;
1157
1158     for (const CXXBasePathElement &PathElement : Path) {
1159       // If the path contains a virtual base class we can't give any hint.
1160       // -1: no hint.
1161       if (PathElement.Base->isVirtual())
1162         return CharUnits::fromQuantity(-1ULL);
1163
1164       if (NumPublicPaths > 1) // Won't use offsets, skip computation.
1165         continue;
1166
1167       // Accumulate the base class offsets.
1168       const ASTRecordLayout &L = Context.getASTRecordLayout(PathElement.Class);
1169       Offset += L.getBaseClassOffset(
1170           PathElement.Base->getType()->getAsCXXRecordDecl());
1171     }
1172   }
1173
1174   // -2: Src is not a public base of Dst.
1175   if (NumPublicPaths == 0)
1176     return CharUnits::fromQuantity(-2ULL);
1177
1178   // -3: Src is a multiple public base type but never a virtual base type.
1179   if (NumPublicPaths > 1)
1180     return CharUnits::fromQuantity(-3ULL);
1181
1182   // Otherwise, the Src type is a unique public nonvirtual base type of Dst.
1183   // Return the offset of Src from the origin of Dst.
1184   return Offset;
1185 }
1186
1187 static llvm::Constant *getBadTypeidFn(CodeGenFunction &CGF) {
1188   // void __cxa_bad_typeid();
1189   llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1190
1191   return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
1192 }
1193
1194 bool ItaniumCXXABI::shouldTypeidBeNullChecked(bool IsDeref,
1195                                               QualType SrcRecordTy) {
1196   return IsDeref;
1197 }
1198
1199 void ItaniumCXXABI::EmitBadTypeidCall(CodeGenFunction &CGF) {
1200   llvm::Value *Fn = getBadTypeidFn(CGF);
1201   CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
1202   CGF.Builder.CreateUnreachable();
1203 }
1204
1205 llvm::Value *ItaniumCXXABI::EmitTypeid(CodeGenFunction &CGF,
1206                                        QualType SrcRecordTy,
1207                                        Address ThisPtr,
1208                                        llvm::Type *StdTypeInfoPtrTy) {
1209   auto *ClassDecl =
1210       cast<CXXRecordDecl>(SrcRecordTy->getAs<RecordType>()->getDecl());
1211   llvm::Value *Value =
1212       CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo(), ClassDecl);
1213
1214   // Load the type info.
1215   Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
1216   return CGF.Builder.CreateAlignedLoad(Value, CGF.getPointerAlign());
1217 }
1218
1219 bool ItaniumCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
1220                                                        QualType SrcRecordTy) {
1221   return SrcIsPtr;
1222 }
1223
1224 llvm::Value *ItaniumCXXABI::EmitDynamicCastCall(
1225     CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1226     QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) {
1227   llvm::Type *PtrDiffLTy =
1228       CGF.ConvertType(CGF.getContext().getPointerDiffType());
1229   llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1230
1231   llvm::Value *SrcRTTI =
1232       CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1233   llvm::Value *DestRTTI =
1234       CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1235
1236   // Compute the offset hint.
1237   const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
1238   const CXXRecordDecl *DestDecl = DestRecordTy->getAsCXXRecordDecl();
1239   llvm::Value *OffsetHint = llvm::ConstantInt::get(
1240       PtrDiffLTy,
1241       computeOffsetHint(CGF.getContext(), SrcDecl, DestDecl).getQuantity());
1242
1243   // Emit the call to __dynamic_cast.
1244   llvm::Value *Value = ThisAddr.getPointer();
1245   Value = CGF.EmitCastToVoidPtr(Value);
1246
1247   llvm::Value *args[] = {Value, SrcRTTI, DestRTTI, OffsetHint};
1248   Value = CGF.EmitNounwindRuntimeCall(getItaniumDynamicCastFn(CGF), args);
1249   Value = CGF.Builder.CreateBitCast(Value, DestLTy);
1250
1251   /// C++ [expr.dynamic.cast]p9:
1252   ///   A failed cast to reference type throws std::bad_cast
1253   if (DestTy->isReferenceType()) {
1254     llvm::BasicBlock *BadCastBlock =
1255         CGF.createBasicBlock("dynamic_cast.bad_cast");
1256
1257     llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1258     CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1259
1260     CGF.EmitBlock(BadCastBlock);
1261     EmitBadCastCall(CGF);
1262   }
1263
1264   return Value;
1265 }
1266
1267 llvm::Value *ItaniumCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF,
1268                                                   Address ThisAddr,
1269                                                   QualType SrcRecordTy,
1270                                                   QualType DestTy) {
1271   llvm::Type *PtrDiffLTy =
1272       CGF.ConvertType(CGF.getContext().getPointerDiffType());
1273   llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1274
1275   auto *ClassDecl =
1276       cast<CXXRecordDecl>(SrcRecordTy->getAs<RecordType>()->getDecl());
1277   // Get the vtable pointer.
1278   llvm::Value *VTable = CGF.GetVTablePtr(ThisAddr, PtrDiffLTy->getPointerTo(),
1279       ClassDecl);
1280
1281   // Get the offset-to-top from the vtable.
1282   llvm::Value *OffsetToTop =
1283       CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL);
1284   OffsetToTop =
1285     CGF.Builder.CreateAlignedLoad(OffsetToTop, CGF.getPointerAlign(),
1286                                   "offset.to.top");
1287
1288   // Finally, add the offset to the pointer.
1289   llvm::Value *Value = ThisAddr.getPointer();
1290   Value = CGF.EmitCastToVoidPtr(Value);
1291   Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop);
1292
1293   return CGF.Builder.CreateBitCast(Value, DestLTy);
1294 }
1295
1296 bool ItaniumCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1297   llvm::Value *Fn = getBadCastFn(CGF);
1298   CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
1299   CGF.Builder.CreateUnreachable();
1300   return true;
1301 }
1302
1303 llvm::Value *
1304 ItaniumCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
1305                                          Address This,
1306                                          const CXXRecordDecl *ClassDecl,
1307                                          const CXXRecordDecl *BaseClassDecl) {
1308   llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy, ClassDecl);
1309   CharUnits VBaseOffsetOffset =
1310       CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(ClassDecl,
1311                                                                BaseClassDecl);
1312
1313   llvm::Value *VBaseOffsetPtr =
1314     CGF.Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(),
1315                                    "vbase.offset.ptr");
1316   VBaseOffsetPtr = CGF.Builder.CreateBitCast(VBaseOffsetPtr,
1317                                              CGM.PtrDiffTy->getPointerTo());
1318
1319   llvm::Value *VBaseOffset =
1320     CGF.Builder.CreateAlignedLoad(VBaseOffsetPtr, CGF.getPointerAlign(),
1321                                   "vbase.offset");
1322
1323   return VBaseOffset;
1324 }
1325
1326 void ItaniumCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) {
1327   // Just make sure we're in sync with TargetCXXABI.
1328   assert(CGM.getTarget().getCXXABI().hasConstructorVariants());
1329
1330   // The constructor used for constructing this as a base class;
1331   // ignores virtual bases.
1332   CGM.EmitGlobal(GlobalDecl(D, Ctor_Base));
1333
1334   // The constructor used for constructing this as a complete class;
1335   // constructs the virtual bases, then calls the base constructor.
1336   if (!D->getParent()->isAbstract()) {
1337     // We don't need to emit the complete ctor if the class is abstract.
1338     CGM.EmitGlobal(GlobalDecl(D, Ctor_Complete));
1339   }
1340 }
1341
1342 void
1343 ItaniumCXXABI::buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
1344                                       SmallVectorImpl<CanQualType> &ArgTys) {
1345   ASTContext &Context = getContext();
1346
1347   // All parameters are already in place except VTT, which goes after 'this'.
1348   // These are Clang types, so we don't need to worry about sret yet.
1349
1350   // Check if we need to add a VTT parameter (which has type void **).
1351   if (T == StructorType::Base && MD->getParent()->getNumVBases() != 0)
1352     ArgTys.insert(ArgTys.begin() + 1,
1353                   Context.getPointerType(Context.VoidPtrTy));
1354 }
1355
1356 void ItaniumCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) {
1357   // The destructor used for destructing this as a base class; ignores
1358   // virtual bases.
1359   CGM.EmitGlobal(GlobalDecl(D, Dtor_Base));
1360
1361   // The destructor used for destructing this as a most-derived class;
1362   // call the base destructor and then destructs any virtual bases.
1363   CGM.EmitGlobal(GlobalDecl(D, Dtor_Complete));
1364
1365   // The destructor in a virtual table is always a 'deleting'
1366   // destructor, which calls the complete destructor and then uses the
1367   // appropriate operator delete.
1368   if (D->isVirtual())
1369     CGM.EmitGlobal(GlobalDecl(D, Dtor_Deleting));
1370 }
1371
1372 void ItaniumCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1373                                               QualType &ResTy,
1374                                               FunctionArgList &Params) {
1375   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1376   assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD));
1377
1378   // Check if we need a VTT parameter as well.
1379   if (NeedsVTTParameter(CGF.CurGD)) {
1380     ASTContext &Context = getContext();
1381
1382     // FIXME: avoid the fake decl
1383     QualType T = Context.getPointerType(Context.VoidPtrTy);
1384     ImplicitParamDecl *VTTDecl
1385       = ImplicitParamDecl::Create(Context, nullptr, MD->getLocation(),
1386                                   &Context.Idents.get("vtt"), T);
1387     Params.insert(Params.begin() + 1, VTTDecl);
1388     getStructorImplicitParamDecl(CGF) = VTTDecl;
1389   }
1390 }
1391
1392 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1393   /// Initialize the 'this' slot.
1394   EmitThisParam(CGF);
1395
1396   /// Initialize the 'vtt' slot if needed.
1397   if (getStructorImplicitParamDecl(CGF)) {
1398     getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
1399         CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
1400   }
1401
1402   /// If this is a function that the ABI specifies returns 'this', initialize
1403   /// the return slot to 'this' at the start of the function.
1404   ///
1405   /// Unlike the setting of return types, this is done within the ABI
1406   /// implementation instead of by clients of CGCXXABI because:
1407   /// 1) getThisValue is currently protected
1408   /// 2) in theory, an ABI could implement 'this' returns some other way;
1409   ///    HasThisReturn only specifies a contract, not the implementation
1410   if (HasThisReturn(CGF.CurGD))
1411     CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1412 }
1413
1414 unsigned ItaniumCXXABI::addImplicitConstructorArgs(
1415     CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
1416     bool ForVirtualBase, bool Delegating, CallArgList &Args) {
1417   if (!NeedsVTTParameter(GlobalDecl(D, Type)))
1418     return 0;
1419
1420   // Insert the implicit 'vtt' argument as the second argument.
1421   llvm::Value *VTT =
1422       CGF.GetVTTParameter(GlobalDecl(D, Type), ForVirtualBase, Delegating);
1423   QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1424   Args.insert(Args.begin() + 1,
1425               CallArg(RValue::get(VTT), VTTTy, /*needscopy=*/false));
1426   return 1;  // Added one arg.
1427 }
1428
1429 void ItaniumCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1430                                        const CXXDestructorDecl *DD,
1431                                        CXXDtorType Type, bool ForVirtualBase,
1432                                        bool Delegating, Address This) {
1433   GlobalDecl GD(DD, Type);
1434   llvm::Value *VTT = CGF.GetVTTParameter(GD, ForVirtualBase, Delegating);
1435   QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1436
1437   llvm::Value *Callee = nullptr;
1438   if (getContext().getLangOpts().AppleKext)
1439     Callee = CGF.BuildAppleKextVirtualDestructorCall(DD, Type, DD->getParent());
1440
1441   if (!Callee)
1442     Callee = CGM.getAddrOfCXXStructor(DD, getFromDtorType(Type));
1443
1444   CGF.EmitCXXMemberOrOperatorCall(DD, Callee, ReturnValueSlot(),
1445                                   This.getPointer(), VTT, VTTTy, nullptr);
1446 }
1447
1448 void ItaniumCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
1449                                           const CXXRecordDecl *RD) {
1450   llvm::GlobalVariable *VTable = getAddrOfVTable(RD, CharUnits());
1451   if (VTable->hasInitializer())
1452     return;
1453
1454   ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1455   const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
1456   llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
1457   llvm::Constant *RTTI =
1458       CGM.GetAddrOfRTTIDescriptor(CGM.getContext().getTagDeclType(RD));
1459
1460   // Create and set the initializer.
1461   llvm::Constant *Init = CGVT.CreateVTableInitializer(
1462       RD, VTLayout.vtable_component_begin(), VTLayout.getNumVTableComponents(),
1463       VTLayout.vtable_thunk_begin(), VTLayout.getNumVTableThunks(), RTTI);
1464   VTable->setInitializer(Init);
1465
1466   // Set the correct linkage.
1467   VTable->setLinkage(Linkage);
1468
1469   if (CGM.supportsCOMDAT() && VTable->isWeakForLinker())
1470     VTable->setComdat(CGM.getModule().getOrInsertComdat(VTable->getName()));
1471
1472   // Set the right visibility.
1473   CGM.setGlobalVisibility(VTable, RD);
1474
1475   // Use pointer alignment for the vtable. Otherwise we would align them based
1476   // on the size of the initializer which doesn't make sense as only single
1477   // values are read.
1478   unsigned PAlign = CGM.getTarget().getPointerAlign(0);
1479   VTable->setAlignment(getContext().toCharUnitsFromBits(PAlign).getQuantity());
1480
1481   // If this is the magic class __cxxabiv1::__fundamental_type_info,
1482   // we will emit the typeinfo for the fundamental types. This is the
1483   // same behaviour as GCC.
1484   const DeclContext *DC = RD->getDeclContext();
1485   if (RD->getIdentifier() &&
1486       RD->getIdentifier()->isStr("__fundamental_type_info") &&
1487       isa<NamespaceDecl>(DC) && cast<NamespaceDecl>(DC)->getIdentifier() &&
1488       cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
1489       DC->getParent()->isTranslationUnit())
1490     EmitFundamentalRTTIDescriptors();
1491
1492   if (!VTable->isDeclarationForLinker())
1493     CGM.EmitVTableTypeMetadata(VTable, VTLayout);
1494 }
1495
1496 bool ItaniumCXXABI::isVirtualOffsetNeededForVTableField(
1497     CodeGenFunction &CGF, CodeGenFunction::VPtr Vptr) {
1498   if (Vptr.NearestVBase == nullptr)
1499     return false;
1500   return NeedsVTTParameter(CGF.CurGD);
1501 }
1502
1503 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructor(
1504     CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1505     const CXXRecordDecl *NearestVBase) {
1506
1507   if ((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1508       NeedsVTTParameter(CGF.CurGD)) {
1509     return getVTableAddressPointInStructorWithVTT(CGF, VTableClass, Base,
1510                                                   NearestVBase);
1511   }
1512   return getVTableAddressPoint(Base, VTableClass);
1513 }
1514
1515 llvm::Constant *
1516 ItaniumCXXABI::getVTableAddressPoint(BaseSubobject Base,
1517                                      const CXXRecordDecl *VTableClass) {
1518   llvm::GlobalValue *VTable = getAddrOfVTable(VTableClass, CharUnits());
1519
1520   // Find the appropriate vtable within the vtable group.
1521   uint64_t AddressPoint = CGM.getItaniumVTableContext()
1522                               .getVTableLayout(VTableClass)
1523                               .getAddressPoint(Base);
1524   llvm::Value *Indices[] = {
1525     llvm::ConstantInt::get(CGM.Int32Ty, 0),
1526     llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint)
1527   };
1528
1529   return llvm::ConstantExpr::getInBoundsGetElementPtr(VTable->getValueType(),
1530                                                       VTable, Indices);
1531 }
1532
1533 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructorWithVTT(
1534     CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1535     const CXXRecordDecl *NearestVBase) {
1536   assert((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1537          NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT");
1538
1539   // Get the secondary vpointer index.
1540   uint64_t VirtualPointerIndex =
1541       CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base);
1542
1543   /// Load the VTT.
1544   llvm::Value *VTT = CGF.LoadCXXVTT();
1545   if (VirtualPointerIndex)
1546     VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1547
1548   // And load the address point from the VTT.
1549   return CGF.Builder.CreateAlignedLoad(VTT, CGF.getPointerAlign());
1550 }
1551
1552 llvm::Constant *ItaniumCXXABI::getVTableAddressPointForConstExpr(
1553     BaseSubobject Base, const CXXRecordDecl *VTableClass) {
1554   return getVTableAddressPoint(Base, VTableClass);
1555 }
1556
1557 llvm::GlobalVariable *ItaniumCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
1558                                                      CharUnits VPtrOffset) {
1559   assert(VPtrOffset.isZero() && "Itanium ABI only supports zero vptr offsets");
1560
1561   llvm::GlobalVariable *&VTable = VTables[RD];
1562   if (VTable)
1563     return VTable;
1564
1565   // Queue up this vtable for possible deferred emission.
1566   CGM.addDeferredVTable(RD);
1567
1568   SmallString<256> Name;
1569   llvm::raw_svector_ostream Out(Name);
1570   getMangleContext().mangleCXXVTable(RD, Out);
1571
1572   ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1573   llvm::ArrayType *ArrayType = llvm::ArrayType::get(
1574       CGM.Int8PtrTy, VTContext.getVTableLayout(RD).getNumVTableComponents());
1575
1576   VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
1577       Name, ArrayType, llvm::GlobalValue::ExternalLinkage);
1578   VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1579
1580   if (RD->hasAttr<DLLImportAttr>())
1581     VTable->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
1582   else if (RD->hasAttr<DLLExportAttr>())
1583     VTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1584
1585   return VTable;
1586 }
1587
1588 llvm::Value *ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1589                                                       GlobalDecl GD,
1590                                                       Address This,
1591                                                       llvm::Type *Ty,
1592                                                       SourceLocation Loc) {
1593   GD = GD.getCanonicalDecl();
1594   Ty = Ty->getPointerTo()->getPointerTo();
1595   auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
1596   llvm::Value *VTable = CGF.GetVTablePtr(This, Ty, MethodDecl->getParent());
1597
1598   uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);
1599   if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
1600     return CGF.EmitVTableTypeCheckedLoad(
1601         MethodDecl->getParent(), VTable,
1602         VTableIndex * CGM.getContext().getTargetInfo().getPointerWidth(0) / 8);
1603   } else {
1604     CGF.EmitTypeMetadataCodeForVCall(MethodDecl->getParent(), VTable, Loc);
1605
1606     llvm::Value *VFuncPtr =
1607         CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
1608     return CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1609   }
1610 }
1611
1612 llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall(
1613     CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
1614     Address This, const CXXMemberCallExpr *CE) {
1615   assert(CE == nullptr || CE->arg_begin() == CE->arg_end());
1616   assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
1617
1618   const CGFunctionInfo *FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration(
1619       Dtor, getFromDtorType(DtorType));
1620   llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
1621   llvm::Value *Callee =
1622       getVirtualFunctionPointer(CGF, GlobalDecl(Dtor, DtorType), This, Ty,
1623                                 CE ? CE->getLocStart() : SourceLocation());
1624
1625   CGF.EmitCXXMemberOrOperatorCall(Dtor, Callee, ReturnValueSlot(),
1626                                   This.getPointer(), /*ImplicitParam=*/nullptr,
1627                                   QualType(), CE);
1628   return nullptr;
1629 }
1630
1631 void ItaniumCXXABI::emitVirtualInheritanceTables(const CXXRecordDecl *RD) {
1632   CodeGenVTables &VTables = CGM.getVTables();
1633   llvm::GlobalVariable *VTT = VTables.GetAddrOfVTT(RD);
1634   VTables.EmitVTTDefinition(VTT, CGM.getVTableLinkage(RD), RD);
1635 }
1636
1637 bool ItaniumCXXABI::canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const {
1638   // We don't emit available_externally vtables if we are in -fapple-kext mode
1639   // because kext mode does not permit devirtualization.
1640   if (CGM.getLangOpts().AppleKext)
1641     return false;
1642
1643   // If we don't have any inline virtual functions, and if vtable is not hidden,
1644   // then we are safe to emit available_externally copy of vtable.
1645   // FIXME we can still emit a copy of the vtable if we
1646   // can emit definition of the inline functions.
1647   return !hasAnyUsedVirtualInlineFunction(RD) && !isVTableHidden(RD);
1648 }
1649 static llvm::Value *performTypeAdjustment(CodeGenFunction &CGF,
1650                                           Address InitialPtr,
1651                                           int64_t NonVirtualAdjustment,
1652                                           int64_t VirtualAdjustment,
1653                                           bool IsReturnAdjustment) {
1654   if (!NonVirtualAdjustment && !VirtualAdjustment)
1655     return InitialPtr.getPointer();
1656
1657   Address V = CGF.Builder.CreateElementBitCast(InitialPtr, CGF.Int8Ty);
1658
1659   // In a base-to-derived cast, the non-virtual adjustment is applied first.
1660   if (NonVirtualAdjustment && !IsReturnAdjustment) {
1661     V = CGF.Builder.CreateConstInBoundsByteGEP(V,
1662                               CharUnits::fromQuantity(NonVirtualAdjustment));
1663   }
1664
1665   // Perform the virtual adjustment if we have one.
1666   llvm::Value *ResultPtr;
1667   if (VirtualAdjustment) {
1668     llvm::Type *PtrDiffTy =
1669         CGF.ConvertType(CGF.getContext().getPointerDiffType());
1670
1671     Address VTablePtrPtr = CGF.Builder.CreateElementBitCast(V, CGF.Int8PtrTy);
1672     llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
1673
1674     llvm::Value *OffsetPtr =
1675         CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
1676
1677     OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
1678
1679     // Load the adjustment offset from the vtable.
1680     llvm::Value *Offset =
1681       CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1682
1683     // Adjust our pointer.
1684     ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getPointer(), Offset);
1685   } else {
1686     ResultPtr = V.getPointer();
1687   }
1688
1689   // In a derived-to-base conversion, the non-virtual adjustment is
1690   // applied second.
1691   if (NonVirtualAdjustment && IsReturnAdjustment) {
1692     ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ResultPtr,
1693                                                        NonVirtualAdjustment);
1694   }
1695
1696   // Cast back to the original type.
1697   return CGF.Builder.CreateBitCast(ResultPtr, InitialPtr.getType());
1698 }
1699
1700 llvm::Value *ItaniumCXXABI::performThisAdjustment(CodeGenFunction &CGF,
1701                                                   Address This,
1702                                                   const ThisAdjustment &TA) {
1703   return performTypeAdjustment(CGF, This, TA.NonVirtual,
1704                                TA.Virtual.Itanium.VCallOffsetOffset,
1705                                /*IsReturnAdjustment=*/false);
1706 }
1707
1708 llvm::Value *
1709 ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
1710                                        const ReturnAdjustment &RA) {
1711   return performTypeAdjustment(CGF, Ret, RA.NonVirtual,
1712                                RA.Virtual.Itanium.VBaseOffsetOffset,
1713                                /*IsReturnAdjustment=*/true);
1714 }
1715
1716 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
1717                                     RValue RV, QualType ResultType) {
1718   if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
1719     return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
1720
1721   // Destructor thunks in the ARM ABI have indeterminate results.
1722   llvm::Type *T = CGF.ReturnValue.getElementType();
1723   RValue Undef = RValue::get(llvm::UndefValue::get(T));
1724   return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
1725 }
1726
1727 /************************** Array allocation cookies **************************/
1728
1729 CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1730   // The array cookie is a size_t; pad that up to the element alignment.
1731   // The cookie is actually right-justified in that space.
1732   return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
1733                   CGM.getContext().getTypeAlignInChars(elementType));
1734 }
1735
1736 Address ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1737                                              Address NewPtr,
1738                                              llvm::Value *NumElements,
1739                                              const CXXNewExpr *expr,
1740                                              QualType ElementType) {
1741   assert(requiresArrayCookie(expr));
1742
1743   unsigned AS = NewPtr.getAddressSpace();
1744
1745   ASTContext &Ctx = getContext();
1746   CharUnits SizeSize = CGF.getSizeSize();
1747
1748   // The size of the cookie.
1749   CharUnits CookieSize =
1750     std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
1751   assert(CookieSize == getArrayCookieSizeImpl(ElementType));
1752
1753   // Compute an offset to the cookie.
1754   Address CookiePtr = NewPtr;
1755   CharUnits CookieOffset = CookieSize - SizeSize;
1756   if (!CookieOffset.isZero())
1757     CookiePtr = CGF.Builder.CreateConstInBoundsByteGEP(CookiePtr, CookieOffset);
1758
1759   // Write the number of elements into the appropriate slot.
1760   Address NumElementsPtr =
1761       CGF.Builder.CreateElementBitCast(CookiePtr, CGF.SizeTy);
1762   llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
1763
1764   // Handle the array cookie specially in ASan.
1765   if (CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) && AS == 0 &&
1766       expr->getOperatorNew()->isReplaceableGlobalAllocationFunction()) {
1767     // The store to the CookiePtr does not need to be instrumented.
1768     CGM.getSanitizerMetadata()->disableSanitizerForInstruction(SI);
1769     llvm::FunctionType *FTy =
1770         llvm::FunctionType::get(CGM.VoidTy, NumElementsPtr.getType(), false);
1771     llvm::Constant *F =
1772         CGM.CreateRuntimeFunction(FTy, "__asan_poison_cxx_array_cookie");
1773     CGF.Builder.CreateCall(F, NumElementsPtr.getPointer());
1774   }
1775
1776   // Finally, compute a pointer to the actual data buffer by skipping
1777   // over the cookie completely.
1778   return CGF.Builder.CreateConstInBoundsByteGEP(NewPtr, CookieSize);
1779 }
1780
1781 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1782                                                 Address allocPtr,
1783                                                 CharUnits cookieSize) {
1784   // The element size is right-justified in the cookie.
1785   Address numElementsPtr = allocPtr;
1786   CharUnits numElementsOffset = cookieSize - CGF.getSizeSize();
1787   if (!numElementsOffset.isZero())
1788     numElementsPtr =
1789       CGF.Builder.CreateConstInBoundsByteGEP(numElementsPtr, numElementsOffset);
1790
1791   unsigned AS = allocPtr.getAddressSpace();
1792   numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
1793   if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) || AS != 0)
1794     return CGF.Builder.CreateLoad(numElementsPtr);
1795   // In asan mode emit a function call instead of a regular load and let the
1796   // run-time deal with it: if the shadow is properly poisoned return the
1797   // cookie, otherwise return 0 to avoid an infinite loop calling DTORs.
1798   // We can't simply ignore this load using nosanitize metadata because
1799   // the metadata may be lost.
1800   llvm::FunctionType *FTy =
1801       llvm::FunctionType::get(CGF.SizeTy, CGF.SizeTy->getPointerTo(0), false);
1802   llvm::Constant *F =
1803       CGM.CreateRuntimeFunction(FTy, "__asan_load_cxx_array_cookie");
1804   return CGF.Builder.CreateCall(F, numElementsPtr.getPointer());
1805 }
1806
1807 CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1808   // ARM says that the cookie is always:
1809   //   struct array_cookie {
1810   //     std::size_t element_size; // element_size != 0
1811   //     std::size_t element_count;
1812   //   };
1813   // But the base ABI doesn't give anything an alignment greater than
1814   // 8, so we can dismiss this as typical ABI-author blindness to
1815   // actual language complexity and round up to the element alignment.
1816   return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),
1817                   CGM.getContext().getTypeAlignInChars(elementType));
1818 }
1819
1820 Address ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1821                                          Address newPtr,
1822                                          llvm::Value *numElements,
1823                                          const CXXNewExpr *expr,
1824                                          QualType elementType) {
1825   assert(requiresArrayCookie(expr));
1826
1827   // The cookie is always at the start of the buffer.
1828   Address cookie = newPtr;
1829
1830   // The first element is the element size.
1831   cookie = CGF.Builder.CreateElementBitCast(cookie, CGF.SizeTy);
1832   llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
1833                  getContext().getTypeSizeInChars(elementType).getQuantity());
1834   CGF.Builder.CreateStore(elementSize, cookie);
1835
1836   // The second element is the element count.
1837   cookie = CGF.Builder.CreateConstInBoundsGEP(cookie, 1, CGF.getSizeSize());
1838   CGF.Builder.CreateStore(numElements, cookie);
1839
1840   // Finally, compute a pointer to the actual data buffer by skipping
1841   // over the cookie completely.
1842   CharUnits cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);
1843   return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
1844 }
1845
1846 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1847                                             Address allocPtr,
1848                                             CharUnits cookieSize) {
1849   // The number of elements is at offset sizeof(size_t) relative to
1850   // the allocated pointer.
1851   Address numElementsPtr
1852     = CGF.Builder.CreateConstInBoundsByteGEP(allocPtr, CGF.getSizeSize());
1853
1854   numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
1855   return CGF.Builder.CreateLoad(numElementsPtr);
1856 }
1857
1858 /*********************** Static local initialization **************************/
1859
1860 static llvm::Constant *getGuardAcquireFn(CodeGenModule &CGM,
1861                                          llvm::PointerType *GuardPtrTy) {
1862   // int __cxa_guard_acquire(__guard *guard_object);
1863   llvm::FunctionType *FTy =
1864     llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
1865                             GuardPtrTy, /*isVarArg=*/false);
1866   return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_acquire",
1867                                    llvm::AttributeSet::get(CGM.getLLVMContext(),
1868                                               llvm::AttributeSet::FunctionIndex,
1869                                                  llvm::Attribute::NoUnwind));
1870 }
1871
1872 static llvm::Constant *getGuardReleaseFn(CodeGenModule &CGM,
1873                                          llvm::PointerType *GuardPtrTy) {
1874   // void __cxa_guard_release(__guard *guard_object);
1875   llvm::FunctionType *FTy =
1876     llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
1877   return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_release",
1878                                    llvm::AttributeSet::get(CGM.getLLVMContext(),
1879                                               llvm::AttributeSet::FunctionIndex,
1880                                                  llvm::Attribute::NoUnwind));
1881 }
1882
1883 static llvm::Constant *getGuardAbortFn(CodeGenModule &CGM,
1884                                        llvm::PointerType *GuardPtrTy) {
1885   // void __cxa_guard_abort(__guard *guard_object);
1886   llvm::FunctionType *FTy =
1887     llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
1888   return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_abort",
1889                                    llvm::AttributeSet::get(CGM.getLLVMContext(),
1890                                               llvm::AttributeSet::FunctionIndex,
1891                                                  llvm::Attribute::NoUnwind));
1892 }
1893
1894 namespace {
1895   struct CallGuardAbort final : EHScopeStack::Cleanup {
1896     llvm::GlobalVariable *Guard;
1897     CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}
1898
1899     void Emit(CodeGenFunction &CGF, Flags flags) override {
1900       CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
1901                                   Guard);
1902     }
1903   };
1904 }
1905
1906 /// The ARM code here follows the Itanium code closely enough that we
1907 /// just special-case it at particular places.
1908 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
1909                                     const VarDecl &D,
1910                                     llvm::GlobalVariable *var,
1911                                     bool shouldPerformInit) {
1912   CGBuilderTy &Builder = CGF.Builder;
1913
1914   // Inline variables that weren't instantiated from variable templates have
1915   // partially-ordered initialization within their translation unit.
1916   bool NonTemplateInline =
1917       D.isInline() &&
1918       !isTemplateInstantiation(D.getTemplateSpecializationKind());
1919
1920   // We only need to use thread-safe statics for local non-TLS variables and
1921   // inline variables; other global initialization is always single-threaded
1922   // or (through lazy dynamic loading in multiple threads) unsequenced.
1923   bool threadsafe = getContext().getLangOpts().ThreadsafeStatics &&
1924                     (D.isLocalVarDecl() || NonTemplateInline) &&
1925                     !D.getTLSKind();
1926
1927   // If we have a global variable with internal linkage and thread-safe statics
1928   // are disabled, we can just let the guard variable be of type i8.
1929   bool useInt8GuardVariable = !threadsafe && var->hasInternalLinkage();
1930
1931   llvm::IntegerType *guardTy;
1932   CharUnits guardAlignment;
1933   if (useInt8GuardVariable) {
1934     guardTy = CGF.Int8Ty;
1935     guardAlignment = CharUnits::One();
1936   } else {
1937     // Guard variables are 64 bits in the generic ABI and size width on ARM
1938     // (i.e. 32-bit on AArch32, 64-bit on AArch64).
1939     if (UseARMGuardVarABI) {
1940       guardTy = CGF.SizeTy;
1941       guardAlignment = CGF.getSizeAlign();
1942     } else {
1943       guardTy = CGF.Int64Ty;
1944       guardAlignment = CharUnits::fromQuantity(
1945                              CGM.getDataLayout().getABITypeAlignment(guardTy));
1946     }
1947   }
1948   llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
1949
1950   // Create the guard variable if we don't already have it (as we
1951   // might if we're double-emitting this function body).
1952   llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&D);
1953   if (!guard) {
1954     // Mangle the name for the guard.
1955     SmallString<256> guardName;
1956     {
1957       llvm::raw_svector_ostream out(guardName);
1958       getMangleContext().mangleStaticGuardVariable(&D, out);
1959     }
1960
1961     // Create the guard variable with a zero-initializer.
1962     // Just absorb linkage and visibility from the guarded variable.
1963     guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
1964                                      false, var->getLinkage(),
1965                                      llvm::ConstantInt::get(guardTy, 0),
1966                                      guardName.str());
1967     guard->setVisibility(var->getVisibility());
1968     // If the variable is thread-local, so is its guard variable.
1969     guard->setThreadLocalMode(var->getThreadLocalMode());
1970     guard->setAlignment(guardAlignment.getQuantity());
1971
1972     // The ABI says: "It is suggested that it be emitted in the same COMDAT
1973     // group as the associated data object." In practice, this doesn't work for
1974     // non-ELF object formats, so only do it for ELF.
1975     llvm::Comdat *C = var->getComdat();
1976     if (!D.isLocalVarDecl() && C &&
1977         CGM.getTarget().getTriple().isOSBinFormatELF()) {
1978       guard->setComdat(C);
1979       // An inline variable's guard function is run from the per-TU
1980       // initialization function, not via a dedicated global ctor function, so
1981       // we can't put it in a comdat.
1982       if (!NonTemplateInline)
1983         CGF.CurFn->setComdat(C);
1984     } else if (CGM.supportsCOMDAT() && guard->isWeakForLinker()) {
1985       guard->setComdat(CGM.getModule().getOrInsertComdat(guard->getName()));
1986     }
1987
1988     CGM.setStaticLocalDeclGuardAddress(&D, guard);
1989   }
1990
1991   Address guardAddr = Address(guard, guardAlignment);
1992
1993   // Test whether the variable has completed initialization.
1994   //
1995   // Itanium C++ ABI 3.3.2:
1996   //   The following is pseudo-code showing how these functions can be used:
1997   //     if (obj_guard.first_byte == 0) {
1998   //       if ( __cxa_guard_acquire (&obj_guard) ) {
1999   //         try {
2000   //           ... initialize the object ...;
2001   //         } catch (...) {
2002   //            __cxa_guard_abort (&obj_guard);
2003   //            throw;
2004   //         }
2005   //         ... queue object destructor with __cxa_atexit() ...;
2006   //         __cxa_guard_release (&obj_guard);
2007   //       }
2008   //     }
2009
2010   // Load the first byte of the guard variable.
2011   llvm::LoadInst *LI =
2012       Builder.CreateLoad(Builder.CreateElementBitCast(guardAddr, CGM.Int8Ty));
2013
2014   // Itanium ABI:
2015   //   An implementation supporting thread-safety on multiprocessor
2016   //   systems must also guarantee that references to the initialized
2017   //   object do not occur before the load of the initialization flag.
2018   //
2019   // In LLVM, we do this by marking the load Acquire.
2020   if (threadsafe)
2021     LI->setAtomic(llvm::AtomicOrdering::Acquire);
2022
2023   // For ARM, we should only check the first bit, rather than the entire byte:
2024   //
2025   // ARM C++ ABI 3.2.3.1:
2026   //   To support the potential use of initialization guard variables
2027   //   as semaphores that are the target of ARM SWP and LDREX/STREX
2028   //   synchronizing instructions we define a static initialization
2029   //   guard variable to be a 4-byte aligned, 4-byte word with the
2030   //   following inline access protocol.
2031   //     #define INITIALIZED 1
2032   //     if ((obj_guard & INITIALIZED) != INITIALIZED) {
2033   //       if (__cxa_guard_acquire(&obj_guard))
2034   //         ...
2035   //     }
2036   //
2037   // and similarly for ARM64:
2038   //
2039   // ARM64 C++ ABI 3.2.2:
2040   //   This ABI instead only specifies the value bit 0 of the static guard
2041   //   variable; all other bits are platform defined. Bit 0 shall be 0 when the
2042   //   variable is not initialized and 1 when it is.
2043   llvm::Value *V =
2044       (UseARMGuardVarABI && !useInt8GuardVariable)
2045           ? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))
2046           : LI;
2047   llvm::Value *isInitialized = Builder.CreateIsNull(V, "guard.uninitialized");
2048
2049   llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
2050   llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2051
2052   // Check if the first byte of the guard variable is zero.
2053   Builder.CreateCondBr(isInitialized, InitCheckBlock, EndBlock);
2054
2055   CGF.EmitBlock(InitCheckBlock);
2056
2057   // Variables used when coping with thread-safe statics and exceptions.
2058   if (threadsafe) {
2059     // Call __cxa_guard_acquire.
2060     llvm::Value *V
2061       = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
2062
2063     llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2064
2065     Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
2066                          InitBlock, EndBlock);
2067
2068     // Call __cxa_guard_abort along the exceptional edge.
2069     CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
2070
2071     CGF.EmitBlock(InitBlock);
2072   }
2073
2074   // Emit the initializer and add a global destructor if appropriate.
2075   CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
2076
2077   if (threadsafe) {
2078     // Pop the guard-abort cleanup if we pushed one.
2079     CGF.PopCleanupBlock();
2080
2081     // Call __cxa_guard_release.  This cannot throw.
2082     CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy),
2083                                 guardAddr.getPointer());
2084   } else {
2085     Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guardAddr);
2086   }
2087
2088   CGF.EmitBlock(EndBlock);
2089 }
2090
2091 /// Register a global destructor using __cxa_atexit.
2092 static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
2093                                         llvm::Constant *dtor,
2094                                         llvm::Constant *addr,
2095                                         bool TLS) {
2096   const char *Name = "__cxa_atexit";
2097   if (TLS) {
2098     const llvm::Triple &T = CGF.getTarget().getTriple();
2099     Name = T.isOSDarwin() ?  "_tlv_atexit" : "__cxa_thread_atexit";
2100   }
2101
2102   // We're assuming that the destructor function is something we can
2103   // reasonably call with the default CC.  Go ahead and cast it to the
2104   // right prototype.
2105   llvm::Type *dtorTy =
2106     llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
2107
2108   // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
2109   llvm::Type *paramTys[] = { dtorTy, CGF.Int8PtrTy, CGF.Int8PtrTy };
2110   llvm::FunctionType *atexitTy =
2111     llvm::FunctionType::get(CGF.IntTy, paramTys, false);
2112
2113   // Fetch the actual function.
2114   llvm::Constant *atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
2115   if (llvm::Function *fn = dyn_cast<llvm::Function>(atexit))
2116     fn->setDoesNotThrow();
2117
2118   // Create a variable that binds the atexit to this shared object.
2119   llvm::Constant *handle =
2120     CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
2121
2122   llvm::Value *args[] = {
2123     llvm::ConstantExpr::getBitCast(dtor, dtorTy),
2124     llvm::ConstantExpr::getBitCast(addr, CGF.Int8PtrTy),
2125     handle
2126   };
2127   CGF.EmitNounwindRuntimeCall(atexit, args);
2128 }
2129
2130 /// Register a global destructor as best as we know how.
2131 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF,
2132                                        const VarDecl &D,
2133                                        llvm::Constant *dtor,
2134                                        llvm::Constant *addr) {
2135   // Use __cxa_atexit if available.
2136   if (CGM.getCodeGenOpts().CXAAtExit)
2137     return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
2138
2139   if (D.getTLSKind())
2140     CGM.ErrorUnsupported(&D, "non-trivial TLS destruction");
2141
2142   // In Apple kexts, we want to add a global destructor entry.
2143   // FIXME: shouldn't this be guarded by some variable?
2144   if (CGM.getLangOpts().AppleKext) {
2145     // Generate a global destructor entry.
2146     return CGM.AddCXXDtorEntry(dtor, addr);
2147   }
2148
2149   CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
2150 }
2151
2152 static bool isThreadWrapperReplaceable(const VarDecl *VD,
2153                                        CodeGen::CodeGenModule &CGM) {
2154   assert(!VD->isStaticLocal() && "static local VarDecls don't need wrappers!");
2155   // Darwin prefers to have references to thread local variables to go through
2156   // the thread wrapper instead of directly referencing the backing variable.
2157   return VD->getTLSKind() == VarDecl::TLS_Dynamic &&
2158          CGM.getTarget().getTriple().isOSDarwin();
2159 }
2160
2161 /// Get the appropriate linkage for the wrapper function. This is essentially
2162 /// the weak form of the variable's linkage; every translation unit which needs
2163 /// the wrapper emits a copy, and we want the linker to merge them.
2164 static llvm::GlobalValue::LinkageTypes
2165 getThreadLocalWrapperLinkage(const VarDecl *VD, CodeGen::CodeGenModule &CGM) {
2166   llvm::GlobalValue::LinkageTypes VarLinkage =
2167       CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false);
2168
2169   // For internal linkage variables, we don't need an external or weak wrapper.
2170   if (llvm::GlobalValue::isLocalLinkage(VarLinkage))
2171     return VarLinkage;
2172
2173   // If the thread wrapper is replaceable, give it appropriate linkage.
2174   if (isThreadWrapperReplaceable(VD, CGM))
2175     if (!llvm::GlobalVariable::isLinkOnceLinkage(VarLinkage) &&
2176         !llvm::GlobalVariable::isWeakODRLinkage(VarLinkage))
2177       return VarLinkage;
2178   return llvm::GlobalValue::WeakODRLinkage;
2179 }
2180
2181 llvm::Function *
2182 ItaniumCXXABI::getOrCreateThreadLocalWrapper(const VarDecl *VD,
2183                                              llvm::Value *Val) {
2184   // Mangle the name for the thread_local wrapper function.
2185   SmallString<256> WrapperName;
2186   {
2187     llvm::raw_svector_ostream Out(WrapperName);
2188     getMangleContext().mangleItaniumThreadLocalWrapper(VD, Out);
2189   }
2190
2191   // FIXME: If VD is a definition, we should regenerate the function attributes
2192   // before returning.
2193   if (llvm::Value *V = CGM.getModule().getNamedValue(WrapperName))
2194     return cast<llvm::Function>(V);
2195
2196   QualType RetQT = VD->getType();
2197   if (RetQT->isReferenceType())
2198     RetQT = RetQT.getNonReferenceType();
2199
2200   const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
2201       getContext().getPointerType(RetQT), FunctionArgList());
2202
2203   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);
2204   llvm::Function *Wrapper =
2205       llvm::Function::Create(FnTy, getThreadLocalWrapperLinkage(VD, CGM),
2206                              WrapperName.str(), &CGM.getModule());
2207
2208   CGM.SetLLVMFunctionAttributes(nullptr, FI, Wrapper);
2209
2210   if (VD->hasDefinition())
2211     CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Wrapper);
2212
2213   // Always resolve references to the wrapper at link time.
2214   if (!Wrapper->hasLocalLinkage() && !(isThreadWrapperReplaceable(VD, CGM) &&
2215       !llvm::GlobalVariable::isLinkOnceLinkage(Wrapper->getLinkage()) &&
2216       !llvm::GlobalVariable::isWeakODRLinkage(Wrapper->getLinkage())))
2217     Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);
2218
2219   if (isThreadWrapperReplaceable(VD, CGM)) {
2220     Wrapper->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2221     Wrapper->addFnAttr(llvm::Attribute::NoUnwind);
2222   }
2223   return Wrapper;
2224 }
2225
2226 void ItaniumCXXABI::EmitThreadLocalInitFuncs(
2227     CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
2228     ArrayRef<llvm::Function *> CXXThreadLocalInits,
2229     ArrayRef<const VarDecl *> CXXThreadLocalInitVars) {
2230   llvm::Function *InitFunc = nullptr;
2231   if (!CXXThreadLocalInits.empty()) {
2232     // Generate a guarded initialization function.
2233     llvm::FunctionType *FTy =
2234         llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
2235     const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2236     InitFunc = CGM.CreateGlobalInitOrDestructFunction(FTy, "__tls_init", FI,
2237                                                       SourceLocation(),
2238                                                       /*TLS=*/true);
2239     llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
2240         CGM.getModule(), CGM.Int8Ty, /*isConstant=*/false,
2241         llvm::GlobalVariable::InternalLinkage,
2242         llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
2243     Guard->setThreadLocal(true);
2244
2245     CharUnits GuardAlign = CharUnits::One();
2246     Guard->setAlignment(GuardAlign.getQuantity());
2247
2248     CodeGenFunction(CGM)
2249         .GenerateCXXGlobalInitFunc(InitFunc, CXXThreadLocalInits,
2250                                    Address(Guard, GuardAlign));
2251     // On Darwin platforms, use CXX_FAST_TLS calling convention.
2252     if (CGM.getTarget().getTriple().isOSDarwin()) {
2253       InitFunc->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2254       InitFunc->addFnAttr(llvm::Attribute::NoUnwind);
2255     }
2256   }
2257   for (const VarDecl *VD : CXXThreadLocals) {
2258     llvm::GlobalVariable *Var =
2259         cast<llvm::GlobalVariable>(CGM.GetGlobalValue(CGM.getMangledName(VD)));
2260
2261     // Some targets require that all access to thread local variables go through
2262     // the thread wrapper.  This means that we cannot attempt to create a thread
2263     // wrapper or a thread helper.
2264     if (isThreadWrapperReplaceable(VD, CGM) && !VD->hasDefinition())
2265       continue;
2266
2267     // Mangle the name for the thread_local initialization function.
2268     SmallString<256> InitFnName;
2269     {
2270       llvm::raw_svector_ostream Out(InitFnName);
2271       getMangleContext().mangleItaniumThreadLocalInit(VD, Out);
2272     }
2273
2274     // If we have a definition for the variable, emit the initialization
2275     // function as an alias to the global Init function (if any). Otherwise,
2276     // produce a declaration of the initialization function.
2277     llvm::GlobalValue *Init = nullptr;
2278     bool InitIsInitFunc = false;
2279     if (VD->hasDefinition()) {
2280       InitIsInitFunc = true;
2281       if (InitFunc)
2282         Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),
2283                                          InitFunc);
2284     } else {
2285       // Emit a weak global function referring to the initialization function.
2286       // This function will not exist if the TU defining the thread_local
2287       // variable in question does not need any dynamic initialization for
2288       // its thread_local variables.
2289       llvm::FunctionType *FnTy = llvm::FunctionType::get(CGM.VoidTy, false);
2290       Init = llvm::Function::Create(
2291           FnTy, llvm::GlobalVariable::ExternalWeakLinkage, InitFnName.str(),
2292           &CGM.getModule());
2293       const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2294       CGM.SetLLVMFunctionAttributes(nullptr, FI, cast<llvm::Function>(Init));
2295     }
2296
2297     if (Init)
2298       Init->setVisibility(Var->getVisibility());
2299
2300     llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Var);
2301     llvm::LLVMContext &Context = CGM.getModule().getContext();
2302     llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Wrapper);
2303     CGBuilderTy Builder(CGM, Entry);
2304     if (InitIsInitFunc) {
2305       if (Init) {
2306         llvm::CallInst *CallVal = Builder.CreateCall(Init);
2307         if (isThreadWrapperReplaceable(VD, CGM))
2308           CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2309       }
2310     } else {
2311       // Don't know whether we have an init function. Call it if it exists.
2312       llvm::Value *Have = Builder.CreateIsNotNull(Init);
2313       llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2314       llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2315       Builder.CreateCondBr(Have, InitBB, ExitBB);
2316
2317       Builder.SetInsertPoint(InitBB);
2318       Builder.CreateCall(Init);
2319       Builder.CreateBr(ExitBB);
2320
2321       Builder.SetInsertPoint(ExitBB);
2322     }
2323
2324     // For a reference, the result of the wrapper function is a pointer to
2325     // the referenced object.
2326     llvm::Value *Val = Var;
2327     if (VD->getType()->isReferenceType()) {
2328       CharUnits Align = CGM.getContext().getDeclAlign(VD);
2329       Val = Builder.CreateAlignedLoad(Val, Align);
2330     }
2331     if (Val->getType() != Wrapper->getReturnType())
2332       Val = Builder.CreatePointerBitCastOrAddrSpaceCast(
2333           Val, Wrapper->getReturnType(), "");
2334     Builder.CreateRet(Val);
2335   }
2336 }
2337
2338 LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2339                                                    const VarDecl *VD,
2340                                                    QualType LValType) {
2341   llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD);
2342   llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Val);
2343
2344   llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
2345   if (isThreadWrapperReplaceable(VD, CGF.CGM))
2346     CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2347
2348   LValue LV;
2349   if (VD->getType()->isReferenceType())
2350     LV = CGF.MakeNaturalAlignAddrLValue(CallVal, LValType);
2351   else
2352     LV = CGF.MakeAddrLValue(CallVal, LValType,
2353                             CGF.getContext().getDeclAlign(VD));
2354   // FIXME: need setObjCGCLValueClass?
2355   return LV;
2356 }
2357
2358 /// Return whether the given global decl needs a VTT parameter, which it does
2359 /// if it's a base constructor or destructor with virtual bases.
2360 bool ItaniumCXXABI::NeedsVTTParameter(GlobalDecl GD) {
2361   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2362
2363   // We don't have any virtual bases, just return early.
2364   if (!MD->getParent()->getNumVBases())
2365     return false;
2366
2367   // Check if we have a base constructor.
2368   if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base)
2369     return true;
2370
2371   // Check if we have a base destructor.
2372   if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
2373     return true;
2374
2375   return false;
2376 }
2377
2378 namespace {
2379 class ItaniumRTTIBuilder {
2380   CodeGenModule &CGM;  // Per-module state.
2381   llvm::LLVMContext &VMContext;
2382   const ItaniumCXXABI &CXXABI;  // Per-module state.
2383
2384   /// Fields - The fields of the RTTI descriptor currently being built.
2385   SmallVector<llvm::Constant *, 16> Fields;
2386
2387   /// GetAddrOfTypeName - Returns the mangled type name of the given type.
2388   llvm::GlobalVariable *
2389   GetAddrOfTypeName(QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage);
2390
2391   /// GetAddrOfExternalRTTIDescriptor - Returns the constant for the RTTI
2392   /// descriptor of the given type.
2393   llvm::Constant *GetAddrOfExternalRTTIDescriptor(QualType Ty);
2394
2395   /// BuildVTablePointer - Build the vtable pointer for the given type.
2396   void BuildVTablePointer(const Type *Ty);
2397
2398   /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
2399   /// inheritance, according to the Itanium C++ ABI, 2.9.5p6b.
2400   void BuildSIClassTypeInfo(const CXXRecordDecl *RD);
2401
2402   /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
2403   /// classes with bases that do not satisfy the abi::__si_class_type_info
2404   /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
2405   void BuildVMIClassTypeInfo(const CXXRecordDecl *RD);
2406
2407   /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct, used
2408   /// for pointer types.
2409   void BuildPointerTypeInfo(QualType PointeeTy);
2410
2411   /// BuildObjCObjectTypeInfo - Build the appropriate kind of
2412   /// type_info for an object type.
2413   void BuildObjCObjectTypeInfo(const ObjCObjectType *Ty);
2414
2415   /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
2416   /// struct, used for member pointer types.
2417   void BuildPointerToMemberTypeInfo(const MemberPointerType *Ty);
2418
2419 public:
2420   ItaniumRTTIBuilder(const ItaniumCXXABI &ABI)
2421       : CGM(ABI.CGM), VMContext(CGM.getModule().getContext()), CXXABI(ABI) {}
2422
2423   // Pointer type info flags.
2424   enum {
2425     /// PTI_Const - Type has const qualifier.
2426     PTI_Const = 0x1,
2427
2428     /// PTI_Volatile - Type has volatile qualifier.
2429     PTI_Volatile = 0x2,
2430
2431     /// PTI_Restrict - Type has restrict qualifier.
2432     PTI_Restrict = 0x4,
2433
2434     /// PTI_Incomplete - Type is incomplete.
2435     PTI_Incomplete = 0x8,
2436
2437     /// PTI_ContainingClassIncomplete - Containing class is incomplete.
2438     /// (in pointer to member).
2439     PTI_ContainingClassIncomplete = 0x10
2440   };
2441
2442   // VMI type info flags.
2443   enum {
2444     /// VMI_NonDiamondRepeat - Class has non-diamond repeated inheritance.
2445     VMI_NonDiamondRepeat = 0x1,
2446
2447     /// VMI_DiamondShaped - Class is diamond shaped.
2448     VMI_DiamondShaped = 0x2
2449   };
2450
2451   // Base class type info flags.
2452   enum {
2453     /// BCTI_Virtual - Base class is virtual.
2454     BCTI_Virtual = 0x1,
2455
2456     /// BCTI_Public - Base class is public.
2457     BCTI_Public = 0x2
2458   };
2459
2460   /// BuildTypeInfo - Build the RTTI type info struct for the given type.
2461   ///
2462   /// \param Force - true to force the creation of this RTTI value
2463   llvm::Constant *BuildTypeInfo(QualType Ty, bool Force = false);
2464 };
2465 }
2466
2467 llvm::GlobalVariable *ItaniumRTTIBuilder::GetAddrOfTypeName(
2468     QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage) {
2469   SmallString<256> Name;
2470   llvm::raw_svector_ostream Out(Name);
2471   CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out);
2472
2473   // We know that the mangled name of the type starts at index 4 of the
2474   // mangled name of the typename, so we can just index into it in order to
2475   // get the mangled name of the type.
2476   llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
2477                                                             Name.substr(4));
2478
2479   llvm::GlobalVariable *GV =
2480     CGM.CreateOrReplaceCXXRuntimeVariable(Name, Init->getType(), Linkage);
2481
2482   GV->setInitializer(Init);
2483
2484   return GV;
2485 }
2486
2487 llvm::Constant *
2488 ItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(QualType Ty) {
2489   // Mangle the RTTI name.
2490   SmallString<256> Name;
2491   llvm::raw_svector_ostream Out(Name);
2492   CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2493
2494   // Look for an existing global.
2495   llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name);
2496
2497   if (!GV) {
2498     // Create a new global variable.
2499     GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
2500                                   /*Constant=*/true,
2501                                   llvm::GlobalValue::ExternalLinkage, nullptr,
2502                                   Name);
2503     if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2504       const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
2505       if (RD->hasAttr<DLLImportAttr>())
2506         GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
2507     }
2508   }
2509
2510   return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
2511 }
2512
2513 /// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type
2514 /// info for that type is defined in the standard library.
2515 static bool TypeInfoIsInStandardLibrary(const BuiltinType *Ty) {
2516   // Itanium C++ ABI 2.9.2:
2517   //   Basic type information (e.g. for "int", "bool", etc.) will be kept in
2518   //   the run-time support library. Specifically, the run-time support
2519   //   library should contain type_info objects for the types X, X* and
2520   //   X const*, for every X in: void, std::nullptr_t, bool, wchar_t, char,
2521   //   unsigned char, signed char, short, unsigned short, int, unsigned int,
2522   //   long, unsigned long, long long, unsigned long long, float, double,
2523   //   long double, char16_t, char32_t, and the IEEE 754r decimal and
2524   //   half-precision floating point types.
2525   //
2526   // GCC also emits RTTI for __int128.
2527   // FIXME: We do not emit RTTI information for decimal types here.
2528
2529   // Types added here must also be added to EmitFundamentalRTTIDescriptors.
2530   switch (Ty->getKind()) {
2531     case BuiltinType::Void:
2532     case BuiltinType::NullPtr:
2533     case BuiltinType::Bool:
2534     case BuiltinType::WChar_S:
2535     case BuiltinType::WChar_U:
2536     case BuiltinType::Char_U:
2537     case BuiltinType::Char_S:
2538     case BuiltinType::UChar:
2539     case BuiltinType::SChar:
2540     case BuiltinType::Short:
2541     case BuiltinType::UShort:
2542     case BuiltinType::Int:
2543     case BuiltinType::UInt:
2544     case BuiltinType::Long:
2545     case BuiltinType::ULong:
2546     case BuiltinType::LongLong:
2547     case BuiltinType::ULongLong:
2548     case BuiltinType::Half:
2549     case BuiltinType::Float:
2550     case BuiltinType::Double:
2551     case BuiltinType::LongDouble:
2552     case BuiltinType::Float128:
2553     case BuiltinType::Char16:
2554     case BuiltinType::Char32:
2555     case BuiltinType::Int128:
2556     case BuiltinType::UInt128:
2557       return true;
2558
2559 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2560     case BuiltinType::Id:
2561 #include "clang/Basic/OpenCLImageTypes.def"
2562     case BuiltinType::OCLSampler:
2563     case BuiltinType::OCLEvent:
2564     case BuiltinType::OCLClkEvent:
2565     case BuiltinType::OCLQueue:
2566     case BuiltinType::OCLNDRange:
2567     case BuiltinType::OCLReserveID:
2568       return false;
2569
2570     case BuiltinType::Dependent:
2571 #define BUILTIN_TYPE(Id, SingletonId)
2572 #define PLACEHOLDER_TYPE(Id, SingletonId) \
2573     case BuiltinType::Id:
2574 #include "clang/AST/BuiltinTypes.def"
2575       llvm_unreachable("asking for RRTI for a placeholder type!");
2576
2577     case BuiltinType::ObjCId:
2578     case BuiltinType::ObjCClass:
2579     case BuiltinType::ObjCSel:
2580       llvm_unreachable("FIXME: Objective-C types are unsupported!");
2581   }
2582
2583   llvm_unreachable("Invalid BuiltinType Kind!");
2584 }
2585
2586 static bool TypeInfoIsInStandardLibrary(const PointerType *PointerTy) {
2587   QualType PointeeTy = PointerTy->getPointeeType();
2588   const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(PointeeTy);
2589   if (!BuiltinTy)
2590     return false;
2591
2592   // Check the qualifiers.
2593   Qualifiers Quals = PointeeTy.getQualifiers();
2594   Quals.removeConst();
2595
2596   if (!Quals.empty())
2597     return false;
2598
2599   return TypeInfoIsInStandardLibrary(BuiltinTy);
2600 }
2601
2602 /// IsStandardLibraryRTTIDescriptor - Returns whether the type
2603 /// information for the given type exists in the standard library.
2604 static bool IsStandardLibraryRTTIDescriptor(QualType Ty) {
2605   // Type info for builtin types is defined in the standard library.
2606   if (const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(Ty))
2607     return TypeInfoIsInStandardLibrary(BuiltinTy);
2608
2609   // Type info for some pointer types to builtin types is defined in the
2610   // standard library.
2611   if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2612     return TypeInfoIsInStandardLibrary(PointerTy);
2613
2614   return false;
2615 }
2616
2617 /// ShouldUseExternalRTTIDescriptor - Returns whether the type information for
2618 /// the given type exists somewhere else, and that we should not emit the type
2619 /// information in this translation unit.  Assumes that it is not a
2620 /// standard-library type.
2621 static bool ShouldUseExternalRTTIDescriptor(CodeGenModule &CGM,
2622                                             QualType Ty) {
2623   ASTContext &Context = CGM.getContext();
2624
2625   // If RTTI is disabled, assume it might be disabled in the
2626   // translation unit that defines any potential key function, too.
2627   if (!Context.getLangOpts().RTTI) return false;
2628
2629   if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2630     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
2631     if (!RD->hasDefinition())
2632       return false;
2633
2634     if (!RD->isDynamicClass())
2635       return false;
2636
2637     // FIXME: this may need to be reconsidered if the key function
2638     // changes.
2639     // N.B. We must always emit the RTTI data ourselves if there exists a key
2640     // function.
2641     bool IsDLLImport = RD->hasAttr<DLLImportAttr>();
2642     if (CGM.getVTables().isVTableExternal(RD))
2643       return IsDLLImport ? false : true;
2644
2645     if (IsDLLImport)
2646       return true;
2647   }
2648
2649   return false;
2650 }
2651
2652 /// IsIncompleteClassType - Returns whether the given record type is incomplete.
2653 static bool IsIncompleteClassType(const RecordType *RecordTy) {
2654   return !RecordTy->getDecl()->isCompleteDefinition();
2655 }
2656
2657 /// ContainsIncompleteClassType - Returns whether the given type contains an
2658 /// incomplete class type. This is true if
2659 ///
2660 ///   * The given type is an incomplete class type.
2661 ///   * The given type is a pointer type whose pointee type contains an
2662 ///     incomplete class type.
2663 ///   * The given type is a member pointer type whose class is an incomplete
2664 ///     class type.
2665 ///   * The given type is a member pointer type whoise pointee type contains an
2666 ///     incomplete class type.
2667 /// is an indirect or direct pointer to an incomplete class type.
2668 static bool ContainsIncompleteClassType(QualType Ty) {
2669   if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2670     if (IsIncompleteClassType(RecordTy))
2671       return true;
2672   }
2673
2674   if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2675     return ContainsIncompleteClassType(PointerTy->getPointeeType());
2676
2677   if (const MemberPointerType *MemberPointerTy =
2678       dyn_cast<MemberPointerType>(Ty)) {
2679     // Check if the class type is incomplete.
2680     const RecordType *ClassType = cast<RecordType>(MemberPointerTy->getClass());
2681     if (IsIncompleteClassType(ClassType))
2682       return true;
2683
2684     return ContainsIncompleteClassType(MemberPointerTy->getPointeeType());
2685   }
2686
2687   return false;
2688 }
2689
2690 // CanUseSingleInheritance - Return whether the given record decl has a "single,
2691 // public, non-virtual base at offset zero (i.e. the derived class is dynamic
2692 // iff the base is)", according to Itanium C++ ABI, 2.95p6b.
2693 static bool CanUseSingleInheritance(const CXXRecordDecl *RD) {
2694   // Check the number of bases.
2695   if (RD->getNumBases() != 1)
2696     return false;
2697
2698   // Get the base.
2699   CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin();
2700
2701   // Check that the base is not virtual.
2702   if (Base->isVirtual())
2703     return false;
2704
2705   // Check that the base is public.
2706   if (Base->getAccessSpecifier() != AS_public)
2707     return false;
2708
2709   // Check that the class is dynamic iff the base is.
2710   const CXXRecordDecl *BaseDecl =
2711     cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
2712   if (!BaseDecl->isEmpty() &&
2713       BaseDecl->isDynamicClass() != RD->isDynamicClass())
2714     return false;
2715
2716   return true;
2717 }
2718
2719 void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) {
2720   // abi::__class_type_info.
2721   static const char * const ClassTypeInfo =
2722     "_ZTVN10__cxxabiv117__class_type_infoE";
2723   // abi::__si_class_type_info.
2724   static const char * const SIClassTypeInfo =
2725     "_ZTVN10__cxxabiv120__si_class_type_infoE";
2726   // abi::__vmi_class_type_info.
2727   static const char * const VMIClassTypeInfo =
2728     "_ZTVN10__cxxabiv121__vmi_class_type_infoE";
2729
2730   const char *VTableName = nullptr;
2731
2732   switch (Ty->getTypeClass()) {
2733 #define TYPE(Class, Base)
2734 #define ABSTRACT_TYPE(Class, Base)
2735 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
2736 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2737 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2738 #include "clang/AST/TypeNodes.def"
2739     llvm_unreachable("Non-canonical and dependent types shouldn't get here");
2740
2741   case Type::LValueReference:
2742   case Type::RValueReference:
2743     llvm_unreachable("References shouldn't get here");
2744
2745   case Type::Auto:
2746     llvm_unreachable("Undeduced auto type shouldn't get here");
2747
2748   case Type::Pipe:
2749     llvm_unreachable("Pipe types shouldn't get here");
2750
2751   case Type::Builtin:
2752   // GCC treats vector and complex types as fundamental types.
2753   case Type::Vector:
2754   case Type::ExtVector:
2755   case Type::Complex:
2756   case Type::Atomic:
2757   // FIXME: GCC treats block pointers as fundamental types?!
2758   case Type::BlockPointer:
2759     // abi::__fundamental_type_info.
2760     VTableName = "_ZTVN10__cxxabiv123__fundamental_type_infoE";
2761     break;
2762
2763   case Type::ConstantArray:
2764   case Type::IncompleteArray:
2765   case Type::VariableArray:
2766     // abi::__array_type_info.
2767     VTableName = "_ZTVN10__cxxabiv117__array_type_infoE";
2768     break;
2769
2770   case Type::FunctionNoProto:
2771   case Type::FunctionProto:
2772     // abi::__function_type_info.
2773     VTableName = "_ZTVN10__cxxabiv120__function_type_infoE";
2774     break;
2775
2776   case Type::Enum:
2777     // abi::__enum_type_info.
2778     VTableName = "_ZTVN10__cxxabiv116__enum_type_infoE";
2779     break;
2780
2781   case Type::Record: {
2782     const CXXRecordDecl *RD =
2783       cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
2784
2785     if (!RD->hasDefinition() || !RD->getNumBases()) {
2786       VTableName = ClassTypeInfo;
2787     } else if (CanUseSingleInheritance(RD)) {
2788       VTableName = SIClassTypeInfo;
2789     } else {
2790       VTableName = VMIClassTypeInfo;
2791     }
2792
2793     break;
2794   }
2795
2796   case Type::ObjCObject:
2797     // Ignore protocol qualifiers.
2798     Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr();
2799
2800     // Handle id and Class.
2801     if (isa<BuiltinType>(Ty)) {
2802       VTableName = ClassTypeInfo;
2803       break;
2804     }
2805
2806     assert(isa<ObjCInterfaceType>(Ty));
2807     // Fall through.
2808
2809   case Type::ObjCInterface:
2810     if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
2811       VTableName = SIClassTypeInfo;
2812     } else {
2813       VTableName = ClassTypeInfo;
2814     }
2815     break;
2816
2817   case Type::ObjCObjectPointer:
2818   case Type::Pointer:
2819     // abi::__pointer_type_info.
2820     VTableName = "_ZTVN10__cxxabiv119__pointer_type_infoE";
2821     break;
2822
2823   case Type::MemberPointer:
2824     // abi::__pointer_to_member_type_info.
2825     VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE";
2826     break;
2827   }
2828
2829   llvm::Constant *VTable =
2830     CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy);
2831
2832   llvm::Type *PtrDiffTy =
2833     CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
2834
2835   // The vtable address point is 2.
2836   llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
2837   VTable =
2838       llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
2839   VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
2840
2841   Fields.push_back(VTable);
2842 }
2843
2844 /// \brief Return the linkage that the type info and type info name constants
2845 /// should have for the given type.
2846 static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
2847                                                              QualType Ty) {
2848   // Itanium C++ ABI 2.9.5p7:
2849   //   In addition, it and all of the intermediate abi::__pointer_type_info
2850   //   structs in the chain down to the abi::__class_type_info for the
2851   //   incomplete class type must be prevented from resolving to the
2852   //   corresponding type_info structs for the complete class type, possibly
2853   //   by making them local static objects. Finally, a dummy class RTTI is
2854   //   generated for the incomplete type that will not resolve to the final
2855   //   complete class RTTI (because the latter need not exist), possibly by
2856   //   making it a local static object.
2857   if (ContainsIncompleteClassType(Ty))
2858     return llvm::GlobalValue::InternalLinkage;
2859
2860   switch (Ty->getLinkage()) {
2861   case NoLinkage:
2862   case InternalLinkage:
2863   case UniqueExternalLinkage:
2864     return llvm::GlobalValue::InternalLinkage;
2865
2866   case VisibleNoLinkage:
2867   case ExternalLinkage:
2868     if (!CGM.getLangOpts().RTTI) {
2869       // RTTI is not enabled, which means that this type info struct is going
2870       // to be used for exception handling. Give it linkonce_odr linkage.
2871       return llvm::GlobalValue::LinkOnceODRLinkage;
2872     }
2873
2874     if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
2875       const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
2876       if (RD->hasAttr<WeakAttr>())
2877         return llvm::GlobalValue::WeakODRLinkage;
2878       if (RD->isDynamicClass()) {
2879         llvm::GlobalValue::LinkageTypes LT = CGM.getVTableLinkage(RD);
2880         // MinGW won't export the RTTI information when there is a key function.
2881         // Make sure we emit our own copy instead of attempting to dllimport it.
2882         if (RD->hasAttr<DLLImportAttr>() &&
2883             llvm::GlobalValue::isAvailableExternallyLinkage(LT))
2884           LT = llvm::GlobalValue::LinkOnceODRLinkage;
2885         return LT;
2886       }
2887     }
2888
2889     return llvm::GlobalValue::LinkOnceODRLinkage;
2890   }
2891
2892   llvm_unreachable("Invalid linkage!");
2893 }
2894
2895 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force) {
2896   // We want to operate on the canonical type.
2897   Ty = Ty.getCanonicalType();
2898
2899   // Check if we've already emitted an RTTI descriptor for this type.
2900   SmallString<256> Name;
2901   llvm::raw_svector_ostream Out(Name);
2902   CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2903
2904   llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name);
2905   if (OldGV && !OldGV->isDeclaration()) {
2906     assert(!OldGV->hasAvailableExternallyLinkage() &&
2907            "available_externally typeinfos not yet implemented");
2908
2909     return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy);
2910   }
2911
2912   // Check if there is already an external RTTI descriptor for this type.
2913   bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty);
2914   if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty)))
2915     return GetAddrOfExternalRTTIDescriptor(Ty);
2916
2917   // Emit the standard library with external linkage.
2918   llvm::GlobalVariable::LinkageTypes Linkage;
2919   if (IsStdLib)
2920     Linkage = llvm::GlobalValue::ExternalLinkage;
2921   else
2922     Linkage = getTypeInfoLinkage(CGM, Ty);
2923
2924   // Add the vtable pointer.
2925   BuildVTablePointer(cast<Type>(Ty));
2926
2927   // And the name.
2928   llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage);
2929   llvm::Constant *TypeNameField;
2930
2931   // If we're supposed to demote the visibility, be sure to set a flag
2932   // to use a string comparison for type_info comparisons.
2933   ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
2934       CXXABI.classifyRTTIUniqueness(Ty, Linkage);
2935   if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
2936     // The flag is the sign bit, which on ARM64 is defined to be clear
2937     // for global pointers.  This is very ARM64-specific.
2938     TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
2939     llvm::Constant *flag =
2940         llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
2941     TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
2942     TypeNameField =
2943         llvm::ConstantExpr::getIntToPtr(TypeNameField, CGM.Int8PtrTy);
2944   } else {
2945     TypeNameField = llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy);
2946   }
2947   Fields.push_back(TypeNameField);
2948
2949   switch (Ty->getTypeClass()) {
2950 #define TYPE(Class, Base)
2951 #define ABSTRACT_TYPE(Class, Base)
2952 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
2953 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2954 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2955 #include "clang/AST/TypeNodes.def"
2956     llvm_unreachable("Non-canonical and dependent types shouldn't get here");
2957
2958   // GCC treats vector types as fundamental types.
2959   case Type::Builtin:
2960   case Type::Vector:
2961   case Type::ExtVector:
2962   case Type::Complex:
2963   case Type::BlockPointer:
2964     // Itanium C++ ABI 2.9.5p4:
2965     // abi::__fundamental_type_info adds no data members to std::type_info.
2966     break;
2967
2968   case Type::LValueReference:
2969   case Type::RValueReference:
2970     llvm_unreachable("References shouldn't get here");
2971
2972   case Type::Auto:
2973     llvm_unreachable("Undeduced auto type shouldn't get here");
2974
2975   case Type::Pipe:
2976     llvm_unreachable("Pipe type shouldn't get here");
2977
2978   case Type::ConstantArray:
2979   case Type::IncompleteArray:
2980   case Type::VariableArray:
2981     // Itanium C++ ABI 2.9.5p5:
2982     // abi::__array_type_info adds no data members to std::type_info.
2983     break;
2984
2985   case Type::FunctionNoProto:
2986   case Type::FunctionProto:
2987     // Itanium C++ ABI 2.9.5p5:
2988     // abi::__function_type_info adds no data members to std::type_info.
2989     break;
2990
2991   case Type::Enum:
2992     // Itanium C++ ABI 2.9.5p5:
2993     // abi::__enum_type_info adds no data members to std::type_info.
2994     break;
2995
2996   case Type::Record: {
2997     const CXXRecordDecl *RD =
2998       cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
2999     if (!RD->hasDefinition() || !RD->getNumBases()) {
3000       // We don't need to emit any fields.
3001       break;
3002     }
3003
3004     if (CanUseSingleInheritance(RD))
3005       BuildSIClassTypeInfo(RD);
3006     else
3007       BuildVMIClassTypeInfo(RD);
3008
3009     break;
3010   }
3011
3012   case Type::ObjCObject:
3013   case Type::ObjCInterface:
3014     BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty));
3015     break;
3016
3017   case Type::ObjCObjectPointer:
3018     BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->getPointeeType());
3019     break;
3020
3021   case Type::Pointer:
3022     BuildPointerTypeInfo(cast<PointerType>(Ty)->getPointeeType());
3023     break;
3024
3025   case Type::MemberPointer:
3026     BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty));
3027     break;
3028
3029   case Type::Atomic:
3030     // No fields, at least for the moment.
3031     break;
3032   }
3033
3034   llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);
3035
3036   llvm::Module &M = CGM.getModule();
3037   llvm::GlobalVariable *GV =
3038       new llvm::GlobalVariable(M, Init->getType(),
3039                                /*Constant=*/true, Linkage, Init, Name);
3040
3041   // If there's already an old global variable, replace it with the new one.
3042   if (OldGV) {
3043     GV->takeName(OldGV);
3044     llvm::Constant *NewPtr =
3045       llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
3046     OldGV->replaceAllUsesWith(NewPtr);
3047     OldGV->eraseFromParent();
3048   }
3049
3050   if (CGM.supportsCOMDAT() && GV->isWeakForLinker())
3051     GV->setComdat(M.getOrInsertComdat(GV->getName()));
3052
3053   // The Itanium ABI specifies that type_info objects must be globally
3054   // unique, with one exception: if the type is an incomplete class
3055   // type or a (possibly indirect) pointer to one.  That exception
3056   // affects the general case of comparing type_info objects produced
3057   // by the typeid operator, which is why the comparison operators on
3058   // std::type_info generally use the type_info name pointers instead
3059   // of the object addresses.  However, the language's built-in uses
3060   // of RTTI generally require class types to be complete, even when
3061   // manipulating pointers to those class types.  This allows the
3062   // implementation of dynamic_cast to rely on address equality tests,
3063   // which is much faster.
3064
3065   // All of this is to say that it's important that both the type_info
3066   // object and the type_info name be uniqued when weakly emitted.
3067
3068   // Give the type_info object and name the formal visibility of the
3069   // type itself.
3070   llvm::GlobalValue::VisibilityTypes llvmVisibility;
3071   if (llvm::GlobalValue::isLocalLinkage(Linkage))
3072     // If the linkage is local, only default visibility makes sense.
3073     llvmVisibility = llvm::GlobalValue::DefaultVisibility;
3074   else if (RTTIUniqueness == ItaniumCXXABI::RUK_NonUniqueHidden)
3075     llvmVisibility = llvm::GlobalValue::HiddenVisibility;
3076   else
3077     llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
3078   TypeName->setVisibility(llvmVisibility);
3079   GV->setVisibility(llvmVisibility);
3080
3081   return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
3082 }
3083
3084 /// ComputeQualifierFlags - Compute the pointer type info flags from the
3085 /// given qualifier.
3086 static unsigned ComputeQualifierFlags(Qualifiers Quals) {
3087   unsigned Flags = 0;
3088
3089   if (Quals.hasConst())
3090     Flags |= ItaniumRTTIBuilder::PTI_Const;
3091   if (Quals.hasVolatile())
3092     Flags |= ItaniumRTTIBuilder::PTI_Volatile;
3093   if (Quals.hasRestrict())
3094     Flags |= ItaniumRTTIBuilder::PTI_Restrict;
3095
3096   return Flags;
3097 }
3098
3099 /// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info
3100 /// for the given Objective-C object type.
3101 void ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) {
3102   // Drop qualifiers.
3103   const Type *T = OT->getBaseType().getTypePtr();
3104   assert(isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T));
3105
3106   // The builtin types are abi::__class_type_infos and don't require
3107   // extra fields.
3108   if (isa<BuiltinType>(T)) return;
3109
3110   ObjCInterfaceDecl *Class = cast<ObjCInterfaceType>(T)->getDecl();
3111   ObjCInterfaceDecl *Super = Class->getSuperClass();
3112
3113   // Root classes are also __class_type_info.
3114   if (!Super) return;
3115
3116   QualType SuperTy = CGM.getContext().getObjCInterfaceType(Super);
3117
3118   // Everything else is single inheritance.
3119   llvm::Constant *BaseTypeInfo =
3120       ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(SuperTy);
3121   Fields.push_back(BaseTypeInfo);
3122 }
3123
3124 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
3125 /// inheritance, according to the Itanium C++ ABI, 2.95p6b.
3126 void ItaniumRTTIBuilder::BuildSIClassTypeInfo(const CXXRecordDecl *RD) {
3127   // Itanium C++ ABI 2.9.5p6b:
3128   // It adds to abi::__class_type_info a single member pointing to the
3129   // type_info structure for the base type,
3130   llvm::Constant *BaseTypeInfo =
3131     ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(RD->bases_begin()->getType());
3132   Fields.push_back(BaseTypeInfo);
3133 }
3134
3135 namespace {
3136   /// SeenBases - Contains virtual and non-virtual bases seen when traversing
3137   /// a class hierarchy.
3138   struct SeenBases {
3139     llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases;
3140     llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases;
3141   };
3142 }
3143
3144 /// ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in
3145 /// abi::__vmi_class_type_info.
3146 ///
3147 static unsigned ComputeVMIClassTypeInfoFlags(const CXXBaseSpecifier *Base,
3148                                              SeenBases &Bases) {
3149
3150   unsigned Flags = 0;
3151
3152   const CXXRecordDecl *BaseDecl =
3153     cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3154
3155   if (Base->isVirtual()) {
3156     // Mark the virtual base as seen.
3157     if (!Bases.VirtualBases.insert(BaseDecl).second) {
3158       // If this virtual base has been seen before, then the class is diamond
3159       // shaped.
3160       Flags |= ItaniumRTTIBuilder::VMI_DiamondShaped;
3161     } else {
3162       if (Bases.NonVirtualBases.count(BaseDecl))
3163         Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3164     }
3165   } else {
3166     // Mark the non-virtual base as seen.
3167     if (!Bases.NonVirtualBases.insert(BaseDecl).second) {
3168       // If this non-virtual base has been seen before, then the class has non-
3169       // diamond shaped repeated inheritance.
3170       Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3171     } else {
3172       if (Bases.VirtualBases.count(BaseDecl))
3173         Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3174     }
3175   }
3176
3177   // Walk all bases.
3178   for (const auto &I : BaseDecl->bases())
3179     Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3180
3181   return Flags;
3182 }
3183
3184 static unsigned ComputeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) {
3185   unsigned Flags = 0;
3186   SeenBases Bases;
3187
3188   // Walk all bases.
3189   for (const auto &I : RD->bases())
3190     Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3191
3192   return Flags;
3193 }
3194
3195 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
3196 /// classes with bases that do not satisfy the abi::__si_class_type_info
3197 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
3198 void ItaniumRTTIBuilder::BuildVMIClassTypeInfo(const CXXRecordDecl *RD) {
3199   llvm::Type *UnsignedIntLTy =
3200     CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3201
3202   // Itanium C++ ABI 2.9.5p6c:
3203   //   __flags is a word with flags describing details about the class
3204   //   structure, which may be referenced by using the __flags_masks
3205   //   enumeration. These flags refer to both direct and indirect bases.
3206   unsigned Flags = ComputeVMIClassTypeInfoFlags(RD);
3207   Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3208
3209   // Itanium C++ ABI 2.9.5p6c:
3210   //   __base_count is a word with the number of direct proper base class
3211   //   descriptions that follow.
3212   Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases()));
3213
3214   if (!RD->getNumBases())
3215     return;
3216
3217   llvm::Type *LongLTy =
3218     CGM.getTypes().ConvertType(CGM.getContext().LongTy);
3219
3220   // Now add the base class descriptions.
3221
3222   // Itanium C++ ABI 2.9.5p6c:
3223   //   __base_info[] is an array of base class descriptions -- one for every
3224   //   direct proper base. Each description is of the type:
3225   //
3226   //   struct abi::__base_class_type_info {
3227   //   public:
3228   //     const __class_type_info *__base_type;
3229   //     long __offset_flags;
3230   //
3231   //     enum __offset_flags_masks {
3232   //       __virtual_mask = 0x1,
3233   //       __public_mask = 0x2,
3234   //       __offset_shift = 8
3235   //     };
3236   //   };
3237   for (const auto &Base : RD->bases()) {
3238     // The __base_type member points to the RTTI for the base type.
3239     Fields.push_back(ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(Base.getType()));
3240
3241     const CXXRecordDecl *BaseDecl =
3242       cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
3243
3244     int64_t OffsetFlags = 0;
3245
3246     // All but the lower 8 bits of __offset_flags are a signed offset.
3247     // For a non-virtual base, this is the offset in the object of the base
3248     // subobject. For a virtual base, this is the offset in the virtual table of
3249     // the virtual base offset for the virtual base referenced (negative).
3250     CharUnits Offset;
3251     if (Base.isVirtual())
3252       Offset =
3253         CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(RD, BaseDecl);
3254     else {
3255       const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3256       Offset = Layout.getBaseClassOffset(BaseDecl);
3257     };
3258
3259     OffsetFlags = uint64_t(Offset.getQuantity()) << 8;
3260
3261     // The low-order byte of __offset_flags contains flags, as given by the
3262     // masks from the enumeration __offset_flags_masks.
3263     if (Base.isVirtual())
3264       OffsetFlags |= BCTI_Virtual;
3265     if (Base.getAccessSpecifier() == AS_public)
3266       OffsetFlags |= BCTI_Public;
3267
3268     Fields.push_back(llvm::ConstantInt::get(LongLTy, OffsetFlags));
3269   }
3270 }
3271
3272 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct,
3273 /// used for pointer types.
3274 void ItaniumRTTIBuilder::BuildPointerTypeInfo(QualType PointeeTy) {
3275   Qualifiers Quals;
3276   QualType UnqualifiedPointeeTy =
3277     CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals);
3278
3279   // Itanium C++ ABI 2.9.5p7:
3280   //   __flags is a flag word describing the cv-qualification and other
3281   //   attributes of the type pointed to
3282   unsigned Flags = ComputeQualifierFlags(Quals);
3283
3284   // Itanium C++ ABI 2.9.5p7:
3285   //   When the abi::__pbase_type_info is for a direct or indirect pointer to an
3286   //   incomplete class type, the incomplete target type flag is set.
3287   if (ContainsIncompleteClassType(UnqualifiedPointeeTy))
3288     Flags |= PTI_Incomplete;
3289
3290   llvm::Type *UnsignedIntLTy =
3291     CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3292   Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3293
3294   // Itanium C++ ABI 2.9.5p7:
3295   //  __pointee is a pointer to the std::type_info derivation for the
3296   //  unqualified type being pointed to.
3297   llvm::Constant *PointeeTypeInfo =
3298     ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(UnqualifiedPointeeTy);
3299   Fields.push_back(PointeeTypeInfo);
3300 }
3301
3302 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
3303 /// struct, used for member pointer types.
3304 void
3305 ItaniumRTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) {
3306   QualType PointeeTy = Ty->getPointeeType();
3307
3308   Qualifiers Quals;
3309   QualType UnqualifiedPointeeTy =
3310     CGM.getContext().getUnqualifiedArrayType(PointeeTy, Quals);
3311
3312   // Itanium C++ ABI 2.9.5p7:
3313   //   __flags is a flag word describing the cv-qualification and other
3314   //   attributes of the type pointed to.
3315   unsigned Flags = ComputeQualifierFlags(Quals);
3316
3317   const RecordType *ClassType = cast<RecordType>(Ty->getClass());
3318
3319   // Itanium C++ ABI 2.9.5p7:
3320   //   When the abi::__pbase_type_info is for a direct or indirect pointer to an
3321   //   incomplete class type, the incomplete target type flag is set.
3322   if (ContainsIncompleteClassType(UnqualifiedPointeeTy))
3323     Flags |= PTI_Incomplete;
3324
3325   if (IsIncompleteClassType(ClassType))
3326     Flags |= PTI_ContainingClassIncomplete;
3327
3328   llvm::Type *UnsignedIntLTy =
3329     CGM.getTypes().ConvertType(CGM.getContext().UnsignedIntTy);
3330   Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3331
3332   // Itanium C++ ABI 2.9.5p7:
3333   //   __pointee is a pointer to the std::type_info derivation for the
3334   //   unqualified type being pointed to.
3335   llvm::Constant *PointeeTypeInfo =
3336     ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(UnqualifiedPointeeTy);
3337   Fields.push_back(PointeeTypeInfo);
3338
3339   // Itanium C++ ABI 2.9.5p9:
3340   //   __context is a pointer to an abi::__class_type_info corresponding to the
3341   //   class type containing the member pointed to
3342   //   (e.g., the "A" in "int A::*").
3343   Fields.push_back(
3344       ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(QualType(ClassType, 0)));
3345 }
3346
3347 llvm::Constant *ItaniumCXXABI::getAddrOfRTTIDescriptor(QualType Ty) {
3348   return ItaniumRTTIBuilder(*this).BuildTypeInfo(Ty);
3349 }
3350
3351 void ItaniumCXXABI::EmitFundamentalRTTIDescriptor(QualType Type) {
3352   QualType PointerType = getContext().getPointerType(Type);
3353   QualType PointerTypeConst = getContext().getPointerType(Type.withConst());
3354   ItaniumRTTIBuilder(*this).BuildTypeInfo(Type, true);
3355   ItaniumRTTIBuilder(*this).BuildTypeInfo(PointerType, true);
3356   ItaniumRTTIBuilder(*this).BuildTypeInfo(PointerTypeConst, true);
3357 }
3358
3359 void ItaniumCXXABI::EmitFundamentalRTTIDescriptors() {
3360   // Types added here must also be added to TypeInfoIsInStandardLibrary.
3361   QualType FundamentalTypes[] = {
3362       getContext().VoidTy,             getContext().NullPtrTy,
3363       getContext().BoolTy,             getContext().WCharTy,
3364       getContext().CharTy,             getContext().UnsignedCharTy,
3365       getContext().SignedCharTy,       getContext().ShortTy,
3366       getContext().UnsignedShortTy,    getContext().IntTy,
3367       getContext().UnsignedIntTy,      getContext().LongTy,
3368       getContext().UnsignedLongTy,     getContext().LongLongTy,
3369       getContext().UnsignedLongLongTy, getContext().Int128Ty,
3370       getContext().UnsignedInt128Ty,   getContext().HalfTy,
3371       getContext().FloatTy,            getContext().DoubleTy,
3372       getContext().LongDoubleTy,       getContext().Float128Ty,
3373       getContext().Char16Ty,           getContext().Char32Ty
3374   };
3375   for (const QualType &FundamentalType : FundamentalTypes)
3376     EmitFundamentalRTTIDescriptor(FundamentalType);
3377 }
3378
3379 /// What sort of uniqueness rules should we use for the RTTI for the
3380 /// given type?
3381 ItaniumCXXABI::RTTIUniquenessKind ItaniumCXXABI::classifyRTTIUniqueness(
3382     QualType CanTy, llvm::GlobalValue::LinkageTypes Linkage) const {
3383   if (shouldRTTIBeUnique())
3384     return RUK_Unique;
3385
3386   // It's only necessary for linkonce_odr or weak_odr linkage.
3387   if (Linkage != llvm::GlobalValue::LinkOnceODRLinkage &&
3388       Linkage != llvm::GlobalValue::WeakODRLinkage)
3389     return RUK_Unique;
3390
3391   // It's only necessary with default visibility.
3392   if (CanTy->getVisibility() != DefaultVisibility)
3393     return RUK_Unique;
3394
3395   // If we're not required to publish this symbol, hide it.
3396   if (Linkage == llvm::GlobalValue::LinkOnceODRLinkage)
3397     return RUK_NonUniqueHidden;
3398
3399   // If we're required to publish this symbol, as we might be under an
3400   // explicit instantiation, leave it with default visibility but
3401   // enable string-comparisons.
3402   assert(Linkage == llvm::GlobalValue::WeakODRLinkage);
3403   return RUK_NonUniqueVisible;
3404 }
3405
3406 // Find out how to codegen the complete destructor and constructor
3407 namespace {
3408 enum class StructorCodegen { Emit, RAUW, Alias, COMDAT };
3409 }
3410 static StructorCodegen getCodegenToUse(CodeGenModule &CGM,
3411                                        const CXXMethodDecl *MD) {
3412   if (!CGM.getCodeGenOpts().CXXCtorDtorAliases)
3413     return StructorCodegen::Emit;
3414
3415   // The complete and base structors are not equivalent if there are any virtual
3416   // bases, so emit separate functions.
3417   if (MD->getParent()->getNumVBases())
3418     return StructorCodegen::Emit;
3419
3420   GlobalDecl AliasDecl;
3421   if (const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3422     AliasDecl = GlobalDecl(DD, Dtor_Complete);
3423   } else {
3424     const auto *CD = cast<CXXConstructorDecl>(MD);
3425     AliasDecl = GlobalDecl(CD, Ctor_Complete);
3426   }
3427   llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3428
3429   if (llvm::GlobalValue::isDiscardableIfUnused(Linkage))
3430     return StructorCodegen::RAUW;
3431
3432   // FIXME: Should we allow available_externally aliases?
3433   if (!llvm::GlobalAlias::isValidLinkage(Linkage))
3434     return StructorCodegen::RAUW;
3435
3436   if (llvm::GlobalValue::isWeakForLinker(Linkage)) {
3437     // Only ELF supports COMDATs with arbitrary names (C5/D5).
3438     if (CGM.getTarget().getTriple().isOSBinFormatELF())
3439       return StructorCodegen::COMDAT;
3440     return StructorCodegen::Emit;
3441   }
3442
3443   return StructorCodegen::Alias;
3444 }
3445
3446 static void emitConstructorDestructorAlias(CodeGenModule &CGM,
3447                                            GlobalDecl AliasDecl,
3448                                            GlobalDecl TargetDecl) {
3449   llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3450
3451   StringRef MangledName = CGM.getMangledName(AliasDecl);
3452   llvm::GlobalValue *Entry = CGM.GetGlobalValue(MangledName);
3453   if (Entry && !Entry->isDeclaration())
3454     return;
3455
3456   auto *Aliasee = cast<llvm::GlobalValue>(CGM.GetAddrOfGlobal(TargetDecl));
3457
3458   // Create the alias with no name.
3459   auto *Alias = llvm::GlobalAlias::create(Linkage, "", Aliasee);
3460
3461   // Switch any previous uses to the alias.
3462   if (Entry) {
3463     assert(Entry->getType() == Aliasee->getType() &&
3464            "declaration exists with different type");
3465     Alias->takeName(Entry);
3466     Entry->replaceAllUsesWith(Alias);
3467     Entry->eraseFromParent();
3468   } else {
3469     Alias->setName(MangledName);
3470   }
3471
3472   // Finally, set up the alias with its proper name and attributes.
3473   CGM.setAliasAttributes(cast<NamedDecl>(AliasDecl.getDecl()), Alias);
3474 }
3475
3476 void ItaniumCXXABI::emitCXXStructor(const CXXMethodDecl *MD,
3477                                     StructorType Type) {
3478   auto *CD = dyn_cast<CXXConstructorDecl>(MD);
3479   const CXXDestructorDecl *DD = CD ? nullptr : cast<CXXDestructorDecl>(MD);
3480
3481   StructorCodegen CGType = getCodegenToUse(CGM, MD);
3482
3483   if (Type == StructorType::Complete) {
3484     GlobalDecl CompleteDecl;
3485     GlobalDecl BaseDecl;
3486     if (CD) {
3487       CompleteDecl = GlobalDecl(CD, Ctor_Complete);
3488       BaseDecl = GlobalDecl(CD, Ctor_Base);
3489     } else {
3490       CompleteDecl = GlobalDecl(DD, Dtor_Complete);
3491       BaseDecl = GlobalDecl(DD, Dtor_Base);
3492     }
3493
3494     if (CGType == StructorCodegen::Alias || CGType == StructorCodegen::COMDAT) {
3495       emitConstructorDestructorAlias(CGM, CompleteDecl, BaseDecl);
3496       return;
3497     }
3498
3499     if (CGType == StructorCodegen::RAUW) {
3500       StringRef MangledName = CGM.getMangledName(CompleteDecl);
3501       auto *Aliasee = CGM.GetAddrOfGlobal(BaseDecl);
3502       CGM.addReplacement(MangledName, Aliasee);
3503       return;
3504     }
3505   }
3506
3507   // The base destructor is equivalent to the base destructor of its
3508   // base class if there is exactly one non-virtual base class with a
3509   // non-trivial destructor, there are no fields with a non-trivial
3510   // destructor, and the body of the destructor is trivial.
3511   if (DD && Type == StructorType::Base && CGType != StructorCodegen::COMDAT &&
3512       !CGM.TryEmitBaseDestructorAsAlias(DD))
3513     return;
3514
3515   llvm::Function *Fn = CGM.codegenCXXStructor(MD, Type);
3516
3517   if (CGType == StructorCodegen::COMDAT) {
3518     SmallString<256> Buffer;
3519     llvm::raw_svector_ostream Out(Buffer);
3520     if (DD)
3521       getMangleContext().mangleCXXDtorComdat(DD, Out);
3522     else
3523       getMangleContext().mangleCXXCtorComdat(CD, Out);
3524     llvm::Comdat *C = CGM.getModule().getOrInsertComdat(Out.str());
3525     Fn->setComdat(C);
3526   } else {
3527     CGM.maybeSetTrivialComdat(*MD, *Fn);
3528   }
3529 }
3530
3531 static llvm::Constant *getBeginCatchFn(CodeGenModule &CGM) {
3532   // void *__cxa_begin_catch(void*);
3533   llvm::FunctionType *FTy = llvm::FunctionType::get(
3534       CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3535
3536   return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch");
3537 }
3538
3539 static llvm::Constant *getEndCatchFn(CodeGenModule &CGM) {
3540   // void __cxa_end_catch();
3541   llvm::FunctionType *FTy =
3542       llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
3543
3544   return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch");
3545 }
3546
3547 static llvm::Constant *getGetExceptionPtrFn(CodeGenModule &CGM) {
3548   // void *__cxa_get_exception_ptr(void*);
3549   llvm::FunctionType *FTy = llvm::FunctionType::get(
3550       CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3551
3552   return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr");
3553 }
3554
3555 namespace {
3556   /// A cleanup to call __cxa_end_catch.  In many cases, the caught
3557   /// exception type lets us state definitively that the thrown exception
3558   /// type does not have a destructor.  In particular:
3559   ///   - Catch-alls tell us nothing, so we have to conservatively
3560   ///     assume that the thrown exception might have a destructor.
3561   ///   - Catches by reference behave according to their base types.
3562   ///   - Catches of non-record types will only trigger for exceptions
3563   ///     of non-record types, which never have destructors.
3564   ///   - Catches of record types can trigger for arbitrary subclasses
3565   ///     of the caught type, so we have to assume the actual thrown
3566   ///     exception type might have a throwing destructor, even if the
3567   ///     caught type's destructor is trivial or nothrow.
3568   struct CallEndCatch final : EHScopeStack::Cleanup {
3569     CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {}
3570     bool MightThrow;
3571
3572     void Emit(CodeGenFunction &CGF, Flags flags) override {
3573       if (!MightThrow) {
3574         CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM));
3575         return;
3576       }
3577
3578       CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM));
3579     }
3580   };
3581 }
3582
3583 /// Emits a call to __cxa_begin_catch and enters a cleanup to call
3584 /// __cxa_end_catch.
3585 ///
3586 /// \param EndMightThrow - true if __cxa_end_catch might throw
3587 static llvm::Value *CallBeginCatch(CodeGenFunction &CGF,
3588                                    llvm::Value *Exn,
3589                                    bool EndMightThrow) {
3590   llvm::CallInst *call =
3591     CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn);
3592
3593   CGF.EHStack.pushCleanup<CallEndCatch>(NormalAndEHCleanup, EndMightThrow);
3594
3595   return call;
3596 }
3597
3598 /// A "special initializer" callback for initializing a catch
3599 /// parameter during catch initialization.
3600 static void InitCatchParam(CodeGenFunction &CGF,
3601                            const VarDecl &CatchParam,
3602                            Address ParamAddr,
3603                            SourceLocation Loc) {
3604   // Load the exception from where the landing pad saved it.
3605   llvm::Value *Exn = CGF.getExceptionFromSlot();
3606
3607   CanQualType CatchType =
3608     CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
3609   llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
3610
3611   // If we're catching by reference, we can just cast the object
3612   // pointer to the appropriate pointer.
3613   if (isa<ReferenceType>(CatchType)) {
3614     QualType CaughtType = cast<ReferenceType>(CatchType)->getPointeeType();
3615     bool EndCatchMightThrow = CaughtType->isRecordType();
3616
3617     // __cxa_begin_catch returns the adjusted object pointer.
3618     llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
3619
3620     // We have no way to tell the personality function that we're
3621     // catching by reference, so if we're catching a pointer,
3622     // __cxa_begin_catch will actually return that pointer by value.
3623     if (const PointerType *PT = dyn_cast<PointerType>(CaughtType)) {
3624       QualType PointeeType = PT->getPointeeType();
3625
3626       // When catching by reference, generally we should just ignore
3627       // this by-value pointer and use the exception object instead.
3628       if (!PointeeType->isRecordType()) {
3629
3630         // Exn points to the struct _Unwind_Exception header, which
3631         // we have to skip past in order to reach the exception data.
3632         unsigned HeaderSize =
3633           CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException();
3634         AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize);
3635
3636       // However, if we're catching a pointer-to-record type that won't
3637       // work, because the personality function might have adjusted
3638       // the pointer.  There's actually no way for us to fully satisfy
3639       // the language/ABI contract here:  we can't use Exn because it
3640       // might have the wrong adjustment, but we can't use the by-value
3641       // pointer because it's off by a level of abstraction.
3642       //
3643       // The current solution is to dump the adjusted pointer into an
3644       // alloca, which breaks language semantics (because changing the
3645       // pointer doesn't change the exception) but at least works.
3646       // The better solution would be to filter out non-exact matches
3647       // and rethrow them, but this is tricky because the rethrow
3648       // really needs to be catchable by other sites at this landing
3649       // pad.  The best solution is to fix the personality function.
3650       } else {
3651         // Pull the pointer for the reference type off.
3652         llvm::Type *PtrTy =
3653           cast<llvm::PointerType>(LLVMCatchTy)->getElementType();
3654
3655         // Create the temporary and write the adjusted pointer into it.
3656         Address ExnPtrTmp =
3657           CGF.CreateTempAlloca(PtrTy, CGF.getPointerAlign(), "exn.byref.tmp");
3658         llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
3659         CGF.Builder.CreateStore(Casted, ExnPtrTmp);
3660
3661         // Bind the reference to the temporary.
3662         AdjustedExn = ExnPtrTmp.getPointer();
3663       }
3664     }
3665
3666     llvm::Value *ExnCast =
3667       CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
3668     CGF.Builder.CreateStore(ExnCast, ParamAddr);
3669     return;
3670   }
3671
3672   // Scalars and complexes.
3673   TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
3674   if (TEK != TEK_Aggregate) {
3675     llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
3676
3677     // If the catch type is a pointer type, __cxa_begin_catch returns
3678     // the pointer by value.
3679     if (CatchType->hasPointerRepresentation()) {
3680       llvm::Value *CastExn =
3681         CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
3682
3683       switch (CatchType.getQualifiers().getObjCLifetime()) {
3684       case Qualifiers::OCL_Strong:
3685         CastExn = CGF.EmitARCRetainNonBlock(CastExn);
3686         // fallthrough
3687
3688       case Qualifiers::OCL_None:
3689       case Qualifiers::OCL_ExplicitNone:
3690       case Qualifiers::OCL_Autoreleasing:
3691         CGF.Builder.CreateStore(CastExn, ParamAddr);
3692         return;
3693
3694       case Qualifiers::OCL_Weak:
3695         CGF.EmitARCInitWeak(ParamAddr, CastExn);
3696         return;
3697       }
3698       llvm_unreachable("bad ownership qualifier!");
3699     }
3700
3701     // Otherwise, it returns a pointer into the exception object.
3702
3703     llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
3704     llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
3705
3706     LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType);
3707     LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType);
3708     switch (TEK) {
3709     case TEK_Complex:
3710       CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV,
3711                              /*init*/ true);
3712       return;
3713     case TEK_Scalar: {
3714       llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc);
3715       CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
3716       return;
3717     }
3718     case TEK_Aggregate:
3719       llvm_unreachable("evaluation kind filtered out!");
3720     }
3721     llvm_unreachable("bad evaluation kind");
3722   }
3723
3724   assert(isa<RecordType>(CatchType) && "unexpected catch type!");
3725   auto catchRD = CatchType->getAsCXXRecordDecl();
3726   CharUnits caughtExnAlignment = CGF.CGM.getClassPointerAlignment(catchRD);
3727
3728   llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
3729
3730   // Check for a copy expression.  If we don't have a copy expression,
3731   // that means a trivial copy is okay.
3732   const Expr *copyExpr = CatchParam.getInit();
3733   if (!copyExpr) {
3734     llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
3735     Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
3736                         caughtExnAlignment);
3737     CGF.EmitAggregateCopy(ParamAddr, adjustedExn, CatchType);
3738     return;
3739   }
3740
3741   // We have to call __cxa_get_exception_ptr to get the adjusted
3742   // pointer before copying.
3743   llvm::CallInst *rawAdjustedExn =
3744     CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn);
3745
3746   // Cast that to the appropriate type.
3747   Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
3748                       caughtExnAlignment);
3749
3750   // The copy expression is defined in terms of an OpaqueValueExpr.
3751   // Find it and map it to the adjusted expression.
3752   CodeGenFunction::OpaqueValueMapping
3753     opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
3754            CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
3755
3756   // Call the copy ctor in a terminate scope.
3757   CGF.EHStack.pushTerminate();
3758
3759   // Perform the copy construction.
3760   CGF.EmitAggExpr(copyExpr,
3761                   AggValueSlot::forAddr(ParamAddr, Qualifiers(),
3762                                         AggValueSlot::IsNotDestructed,
3763                                         AggValueSlot::DoesNotNeedGCBarriers,
3764                                         AggValueSlot::IsNotAliased));
3765
3766   // Leave the terminate scope.
3767   CGF.EHStack.popTerminate();
3768
3769   // Undo the opaque value mapping.
3770   opaque.pop();
3771
3772   // Finally we can call __cxa_begin_catch.
3773   CallBeginCatch(CGF, Exn, true);
3774 }
3775
3776 /// Begins a catch statement by initializing the catch variable and
3777 /// calling __cxa_begin_catch.
3778 void ItaniumCXXABI::emitBeginCatch(CodeGenFunction &CGF,
3779                                    const CXXCatchStmt *S) {
3780   // We have to be very careful with the ordering of cleanups here:
3781   //   C++ [except.throw]p4:
3782   //     The destruction [of the exception temporary] occurs
3783   //     immediately after the destruction of the object declared in
3784   //     the exception-declaration in the handler.
3785   //
3786   // So the precise ordering is:
3787   //   1.  Construct catch variable.
3788   //   2.  __cxa_begin_catch
3789   //   3.  Enter __cxa_end_catch cleanup
3790   //   4.  Enter dtor cleanup
3791   //
3792   // We do this by using a slightly abnormal initialization process.
3793   // Delegation sequence:
3794   //   - ExitCXXTryStmt opens a RunCleanupsScope
3795   //     - EmitAutoVarAlloca creates the variable and debug info
3796   //       - InitCatchParam initializes the variable from the exception
3797   //       - CallBeginCatch calls __cxa_begin_catch
3798   //       - CallBeginCatch enters the __cxa_end_catch cleanup
3799   //     - EmitAutoVarCleanups enters the variable destructor cleanup
3800   //   - EmitCXXTryStmt emits the code for the catch body
3801   //   - EmitCXXTryStmt close the RunCleanupsScope
3802
3803   VarDecl *CatchParam = S->getExceptionDecl();
3804   if (!CatchParam) {
3805     llvm::Value *Exn = CGF.getExceptionFromSlot();
3806     CallBeginCatch(CGF, Exn, true);
3807     return;
3808   }
3809
3810   // Emit the local.
3811   CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
3812   InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getLocStart());
3813   CGF.EmitAutoVarCleanups(var);
3814 }
3815
3816 /// Get or define the following function:
3817 ///   void @__clang_call_terminate(i8* %exn) nounwind noreturn
3818 /// This code is used only in C++.
3819 static llvm::Constant *getClangCallTerminateFn(CodeGenModule &CGM) {
3820   llvm::FunctionType *fnTy =
3821     llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3822   llvm::Constant *fnRef =
3823     CGM.CreateRuntimeFunction(fnTy, "__clang_call_terminate");
3824
3825   llvm::Function *fn = dyn_cast<llvm::Function>(fnRef);
3826   if (fn && fn->empty()) {
3827     fn->setDoesNotThrow();
3828     fn->setDoesNotReturn();
3829
3830     // What we really want is to massively penalize inlining without
3831     // forbidding it completely.  The difference between that and
3832     // 'noinline' is negligible.
3833     fn->addFnAttr(llvm::Attribute::NoInline);
3834
3835     // Allow this function to be shared across translation units, but
3836     // we don't want it to turn into an exported symbol.
3837     fn->setLinkage(llvm::Function::LinkOnceODRLinkage);
3838     fn->setVisibility(llvm::Function::HiddenVisibility);
3839     if (CGM.supportsCOMDAT())
3840       fn->setComdat(CGM.getModule().getOrInsertComdat(fn->getName()));
3841
3842     // Set up the function.
3843     llvm::BasicBlock *entry =
3844       llvm::BasicBlock::Create(CGM.getLLVMContext(), "", fn);
3845     CGBuilderTy builder(CGM, entry);
3846
3847     // Pull the exception pointer out of the parameter list.
3848     llvm::Value *exn = &*fn->arg_begin();
3849
3850     // Call __cxa_begin_catch(exn).
3851     llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
3852     catchCall->setDoesNotThrow();
3853     catchCall->setCallingConv(CGM.getRuntimeCC());
3854
3855     // Call std::terminate().
3856     llvm::CallInst *termCall = builder.CreateCall(CGM.getTerminateFn());
3857     termCall->setDoesNotThrow();
3858     termCall->setDoesNotReturn();
3859     termCall->setCallingConv(CGM.getRuntimeCC());
3860
3861     // std::terminate cannot return.
3862     builder.CreateUnreachable();
3863   }
3864
3865   return fnRef;
3866 }
3867
3868 llvm::CallInst *
3869 ItaniumCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
3870                                                    llvm::Value *Exn) {
3871   // In C++, we want to call __cxa_begin_catch() before terminating.
3872   if (Exn) {
3873     assert(CGF.CGM.getLangOpts().CPlusPlus);
3874     return CGF.EmitNounwindRuntimeCall(getClangCallTerminateFn(CGF.CGM), Exn);
3875   }
3876   return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
3877 }