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