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