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