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/Intrinsics.h"
  29 #include "llvm/DataLayout.h"
  30 #include "llvm/Value.h"
  31
  32 using namespace clang;
  33 using namespace CodeGen;
  34
  35 namespace {
  36 class ItaniumCXXABI : public CodeGen::CGCXXABI {
  37 private:
  38   llvm::IntegerType *PtrDiffTy;
  39 protected:
  40   bool IsARM;
  41
  42   // It's a little silly for us to cache this.
  43   llvm::IntegerType *getPtrDiffTy() {
  44     if (!PtrDiffTy) {
  45       QualType T = getContext().getPointerDiffType();
  46       llvm::Type *Ty = CGM.getTypes().ConvertType(T);
  47       PtrDiffTy = cast<llvm::IntegerType>(Ty);
  48     }
  49     return PtrDiffTy;
  50   }
  51
  52 public:
  53   ItaniumCXXABI(CodeGen::CodeGenModule &CGM, bool IsARM = false) :
  54     CGCXXABI(CGM), PtrDiffTy(0), IsARM(IsARM) { }
  55
  56   bool isZeroInitializable(const MemberPointerType *MPT);
  57
  58   llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT);
  59
  60   llvm::Value *EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
  61                                                llvm::Value *&This,
  62                                                llvm::Value *MemFnPtr,
  63                                                const MemberPointerType *MPT);
  64
  65   llvm::Value *EmitMemberDataPointerAddress(CodeGenFunction &CGF,
  66                                             llvm::Value *Base,
  67                                             llvm::Value *MemPtr,
  68                                             const MemberPointerType *MPT);
  69
  70   llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
  71                                            const CastExpr *E,
  72                                            llvm::Value *Src);
  73   llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
  74                                               llvm::Constant *Src);
  75
  76   llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);
  77
  78   llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD);
  79   llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
  80                                         CharUnits offset);
  81   llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT);
  82   llvm::Constant *BuildMemberPointer(const CXXMethodDecl *MD,
  83                                      CharUnits ThisAdjustment);
  84
  85   llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
  86                                            llvm::Value *L,
  87                                            llvm::Value *R,
  88                                            const MemberPointerType *MPT,
  89                                            bool Inequality);
  90
  91   llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
  92                                           llvm::Value *Addr,
  93                                           const MemberPointerType *MPT);
  94
  95   llvm::Value *adjustToCompleteObject(CodeGenFunction &CGF,
  96                                       llvm::Value *ptr,
  97                                       QualType type);
  98
  99   void BuildConstructorSignature(const CXXConstructorDecl *Ctor,
 100                                  CXXCtorType T,
 101                                  CanQualType &ResTy,
 102                                  SmallVectorImpl<CanQualType> &ArgTys);
 103
 104   void BuildDestructorSignature(const CXXDestructorDecl *Dtor,
 105                                 CXXDtorType T,
 106                                 CanQualType &ResTy,
 107                                 SmallVectorImpl<CanQualType> &ArgTys);
 108
 109   void BuildInstanceFunctionParams(CodeGenFunction &CGF,
 110                                    QualType &ResTy,
 111                                    FunctionArgList &Params);
 112
 113   void EmitInstanceFunctionProlog(CodeGenFunction &CGF);
 114
 115   StringRef GetPureVirtualCallName() { return "__cxa_pure_virtual"; }
 116   StringRef GetDeletedVirtualCallName() { return "__cxa_deleted_virtual"; }
 117
 118   CharUnits getArrayCookieSizeImpl(QualType elementType);
 119   llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
 120                                      llvm::Value *NewPtr,
 121                                      llvm::Value *NumElements,
 122                                      const CXXNewExpr *expr,
 123                                      QualType ElementType);
 124   llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
 125                                    llvm::Value *allocPtr,
 126                                    CharUnits cookieSize);
 127
 128   void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
 129                        llvm::GlobalVariable *DeclPtr, bool PerformInit);
 130   void registerGlobalDtor(CodeGenFunction &CGF, llvm::Constant *dtor,
 131                           llvm::Constant *addr);
 132
 133   void EmitVTables(const CXXRecordDecl *Class);
 134 };
 135
 136 class ARMCXXABI : public ItaniumCXXABI {
 137 public:
 138   ARMCXXABI(CodeGen::CodeGenModule &CGM) : ItaniumCXXABI(CGM, /*ARM*/ true) {}
 139
 140   void BuildConstructorSignature(const CXXConstructorDecl *Ctor,
 141                                  CXXCtorType T,
 142                                  CanQualType &ResTy,
 143                                  SmallVectorImpl<CanQualType> &ArgTys);
 144
 145   void BuildDestructorSignature(const CXXDestructorDecl *Dtor,
 146                                 CXXDtorType T,
 147                                 CanQualType &ResTy,
 148                                 SmallVectorImpl<CanQualType> &ArgTys);
 149
 150   void BuildInstanceFunctionParams(CodeGenFunction &CGF,
 151                                    QualType &ResTy,
 152                                    FunctionArgList &Params);
 153
 154   void EmitInstanceFunctionProlog(CodeGenFunction &CGF);
 155
 156   void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResTy);
 157
 158   CharUnits getArrayCookieSizeImpl(QualType elementType);
 159   llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF,
 160                                      llvm::Value *NewPtr,
 161                                      llvm::Value *NumElements,
 162                                      const CXXNewExpr *expr,
 163                                      QualType ElementType);
 164   llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, llvm::Value *allocPtr,
 165                                    CharUnits cookieSize);
 166
 167 private:
 168   /// \brief Returns true if the given instance method is one of the
 169   /// kinds that the ARM ABI says returns 'this'.
 170   static bool HasThisReturn(GlobalDecl GD) {
 171     const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 172     return ((isa<CXXDestructorDecl>(MD) && GD.getDtorType() != Dtor_Deleting) ||
 173             (isa<CXXConstructorDecl>(MD)));
 174   }
 175 };
 176 }
 177
 178 CodeGen::CGCXXABI *CodeGen::CreateItaniumCXXABI(CodeGenModule &CGM) {
 179   return new ItaniumCXXABI(CGM);
 180 }
 181
 182 CodeGen::CGCXXABI *CodeGen::CreateARMCXXABI(CodeGenModule &CGM) {
 183   return new ARMCXXABI(CGM);
 184 }
 185
 186 llvm::Type *
 187 ItaniumCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
 188   if (MPT->isMemberDataPointer())
 189     return getPtrDiffTy();
 190   return llvm::StructType::get(getPtrDiffTy(), getPtrDiffTy(), NULL);
 191 }
 192
 193 /// In the Itanium and ARM ABIs, method pointers have the form:
 194 ///   struct { ptrdiff_t ptr; ptrdiff_t adj; } memptr;
 195 ///
 196 /// In the Itanium ABI:
 197 ///  - method pointers are virtual if (memptr.ptr & 1) is nonzero
 198 ///  - the this-adjustment is (memptr.adj)
 199 ///  - the virtual offset is (memptr.ptr - 1)
 200 ///
 201 /// In the ARM ABI:
 202 ///  - method pointers are virtual if (memptr.adj & 1) is nonzero
 203 ///  - the this-adjustment is (memptr.adj >> 1)
 204 ///  - the virtual offset is (memptr.ptr)
 205 /// ARM uses 'adj' for the virtual flag because Thumb functions
 206 /// may be only single-byte aligned.
 207 ///
 208 /// If the member is virtual, the adjusted 'this' pointer points
 209 /// to a vtable pointer from which the virtual offset is applied.
 210 ///
 211 /// If the member is non-virtual, memptr.ptr is the address of
 212 /// the function to call.
 213 llvm::Value *
 214 ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
 215                                                llvm::Value *&This,
 216                                                llvm::Value *MemFnPtr,
 217                                                const MemberPointerType *MPT) {
 218   CGBuilderTy &Builder = CGF.Builder;
 219
 220   const FunctionProtoType *FPT =
 221     MPT->getPointeeType()->getAs<FunctionProtoType>();
 222   const CXXRecordDecl *RD =
 223     cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
 224
 225   llvm::FunctionType *FTy =
 226     CGM.getTypes().GetFunctionType(
 227       CGM.getTypes().arrangeCXXMethodType(RD, FPT));
 228
 229   llvm::IntegerType *ptrdiff = getPtrDiffTy();
 230   llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(ptrdiff, 1);
 231
 232   llvm::BasicBlock *FnVirtual = CGF.createBasicBlock("memptr.virtual");
 233   llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
 234   llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
 235
 236   // Extract memptr.adj, which is in the second field.
 237   llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1, "memptr.adj");
 238
 239   // Compute the true adjustment.
 240   llvm::Value *Adj = RawAdj;
 241   if (IsARM)
 242     Adj = Builder.CreateAShr(Adj, ptrdiff_1, "memptr.adj.shifted");
 243
 244   // Apply the adjustment and cast back to the original struct type
 245   // for consistency.
 246   llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
 247   Ptr = Builder.CreateInBoundsGEP(Ptr, Adj);
 248   This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
 249
 250   // Load the function pointer.
 251   llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0, "memptr.ptr");
 252
 253   // If the LSB in the function pointer is 1, the function pointer points to
 254   // a virtual function.
 255   llvm::Value *IsVirtual;
 256   if (IsARM)
 257     IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1);
 258   else
 259     IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1);
 260   IsVirtual = Builder.CreateIsNotNull(IsVirtual, "memptr.isvirtual");
 261   Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
 262
 263   // In the virtual path, the adjustment left 'This' pointing to the
 264   // vtable of the correct base subobject.  The "function pointer" is an
 265   // offset within the vtable (+1 for the virtual flag on non-ARM).
 266   CGF.EmitBlock(FnVirtual);
 267
 268   // Cast the adjusted this to a pointer to vtable pointer and load.
 269   llvm::Type *VTableTy = Builder.getInt8PtrTy();
 270   llvm::Value *VTable = Builder.CreateBitCast(This, VTableTy->getPointerTo());
 271   VTable = Builder.CreateLoad(VTable, "memptr.vtable");
 272
 273   // Apply the offset.
 274   llvm::Value *VTableOffset = FnAsInt;
 275   if (!IsARM) VTableOffset = Builder.CreateSub(VTableOffset, ptrdiff_1);
 276   VTable = Builder.CreateGEP(VTable, VTableOffset);
 277
 278   // Load the virtual function to call.
 279   VTable = Builder.CreateBitCast(VTable, FTy->getPointerTo()->getPointerTo());
 280   llvm::Value *VirtualFn = Builder.CreateLoad(VTable, "memptr.virtualfn");
 281   CGF.EmitBranch(FnEnd);
 282
 283   // In the non-virtual path, the function pointer is actually a
 284   // function pointer.
 285   CGF.EmitBlock(FnNonVirtual);
 286   llvm::Value *NonVirtualFn =
 287     Builder.CreateIntToPtr(FnAsInt, FTy->getPointerTo(), "memptr.nonvirtualfn");
 288
 289   // We're done.
 290   CGF.EmitBlock(FnEnd);
 291   llvm::PHINode *Callee = Builder.CreatePHI(FTy->getPointerTo(), 2);
 292   Callee->addIncoming(VirtualFn, FnVirtual);
 293   Callee->addIncoming(NonVirtualFn, FnNonVirtual);
 294   return Callee;
 295 }
 296
 297 /// Compute an l-value by applying the given pointer-to-member to a
 298 /// base object.
 299 llvm::Value *ItaniumCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF,
 300                                                          llvm::Value *Base,
 301                                                          llvm::Value *MemPtr,
 302                                            const MemberPointerType *MPT) {
 303   assert(MemPtr->getType() == getPtrDiffTy());
 304
 305   CGBuilderTy &Builder = CGF.Builder;
 306
 307   unsigned AS = Base->getType()->getPointerAddressSpace();
 308
 309   // Cast to char*.
 310   Base = Builder.CreateBitCast(Base, Builder.getInt8Ty()->getPointerTo(AS));
 311
 312   // Apply the offset, which we assume is non-null.
 313   llvm::Value *Addr = Builder.CreateInBoundsGEP(Base, MemPtr, "memptr.offset");
 314
 315   // Cast the address to the appropriate pointer type, adopting the
 316   // address space of the base pointer.
 317   llvm::Type *PType
 318     = CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS);
 319   return Builder.CreateBitCast(Addr, PType);
 320 }
 321
 322 /// Perform a bitcast, derived-to-base, or base-to-derived member pointer
 323 /// conversion.
 324 ///
 325 /// Bitcast conversions are always a no-op under Itanium.
 326 ///
 327 /// Obligatory offset/adjustment diagram:
 328 ///         <-- offset -->          <-- adjustment -->
 329 ///   |--------------------------|----------------------|--------------------|
 330 ///   ^Derived address point     ^Base address point    ^Member address point
 331 ///
 332 /// So when converting a base member pointer to a derived member pointer,
 333 /// we add the offset to the adjustment because the address point has
 334 /// decreased;  and conversely, when converting a derived MP to a base MP
 335 /// we subtract the offset from the adjustment because the address point
 336 /// has increased.
 337 ///
 338 /// The standard forbids (at compile time) conversion to and from
 339 /// virtual bases, which is why we don't have to consider them here.
 340 ///
 341 /// The standard forbids (at run time) casting a derived MP to a base
 342 /// MP when the derived MP does not point to a member of the base.
 343 /// This is why -1 is a reasonable choice for null data member
 344 /// pointers.
 345 llvm::Value *
 346 ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
 347                                            const CastExpr *E,
 348                                            llvm::Value *src) {
 349   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
 350          E->getCastKind() == CK_BaseToDerivedMemberPointer ||
 351          E->getCastKind() == CK_ReinterpretMemberPointer);
 352
 353   // Under Itanium, reinterprets don't require any additional processing.
 354   if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
 355
 356   // Use constant emission if we can.
 357   if (isa<llvm::Constant>(src))
 358     return EmitMemberPointerConversion(E, cast<llvm::Constant>(src));
 359
 360   llvm::Constant *adj = getMemberPointerAdjustment(E);
 361   if (!adj) return src;
 362
 363   CGBuilderTy &Builder = CGF.Builder;
 364   bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
 365
 366   const MemberPointerType *destTy =
 367     E->getType()->castAs<MemberPointerType>();
 368
 369   // For member data pointers, this is just a matter of adding the
 370   // offset if the source is non-null.
 371   if (destTy->isMemberDataPointer()) {
 372     llvm::Value *dst;
 373     if (isDerivedToBase)
 374       dst = Builder.CreateNSWSub(src, adj, "adj");
 375     else
 376       dst = Builder.CreateNSWAdd(src, adj, "adj");
 377
 378     // Null check.
 379     llvm::Value *null = llvm::Constant::getAllOnesValue(src->getType());
 380     llvm::Value *isNull = Builder.CreateICmpEQ(src, null, "memptr.isnull");
 381     return Builder.CreateSelect(isNull, src, dst);
 382   }
 383
 384   // The this-adjustment is left-shifted by 1 on ARM.
 385   if (IsARM) {
 386     uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
 387     offset <<= 1;
 388     adj = llvm::ConstantInt::get(adj->getType(), offset);
 389   }
 390
 391   llvm::Value *srcAdj = Builder.CreateExtractValue(src, 1, "src.adj");
 392   llvm::Value *dstAdj;
 393   if (isDerivedToBase)
 394     dstAdj = Builder.CreateNSWSub(srcAdj, adj, "adj");
 395   else
 396     dstAdj = Builder.CreateNSWAdd(srcAdj, adj, "adj");
 397
 398   return Builder.CreateInsertValue(src, dstAdj, 1);
 399 }
 400
 401 llvm::Constant *
 402 ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
 403                                            llvm::Constant *src) {
 404   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
 405          E->getCastKind() == CK_BaseToDerivedMemberPointer ||
 406          E->getCastKind() == CK_ReinterpretMemberPointer);
 407
 408   // Under Itanium, reinterprets don't require any additional processing.
 409   if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
 410
 411   // If the adjustment is trivial, we don't need to do anything.
 412   llvm::Constant *adj = getMemberPointerAdjustment(E);
 413   if (!adj) return src;
 414
 415   bool isDerivedToBase = (E->getCastKind() == CK_DerivedToBaseMemberPointer);
 416
 417   const MemberPointerType *destTy =
 418     E->getType()->castAs<MemberPointerType>();
 419
 420   // For member data pointers, this is just a matter of adding the
 421   // offset if the source is non-null.
 422   if (destTy->isMemberDataPointer()) {
 423     // null maps to null.
 424     if (src->isAllOnesValue()) return src;
 425
 426     if (isDerivedToBase)
 427       return llvm::ConstantExpr::getNSWSub(src, adj);
 428     else
 429       return llvm::ConstantExpr::getNSWAdd(src, adj);
 430   }
 431
 432   // The this-adjustment is left-shifted by 1 on ARM.
 433   if (IsARM) {
 434     uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
 435     offset <<= 1;
 436     adj = llvm::ConstantInt::get(adj->getType(), offset);
 437   }
 438
 439   llvm::Constant *srcAdj = llvm::ConstantExpr::getExtractValue(src, 1);
 440   llvm::Constant *dstAdj;
 441   if (isDerivedToBase)
 442     dstAdj = llvm::ConstantExpr::getNSWSub(srcAdj, adj);
 443   else
 444     dstAdj = llvm::ConstantExpr::getNSWAdd(srcAdj, adj);
 445
 446   return llvm::ConstantExpr::getInsertValue(src, dstAdj, 1);
 447 }
 448
 449 llvm::Constant *
 450 ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
 451   llvm::Type *ptrdiff_t = getPtrDiffTy();
 452
 453   // Itanium C++ ABI 2.3:
 454   //   A NULL pointer is represented as -1.
 455   if (MPT->isMemberDataPointer())
 456     return llvm::ConstantInt::get(ptrdiff_t, -1ULL, /*isSigned=*/true);
 457
 458   llvm::Constant *Zero = llvm::ConstantInt::get(ptrdiff_t, 0);
 459   llvm::Constant *Values[2] = { Zero, Zero };
 460   return llvm::ConstantStruct::getAnon(Values);
 461 }
 462
 463 llvm::Constant *
 464 ItaniumCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
 465                                      CharUnits offset) {
 466   // Itanium C++ ABI 2.3:
 467   //   A pointer to data member is an offset from the base address of
 468   //   the class object containing it, represented as a ptrdiff_t
 469   return llvm::ConstantInt::get(getPtrDiffTy(), offset.getQuantity());
 470 }
 471
 472 llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const CXXMethodDecl *MD) {
 473   return BuildMemberPointer(MD, CharUnits::Zero());
 474 }
 475
 476 llvm::Constant *ItaniumCXXABI::BuildMemberPointer(const CXXMethodDecl *MD,
 477                                                   CharUnits ThisAdjustment) {
 478   assert(MD->isInstance() && "Member function must not be static!");
 479   MD = MD->getCanonicalDecl();
 480
 481   CodeGenTypes &Types = CGM.getTypes();
 482   llvm::Type *ptrdiff_t = getPtrDiffTy();
 483
 484   // Get the function pointer (or index if this is a virtual function).
 485   llvm::Constant *MemPtr[2];
 486   if (MD->isVirtual()) {
 487     uint64_t Index = CGM.getVTableContext().getMethodVTableIndex(MD);
 488
 489     const ASTContext &Context = getContext();
 490     CharUnits PointerWidth =
 491       Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
 492     uint64_t VTableOffset = (Index * PointerWidth.getQuantity());
 493
 494     if (IsARM) {
 495       // ARM C++ ABI 3.2.1:
 496       //   This ABI specifies that adj contains twice the this
 497       //   adjustment, plus 1 if the member function is virtual. The
 498       //   least significant bit of adj then makes exactly the same
 499       //   discrimination as the least significant bit of ptr does for
 500       //   Itanium.
 501       MemPtr[0] = llvm::ConstantInt::get(ptrdiff_t, VTableOffset);
 502       MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t,
 503                                          2 * ThisAdjustment.getQuantity() + 1);
 504     } else {
 505       // Itanium C++ ABI 2.3:
 506       //   For a virtual function, [the pointer field] is 1 plus the
 507       //   virtual table offset (in bytes) of the function,
 508       //   represented as a ptrdiff_t.
 509       MemPtr[0] = llvm::ConstantInt::get(ptrdiff_t, VTableOffset + 1);
 510       MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t,
 511                                          ThisAdjustment.getQuantity());
 512     }
 513   } else {
 514     const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
 515     llvm::Type *Ty;
 516     // Check whether the function has a computable LLVM signature.
 517     if (Types.isFuncTypeConvertible(FPT)) {
 518       // The function has a computable LLVM signature; use the correct type.
 519       Ty = Types.GetFunctionType(Types.arrangeCXXMethodDeclaration(MD));
 520     } else {
 521       // Use an arbitrary non-function type to tell GetAddrOfFunction that the
 522       // function type is incomplete.
 523       Ty = ptrdiff_t;
 524     }
 525     llvm::Constant *addr = CGM.GetAddrOfFunction(MD, Ty);
 526
 527     MemPtr[0] = llvm::ConstantExpr::getPtrToInt(addr, ptrdiff_t);
 528     MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, (IsARM ? 2 : 1) *
 529                                        ThisAdjustment.getQuantity());
 530   }
 531
 532   return llvm::ConstantStruct::getAnon(MemPtr);
 533 }
 534
 535 llvm::Constant *ItaniumCXXABI::EmitMemberPointer(const APValue &MP,
 536                                                  QualType MPType) {
 537   const MemberPointerType *MPT = MPType->castAs<MemberPointerType>();
 538   const ValueDecl *MPD = MP.getMemberPointerDecl();
 539   if (!MPD)
 540     return EmitNullMemberPointer(MPT);
 541
 542   // Compute the this-adjustment.
 543   CharUnits ThisAdjustment = CharUnits::Zero();
 544   ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
 545   bool DerivedMember = MP.isMemberPointerToDerivedMember();
 546   const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
 547   for (unsigned I = 0, N = Path.size(); I != N; ++I) {
 548     const CXXRecordDecl *Base = RD;
 549     const CXXRecordDecl *Derived = Path[I];
 550     if (DerivedMember)
 551       std::swap(Base, Derived);
 552     ThisAdjustment +=
 553       getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
 554     RD = Path[I];
 555   }
 556   if (DerivedMember)
 557     ThisAdjustment = -ThisAdjustment;
 558
 559   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MPD))
 560     return BuildMemberPointer(MD, ThisAdjustment);
 561
 562   CharUnits FieldOffset =
 563     getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD));
 564   return EmitMemberDataPointer(MPT, ThisAdjustment + FieldOffset);
 565 }
 566
 567 /// The comparison algorithm is pretty easy: the member pointers are
 568 /// the same if they're either bitwise identical *or* both null.
 569 ///
 570 /// ARM is different here only because null-ness is more complicated.
 571 llvm::Value *
 572 ItaniumCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
 573                                            llvm::Value *L,
 574                                            llvm::Value *R,
 575                                            const MemberPointerType *MPT,
 576                                            bool Inequality) {
 577   CGBuilderTy &Builder = CGF.Builder;
 578
 579   llvm::ICmpInst::Predicate Eq;
 580   llvm::Instruction::BinaryOps And, Or;
 581   if (Inequality) {
 582     Eq = llvm::ICmpInst::ICMP_NE;
 583     And = llvm::Instruction::Or;
 584     Or = llvm::Instruction::And;
 585   } else {
 586     Eq = llvm::ICmpInst::ICMP_EQ;
 587     And = llvm::Instruction::And;
 588     Or = llvm::Instruction::Or;
 589   }
 590
 591   // Member data pointers are easy because there's a unique null
 592   // value, so it just comes down to bitwise equality.
 593   if (MPT->isMemberDataPointer())
 594     return Builder.CreateICmp(Eq, L, R);
 595
 596   // For member function pointers, the tautologies are more complex.
 597   // The Itanium tautology is:
 598   //   (L == R) <==> (L.ptr == R.ptr && (L.ptr == 0 || L.adj == R.adj))
 599   // The ARM tautology is:
 600   //   (L == R) <==> (L.ptr == R.ptr &&
 601   //                  (L.adj == R.adj ||
 602   //                   (L.ptr == 0 && ((L.adj|R.adj) & 1) == 0)))
 603   // The inequality tautologies have exactly the same structure, except
 604   // applying De Morgan's laws.
 605
 606   llvm::Value *LPtr = Builder.CreateExtractValue(L, 0, "lhs.memptr.ptr");
 607   llvm::Value *RPtr = Builder.CreateExtractValue(R, 0, "rhs.memptr.ptr");
 608
 609   // This condition tests whether L.ptr == R.ptr.  This must always be
 610   // true for equality to hold.
 611   llvm::Value *PtrEq = Builder.CreateICmp(Eq, LPtr, RPtr, "cmp.ptr");
 612
 613   // This condition, together with the assumption that L.ptr == R.ptr,
 614   // tests whether the pointers are both null.  ARM imposes an extra
 615   // condition.
 616   llvm::Value *Zero = llvm::Constant::getNullValue(LPtr->getType());
 617   llvm::Value *EqZero = Builder.CreateICmp(Eq, LPtr, Zero, "cmp.ptr.null");
 618
 619   // This condition tests whether L.adj == R.adj.  If this isn't
 620   // true, the pointers are unequal unless they're both null.
 621   llvm::Value *LAdj = Builder.CreateExtractValue(L, 1, "lhs.memptr.adj");
 622   llvm::Value *RAdj = Builder.CreateExtractValue(R, 1, "rhs.memptr.adj");
 623   llvm::Value *AdjEq = Builder.CreateICmp(Eq, LAdj, RAdj, "cmp.adj");
 624
 625   // Null member function pointers on ARM clear the low bit of Adj,
 626   // so the zero condition has to check that neither low bit is set.
 627   if (IsARM) {
 628     llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1);
 629
 630     // Compute (l.adj | r.adj) & 1 and test it against zero.
 631     llvm::Value *OrAdj = Builder.CreateOr(LAdj, RAdj, "or.adj");
 632     llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One);
 633     llvm::Value *OrAdjAnd1EqZero = Builder.CreateICmp(Eq, OrAdjAnd1, Zero,
 634                                                       "cmp.or.adj");
 635     EqZero = Builder.CreateBinOp(And, EqZero, OrAdjAnd1EqZero);
 636   }
 637
 638   // Tie together all our conditions.
 639   llvm::Value *Result = Builder.CreateBinOp(Or, EqZero, AdjEq);
 640   Result = Builder.CreateBinOp(And, PtrEq, Result,
 641                                Inequality ? "memptr.ne" : "memptr.eq");
 642   return Result;
 643 }
 644
 645 llvm::Value *
 646 ItaniumCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
 647                                           llvm::Value *MemPtr,
 648                                           const MemberPointerType *MPT) {
 649   CGBuilderTy &Builder = CGF.Builder;
 650
 651   /// For member data pointers, this is just a check against -1.
 652   if (MPT->isMemberDataPointer()) {
 653     assert(MemPtr->getType() == getPtrDiffTy());
 654     llvm::Value *NegativeOne =
 655       llvm::Constant::getAllOnesValue(MemPtr->getType());
 656     return Builder.CreateICmpNE(MemPtr, NegativeOne, "memptr.tobool");
 657   }
 658
 659   // In Itanium, a member function pointer is not null if 'ptr' is not null.
 660   llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0, "memptr.ptr");
 661
 662   llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0);
 663   llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero, "memptr.tobool");
 664
 665   // On ARM, a member function pointer is also non-null if the low bit of 'adj'
 666   // (the virtual bit) is set.
 667   if (IsARM) {
 668     llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);
 669     llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1, "memptr.adj");
 670     llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit");
 671     llvm::Value *IsVirtual = Builder.CreateICmpNE(VirtualBit, Zero,
 672                                                   "memptr.isvirtual");
 673     Result = Builder.CreateOr(Result, IsVirtual);
 674   }
 675
 676   return Result;
 677 }
 678
 679 /// The Itanium ABI requires non-zero initialization only for data
 680 /// member pointers, for which '0' is a valid offset.
 681 bool ItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
 682   return MPT->getPointeeType()->isFunctionType();
 683 }
 684
 685 /// The Itanium ABI always places an offset to the complete object
 686 /// at entry -2 in the vtable.
 687 llvm::Value *ItaniumCXXABI::adjustToCompleteObject(CodeGenFunction &CGF,
 688                                                    llvm::Value *ptr,
 689                                                    QualType type) {
 690   // Grab the vtable pointer as an intptr_t*.
 691   llvm::Value *vtable = CGF.GetVTablePtr(ptr, CGF.IntPtrTy->getPointerTo());
 692
 693   // Track back to entry -2 and pull out the offset there.
 694   llvm::Value *offsetPtr =
 695     CGF.Builder.CreateConstInBoundsGEP1_64(vtable, -2, "complete-offset.ptr");
 696   llvm::LoadInst *offset = CGF.Builder.CreateLoad(offsetPtr);
 697   offset->setAlignment(CGF.PointerAlignInBytes);
 698
 699   // Apply the offset.
 700   ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8PtrTy);
 701   return CGF.Builder.CreateInBoundsGEP(ptr, offset);
 702 }
 703
 704 /// The generic ABI passes 'this', plus a VTT if it's initializing a
 705 /// base subobject.
 706 void ItaniumCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor,
 707                                               CXXCtorType Type,
 708                                               CanQualType &ResTy,
 709                                 SmallVectorImpl<CanQualType> &ArgTys) {
 710   ASTContext &Context = getContext();
 711
 712   // 'this' is already there.
 713
 714   // Check if we need to add a VTT parameter (which has type void **).
 715   if (Type == Ctor_Base && Ctor->getParent()->getNumVBases() != 0)
 716     ArgTys.push_back(Context.getPointerType(Context.VoidPtrTy));
 717 }
 718
 719 /// The ARM ABI does the same as the Itanium ABI, but returns 'this'.
 720 void ARMCXXABI::BuildConstructorSignature(const CXXConstructorDecl *Ctor,
 721                                           CXXCtorType Type,
 722                                           CanQualType &ResTy,
 723                                 SmallVectorImpl<CanQualType> &ArgTys) {
 724   ItaniumCXXABI::BuildConstructorSignature(Ctor, Type, ResTy, ArgTys);
 725   ResTy = ArgTys[0];
 726 }
 727
 728 /// The generic ABI passes 'this', plus a VTT if it's destroying a
 729 /// base subobject.
 730 void ItaniumCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor,
 731                                              CXXDtorType Type,
 732                                              CanQualType &ResTy,
 733                                 SmallVectorImpl<CanQualType> &ArgTys) {
 734   ASTContext &Context = getContext();
 735
 736   // 'this' is already there.
 737
 738   // Check if we need to add a VTT parameter (which has type void **).
 739   if (Type == Dtor_Base && Dtor->getParent()->getNumVBases() != 0)
 740     ArgTys.push_back(Context.getPointerType(Context.VoidPtrTy));
 741 }
 742
 743 /// The ARM ABI does the same as the Itanium ABI, but returns 'this'
 744 /// for non-deleting destructors.
 745 void ARMCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor,
 746                                          CXXDtorType Type,
 747                                          CanQualType &ResTy,
 748                                 SmallVectorImpl<CanQualType> &ArgTys) {
 749   ItaniumCXXABI::BuildDestructorSignature(Dtor, Type, ResTy, ArgTys);
 750
 751   if (Type != Dtor_Deleting)
 752     ResTy = ArgTys[0];
 753 }
 754
 755 void ItaniumCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF,
 756                                                 QualType &ResTy,
 757                                                 FunctionArgList &Params) {
 758   /// Create the 'this' variable.
 759   BuildThisParam(CGF, Params);
 760
 761   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
 762   assert(MD->isInstance());
 763
 764   // Check if we need a VTT parameter as well.
 765   if (CodeGenVTables::needsVTTParameter(CGF.CurGD)) {
 766     ASTContext &Context = getContext();
 767
 768     // FIXME: avoid the fake decl
 769     QualType T = Context.getPointerType(Context.VoidPtrTy);
 770     ImplicitParamDecl *VTTDecl
 771       = ImplicitParamDecl::Create(Context, 0, MD->getLocation(),
 772                                   &Context.Idents.get("vtt"), T);
 773     Params.push_back(VTTDecl);
 774     getVTTDecl(CGF) = VTTDecl;
 775   }
 776 }
 777
 778 void ARMCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF,
 779                                             QualType &ResTy,
 780                                             FunctionArgList &Params) {
 781   ItaniumCXXABI::BuildInstanceFunctionParams(CGF, ResTy, Params);
 782
 783   // Return 'this' from certain constructors and destructors.
 784   if (HasThisReturn(CGF.CurGD))
 785     ResTy = Params[0]->getType();
 786 }
 787
 788 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
 789   /// Initialize the 'this' slot.
 790   EmitThisParam(CGF);
 791
 792   /// Initialize the 'vtt' slot if needed.
 793   if (getVTTDecl(CGF)) {
 794     getVTTValue(CGF)
 795       = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getVTTDecl(CGF)),
 796                                "vtt");
 797   }
 798 }
 799
 800 void ARMCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
 801   ItaniumCXXABI::EmitInstanceFunctionProlog(CGF);
 802
 803   /// Initialize the return slot to 'this' at the start of the
 804   /// function.
 805   if (HasThisReturn(CGF.CurGD))
 806     CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
 807 }
 808
 809 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
 810                                     RValue RV, QualType ResultType) {
 811   if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
 812     return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
 813
 814   // Destructor thunks in the ARM ABI have indeterminate results.
 815   llvm::Type *T =
 816     cast<llvm::PointerType>(CGF.ReturnValue->getType())->getElementType();
 817   RValue Undef = RValue::get(llvm::UndefValue::get(T));
 818   return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
 819 }
 820
 821 /************************** Array allocation cookies **************************/
 822
 823 CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
 824   // The array cookie is a size_t; pad that up to the element alignment.
 825   // The cookie is actually right-justified in that space.
 826   return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
 827                   CGM.getContext().getTypeAlignInChars(elementType));
 828 }
 829
 830 llvm::Value *ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
 831                                                   llvm::Value *NewPtr,
 832                                                   llvm::Value *NumElements,
 833                                                   const CXXNewExpr *expr,
 834                                                   QualType ElementType) {
 835   assert(requiresArrayCookie(expr));
 836
 837   unsigned AS = NewPtr->getType()->getPointerAddressSpace();
 838
 839   ASTContext &Ctx = getContext();
 840   QualType SizeTy = Ctx.getSizeType();
 841   CharUnits SizeSize = Ctx.getTypeSizeInChars(SizeTy);
 842
 843   // The size of the cookie.
 844   CharUnits CookieSize =
 845     std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
 846   assert(CookieSize == getArrayCookieSizeImpl(ElementType));
 847
 848   // Compute an offset to the cookie.
 849   llvm::Value *CookiePtr = NewPtr;
 850   CharUnits CookieOffset = CookieSize - SizeSize;
 851   if (!CookieOffset.isZero())
 852     CookiePtr = CGF.Builder.CreateConstInBoundsGEP1_64(CookiePtr,
 853                                                  CookieOffset.getQuantity());
 854
 855   // Write the number of elements into the appropriate slot.
 856   llvm::Value *NumElementsPtr
 857     = CGF.Builder.CreateBitCast(CookiePtr,
 858                                 CGF.ConvertType(SizeTy)->getPointerTo(AS));
 859   CGF.Builder.CreateStore(NumElements, NumElementsPtr);
 860
 861   // Finally, compute a pointer to the actual data buffer by skipping
 862   // over the cookie completely.
 863   return CGF.Builder.CreateConstInBoundsGEP1_64(NewPtr,
 864                                                 CookieSize.getQuantity());
 865 }
 866
 867 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
 868                                                 llvm::Value *allocPtr,
 869                                                 CharUnits cookieSize) {
 870   // The element size is right-justified in the cookie.
 871   llvm::Value *numElementsPtr = allocPtr;
 872   CharUnits numElementsOffset =
 873     cookieSize - CharUnits::fromQuantity(CGF.SizeSizeInBytes);
 874   if (!numElementsOffset.isZero())
 875     numElementsPtr =
 876       CGF.Builder.CreateConstInBoundsGEP1_64(numElementsPtr,
 877                                              numElementsOffset.getQuantity());
 878
 879   unsigned AS = allocPtr->getType()->getPointerAddressSpace();
 880   numElementsPtr =
 881     CGF.Builder.CreateBitCast(numElementsPtr, CGF.SizeTy->getPointerTo(AS));
 882   return CGF.Builder.CreateLoad(numElementsPtr);
 883 }
 884
 885 CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
 886   // On ARM, the cookie is always:
 887   //   struct array_cookie {
 888   //     std::size_t element_size; // element_size != 0
 889   //     std::size_t element_count;
 890   //   };
 891   // TODO: what should we do if the allocated type actually wants
 892   // greater alignment?
 893   return CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes);
 894 }
 895
 896 llvm::Value *ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
 897                                               llvm::Value *NewPtr,
 898                                               llvm::Value *NumElements,
 899                                               const CXXNewExpr *expr,
 900                                               QualType ElementType) {
 901   assert(requiresArrayCookie(expr));
 902
 903   // NewPtr is a char*.
 904
 905   unsigned AS = NewPtr->getType()->getPointerAddressSpace();
 906
 907   ASTContext &Ctx = getContext();
 908   CharUnits SizeSize = Ctx.getTypeSizeInChars(Ctx.getSizeType());
 909   llvm::IntegerType *SizeTy =
 910     cast<llvm::IntegerType>(CGF.ConvertType(Ctx.getSizeType()));
 911
 912   // The cookie is always at the start of the buffer.
 913   llvm::Value *CookiePtr = NewPtr;
 914
 915   // The first element is the element size.
 916   CookiePtr = CGF.Builder.CreateBitCast(CookiePtr, SizeTy->getPointerTo(AS));
 917   llvm::Value *ElementSize = llvm::ConstantInt::get(SizeTy,
 918                           Ctx.getTypeSizeInChars(ElementType).getQuantity());
 919   CGF.Builder.CreateStore(ElementSize, CookiePtr);
 920
 921   // The second element is the element count.
 922   CookiePtr = CGF.Builder.CreateConstInBoundsGEP1_32(CookiePtr, 1);
 923   CGF.Builder.CreateStore(NumElements, CookiePtr);
 924
 925   // Finally, compute a pointer to the actual data buffer by skipping
 926   // over the cookie completely.
 927   CharUnits CookieSize = 2 * SizeSize;
 928   return CGF.Builder.CreateConstInBoundsGEP1_64(NewPtr,
 929                                                 CookieSize.getQuantity());
 930 }
 931
 932 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
 933                                             llvm::Value *allocPtr,
 934                                             CharUnits cookieSize) {
 935   // The number of elements is at offset sizeof(size_t) relative to
 936   // the allocated pointer.
 937   llvm::Value *numElementsPtr
 938     = CGF.Builder.CreateConstInBoundsGEP1_64(allocPtr, CGF.SizeSizeInBytes);
 939
 940   unsigned AS = allocPtr->getType()->getPointerAddressSpace();
 941   numElementsPtr =
 942     CGF.Builder.CreateBitCast(numElementsPtr, CGF.SizeTy->getPointerTo(AS));
 943   return CGF.Builder.CreateLoad(numElementsPtr);
 944 }
 945
 946 /*********************** Static local initialization **************************/
 947
 948 static llvm::Constant *getGuardAcquireFn(CodeGenModule &CGM,
 949                                          llvm::PointerType *GuardPtrTy) {
 950   // int __cxa_guard_acquire(__guard *guard_object);
 951   llvm::FunctionType *FTy =
 952     llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
 953                             GuardPtrTy, /*isVarArg=*/false);
 954   return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_acquire",
 955                                    llvm::Attributes::get(CGM.getLLVMContext(),
 956                                                  llvm::Attributes::NoUnwind));
 957 }
 958
 959 static llvm::Constant *getGuardReleaseFn(CodeGenModule &CGM,
 960                                          llvm::PointerType *GuardPtrTy) {
 961   // void __cxa_guard_release(__guard *guard_object);
 962   llvm::FunctionType *FTy =
 963     llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
 964   return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_release",
 965                                    llvm::Attributes::get(CGM.getLLVMContext(),
 966                                                  llvm::Attributes::NoUnwind));
 967 }
 968
 969 static llvm::Constant *getGuardAbortFn(CodeGenModule &CGM,
 970                                        llvm::PointerType *GuardPtrTy) {
 971   // void __cxa_guard_abort(__guard *guard_object);
 972   llvm::FunctionType *FTy =
 973     llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
 974   return CGM.CreateRuntimeFunction(FTy, "__cxa_guard_abort",
 975                                    llvm::Attributes::get(CGM.getLLVMContext(),
 976                                                  llvm::Attributes::NoUnwind));
 977 }
 978
 979 namespace {
 980   struct CallGuardAbort : EHScopeStack::Cleanup {
 981     llvm::GlobalVariable *Guard;
 982     CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}
 983
 984     void Emit(CodeGenFunction &CGF, Flags flags) {
 985       CGF.Builder.CreateCall(getGuardAbortFn(CGF.CGM, Guard->getType()), Guard)
 986         ->setDoesNotThrow();
 987     }
 988   };
 989 }
 990
 991 /// The ARM code here follows the Itanium code closely enough that we
 992 /// just special-case it at particular places.
 993 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
 994                                     const VarDecl &D,
 995                                     llvm::GlobalVariable *var,
 996                                     bool shouldPerformInit) {
 997   CGBuilderTy &Builder = CGF.Builder;
 998
 999   // We only need to use thread-safe statics for local variables;
1000   // global initialization is always single-threaded.
1001   bool threadsafe =
1002     (getContext().getLangOpts().ThreadsafeStatics && D.isLocalVarDecl());
1003
1004   // If we have a global variable with internal linkage and thread-safe statics
1005   // are disabled, we can just let the guard variable be of type i8.
1006   bool useInt8GuardVariable = !threadsafe && var->hasInternalLinkage();
1007
1008   llvm::IntegerType *guardTy;
1009   if (useInt8GuardVariable) {
1010     guardTy = CGF.Int8Ty;
1011   } else {
1012     // Guard variables are 64 bits in the generic ABI and 32 bits on ARM.
1013     guardTy = (IsARM ? CGF.Int32Ty : CGF.Int64Ty);
1014   }
1015   llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
1016
1017   // Create the guard variable if we don't already have it (as we
1018   // might if we're double-emitting this function body).
1019   llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&D);
1020   if (!guard) {
1021     // Mangle the name for the guard.
1022     SmallString<256> guardName;
1023     {
1024       llvm::raw_svector_ostream out(guardName);
1025       getMangleContext().mangleItaniumGuardVariable(&D, out);
1026       out.flush();
1027     }
1028
1029     // Create the guard variable with a zero-initializer.
1030     // Just absorb linkage and visibility from the guarded variable.
1031     guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
1032                                      false, var->getLinkage(),
1033                                      llvm::ConstantInt::get(guardTy, 0),
1034                                      guardName.str());
1035     guard->setVisibility(var->getVisibility());
1036
1037     CGM.setStaticLocalDeclGuardAddress(&D, guard);
1038   }
1039
1040   // Test whether the variable has completed initialization.
1041   llvm::Value *isInitialized;
1042
1043   // ARM C++ ABI 3.2.3.1:
1044   //   To support the potential use of initialization guard variables
1045   //   as semaphores that are the target of ARM SWP and LDREX/STREX
1046   //   synchronizing instructions we define a static initialization
1047   //   guard variable to be a 4-byte aligned, 4- byte word with the
1048   //   following inline access protocol.
1049   //     #define INITIALIZED 1
1050   //     if ((obj_guard & INITIALIZED) != INITIALIZED) {
1051   //       if (__cxa_guard_acquire(&obj_guard))
1052   //         ...
1053   //     }
1054   if (IsARM && !useInt8GuardVariable) {
1055     llvm::Value *V = Builder.CreateLoad(guard);
1056     V = Builder.CreateAnd(V, Builder.getInt32(1));
1057     isInitialized = Builder.CreateIsNull(V, "guard.uninitialized");
1058
1059   // Itanium C++ ABI 3.3.2:
1060   //   The following is pseudo-code showing how these functions can be used:
1061   //     if (obj_guard.first_byte == 0) {
1062   //       if ( __cxa_guard_acquire (&obj_guard) ) {
1063   //         try {
1064   //           ... initialize the object ...;
1065   //         } catch (...) {
1066   //            __cxa_guard_abort (&obj_guard);
1067   //            throw;
1068   //         }
1069   //         ... queue object destructor with __cxa_atexit() ...;
1070   //         __cxa_guard_release (&obj_guard);
1071   //       }
1072   //     }
1073   } else {
1074     // Load the first byte of the guard variable.
1075     llvm::LoadInst *LI =
1076       Builder.CreateLoad(Builder.CreateBitCast(guard, CGM.Int8PtrTy));
1077     LI->setAlignment(1);
1078
1079     // Itanium ABI:
1080     //   An implementation supporting thread-safety on multiprocessor
1081     //   systems must also guarantee that references to the initialized
1082     //   object do not occur before the load of the initialization flag.
1083     //
1084     // In LLVM, we do this by marking the load Acquire.
1085     if (threadsafe)
1086       LI->setAtomic(llvm::Acquire);
1087
1088     isInitialized = Builder.CreateIsNull(LI, "guard.uninitialized");
1089   }
1090
1091   llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
1092   llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
1093
1094   // Check if the first byte of the guard variable is zero.
1095   Builder.CreateCondBr(isInitialized, InitCheckBlock, EndBlock);
1096
1097   CGF.EmitBlock(InitCheckBlock);
1098
1099   // Variables used when coping with thread-safe statics and exceptions.
1100   if (threadsafe) {
1101     // Call __cxa_guard_acquire.
1102     llvm::Value *V
1103       = Builder.CreateCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
1104
1105     llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
1106
1107     Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
1108                          InitBlock, EndBlock);
1109
1110     // Call __cxa_guard_abort along the exceptional edge.
1111     CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
1112
1113     CGF.EmitBlock(InitBlock);
1114   }
1115
1116   // Emit the initializer and add a global destructor if appropriate.
1117   CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
1118
1119   if (threadsafe) {
1120     // Pop the guard-abort cleanup if we pushed one.
1121     CGF.PopCleanupBlock();
1122
1123     // Call __cxa_guard_release.  This cannot throw.
1124     Builder.CreateCall(getGuardReleaseFn(CGM, guardPtrTy), guard);
1125   } else {
1126     Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guard);
1127   }
1128
1129   CGF.EmitBlock(EndBlock);
1130 }
1131
1132 /// Register a global destructor using __cxa_atexit.
1133 static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
1134                                         llvm::Constant *dtor,
1135                                         llvm::Constant *addr) {
1136   // We're assuming that the destructor function is something we can
1137   // reasonably call with the default CC.  Go ahead and cast it to the
1138   // right prototype.
1139   llvm::Type *dtorTy =
1140     llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
1141
1142   // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
1143   llvm::Type *paramTys[] = { dtorTy, CGF.Int8PtrTy, CGF.Int8PtrTy };
1144   llvm::FunctionType *atexitTy =
1145     llvm::FunctionType::get(CGF.IntTy, paramTys, false);
1146
1147   // Fetch the actual function.
1148   llvm::Constant *atexit =
1149     CGF.CGM.CreateRuntimeFunction(atexitTy, "__cxa_atexit");
1150   if (llvm::Function *fn = dyn_cast<llvm::Function>(atexit))
1151     fn->setDoesNotThrow();
1152
1153   // Create a variable that binds the atexit to this shared object.
1154   llvm::Constant *handle =
1155     CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
1156
1157   llvm::Value *args[] = {
1158     llvm::ConstantExpr::getBitCast(dtor, dtorTy),
1159     llvm::ConstantExpr::getBitCast(addr, CGF.Int8PtrTy),
1160     handle
1161   };
1162   CGF.Builder.CreateCall(atexit, args)->setDoesNotThrow();
1163 }
1164
1165 /// Register a global destructor as best as we know how.
1166 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF,
1167                                        llvm::Constant *dtor,
1168                                        llvm::Constant *addr) {
1169   // Use __cxa_atexit if available.
1170   if (CGM.getCodeGenOpts().CXAAtExit) {
1171     return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr);
1172   }
1173
1174   // In Apple kexts, we want to add a global destructor entry.
1175   // FIXME: shouldn't this be guarded by some variable?
1176   if (CGM.getLangOpts().AppleKext) {
1177     // Generate a global destructor entry.
1178     return CGM.AddCXXDtorEntry(dtor, addr);
1179   }
1180
1181   CGF.registerGlobalDtorWithAtExit(dtor, addr);
1182 }
1183
1184 /// Generate and emit virtual tables for the given class.
1185 void ItaniumCXXABI::EmitVTables(const CXXRecordDecl *Class) {
1186   CGM.getVTables().GenerateClassData(CGM.getVTableLinkage(Class), Class);
1187 }