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