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