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