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