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 = CGCallee::forDirect(
1566  CGM.getAddrOfCXXStructor(DD, getFromDtorType(Type)), GD);
1567 
1568  CGF.EmitCXXMemberOrOperatorCall(DD, Callee, ReturnValueSlot(),
1569  This.getPointer(), VTT, VTTTy,
1570  nullptr, nullptr);
1571 }
1572 
1573 void ItaniumCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
1574  const CXXRecordDecl *RD) {
1575  llvm::GlobalVariable *VTable = getAddrOfVTable(RD, CharUnits());
1576  if (VTable->hasInitializer())
1577  return;
1578 
1579  ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1580  const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
1581  llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
1582  llvm::Constant *RTTI =
1583  CGM.GetAddrOfRTTIDescriptor(CGM.getContext().getTagDeclType(RD));
1584 
1585  // Create and set the initializer.
1586  ConstantInitBuilder Builder(CGM);
1587  auto Components = Builder.beginStruct();
1588  CGVT.createVTableInitializer(Components, VTLayout, RTTI);
1589  Components.finishAndSetAsInitializer(VTable);
1590 
1591  // Set the correct linkage.
1592  VTable->setLinkage(Linkage);
1593 
1594  if (CGM.supportsCOMDAT() && VTable->isWeakForLinker())
1595  VTable->setComdat(CGM.getModule().getOrInsertComdat(VTable->getName()));
1596 
1597  // Set the right visibility.
1598  CGM.setGVProperties(VTable, RD);
1599 
1600  // If this is the magic class __cxxabiv1::__fundamental_type_info,
1601  // we will emit the typeinfo for the fundamental types. This is the
1602  // same behaviour as GCC.
1603  const DeclContext *DC = RD->getDeclContext();
1604  if (RD->getIdentifier() &&
1605  RD->getIdentifier()->isStr("__fundamental_type_info") &&
1606  isa<NamespaceDecl>(DC) && cast<NamespaceDecl>(DC)->getIdentifier() &&
1607  cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
1608  DC->getParent()->isTranslationUnit())
1609  EmitFundamentalRTTIDescriptors(RD);
1610 
1611  if (!VTable->isDeclarationForLinker())
1612  CGM.EmitVTableTypeMetadata(VTable, VTLayout);
1613 }
1614 
1615 bool ItaniumCXXABI::isVirtualOffsetNeededForVTableField(
1617  if (Vptr.NearestVBase == nullptr)
1618  return false;
1619  return NeedsVTTParameter(CGF.CurGD);
1620 }
1621 
1622 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructor(
1623  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1624  const CXXRecordDecl *NearestVBase) {
1625 
1626  if ((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1627  NeedsVTTParameter(CGF.CurGD)) {
1628  return getVTableAddressPointInStructorWithVTT(CGF, VTableClass, Base,
1629  NearestVBase);
1630  }
1631  return getVTableAddressPoint(Base, VTableClass);
1632 }
1633 
1634 llvm::Constant *
1635 ItaniumCXXABI::getVTableAddressPoint(BaseSubobject Base,
1636  const CXXRecordDecl *VTableClass) {
1637  llvm::GlobalValue *VTable = getAddrOfVTable(VTableClass, CharUnits());
1638 
1639  // Find the appropriate vtable within the vtable group, and the address point
1640  // within that vtable.
1641  VTableLayout::AddressPointLocation AddressPoint =
1642  CGM.getItaniumVTableContext()
1643  .getVTableLayout(VTableClass)
1644  .getAddressPoint(Base);
1645  llvm::Value *Indices[] = {
1646  llvm::ConstantInt::get(CGM.Int32Ty, 0),
1647  llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.VTableIndex),
1648  llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.AddressPointIndex),
1649  };
1650 
1651  return llvm::ConstantExpr::getGetElementPtr(VTable->getValueType(), VTable,
1652  Indices, /*InBounds=*/true,
1653  /*InRangeIndex=*/1);
1654 }
1655 
1656 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructorWithVTT(
1657  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1658  const CXXRecordDecl *NearestVBase) {
1659  assert((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1660  NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT");
1661 
1662  // Get the secondary vpointer index.
1663  uint64_t VirtualPointerIndex =
1664  CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base);
1665 
1666  /// Load the VTT.
1667  llvm::Value *VTT = CGF.LoadCXXVTT();
1668  if (VirtualPointerIndex)
1669  VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1670 
1671  // And load the address point from the VTT.
1672  return CGF.Builder.CreateAlignedLoad(VTT, CGF.getPointerAlign());
1673 }
1674 
1675 llvm::Constant *ItaniumCXXABI::getVTableAddressPointForConstExpr(
1676  BaseSubobject Base, const CXXRecordDecl *VTableClass) {
1677  return getVTableAddressPoint(Base, VTableClass);
1678 }
1679 
1680 llvm::GlobalVariable *ItaniumCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
1681  CharUnits VPtrOffset) {
1682  assert(VPtrOffset.isZero() && "Itanium ABI only supports zero vptr offsets");
1683 
1684  llvm::GlobalVariable *&VTable = VTables[RD];
1685  if (VTable)
1686  return VTable;
1687 
1688  // Queue up this vtable for possible deferred emission.
1689  CGM.addDeferredVTable(RD);
1690 
1691  SmallString<256> Name;
1692  llvm::raw_svector_ostream Out(Name);
1693  getMangleContext().mangleCXXVTable(RD, Out);
1694 
1695  const VTableLayout &VTLayout =
1696  CGM.getItaniumVTableContext().getVTableLayout(RD);
1697  llvm::Type *VTableType = CGM.getVTables().getVTableType(VTLayout);
1698 
1699  // Use pointer alignment for the vtable. Otherwise we would align them based
1700  // on the size of the initializer which doesn't make sense as only single
1701  // values are read.
1702  unsigned PAlign = CGM.getTarget().getPointerAlign(0);
1703 
1704  VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
1705  Name, VTableType, llvm::GlobalValue::ExternalLinkage,
1706  getContext().toCharUnitsFromBits(PAlign).getQuantity());
1707  VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1708 
1709  CGM.setGVProperties(VTable, RD);
1710 
1711  return VTable;
1712 }
1713 
1714 CGCallee ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1715  GlobalDecl GD,
1716  Address This,
1717  llvm::Type *Ty,
1718  SourceLocation Loc) {
1719  Ty = Ty->getPointerTo()->getPointerTo();
1720  auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
1721  llvm::Value *VTable = CGF.GetVTablePtr(This, Ty, MethodDecl->getParent());
1722 
1723  uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);
1724  llvm::Value *VFunc;
1725  if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
1726  VFunc = CGF.EmitVTableTypeCheckedLoad(
1727  MethodDecl->getParent(), VTable,
1728  VTableIndex * CGM.getContext().getTargetInfo().getPointerWidth(0) / 8);
1729  } else {
1730  CGF.EmitTypeMetadataCodeForVCall(MethodDecl->getParent(), VTable, Loc);
1731 
1732  llvm::Value *VFuncPtr =
1733  CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
1734  auto *VFuncLoad =
1735  CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1736 
1737  // Add !invariant.load md to virtual function load to indicate that
1738  // function didn't change inside vtable.
1739  // It's safe to add it without -fstrict-vtable-pointers, but it would not
1740  // help in devirtualization because it will only matter if we will have 2
1741  // the same virtual function loads from the same vtable load, which won't
1742  // happen without enabled devirtualization with -fstrict-vtable-pointers.
1743  if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1744  CGM.getCodeGenOpts().StrictVTablePointers)
1745  VFuncLoad->setMetadata(
1746  llvm::LLVMContext::MD_invariant_load,
1747  llvm::MDNode::get(CGM.getLLVMContext(),
1749  VFunc = VFuncLoad;
1750  }
1751 
1752  CGCallee Callee(GD, VFunc);
1753  return Callee;
1754 }
1755 
1756 llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall(
1757  CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
1758  Address This, const CXXMemberCallExpr *CE) {
1759  assert(CE == nullptr || CE->arg_begin() == CE->arg_end());
1760  assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
1761 
1762  const CGFunctionInfo *FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration(
1763  Dtor, getFromDtorType(DtorType));
1764  llvm::FunctionType *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
1765  CGCallee Callee =
1766  CGCallee::forVirtual(CE, GlobalDecl(Dtor, DtorType), This, Ty);
1767 
1768  CGF.EmitCXXMemberOrOperatorCall(Dtor, Callee, ReturnValueSlot(),
1769  This.getPointer(), /*ImplicitParam=*/nullptr,
1770  QualType(), CE, nullptr);
1771  return nullptr;
1772 }
1773 
1774 void ItaniumCXXABI::emitVirtualInheritanceTables(const CXXRecordDecl *RD) {
1775  CodeGenVTables &VTables = CGM.getVTables();
1776  llvm::GlobalVariable *VTT = VTables.GetAddrOfVTT(RD);
1777  VTables.EmitVTTDefinition(VTT, CGM.getVTableLinkage(RD), RD);
1778 }
1779 
1780 bool ItaniumCXXABI::canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const {
1781  // We don't emit available_externally vtables if we are in -fapple-kext mode
1782  // because kext mode does not permit devirtualization.
1783  if (CGM.getLangOpts().AppleKext)
1784  return false;
1785 
1786  // If the vtable is hidden then it is not safe to emit an available_externally
1787  // copy of vtable.
1788  if (isVTableHidden(RD))
1789  return false;
1790 
1791  if (CGM.getCodeGenOpts().ForceEmitVTables)
1792  return true;
1793 
1794  // If we don't have any not emitted inline virtual function then we are safe
1795  // to emit an available_externally copy of vtable.
1796  // FIXME we can still emit a copy of the vtable if we
1797  // can emit definition of the inline functions.
1798  return !hasAnyUnusedVirtualInlineFunction(RD);
1799 }
1801  Address InitialPtr,
1802  int64_t NonVirtualAdjustment,
1803  int64_t VirtualAdjustment,
1804  bool IsReturnAdjustment) {
1805  if (!NonVirtualAdjustment && !VirtualAdjustment)
1806  return InitialPtr.getPointer();
1807 
1808  Address V = CGF.Builder.CreateElementBitCast(InitialPtr, CGF.Int8Ty);
1809 
1810  // In a base-to-derived cast, the non-virtual adjustment is applied first.
1811  if (NonVirtualAdjustment && !IsReturnAdjustment) {
1813  CharUnits::fromQuantity(NonVirtualAdjustment));
1814  }
1815 
1816  // Perform the virtual adjustment if we have one.
1817  llvm::Value *ResultPtr;
1818  if (VirtualAdjustment) {
1819  llvm::Type *PtrDiffTy =
1821 
1822  Address VTablePtrPtr = CGF.Builder.CreateElementBitCast(V, CGF.Int8PtrTy);
1823  llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
1824 
1825  llvm::Value *OffsetPtr =
1826  CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
1827 
1828  OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
1829 
1830  // Load the adjustment offset from the vtable.
1831  llvm::Value *Offset =
1832  CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1833 
1834  // Adjust our pointer.
1835  ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getPointer(), Offset);
1836  } else {
1837  ResultPtr = V.getPointer();
1838  }
1839 
1840  // In a derived-to-base conversion, the non-virtual adjustment is
1841  // applied second.
1842  if (NonVirtualAdjustment && IsReturnAdjustment) {
1843  ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ResultPtr,
1844  NonVirtualAdjustment);
1845  }
1846 
1847  // Cast back to the original type.
1848  return CGF.Builder.CreateBitCast(ResultPtr, InitialPtr.getType());
1849 }
1850 
1851 llvm::Value *ItaniumCXXABI::performThisAdjustment(CodeGenFunction &CGF,
1852  Address This,
1853  const ThisAdjustment &TA) {
1854  return performTypeAdjustment(CGF, This, TA.NonVirtual,
1856  /*IsReturnAdjustment=*/false);
1857 }
1858 
1859 llvm::Value *
1860 ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
1861  const ReturnAdjustment &RA) {
1862  return performTypeAdjustment(CGF, Ret, RA.NonVirtual,
1864  /*IsReturnAdjustment=*/true);
1865 }
1866 
1867 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
1868  RValue RV, QualType ResultType) {
1869  if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
1870  return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
1871 
1872  // Destructor thunks in the ARM ABI have indeterminate results.
1874  RValue Undef = RValue::get(llvm::UndefValue::get(T));
1875  return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
1876 }
1877 
1878 /************************** Array allocation cookies **************************/
1879 
1880 CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1881  // The array cookie is a size_t; pad that up to the element alignment.
1882  // The cookie is actually right-justified in that space.
1883  return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
1884  CGM.getContext().getTypeAlignInChars(elementType));
1885 }
1886 
1887 Address ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1888  Address NewPtr,
1889  llvm::Value *NumElements,
1890  const CXXNewExpr *expr,
1891  QualType ElementType) {
1892  assert(requiresArrayCookie(expr));
1893 
1894  unsigned AS = NewPtr.getAddressSpace();
1895 
1896  ASTContext &Ctx = getContext();
1897  CharUnits SizeSize = CGF.getSizeSize();
1898 
1899  // The size of the cookie.
1900  CharUnits CookieSize =
1901  std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
1902  assert(CookieSize == getArrayCookieSizeImpl(ElementType));
1903 
1904  // Compute an offset to the cookie.
1905  Address CookiePtr = NewPtr;
1906  CharUnits CookieOffset = CookieSize - SizeSize;
1907  if (!CookieOffset.isZero())
1908  CookiePtr = CGF.Builder.CreateConstInBoundsByteGEP(CookiePtr, CookieOffset);
1909 
1910  // Write the number of elements into the appropriate slot.
1911  Address NumElementsPtr =
1912  CGF.Builder.CreateElementBitCast(CookiePtr, CGF.SizeTy);
1913  llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
1914 
1915  // Handle the array cookie specially in ASan.
1916  if (CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) && AS == 0 &&
1918  CGM.getCodeGenOpts().SanitizeAddressPoisonCustomArrayCookie)) {
1919  // The store to the CookiePtr does not need to be instrumented.
1920  CGM.getSanitizerMetadata()->disableSanitizerForInstruction(SI);
1921  llvm::FunctionType *FTy =
1922  llvm::FunctionType::get(CGM.VoidTy, NumElementsPtr.getType(), false);
1923  llvm::Constant *F =
1924  CGM.CreateRuntimeFunction(FTy, "__asan_poison_cxx_array_cookie");
1925  CGF.Builder.CreateCall(F, NumElementsPtr.getPointer());
1926  }
1927 
1928  // Finally, compute a pointer to the actual data buffer by skipping
1929  // over the cookie completely.
1930  return CGF.Builder.CreateConstInBoundsByteGEP(NewPtr, CookieSize);
1931 }
1932 
1933 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1934  Address allocPtr,
1935  CharUnits cookieSize) {
1936  // The element size is right-justified in the cookie.
1937  Address numElementsPtr = allocPtr;
1938  CharUnits numElementsOffset = cookieSize - CGF.getSizeSize();
1939  if (!numElementsOffset.isZero())
1940  numElementsPtr =
1941  CGF.Builder.CreateConstInBoundsByteGEP(numElementsPtr, numElementsOffset);
1942 
1943  unsigned AS = allocPtr.getAddressSpace();
1944  numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
1945  if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) || AS != 0)
1946  return CGF.Builder.CreateLoad(numElementsPtr);
1947  // In asan mode emit a function call instead of a regular load and let the
1948  // run-time deal with it: if the shadow is properly poisoned return the
1949  // cookie, otherwise return 0 to avoid an infinite loop calling DTORs.
1950  // We can't simply ignore this load using nosanitize metadata because
1951  // the metadata may be lost.
1952  llvm::FunctionType *FTy =
1953  llvm::FunctionType::get(CGF.SizeTy, CGF.SizeTy->getPointerTo(0), false);
1954  llvm::Constant *F =
1955  CGM.CreateRuntimeFunction(FTy, "__asan_load_cxx_array_cookie");
1956  return CGF.Builder.CreateCall(F, numElementsPtr.getPointer());
1957 }
1958 
1959 CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1960  // ARM says that the cookie is always:
1961  // struct array_cookie {
1962  // std::size_t element_size; // element_size != 0
1963  // std::size_t element_count;
1964  // };
1965  // But the base ABI doesn't give anything an alignment greater than
1966  // 8, so we can dismiss this as typical ABI-author blindness to
1967  // actual language complexity and round up to the element alignment.
1968  return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),
1969  CGM.getContext().getTypeAlignInChars(elementType));
1970 }
1971 
1972 Address ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1973  Address newPtr,
1974  llvm::Value *numElements,
1975  const CXXNewExpr *expr,
1976  QualType elementType) {
1977  assert(requiresArrayCookie(expr));
1978 
1979  // The cookie is always at the start of the buffer.
1980  Address cookie = newPtr;
1981 
1982  // The first element is the element size.
1983  cookie = CGF.Builder.CreateElementBitCast(cookie, CGF.SizeTy);
1984  llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
1985  getContext().getTypeSizeInChars(elementType).getQuantity());
1986  CGF.Builder.CreateStore(elementSize, cookie);
1987 
1988  // The second element is the element count.
1989  cookie = CGF.Builder.CreateConstInBoundsGEP(cookie, 1, CGF.getSizeSize());
1990  CGF.Builder.CreateStore(numElements, cookie);
1991 
1992  // Finally, compute a pointer to the actual data buffer by skipping
1993  // over the cookie completely.
1994  CharUnits cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);
1995  return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
1996 }
1997 
1998 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1999  Address allocPtr,
2000  CharUnits cookieSize) {
2001  // The number of elements is at offset sizeof(size_t) relative to
2002  // the allocated pointer.
2003  Address numElementsPtr
2004  = CGF.Builder.CreateConstInBoundsByteGEP(allocPtr, CGF.getSizeSize());
2005 
2006  numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
2007  return CGF.Builder.CreateLoad(numElementsPtr);
2008 }
2009 
2010 /*********************** Static local initialization **************************/
2011 
2012 static llvm::Constant *getGuardAcquireFn(CodeGenModule &CGM,
2013  llvm::PointerType *GuardPtrTy) {
2014  // int __cxa_guard_acquire(__guard *guard_object);
2015  llvm::FunctionType *FTy =
2016  llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
2017  GuardPtrTy, /*isVarArg=*/false);
2018  return CGM.CreateRuntimeFunction(
2019  FTy, "__cxa_guard_acquire",
2020  llvm::AttributeList::get(CGM.getLLVMContext(),
2021  llvm::AttributeList::FunctionIndex,
2022  llvm::Attribute::NoUnwind));
2023 }
2024 
2025 static llvm::Constant *getGuardReleaseFn(CodeGenModule &CGM,
2026  llvm::PointerType *GuardPtrTy) {
2027  // void __cxa_guard_release(__guard *guard_object);
2028  llvm::FunctionType *FTy =
2029  llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
2030  return CGM.CreateRuntimeFunction(
2031  FTy, "__cxa_guard_release",
2032  llvm::AttributeList::get(CGM.getLLVMContext(),
2033  llvm::AttributeList::FunctionIndex,
2034  llvm::Attribute::NoUnwind));
2035 }
2036 
2037 static llvm::Constant *getGuardAbortFn(CodeGenModule &CGM,
2038  llvm::PointerType *GuardPtrTy) {
2039  // void __cxa_guard_abort(__guard *guard_object);
2040  llvm::FunctionType *FTy =
2041  llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
2042  return CGM.CreateRuntimeFunction(
2043  FTy, "__cxa_guard_abort",
2044  llvm::AttributeList::get(CGM.getLLVMContext(),
2045  llvm::AttributeList::FunctionIndex,
2046  llvm::Attribute::NoUnwind));
2047 }
2048 
2049 namespace {
2050  struct CallGuardAbort final : EHScopeStack::Cleanup {
2051  llvm::GlobalVariable *Guard;
2052  CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}
2053 
2054  void Emit(CodeGenFunction &CGF, Flags flags) override {
2055  CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
2056  Guard);
2057  }
2058  };
2059 }
2060 
2061 /// The ARM code here follows the Itanium code closely enough that we
2062 /// just special-case it at particular places.
2063 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
2064  const VarDecl &D,
2065  llvm::GlobalVariable *var,
2066  bool shouldPerformInit) {
2067  CGBuilderTy &Builder = CGF.Builder;
2068 
2069  // Inline variables that weren't instantiated from variable templates have
2070  // partially-ordered initialization within their translation unit.
2071  bool NonTemplateInline =
2072  D.isInline() &&
2074 
2075  // We only need to use thread-safe statics for local non-TLS variables and
2076  // inline variables; other global initialization is always single-threaded
2077  // or (through lazy dynamic loading in multiple threads) unsequenced.
2078  bool threadsafe = getContext().getLangOpts().ThreadsafeStatics &&
2079  (D.isLocalVarDecl() || NonTemplateInline) &&
2080  !D.getTLSKind();
2081 
2082  // If we have a global variable with internal linkage and thread-safe statics
2083  // are disabled, we can just let the guard variable be of type i8.
2084  bool useInt8GuardVariable = !threadsafe && var->hasInternalLinkage();
2085 
2086  llvm::IntegerType *guardTy;
2087  CharUnits guardAlignment;
2088  if (useInt8GuardVariable) {
2089  guardTy = CGF.Int8Ty;
2090  guardAlignment = CharUnits::One();
2091  } else {
2092  // Guard variables are 64 bits in the generic ABI and size width on ARM
2093  // (i.e. 32-bit on AArch32, 64-bit on AArch64).
2094  if (UseARMGuardVarABI) {
2095  guardTy = CGF.SizeTy;
2096  guardAlignment = CGF.getSizeAlign();
2097  } else {
2098  guardTy = CGF.Int64Ty;
2099  guardAlignment = CharUnits::fromQuantity(
2100  CGM.getDataLayout().getABITypeAlignment(guardTy));
2101  }
2102  }
2103  llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
2104 
2105  // Create the guard variable if we don't already have it (as we
2106  // might if we're double-emitting this function body).
2107  llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&D);
2108  if (!guard) {
2109  // Mangle the name for the guard.
2110  SmallString<256> guardName;
2111  {
2112  llvm::raw_svector_ostream out(guardName);
2113  getMangleContext().mangleStaticGuardVariable(&D, out);
2114  }
2115 
2116  // Create the guard variable with a zero-initializer.
2117  // Just absorb linkage and visibility from the guarded variable.
2118  guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
2119  false, var->getLinkage(),
2120  llvm::ConstantInt::get(guardTy, 0),
2121  guardName.str());
2122  guard->setDSOLocal(var->isDSOLocal());
2123  guard->setVisibility(var->getVisibility());
2124  // If the variable is thread-local, so is its guard variable.
2125  guard->setThreadLocalMode(var->getThreadLocalMode());
2126  guard->setAlignment(guardAlignment.getQuantity());
2127 
2128  // The ABI says: "It is suggested that it be emitted in the same COMDAT
2129  // group as the associated data object." In practice, this doesn't work for
2130  // non-ELF and non-Wasm object formats, so only do it for ELF and Wasm.
2131  llvm::Comdat *C = var->getComdat();
2132  if (!D.isLocalVarDecl() && C &&
2133  (CGM.getTarget().getTriple().isOSBinFormatELF() ||
2134  CGM.getTarget().getTriple().isOSBinFormatWasm())) {
2135  guard->setComdat(C);
2136  // An inline variable's guard function is run from the per-TU
2137  // initialization function, not via a dedicated global ctor function, so
2138  // we can't put it in a comdat.
2139  if (!NonTemplateInline)
2140  CGF.CurFn->setComdat(C);
2141  } else if (CGM.supportsCOMDAT() && guard->isWeakForLinker()) {
2142  guard->setComdat(CGM.getModule().getOrInsertComdat(guard->getName()));
2143  }
2144 
2145  CGM.setStaticLocalDeclGuardAddress(&D, guard);
2146  }
2147 
2148  Address guardAddr = Address(guard, guardAlignment);
2149 
2150  // Test whether the variable has completed initialization.
2151  //
2152  // Itanium C++ ABI 3.3.2:
2153  // The following is pseudo-code showing how these functions can be used:
2154  // if (obj_guard.first_byte == 0) {
2155  // if ( __cxa_guard_acquire (&obj_guard) ) {
2156  // try {
2157  // ... initialize the object ...;
2158  // } catch (...) {
2159  // __cxa_guard_abort (&obj_guard);
2160  // throw;
2161  // }
2162  // ... queue object destructor with __cxa_atexit() ...;
2163  // __cxa_guard_release (&obj_guard);
2164  // }
2165  // }
2166 
2167  // Load the first byte of the guard variable.
2168  llvm::LoadInst *LI =
2169  Builder.CreateLoad(Builder.CreateElementBitCast(guardAddr, CGM.Int8Ty));
2170 
2171  // Itanium ABI:
2172  // An implementation supporting thread-safety on multiprocessor
2173  // systems must also guarantee that references to the initialized
2174  // object do not occur before the load of the initialization flag.
2175  //
2176  // In LLVM, we do this by marking the load Acquire.
2177  if (threadsafe)
2178  LI->setAtomic(llvm::AtomicOrdering::Acquire);
2179 
2180  // For ARM, we should only check the first bit, rather than the entire byte:
2181  //
2182  // ARM C++ ABI 3.2.3.1:
2183  // To support the potential use of initialization guard variables
2184  // as semaphores that are the target of ARM SWP and LDREX/STREX
2185  // synchronizing instructions we define a static initialization
2186  // guard variable to be a 4-byte aligned, 4-byte word with the
2187  // following inline access protocol.
2188  // #define INITIALIZED 1
2189  // if ((obj_guard & INITIALIZED) != INITIALIZED) {
2190  // if (__cxa_guard_acquire(&obj_guard))
2191  // ...
2192  // }
2193  //
2194  // and similarly for ARM64:
2195  //
2196  // ARM64 C++ ABI 3.2.2:
2197  // This ABI instead only specifies the value bit 0 of the static guard
2198  // variable; all other bits are platform defined. Bit 0 shall be 0 when the
2199  // variable is not initialized and 1 when it is.
2200  llvm::Value *V =
2201  (UseARMGuardVarABI && !useInt8GuardVariable)
2202  ? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))
2203  : LI;
2204  llvm::Value *NeedsInit = Builder.CreateIsNull(V, "guard.uninitialized");
2205 
2206  llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
2207  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2208 
2209  // Check if the first byte of the guard variable is zero.
2210  CGF.EmitCXXGuardedInitBranch(NeedsInit, InitCheckBlock, EndBlock,
2212 
2213  CGF.EmitBlock(InitCheckBlock);
2214 
2215  // Variables used when coping with thread-safe statics and exceptions.
2216  if (threadsafe) {
2217  // Call __cxa_guard_acquire.
2218  llvm::Value *V
2219  = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
2220 
2221  llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2222 
2223  Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
2224  InitBlock, EndBlock);
2225 
2226  // Call __cxa_guard_abort along the exceptional edge.
2227  CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
2228 
2229  CGF.EmitBlock(InitBlock);
2230  }
2231 
2232  // Emit the initializer and add a global destructor if appropriate.
2233  CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
2234 
2235  if (threadsafe) {
2236  // Pop the guard-abort cleanup if we pushed one.
2237  CGF.PopCleanupBlock();
2238 
2239  // Call __cxa_guard_release. This cannot throw.
2240  CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy),
2241  guardAddr.getPointer());
2242  } else {
2243  Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guardAddr);
2244  }
2245 
2246  CGF.EmitBlock(EndBlock);
2247 }
2248 
2249 /// Register a global destructor using __cxa_atexit.
2251  llvm::Constant *dtor,
2252  llvm::Constant *addr,
2253  bool TLS) {
2254  const char *Name = "__cxa_atexit";
2255  if (TLS) {
2256  const llvm::Triple &T = CGF.getTarget().getTriple();
2257  Name = T.isOSDarwin() ? "_tlv_atexit" : "__cxa_thread_atexit";
2258  }
2259 
2260  // We're assuming that the destructor function is something we can
2261  // reasonably call with the default CC. Go ahead and cast it to the
2262  // right prototype.
2263  llvm::Type *dtorTy =
2264  llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
2265 
2266  // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
2267  llvm::Type *paramTys[] = { dtorTy, CGF.Int8PtrTy, CGF.Int8PtrTy };
2268  llvm::FunctionType *atexitTy =
2269  llvm::FunctionType::get(CGF.IntTy, paramTys, false);
2270 
2271  // Fetch the actual function.
2272  llvm::Constant *atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
2273  if (llvm::Function *fn = dyn_cast<llvm::Function>(atexit))
2274  fn->setDoesNotThrow();
2275 
2276  // Create a variable that binds the atexit to this shared object.
2277  llvm::Constant *handle =
2278  CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
2279  auto *GV = cast<llvm::GlobalValue>(handle->stripPointerCasts());
2280  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
2281 
2282  if (!addr)
2283  // addr is null when we are trying to register a dtor annotated with
2284  // __attribute__((destructor)) in a constructor function. Using null here is
2285  // okay because this argument is just passed back to the destructor
2286  // function.
2287  addr = llvm::Constant::getNullValue(CGF.Int8PtrTy);
2288 
2289  llvm::Value *args[] = {
2290  llvm::ConstantExpr::getBitCast(dtor, dtorTy),
2291  llvm::ConstantExpr::getBitCast(addr, CGF.Int8PtrTy),
2292  handle
2293  };
2294  CGF.EmitNounwindRuntimeCall(atexit, args);
2295 }
2296 
2297 void CodeGenModule::registerGlobalDtorsWithAtExit() {
2298  for (const auto I : DtorsUsingAtExit) {
2299  int Priority = I.first;
2300  const llvm::TinyPtrVector<llvm::Function *> &Dtors = I.second;
2301 
2302  // Create a function that registers destructors that have the same priority.
2303  //
2304  // Since constructor functions are run in non-descending order of their
2305  // priorities, destructors are registered in non-descending order of their
2306  // priorities, and since destructor functions are run in the reverse order
2307  // of their registration, destructor functions are run in non-ascending
2308  // order of their priorities.
2309  CodeGenFunction CGF(*this);
2310  std::string GlobalInitFnName =
2311  std::string("__GLOBAL_init_") + llvm::to_string(Priority);
2312  llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
2313  llvm::Function *GlobalInitFn = CreateGlobalInitOrDestructFunction(
2314  FTy, GlobalInitFnName, getTypes().arrangeNullaryFunction(),
2315  SourceLocation());
2316  ASTContext &Ctx = getContext();
2317  QualType ReturnTy = Ctx.VoidTy;
2318  QualType FunctionTy = Ctx.getFunctionType(ReturnTy, llvm::None, {});
2321  &Ctx.Idents.get(GlobalInitFnName), FunctionTy, nullptr, SC_Static,
2322  false, false);
2323  CGF.StartFunction(GlobalDecl(FD), ReturnTy, GlobalInitFn,
2324  getTypes().arrangeNullaryFunction(), FunctionArgList(),
2326 
2327  for (auto *Dtor : Dtors) {
2328  // Register the destructor function calling __cxa_atexit if it is
2329  // available. Otherwise fall back on calling atexit.
2330  if (getCodeGenOpts().CXAAtExit)
2331  emitGlobalDtorWithCXAAtExit(CGF, Dtor, nullptr, false);
2332  else
2333  CGF.registerGlobalDtorWithAtExit(Dtor);
2334  }
2335 
2336  CGF.FinishFunction();
2337  AddGlobalCtor(GlobalInitFn, Priority, nullptr);
2338  }
2339 }
2340 
2341 /// Register a global destructor as best as we know how.
2342 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF,
2343  const VarDecl &D,
2344  llvm::Constant *dtor,
2345  llvm::Constant *addr) {
2346  if (D.isNoDestroy(CGM.getContext()))
2347  return;
2348 
2349  // Use __cxa_atexit if available.
2350  if (CGM.getCodeGenOpts().CXAAtExit)
2351  return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
2352 
2353  if (D.getTLSKind())
2354  CGM.ErrorUnsupported(&D, "non-trivial TLS destruction");
2355 
2356  // In Apple kexts, we want to add a global destructor entry.
2357  // FIXME: shouldn't this be guarded by some variable?
2358  if (CGM.getLangOpts().AppleKext) {
2359  // Generate a global destructor entry.
2360  return CGM.AddCXXDtorEntry(dtor, addr);
2361  }
2362 
2363  CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
2364 }
2365 
2366 static bool isThreadWrapperReplaceable(const VarDecl *VD,
2367  CodeGen::CodeGenModule &CGM) {
2368  assert(!VD->isStaticLocal() && "static local VarDecls don't need wrappers!");
2369  // Darwin prefers to have references to thread local variables to go through
2370  // the thread wrapper instead of directly referencing the backing variable.
2371  return VD->getTLSKind() == VarDecl::TLS_Dynamic &&
2372  CGM.getTarget().getTriple().isOSDarwin();
2373 }
2374 
2375 /// Get the appropriate linkage for the wrapper function. This is essentially
2376 /// the weak form of the variable's linkage; every translation unit which needs
2377 /// the wrapper emits a copy, and we want the linker to merge them.
2378 static llvm::GlobalValue::LinkageTypes
2380  llvm::GlobalValue::LinkageTypes VarLinkage =
2381  CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false);
2382 
2383  // For internal linkage variables, we don't need an external or weak wrapper.
2384  if (llvm::GlobalValue::isLocalLinkage(VarLinkage))
2385  return VarLinkage;
2386 
2387  // If the thread wrapper is replaceable, give it appropriate linkage.
2388  if (isThreadWrapperReplaceable(VD, CGM))
2389  if (!llvm::GlobalVariable::isLinkOnceLinkage(VarLinkage) &&
2390  !llvm::GlobalVariable::isWeakODRLinkage(VarLinkage))
2391  return VarLinkage;
2392  return llvm::GlobalValue::WeakODRLinkage;
2393 }
2394 
2395 llvm::Function *
2396 ItaniumCXXABI::getOrCreateThreadLocalWrapper(const VarDecl *VD,
2397  llvm::Value *Val) {
2398  // Mangle the name for the thread_local wrapper function.
2399  SmallString<256> WrapperName;
2400  {
2401  llvm::raw_svector_ostream Out(WrapperName);
2402  getMangleContext().mangleItaniumThreadLocalWrapper(VD, Out);
2403  }
2404 
2405  // FIXME: If VD is a definition, we should regenerate the function attributes
2406  // before returning.
2407  if (llvm::Value *V = CGM.getModule().getNamedValue(WrapperName))
2408  return cast<llvm::Function>(V);
2409 
2410  QualType RetQT = VD->getType();
2411  if (RetQT->isReferenceType())
2412  RetQT = RetQT.getNonReferenceType();
2413 
2414  const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
2415  getContext().getPointerType(RetQT), FunctionArgList());
2416 
2417  llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);
2418  llvm::Function *Wrapper =
2420  WrapperName.str(), &CGM.getModule());
2421 
2422  CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, Wrapper);
2423 
2424  if (VD->hasDefinition())
2425  CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Wrapper);
2426 
2427  // Always resolve references to the wrapper at link time.
2428  if (!Wrapper->hasLocalLinkage() && !(isThreadWrapperReplaceable(VD, CGM) &&
2429  !llvm::GlobalVariable::isLinkOnceLinkage(Wrapper->getLinkage()) &&
2430  !llvm::GlobalVariable::isWeakODRLinkage(Wrapper->getLinkage())))
2431  Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);
2432 
2433  if (isThreadWrapperReplaceable(VD, CGM)) {
2434  Wrapper->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2435  Wrapper->addFnAttr(llvm::Attribute::NoUnwind);
2436  }
2437  return Wrapper;
2438 }
2439 
2440 void ItaniumCXXABI::EmitThreadLocalInitFuncs(
2441  CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
2442  ArrayRef<llvm::Function *> CXXThreadLocalInits,
2443  ArrayRef<const VarDecl *> CXXThreadLocalInitVars) {
2444  llvm::Function *InitFunc = nullptr;
2445 
2446  // Separate initializers into those with ordered (or partially-ordered)
2447  // initialization and those with unordered initialization.
2449  llvm::SmallDenseMap<const VarDecl *, llvm::Function *> UnorderedInits;
2450  for (unsigned I = 0; I != CXXThreadLocalInits.size(); ++I) {
2452  CXXThreadLocalInitVars[I]->getTemplateSpecializationKind()))
2453  UnorderedInits[CXXThreadLocalInitVars[I]->getCanonicalDecl()] =
2454  CXXThreadLocalInits[I];
2455  else
2456  OrderedInits.push_back(CXXThreadLocalInits[I]);
2457  }
2458 
2459  if (!OrderedInits.empty()) {
2460  // Generate a guarded initialization function.
2461  llvm::FunctionType *FTy =
2462  llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
2463  const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2464  InitFunc = CGM.CreateGlobalInitOrDestructFunction(FTy, "__tls_init", FI,
2465  SourceLocation(),
2466  /*TLS=*/true);
2467  llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
2468  CGM.getModule(), CGM.Int8Ty, /*isConstant=*/false,
2470  llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
2471  Guard->setThreadLocal(true);
2472 
2473  CharUnits GuardAlign = CharUnits::One();
2474  Guard->setAlignment(GuardAlign.getQuantity());
2475 
2477  InitFunc, OrderedInits, ConstantAddress(Guard, GuardAlign));
2478  // On Darwin platforms, use CXX_FAST_TLS calling convention.
2479  if (CGM.getTarget().getTriple().isOSDarwin()) {
2480  InitFunc->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2481  InitFunc->addFnAttr(llvm::Attribute::NoUnwind);
2482  }
2483  }
2484 
2485  // Emit thread wrappers.
2486  for (const VarDecl *VD : CXXThreadLocals) {
2487  llvm::GlobalVariable *Var =
2488  cast<llvm::GlobalVariable>(CGM.GetGlobalValue(CGM.getMangledName(VD)));
2489  llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Var);
2490 
2491  // Some targets require that all access to thread local variables go through
2492  // the thread wrapper. This means that we cannot attempt to create a thread
2493  // wrapper or a thread helper.
2494  if (isThreadWrapperReplaceable(VD, CGM) && !VD->hasDefinition()) {
2495  Wrapper->setLinkage(llvm::Function::ExternalLinkage);
2496  continue;
2497  }
2498 
2499  // Mangle the name for the thread_local initialization function.
2500  SmallString<256> InitFnName;
2501  {
2502  llvm::raw_svector_ostream Out(InitFnName);
2503  getMangleContext().mangleItaniumThreadLocalInit(VD, Out);
2504  }
2505 
2506  // If we have a definition for the variable, emit the initialization
2507  // function as an alias to the global Init function (if any). Otherwise,
2508  // produce a declaration of the initialization function.
2509  llvm::GlobalValue *Init = nullptr;
2510  bool InitIsInitFunc = false;
2511  if (VD->hasDefinition()) {
2512  InitIsInitFunc = true;
2513  llvm::Function *InitFuncToUse = InitFunc;
2515  InitFuncToUse = UnorderedInits.lookup(VD->getCanonicalDecl());
2516  if (InitFuncToUse)
2517  Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),
2518  InitFuncToUse);
2519  } else {
2520  // Emit a weak global function referring to the initialization function.
2521  // This function will not exist if the TU defining the thread_local
2522  // variable in question does not need any dynamic initialization for
2523  // its thread_local variables.
2524  llvm::FunctionType *FnTy = llvm::FunctionType::get(CGM.VoidTy, false);
2525  Init = llvm::Function::Create(FnTy,
2526  llvm::GlobalVariable::ExternalWeakLinkage,
2527  InitFnName.str(), &CGM.getModule());
2528  const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2530  cast<llvm::Function>(Init));
2531  }
2532 
2533  if (Init) {
2534  Init->setVisibility(Var->getVisibility());
2535  Init->setDSOLocal(Var->isDSOLocal());
2536  }
2537 
2538  llvm::LLVMContext &Context = CGM.getModule().getContext();
2539  llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Wrapper);
2540  CGBuilderTy Builder(CGM, Entry);
2541  if (InitIsInitFunc) {
2542  if (Init) {
2543  llvm::CallInst *CallVal = Builder.CreateCall(Init);
2544  if (isThreadWrapperReplaceable(VD, CGM)) {
2545  CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2546  llvm::Function *Fn =
2547  cast<llvm::Function>(cast<llvm::GlobalAlias>(Init)->getAliasee());
2548  Fn->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2549  }
2550  }
2551  } else {
2552  // Don't know whether we have an init function. Call it if it exists.
2553  llvm::Value *Have = Builder.CreateIsNotNull(Init);
2554  llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2555  llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2556  Builder.CreateCondBr(Have, InitBB, ExitBB);
2557 
2558  Builder.SetInsertPoint(InitBB);
2559  Builder.CreateCall(Init);
2560  Builder.CreateBr(ExitBB);
2561 
2562  Builder.SetInsertPoint(ExitBB);
2563  }
2564 
2565  // For a reference, the result of the wrapper function is a pointer to
2566  // the referenced object.
2567  llvm::Value *Val = Var;
2568  if (VD->getType()->isReferenceType()) {
2569  CharUnits Align = CGM.getContext().getDeclAlign(VD);
2570  Val = Builder.CreateAlignedLoad(Val, Align);
2571  }
2572  if (Val->getType() != Wrapper->getReturnType())
2574  Val, Wrapper->getReturnType(), "");
2575  Builder.CreateRet(Val);
2576  }
2577 }
2578 
2579 LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2580  const VarDecl *VD,
2581  QualType LValType) {
2582  llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD);
2583  llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Val);
2584 
2585  llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
2586  CallVal->setCallingConv(Wrapper->getCallingConv());
2587 
2588  LValue LV;
2589  if (VD->getType()->isReferenceType())
2590  LV = CGF.MakeNaturalAlignAddrLValue(CallVal, LValType);
2591  else
2592  LV = CGF.MakeAddrLValue(CallVal, LValType,
2593  CGF.getContext().getDeclAlign(VD));
2594  // FIXME: need setObjCGCLValueClass?
2595  return LV;
2596 }
2597 
2598 /// Return whether the given global decl needs a VTT parameter, which it does
2599 /// if it's a base constructor or destructor with virtual bases.
2600 bool ItaniumCXXABI::NeedsVTTParameter(GlobalDecl GD) {
2601  const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2602 
2603  // We don't have any virtual bases, just return early.
2604  if (!MD->getParent()->getNumVBases())
2605  return false;
2606 
2607  // Check if we have a base constructor.
2608  if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base)
2609  return true;
2610 
2611  // Check if we have a base destructor.
2612  if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
2613  return true;
2614 
2615  return false;
2616 }
2617 
2618 namespace {
2619 class ItaniumRTTIBuilder {
2620  CodeGenModule &CGM; // Per-module state.
2621  llvm::LLVMContext &VMContext;
2622  const ItaniumCXXABI &CXXABI; // Per-module state.
2623 
2624  /// Fields - The fields of the RTTI descriptor currently being built.
2626 
2627  /// GetAddrOfTypeName - Returns the mangled type name of the given type.
2628  llvm::GlobalVariable *
2629  GetAddrOfTypeName(QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage);
2630 
2631  /// GetAddrOfExternalRTTIDescriptor - Returns the constant for the RTTI
2632  /// descriptor of the given type.
2633  llvm::Constant *GetAddrOfExternalRTTIDescriptor(QualType Ty);
2634 
2635  /// BuildVTablePointer - Build the vtable pointer for the given type.
2636  void BuildVTablePointer(const Type *Ty);
2637 
2638  /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
2639  /// inheritance, according to the Itanium C++ ABI, 2.9.5p6b.
2640  void BuildSIClassTypeInfo(const CXXRecordDecl *RD);
2641 
2642  /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
2643  /// classes with bases that do not satisfy the abi::__si_class_type_info
2644  /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
2645  void BuildVMIClassTypeInfo(const CXXRecordDecl *RD);
2646 
2647  /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct, used
2648  /// for pointer types.
2649  void BuildPointerTypeInfo(QualType PointeeTy);
2650 
2651  /// BuildObjCObjectTypeInfo - Build the appropriate kind of
2652  /// type_info for an object type.
2653  void BuildObjCObjectTypeInfo(const ObjCObjectType *Ty);
2654 
2655  /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
2656  /// struct, used for member pointer types.
2657  void BuildPointerToMemberTypeInfo(const MemberPointerType *Ty);
2658 
2659 public:
2660  ItaniumRTTIBuilder(const ItaniumCXXABI &ABI)
2661  : CGM(ABI.CGM), VMContext(CGM.getModule().getContext()), CXXABI(ABI) {}
2662 
2663  // Pointer type info flags.
2664  enum {
2665  /// PTI_Const - Type has const qualifier.
2666  PTI_Const = 0x1,
2667 
2668  /// PTI_Volatile - Type has volatile qualifier.
2669  PTI_Volatile = 0x2,
2670 
2671  /// PTI_Restrict - Type has restrict qualifier.
2672  PTI_Restrict = 0x4,
2673 
2674  /// PTI_Incomplete - Type is incomplete.
2675  PTI_Incomplete = 0x8,
2676 
2677  /// PTI_ContainingClassIncomplete - Containing class is incomplete.
2678  /// (in pointer to member).
2679  PTI_ContainingClassIncomplete = 0x10,
2680 
2681  /// PTI_TransactionSafe - Pointee is transaction_safe function (C++ TM TS).
2682  //PTI_TransactionSafe = 0x20,
2683 
2684  /// PTI_Noexcept - Pointee is noexcept function (C++1z).
2685  PTI_Noexcept = 0x40,
2686  };
2687 
2688  // VMI type info flags.
2689  enum {
2690  /// VMI_NonDiamondRepeat - Class has non-diamond repeated inheritance.
2691  VMI_NonDiamondRepeat = 0x1,
2692 
2693  /// VMI_DiamondShaped - Class is diamond shaped.
2694  VMI_DiamondShaped = 0x2
2695  };
2696 
2697  // Base class type info flags.
2698  enum {
2699  /// BCTI_Virtual - Base class is virtual.
2700  BCTI_Virtual = 0x1,
2701 
2702  /// BCTI_Public - Base class is public.
2703  BCTI_Public = 0x2
2704  };
2705 
2706  /// BuildTypeInfo - Build the RTTI type info struct for the given type, or
2707  /// link to an existing RTTI descriptor if one already exists.
2708  llvm::Constant *BuildTypeInfo(QualType Ty);
2709 
2710  /// BuildTypeInfo - Build the RTTI type info struct for the given type.
2711  llvm::Constant *BuildTypeInfo(
2712  QualType Ty,
2713  llvm::GlobalVariable::LinkageTypes Linkage,
2714  llvm::GlobalValue::VisibilityTypes Visibility,
2715  llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass);
2716 };
2717 }
2718 
2719 llvm::GlobalVariable *ItaniumRTTIBuilder::GetAddrOfTypeName(
2720  QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage) {
2721  SmallString<256> Name;
2722  llvm::raw_svector_ostream Out(Name);
2723  CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out);
2724 
2725  // We know that the mangled name of the type starts at index 4 of the
2726  // mangled name of the typename, so we can just index into it in order to
2727  // get the mangled name of the type.
2728  llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
2729  Name.substr(4));
2730  auto Align = CGM.getContext().getTypeAlignInChars(CGM.getContext().CharTy);
2731 
2732  llvm::GlobalVariable *GV = CGM.CreateOrReplaceCXXRuntimeVariable(
2733  Name, Init->getType(), Linkage, Align.getQuantity());
2734 
2735  GV->setInitializer(Init);
2736 
2737  return GV;
2738 }
2739 
2740 llvm::Constant *
2741 ItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(QualType Ty) {
2742  // Mangle the RTTI name.
2743  SmallString<256> Name;
2744  llvm::raw_svector_ostream Out(Name);
2745  CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2746 
2747  // Look for an existing global.
2748  llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name);
2749 
2750  if (!GV) {
2751  // Create a new global variable.
2752  // Note for the future: If we would ever like to do deferred emission of
2753  // RTTI, check if emitting vtables opportunistically need any adjustment.
2754 
2755  GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
2756  /*Constant=*/true,
2758  Name);
2759  const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
2760  CGM.setGVProperties(GV, RD);
2761  }
2762 
2763  return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
2764 }
2765 
2766 /// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type
2767 /// info for that type is defined in the standard library.
2769  // Itanium C++ ABI 2.9.2:
2770  // Basic type information (e.g. for "int", "bool", etc.) will be kept in
2771  // the run-time support library. Specifically, the run-time support
2772  // library should contain type_info objects for the types X, X* and
2773  // X const*, for every X in: void, std::nullptr_t, bool, wchar_t, char,
2774  // unsigned char, signed char, short, unsigned short, int, unsigned int,
2775  // long, unsigned long, long long, unsigned long long, float, double,
2776  // long double, char16_t, char32_t, and the IEEE 754r decimal and
2777  // half-precision floating point types.
2778  //
2779  // GCC also emits RTTI for __int128.
2780  // FIXME: We do not emit RTTI information for decimal types here.
2781 
2782  // Types added here must also be added to EmitFundamentalRTTIDescriptors.
2783  switch (Ty->getKind()) {
2784  case BuiltinType::Void:
2785  case BuiltinType::NullPtr:
2786  case BuiltinType::Bool:
2787  case BuiltinType::WChar_S:
2788  case BuiltinType::WChar_U:
2789  case BuiltinType::Char_U:
2790  case BuiltinType::Char_S:
2791  case BuiltinType::UChar:
2792  case BuiltinType::SChar:
2793  case BuiltinType::Short:
2794  case BuiltinType::UShort:
2795  case BuiltinType::Int:
2796  case BuiltinType::UInt:
2797  case BuiltinType::Long:
2798  case BuiltinType::ULong:
2799  case BuiltinType::LongLong:
2800  case BuiltinType::ULongLong:
2801  case BuiltinType::Half:
2802  case BuiltinType::Float:
2803  case BuiltinType::Double:
2804  case BuiltinType::LongDouble:
2805  case BuiltinType::Float16:
2806  case BuiltinType::Float128:
2807  case BuiltinType::Char8:
2808  case BuiltinType::Char16:
2809  case BuiltinType::Char32:
2810  case BuiltinType::Int128:
2811  case BuiltinType::UInt128:
2812  return true;
2813 
2814 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2815  case BuiltinType::Id:
2816 #include "clang/Basic/OpenCLImageTypes.def"
2817 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2818  case BuiltinType::Id:
2819 #include "clang/Basic/OpenCLExtensionTypes.def"
2820  case BuiltinType::OCLSampler:
2821  case BuiltinType::OCLEvent:
2822  case BuiltinType::OCLClkEvent:
2823  case BuiltinType::OCLQueue:
2824  case BuiltinType::OCLReserveID:
2825  case BuiltinType::ShortAccum:
2826  case BuiltinType::Accum:
2827  case BuiltinType::LongAccum:
2828  case BuiltinType::UShortAccum:
2829  case BuiltinType::UAccum:
2830  case BuiltinType::ULongAccum:
2831  case BuiltinType::ShortFract:
2832  case BuiltinType::Fract:
2833  case BuiltinType::LongFract:
2834  case BuiltinType::UShortFract:
2835  case BuiltinType::UFract:
2836  case BuiltinType::ULongFract:
2837  case BuiltinType::SatShortAccum:
2838  case BuiltinType::SatAccum:
2839  case BuiltinType::SatLongAccum:
2840  case BuiltinType::SatUShortAccum:
2841  case BuiltinType::SatUAccum:
2842  case BuiltinType::SatULongAccum:
2843  case BuiltinType::SatShortFract:
2844  case BuiltinType::SatFract:
2845  case BuiltinType::SatLongFract:
2846  case BuiltinType::SatUShortFract:
2847  case BuiltinType::SatUFract:
2848  case BuiltinType::SatULongFract:
2849  return false;
2850 
2851  case BuiltinType::Dependent:
2852 #define BUILTIN_TYPE(Id, SingletonId)
2853 #define PLACEHOLDER_TYPE(Id, SingletonId) \
2854  case BuiltinType::Id:
2855 #include "clang/AST/BuiltinTypes.def"
2856  llvm_unreachable("asking for RRTI for a placeholder type!");
2857 
2858  case BuiltinType::ObjCId:
2859  case BuiltinType::ObjCClass:
2860  case BuiltinType::ObjCSel:
2861  llvm_unreachable("FIXME: Objective-C types are unsupported!");
2862  }
2863 
2864  llvm_unreachable("Invalid BuiltinType Kind!");
2865 }
2866 
2867 static bool TypeInfoIsInStandardLibrary(const PointerType *PointerTy) {
2868  QualType PointeeTy = PointerTy->getPointeeType();
2869  const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(PointeeTy);
2870  if (!BuiltinTy)
2871  return false;
2872 
2873  // Check the qualifiers.
2874  Qualifiers Quals = PointeeTy.getQualifiers();
2875  Quals.removeConst();
2876 
2877  if (!Quals.empty())
2878  return false;
2879 
2880  return TypeInfoIsInStandardLibrary(BuiltinTy);
2881 }
2882 
2883 /// IsStandardLibraryRTTIDescriptor - Returns whether the type
2884 /// information for the given type exists in the standard library.
2886  // Type info for builtin types is defined in the standard library.
2887  if (const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(Ty))
2888  return TypeInfoIsInStandardLibrary(BuiltinTy);
2889 
2890  // Type info for some pointer types to builtin types is defined in the
2891  // standard library.
2892  if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2893  return TypeInfoIsInStandardLibrary(PointerTy);
2894 
2895  return false;
2896 }
2897 
2898 /// ShouldUseExternalRTTIDescriptor - Returns whether the type information for
2899 /// the given type exists somewhere else, and that we should not emit the type
2900 /// information in this translation unit. Assumes that it is not a
2901 /// standard-library type.
2903  QualType Ty) {
2904  ASTContext &Context = CGM.getContext();
2905 
2906  // If RTTI is disabled, assume it might be disabled in the
2907  // translation unit that defines any potential key function, too.
2908  if (!Context.getLangOpts().RTTI) return false;
2909 
2910  if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2911  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
2912  if (!RD->hasDefinition())
2913  return false;
2914 
2915  if (!RD->isDynamicClass())
2916  return false;
2917 
2918  // FIXME: this may need to be reconsidered if the key function
2919  // changes.
2920  // N.B. We must always emit the RTTI data ourselves if there exists a key
2921  // function.
2922  bool IsDLLImport = RD->hasAttr<DLLImportAttr>();
2923 
2924  // Don't import the RTTI but emit it locally.
2925  if (CGM.getTriple().isWindowsGNUEnvironment() && IsDLLImport)
2926  return false;
2927 
2928  if (CGM.getVTables().isVTableExternal(RD))
2929  return IsDLLImport && !CGM.getTriple().isWindowsItaniumEnvironment()
2930  ? false
2931  : true;
2932 
2933  if (IsDLLImport)
2934  return true;
2935  }
2936 
2937  return false;
2938 }
2939 
2940 /// IsIncompleteClassType - Returns whether the given record type is incomplete.
2941 static bool IsIncompleteClassType(const RecordType *RecordTy) {
2942  return !RecordTy->getDecl()->isCompleteDefinition();
2943 }
2944 
2945 /// ContainsIncompleteClassType - Returns whether the given type contains an
2946 /// incomplete class type. This is true if
2947 ///
2948 /// * The given type is an incomplete class type.
2949 /// * The given type is a pointer type whose pointee type contains an
2950 /// incomplete class type.
2951 /// * The given type is a member pointer type whose class is an incomplete
2952 /// class type.
2953 /// * The given type is a member pointer type whoise pointee type contains an
2954 /// incomplete class type.
2955 /// is an indirect or direct pointer to an incomplete class type.
2957  if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2958  if (IsIncompleteClassType(RecordTy))
2959  return true;
2960  }
2961 
2962  if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2963  return ContainsIncompleteClassType(PointerTy->getPointeeType());
2964 
2965  if (const MemberPointerType *MemberPointerTy =
2966  dyn_cast<MemberPointerType>(Ty)) {
2967  // Check if the class type is incomplete.
2968  const RecordType *ClassType = cast<RecordType>(MemberPointerTy->getClass());
2969  if (IsIncompleteClassType(ClassType))
2970  return true;
2971 
2972  return ContainsIncompleteClassType(MemberPointerTy->getPointeeType());
2973  }
2974 
2975  return false;
2976 }
2977 
2978 // CanUseSingleInheritance - Return whether the given record decl has a "single,
2979 // public, non-virtual base at offset zero (i.e. the derived class is dynamic
2980 // iff the base is)", according to Itanium C++ ABI, 2.95p6b.
2981 static bool CanUseSingleInheritance(const CXXRecordDecl *RD) {
2982  // Check the number of bases.
2983  if (RD->getNumBases() != 1)
2984  return false;
2985 
2986  // Get the base.
2988 
2989  // Check that the base is not virtual.
2990  if (Base->isVirtual())
2991  return false;
2992 
2993  // Check that the base is public.
2994  if (Base->getAccessSpecifier() != AS_public)
2995  return false;
2996 
2997  // Check that the class is dynamic iff the base is.
2998  const CXXRecordDecl *BaseDecl =
2999  cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3000  if (!BaseDecl->isEmpty() &&
3001  BaseDecl->isDynamicClass() != RD->isDynamicClass())
3002  return false;
3003 
3004  return true;
3005 }
3006 
3007 void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) {
3008  // abi::__class_type_info.
3009  static const char * const ClassTypeInfo =
3010  "_ZTVN10__cxxabiv117__class_type_infoE";
3011  // abi::__si_class_type_info.
3012  static const char * const SIClassTypeInfo =
3013  "_ZTVN10__cxxabiv120__si_class_type_infoE";
3014  // abi::__vmi_class_type_info.
3015  static const char * const VMIClassTypeInfo =
3016  "_ZTVN10__cxxabiv121__vmi_class_type_infoE";
3017 
3018  const char *VTableName = nullptr;
3019 
3020  switch (Ty->getTypeClass()) {
3021 #define TYPE(Class, Base)
3022 #define ABSTRACT_TYPE(Class, Base)
3023 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3024 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3025 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
3026 #include "clang/AST/TypeNodes.def"
3027  llvm_unreachable("Non-canonical and dependent types shouldn't get here");
3028 
3029  case Type::LValueReference:
3030  case Type::RValueReference:
3031  llvm_unreachable("References shouldn't get here");
3032 
3033  case Type::Auto:
3034  case Type::DeducedTemplateSpecialization:
3035  llvm_unreachable("Undeduced type shouldn't get here");
3036 
3037  case Type::Pipe:
3038  llvm_unreachable("Pipe types shouldn't get here");
3039 
3040  case Type::Builtin:
3041  // GCC treats vector and complex types as fundamental types.
3042  case Type::Vector:
3043  case Type::ExtVector:
3044  case Type::Complex:
3045  case Type::Atomic:
3046  // FIXME: GCC treats block pointers as fundamental types?!
3047  case Type::BlockPointer:
3048  // abi::__fundamental_type_info.
3049  VTableName = "_ZTVN10__cxxabiv123__fundamental_type_infoE";
3050  break;
3051 
3052  case Type::ConstantArray:
3053  case Type::IncompleteArray:
3054  case Type::VariableArray:
3055  // abi::__array_type_info.
3056  VTableName = "_ZTVN10__cxxabiv117__array_type_infoE";
3057  break;
3058 
3059  case Type::FunctionNoProto:
3060  case Type::FunctionProto:
3061  // abi::__function_type_info.
3062  VTableName = "_ZTVN10__cxxabiv120__function_type_infoE";
3063  break;
3064 
3065  case Type::Enum:
3066  // abi::__enum_type_info.
3067  VTableName = "_ZTVN10__cxxabiv116__enum_type_infoE";
3068  break;
3069 
3070  case Type::Record: {
3071  const CXXRecordDecl *RD =
3072  cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
3073 
3074  if (!RD->hasDefinition() || !RD->getNumBases()) {
3075  VTableName = ClassTypeInfo;
3076  } else if (CanUseSingleInheritance(RD)) {
3077  VTableName = SIClassTypeInfo;
3078  } else {
3079  VTableName = VMIClassTypeInfo;
3080  }
3081 
3082  break;
3083  }
3084 
3085  case Type::ObjCObject:
3086  // Ignore protocol qualifiers.
3087  Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr();
3088 
3089  // Handle id and Class.
3090  if (isa<BuiltinType>(Ty)) {
3091  VTableName = ClassTypeInfo;
3092  break;
3093  }
3094 
3095  assert(isa<ObjCInterfaceType>(Ty));
3096  LLVM_FALLTHROUGH;
3097 
3098  case Type::ObjCInterface:
3099  if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
3100  VTableName = SIClassTypeInfo;
3101  } else {
3102  VTableName = ClassTypeInfo;
3103  }
3104  break;
3105 
3106  case Type::ObjCObjectPointer:
3107  case Type::Pointer:
3108  // abi::__pointer_type_info.
3109  VTableName = "_ZTVN10__cxxabiv119__pointer_type_infoE";
3110  break;
3111 
3112  case Type::MemberPointer:
3113  // abi::__pointer_to_member_type_info.
3114  VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE";
3115  break;
3116  }
3117 
3118  llvm::Constant *VTable =
3119  CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy);
3120  CGM.setDSOLocal(cast<llvm::GlobalValue>(VTable->stripPointerCasts()));
3121 
3122  llvm::Type *PtrDiffTy =
3124 
3125  // The vtable address point is 2.
3126  llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
3127  VTable =
3128  llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
3129  VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
3130 
3131  Fields.push_back(VTable);
3132 }
3133 
3134 /// Return the linkage that the type info and type info name constants
3135 /// should have for the given type.
3136 static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
3137  QualType Ty) {
3138  // Itanium C++ ABI 2.9.5p7:
3139  // In addition, it and all of the intermediate abi::__pointer_type_info
3140  // structs in the chain down to the abi::__class_type_info for the
3141  // incomplete class type must be prevented from resolving to the
3142  // corresponding type_info structs for the complete class type, possibly
3143  // by making them local static objects. Finally, a dummy class RTTI is
3144  // generated for the incomplete type that will not resolve to the final
3145  // complete class RTTI (because the latter need not exist), possibly by
3146  // making it a local static object.
3149 
3150  switch (Ty->getLinkage()) {
3151  case NoLinkage:
3152  case InternalLinkage:
3153  case UniqueExternalLinkage:
3155 
3156  case VisibleNoLinkage:
3157  case ModuleInternalLinkage:
3158  case ModuleLinkage:
3159  case ExternalLinkage:
3160  // RTTI is not enabled, which means that this type info struct is going
3161  // to be used for exception handling. Give it linkonce_odr linkage.
3162  if (!CGM.getLangOpts().RTTI)
3163  return llvm::GlobalValue::LinkOnceODRLinkage;
3164 
3165  if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
3166  const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
3167  if (RD->hasAttr<WeakAttr>())
3168  return llvm::GlobalValue::WeakODRLinkage;
3169  if (CGM.getTriple().isWindowsItaniumEnvironment())
3170  if (RD->hasAttr<DLLImportAttr>() &&
3173  // MinGW always uses LinkOnceODRLinkage for type info.
3174  if (RD->isDynamicClass() &&
3175  !CGM.getContext()
3176  .getTargetInfo()
3177  .getTriple()
3178  .isWindowsGNUEnvironment())
3179  return CGM.getVTableLinkage(RD);
3180  }
3181 
3182  return llvm::GlobalValue::LinkOnceODRLinkage;
3183  }
3184 
3185  llvm_unreachable("Invalid linkage!");
3186 }
3187 
3188 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty) {
3189  // We want to operate on the canonical type.
3190  Ty = Ty.getCanonicalType();
3191 
3192  // Check if we've already emitted an RTTI descriptor for this type.
3193  SmallString<256> Name;
3194  llvm::raw_svector_ostream Out(Name);
3195  CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
3196 
3197  llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name);
3198  if (OldGV && !OldGV->isDeclaration()) {
3199  assert(!OldGV->hasAvailableExternallyLinkage() &&
3200  "available_externally typeinfos not yet implemented");
3201 
3202  return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy);
3203  }
3204 
3205  // Check if there is already an external RTTI descriptor for this type.
3208  return GetAddrOfExternalRTTIDescriptor(Ty);
3209 
3210  // Emit the standard library with external linkage.
3211  llvm::GlobalVariable::LinkageTypes Linkage = getTypeInfoLinkage(CGM, Ty);
3212 
3213  // Give the type_info object and name the formal visibility of the
3214  // type itself.
3215  llvm::GlobalValue::VisibilityTypes llvmVisibility;
3216  if (llvm::GlobalValue::isLocalLinkage(Linkage))
3217  // If the linkage is local, only default visibility makes sense.
3218  llvmVisibility = llvm::GlobalValue::DefaultVisibility;
3219  else if (CXXABI.classifyRTTIUniqueness(Ty, Linkage) ==
3220  ItaniumCXXABI::RUK_NonUniqueHidden)
3221  llvmVisibility = llvm::GlobalValue::HiddenVisibility;
3222  else
3223  llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
3224 
3225  llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass =
3226  llvm::GlobalValue::DefaultStorageClass;
3227  if (CGM.getTriple().isWindowsItaniumEnvironment()) {
3228  auto RD = Ty->getAsCXXRecordDecl();
3229  if (RD && RD->hasAttr<DLLExportAttr>())
3230  DLLStorageClass = llvm::GlobalValue::DLLExportStorageClass;
3231  }
3232 
3233  return BuildTypeInfo(Ty, Linkage, llvmVisibility, DLLStorageClass);
3234 }
3235 
3236 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(
3237  QualType Ty,
3238  llvm::GlobalVariable::LinkageTypes Linkage,
3239  llvm::GlobalValue::VisibilityTypes Visibility,
3240  llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass) {
3241  // Add the vtable pointer.
3242  BuildVTablePointer(cast<Type>(Ty));
3243 
3244  // And the name.
3245  llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage);
3246  llvm::Constant *TypeNameField;
3247 
3248  // If we're supposed to demote the visibility, be sure to set a flag
3249  // to use a string comparison for type_info comparisons.
3250  ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
3251  CXXABI.classifyRTTIUniqueness(Ty, Linkage);
3252  if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
3253  // The flag is the sign bit, which on ARM64 is defined to be clear
3254  // for global pointers. This is very ARM64-specific.
3255  TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
3256  llvm::Constant *flag =
3257  llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
3258  TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
3259  TypeNameField =
3260  llvm::ConstantExpr::getIntToPtr(TypeNameField, CGM.Int8PtrTy);
3261  } else {
3262  TypeNameField = llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy);
3263  }
3264  Fields.push_back(TypeNameField);
3265 
3266  switch (Ty->getTypeClass()) {
3267 #define TYPE(Class, Base)
3268 #define ABSTRACT_TYPE(Class, Base)
3269 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3270 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3271 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
3272 #include "clang/AST/TypeNodes.def"
3273  llvm_unreachable("Non-canonical and dependent types shouldn't get here");
3274 
3275  // GCC treats vector types as fundamental types.
3276  case Type::Builtin:
3277  case Type::Vector:
3278  case Type::ExtVector:
3279  case Type::Complex:
3280  case Type::BlockPointer:
3281  // Itanium C++ ABI 2.9.5p4:
3282  // abi::__fundamental_type_info adds no data members to std::type_info.
3283  break;
3284 
3285  case Type::LValueReference:
3286  case Type::RValueReference:
3287  llvm_unreachable("References shouldn't get here");
3288 
3289  case Type::Auto:
3290  case Type::DeducedTemplateSpecialization:
3291  llvm_unreachable("Undeduced type shouldn't get here");
3292 
3293  case Type::Pipe:
3294  llvm_unreachable("Pipe type shouldn't get here");
3295 
3296  case Type::ConstantArray:
3297  case Type::IncompleteArray:
3298  case Type::VariableArray:
3299  // Itanium C++ ABI 2.9.5p5:
3300  // abi::__array_type_info adds no data members to std::type_info.
3301  break;
3302 
3303  case Type::FunctionNoProto:
3304  case Type::FunctionProto:
3305  // Itanium C++ ABI 2.9.5p5:
3306  // abi::__function_type_info adds no data members to std::type_info.
3307  break;
3308 
3309  case Type::Enum:
3310  // Itanium C++ ABI 2.9.5p5:
3311  // abi::__enum_type_info adds no data members to std::type_info.
3312  break;
3313 
3314  case Type::Record: {
3315  const CXXRecordDecl *RD =
3316  cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
3317  if (!RD->hasDefinition() || !RD->getNumBases()) {
3318  // We don't need to emit any fields.
3319  break;
3320  }
3321 
3322  if (CanUseSingleInheritance(RD))
3323  BuildSIClassTypeInfo(RD);
3324  else
3325  BuildVMIClassTypeInfo(RD);
3326 
3327  break;
3328  }
3329 
3330  case Type::ObjCObject:
3331  case Type::ObjCInterface:
3332  BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty));
3333  break;
3334 
3335  case Type::ObjCObjectPointer:
3336  BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->getPointeeType());
3337  break;
3338 
3339  case Type::Pointer:
3340  BuildPointerTypeInfo(cast<PointerType>(Ty)->getPointeeType());
3341  break;
3342 
3343  case Type::MemberPointer:
3344  BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty));
3345  break;
3346 
3347  case Type::Atomic:
3348  // No fields, at least for the moment.
3349  break;
3350  }
3351 
3352  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);
3353 
3354  SmallString<256> Name;
3355  llvm::raw_svector_ostream Out(Name);
3356  CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
3357  llvm::Module &M = CGM.getModule();
3358  llvm::GlobalVariable *OldGV = M.getNamedGlobal(Name);
3359  llvm::GlobalVariable *GV =
3360  new llvm::GlobalVariable(M, Init->getType(),
3361  /*Constant=*/true, Linkage, Init, Name);
3362 
3363  // If there's already an old global variable, replace it with the new one.
3364  if (OldGV) {
3365  GV->takeName(OldGV);
3366  llvm::Constant *NewPtr =
3367  llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
3368  OldGV->replaceAllUsesWith(NewPtr);
3369  OldGV->eraseFromParent();
3370  }
3371 
3372  if (CGM.supportsCOMDAT() && GV->isWeakForLinker())
3373  GV->setComdat(M.getOrInsertComdat(GV->getName()));
3374 
3375  CharUnits Align =
3377  GV->setAlignment(Align.getQuantity());
3378 
3379  // The Itanium ABI specifies that type_info objects must be globally
3380  // unique, with one exception: if the type is an incomplete class
3381  // type or a (possibly indirect) pointer to one. That exception
3382  // affects the general case of comparing type_info objects produced
3383  // by the typeid operator, which is why the comparison operators on
3384  // std::type_info generally use the type_info name pointers instead
3385  // of the object addresses. However, the language's built-in uses
3386  // of RTTI generally require class types to be complete, even when
3387  // manipulating pointers to those class types. This allows the
3388  // implementation of dynamic_cast to rely on address equality tests,
3389  // which is much faster.
3390 
3391  // All of this is to say that it's important that both the type_info
3392  // object and the type_info name be uniqued when weakly emitted.
3393 
3394  TypeName->setVisibility(Visibility);
3395  CGM.setDSOLocal(TypeName);
3396 
3397  GV->setVisibility(Visibility);
3398  CGM.setDSOLocal(GV);
3399 
3400  TypeName->setDLLStorageClass(DLLStorageClass);
3401  GV->setDLLStorageClass(DLLStorageClass);
3402 
3403  return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
3404 }
3405 
3406 /// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info
3407 /// for the given Objective-C object type.
3408 void ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) {
3409  // Drop qualifiers.
3410  const Type *T = OT->getBaseType().getTypePtr();
3411  assert(isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T));
3412 
3413  // The builtin types are abi::__class_type_infos and don't require
3414  // extra fields.
3415  if (isa<BuiltinType>(T)) return;
3416 
3417  ObjCInterfaceDecl *Class = cast<ObjCInterfaceType>(T)->getDecl();
3418  ObjCInterfaceDecl *Super = Class->getSuperClass();
3419 
3420  // Root classes are also __class_type_info.
3421  if (!Super) return;
3422 
3423  QualType SuperTy = CGM.getContext().getObjCInterfaceType(Super);
3424 
3425  // Everything else is single inheritance.
3426  llvm::Constant *BaseTypeInfo =
3427  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(SuperTy);
3428  Fields.push_back(BaseTypeInfo);
3429 }
3430 
3431 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
3432 /// inheritance, according to the Itanium C++ ABI, 2.95p6b.
3433 void ItaniumRTTIBuilder::BuildSIClassTypeInfo(const CXXRecordDecl *RD) {
3434  // Itanium C++ ABI 2.9.5p6b:
3435  // It adds to abi::__class_type_info a single member pointing to the
3436  // type_info structure for the base type,
3437  llvm::Constant *BaseTypeInfo =
3438  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(RD->bases_begin()->getType());
3439  Fields.push_back(BaseTypeInfo);
3440 }
3441 
3442 namespace {
3443  /// SeenBases - Contains virtual and non-virtual bases seen when traversing
3444  /// a class hierarchy.
3445  struct SeenBases {
3446  llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases;
3447  llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases;
3448  };
3449 }
3450 
3451 /// ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in
3452 /// abi::__vmi_class_type_info.
3453 ///
3455  SeenBases &Bases) {
3456 
3457  unsigned Flags = 0;
3458 
3459  const CXXRecordDecl *BaseDecl =
3460  cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3461 
3462  if (Base->isVirtual()) {
3463  // Mark the virtual base as seen.
3464  if (!Bases.VirtualBases.insert(BaseDecl).second) {
3465  // If this virtual base has been seen before, then the class is diamond
3466  // shaped.
3467  Flags |= ItaniumRTTIBuilder::VMI_DiamondShaped;
3468  } else {
3469  if (Bases.NonVirtualBases.count(BaseDecl))
3470  Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3471  }
3472  } else {
3473  // Mark the non-virtual base as seen.
3474  if (!Bases.NonVirtualBases.insert(BaseDecl).second) {
3475  // If this non-virtual base has been seen before, then the class has non-
3476  // diamond shaped repeated inheritance.
3477  Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3478  } else {
3479  if (Bases.VirtualBases.count(BaseDecl))
3480  Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3481  }
3482  }
3483 
3484  // Walk all bases.
3485  for (const auto &I : BaseDecl->bases())
3486  Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3487 
3488  return Flags;
3489 }
3490 
3491 static unsigned ComputeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) {
3492  unsigned Flags = 0;
3493  SeenBases Bases;
3494 
3495  // Walk all bases.
3496  for (const auto &I : RD->bases())
3497  Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3498 
3499  return Flags;
3500 }
3501 
3502 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
3503 /// classes with bases that do not satisfy the abi::__si_class_type_info
3504 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
3505 void ItaniumRTTIBuilder::BuildVMIClassTypeInfo(const CXXRecordDecl *RD) {
3506  llvm::Type *UnsignedIntLTy =
3508 
3509  // Itanium C++ ABI 2.9.5p6c:
3510  // __flags is a word with flags describing details about the class
3511  // structure, which may be referenced by using the __flags_masks
3512  // enumeration. These flags refer to both direct and indirect bases.
3513  unsigned Flags = ComputeVMIClassTypeInfoFlags(RD);
3514  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3515 
3516  // Itanium C++ ABI 2.9.5p6c:
3517  // __base_count is a word with the number of direct proper base class
3518  // descriptions that follow.
3519  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases()));
3520 
3521  if (!RD->getNumBases())
3522  return;
3523 
3524  // Now add the base class descriptions.
3525 
3526  // Itanium C++ ABI 2.9.5p6c:
3527  // __base_info[] is an array of base class descriptions -- one for every
3528  // direct proper base. Each description is of the type:
3529  //
3530  // struct abi::__base_class_type_info {
3531  // public:
3532  // const __class_type_info *__base_type;
3533  // long __offset_flags;
3534  //
3535  // enum __offset_flags_masks {
3536  // __virtual_mask = 0x1,
3537  // __public_mask = 0x2,
3538  // __offset_shift = 8
3539  // };
3540  // };
3541 
3542  // If we're in mingw and 'long' isn't wide enough for a pointer, use 'long
3543  // long' instead of 'long' for __offset_flags. libstdc++abi uses long long on
3544  // LLP64 platforms.
3545  // FIXME: Consider updating libc++abi to match, and extend this logic to all
3546  // LLP64 platforms.
3547  QualType OffsetFlagsTy = CGM.getContext().LongTy;
3548  const TargetInfo &TI = CGM.getContext().getTargetInfo();
3549  if (TI.getTriple().isOSCygMing() && TI.getPointerWidth(0) > TI.getLongWidth())
3550  OffsetFlagsTy = CGM.getContext().LongLongTy;
3551  llvm::Type *OffsetFlagsLTy =
3552  CGM.getTypes().ConvertType(OffsetFlagsTy);
3553 
3554  for (const auto &Base : RD->bases()) {
3555  // The __base_type member points to the RTTI for the base type.
3556  Fields.push_back(ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(Base.getType()));
3557 
3558  const CXXRecordDecl *BaseDecl =
3559  cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
3560 
3561  int64_t OffsetFlags = 0;
3562 
3563  // All but the lower 8 bits of __offset_flags are a signed offset.
3564  // For a non-virtual base, this is the offset in the object of the base
3565  // subobject. For a virtual base, this is the offset in the virtual table of
3566  // the virtual base offset for the virtual base referenced (negative).
3567  CharUnits Offset;
3568  if (Base.isVirtual())
3569  Offset =
3571  else {
3572  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3573  Offset = Layout.getBaseClassOffset(BaseDecl);
3574  };
3575 
3576  OffsetFlags = uint64_t(Offset.getQuantity()) << 8;
3577 
3578  // The low-order byte of __offset_flags contains flags, as given by the
3579  // masks from the enumeration __offset_flags_masks.
3580  if (Base.isVirtual())
3581  OffsetFlags |= BCTI_Virtual;
3582  if (Base.getAccessSpecifier() == AS_public)
3583  OffsetFlags |= BCTI_Public;
3584 
3585  Fields.push_back(llvm::ConstantInt::get(OffsetFlagsLTy, OffsetFlags));
3586  }
3587 }
3588 
3589 /// Compute the flags for a __pbase_type_info, and remove the corresponding
3590 /// pieces from \p Type.
3591 static unsigned extractPBaseFlags(ASTContext &Ctx, QualType &Type) {
3592  unsigned Flags = 0;
3593 
3594  if (Type.isConstQualified())
3595  Flags |= ItaniumRTTIBuilder::PTI_Const;
3596  if (Type.isVolatileQualified())
3597  Flags |= ItaniumRTTIBuilder::PTI_Volatile;
3598  if (Type.isRestrictQualified())
3599  Flags |= ItaniumRTTIBuilder::PTI_Restrict;
3600  Type = Type.getUnqualifiedType();
3601 
3602  // Itanium C++ ABI 2.9.5p7:
3603  // When the abi::__pbase_type_info is for a direct or indirect pointer to an
3604  // incomplete class type, the incomplete target type flag is set.
3605  if (ContainsIncompleteClassType(Type))
3606  Flags |= ItaniumRTTIBuilder::PTI_Incomplete;
3607 
3608  if (auto *Proto = Type->getAs<FunctionProtoType>()) {
3609  if (Proto->isNothrow()) {
3610  Flags |= ItaniumRTTIBuilder::PTI_Noexcept;
3611  Type = Ctx.getFunctionTypeWithExceptionSpec(Type, EST_None);
3612  }
3613  }
3614 
3615  return Flags;
3616 }
3617 
3618 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct,
3619 /// used for pointer types.
3620 void ItaniumRTTIBuilder::BuildPointerTypeInfo(QualType PointeeTy) {
3621  // Itanium C++ ABI 2.9.5p7:
3622  // __flags is a flag word describing the cv-qualification and other
3623  // attributes of the type pointed to
3624  unsigned Flags = extractPBaseFlags(CGM.getContext(), PointeeTy);
3625 
3626  llvm::Type *UnsignedIntLTy =
3628  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3629 
3630  // Itanium C++ ABI 2.9.5p7:
3631  // __pointee is a pointer to the std::type_info derivation for the
3632  // unqualified type being pointed to.
3633  llvm::Constant *PointeeTypeInfo =
3634  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(PointeeTy);
3635  Fields.push_back(PointeeTypeInfo);
3636 }
3637 
3638 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
3639 /// struct, used for member pointer types.
3640 void
3641 ItaniumRTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) {
3642  QualType PointeeTy = Ty->getPointeeType();
3643 
3644  // Itanium C++ ABI 2.9.5p7:
3645  // __flags is a flag word describing the cv-qualification and other
3646  // attributes of the type pointed to.
3647  unsigned Flags = extractPBaseFlags(CGM.getContext(), PointeeTy);
3648 
3649  const RecordType *ClassType = cast<RecordType>(Ty->getClass());
3650  if (IsIncompleteClassType(ClassType))
3651  Flags |= PTI_ContainingClassIncomplete;
3652 
3653  llvm::Type *UnsignedIntLTy =
3655  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3656 
3657  // Itanium C++ ABI 2.9.5p7:
3658  // __pointee is a pointer to the std::type_info derivation for the
3659  // unqualified type being pointed to.
3660  llvm::Constant *PointeeTypeInfo =
3661  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(PointeeTy);
3662  Fields.push_back(PointeeTypeInfo);
3663 
3664  // Itanium C++ ABI 2.9.5p9:
3665  // __context is a pointer to an abi::__class_type_info corresponding to the
3666  // class type containing the member pointed to
3667  // (e.g., the "A" in "int A::*").
3668  Fields.push_back(
3669  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(QualType(ClassType, 0)));
3670 }
3671 
3672 llvm::Constant *ItaniumCXXABI::getAddrOfRTTIDescriptor(QualType Ty) {
3673  return ItaniumRTTIBuilder(*this).BuildTypeInfo(Ty);
3674 }
3675 
3676 void ItaniumCXXABI::EmitFundamentalRTTIDescriptors(const CXXRecordDecl *RD) {
3677  // Types added here must also be added to TypeInfoIsInStandardLibrary.
3678  QualType FundamentalTypes[] = {
3679  getContext().VoidTy, getContext().NullPtrTy,
3680  getContext().BoolTy, getContext().WCharTy,
3681  getContext().CharTy, getContext().UnsignedCharTy,
3682  getContext().SignedCharTy, getContext().ShortTy,
3683  getContext().UnsignedShortTy, getContext().IntTy,
3684  getContext().UnsignedIntTy, getContext().LongTy,
3685  getContext().UnsignedLongTy, getContext().LongLongTy,
3686  getContext().UnsignedLongLongTy, getContext().Int128Ty,
3687  getContext().UnsignedInt128Ty, getContext().HalfTy,
3688  getContext().FloatTy, getContext().DoubleTy,
3689  getContext().LongDoubleTy, getContext().Float128Ty,
3690  getContext().Char8Ty, getContext().Char16Ty,
3691  getContext().Char32Ty
3692  };
3693  llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass =
3694  RD->hasAttr<DLLExportAttr>()
3695  ? llvm::GlobalValue::DLLExportStorageClass
3696  : llvm::GlobalValue::DefaultStorageClass;
3697  llvm::GlobalValue::VisibilityTypes Visibility =
3699  for (const QualType &FundamentalType : FundamentalTypes) {
3700  QualType PointerType = getContext().getPointerType(FundamentalType);
3701  QualType PointerTypeConst = getContext().getPointerType(
3702  FundamentalType.withConst());
3703  for (QualType Type : {FundamentalType, PointerType, PointerTypeConst})
3704  ItaniumRTTIBuilder(*this).BuildTypeInfo(
3706  Visibility, DLLStorageClass);
3707  }
3708 }
3709 
3710 /// What sort of uniqueness rules should we use for the RTTI for the
3711 /// given type?
3712 ItaniumCXXABI::RTTIUniquenessKind ItaniumCXXABI::classifyRTTIUniqueness(
3713  QualType CanTy, llvm::GlobalValue::LinkageTypes Linkage) const {
3714  if (shouldRTTIBeUnique())
3715  return RUK_Unique;
3716 
3717  // It's only necessary for linkonce_odr or weak_odr linkage.
3718  if (Linkage != llvm::GlobalValue::LinkOnceODRLinkage &&
3719  Linkage != llvm::GlobalValue::WeakODRLinkage)
3720  return RUK_Unique;
3721 
3722  // It's only necessary with default visibility.
3723  if (CanTy->getVisibility() != DefaultVisibility)
3724  return RUK_Unique;
3725 
3726  // If we're not required to publish this symbol, hide it.
3727  if (Linkage == llvm::GlobalValue::LinkOnceODRLinkage)
3728  return RUK_NonUniqueHidden;
3729 
3730  // If we're required to publish this symbol, as we might be under an
3731  // explicit instantiation, leave it with default visibility but
3732  // enable string-comparisons.
3733  assert(Linkage == llvm::GlobalValue::WeakODRLinkage);
3734  return RUK_NonUniqueVisible;
3735 }
3736 
3737 // Find out how to codegen the complete destructor and constructor
3738 namespace {
3739 enum class StructorCodegen { Emit, RAUW, Alias, COMDAT };
3740 }
3742  const CXXMethodDecl *MD) {
3743  if (!CGM.getCodeGenOpts().CXXCtorDtorAliases)
3744  return StructorCodegen::Emit;
3745 
3746  // The complete and base structors are not equivalent if there are any virtual
3747  // bases, so emit separate functions.
3748  if (MD->getParent()->getNumVBases())
3749  return StructorCodegen::Emit;
3750 
3751  GlobalDecl AliasDecl;
3752  if (const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3753  AliasDecl = GlobalDecl(DD, Dtor_Complete);
3754  } else {
3755  const auto *CD = cast<CXXConstructorDecl>(MD);
3756  AliasDecl = GlobalDecl(CD, Ctor_Complete);
3757  }
3758  llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3759 
3760  if (llvm::GlobalValue::isDiscardableIfUnused(Linkage))
3761  return StructorCodegen::RAUW;
3762 
3763  // FIXME: Should we allow available_externally aliases?
3764  if (!llvm::GlobalAlias::isValidLinkage(Linkage))
3765  return StructorCodegen::RAUW;
3766 
3767  if (llvm::GlobalValue::isWeakForLinker(Linkage)) {
3768  // Only ELF and wasm support COMDATs with arbitrary names (C5/D5).
3769  if (CGM.getTarget().getTriple().isOSBinFormatELF() ||
3770  CGM.getTarget().getTriple().isOSBinFormatWasm())
3771  return StructorCodegen::COMDAT;
3772  return StructorCodegen::Emit;
3773  }
3774 
3775  return StructorCodegen::Alias;
3776 }
3777 
3779  GlobalDecl AliasDecl,
3780  GlobalDecl TargetDecl) {
3781  llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3782 
3783  StringRef MangledName = CGM.getMangledName(AliasDecl);
3784  llvm::GlobalValue *Entry = CGM.GetGlobalValue(MangledName);
3785  if (Entry && !Entry->isDeclaration())
3786  return;
3787 
3788  auto *Aliasee = cast<llvm::GlobalValue>(CGM.GetAddrOfGlobal(TargetDecl));
3789 
3790  // Create the alias with no name.
3791  auto *Alias = llvm::GlobalAlias::create(Linkage, "", Aliasee);
3792 
3793  // Constructors and destructors are always unnamed_addr.
3794  Alias->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3795 
3796  // Switch any previous uses to the alias.
3797  if (Entry) {
3798  assert(Entry->getType() == Aliasee->getType() &&
3799  "declaration exists with different type");
3800  Alias->takeName(Entry);
3801  Entry->replaceAllUsesWith(Alias);
3802  Entry->eraseFromParent();
3803  } else {
3804  Alias->setName(MangledName);
3805  }
3806 
3807  // Finally, set up the alias with its proper name and attributes.
3808  CGM.SetCommonAttributes(AliasDecl, Alias);
3809 }
3810 
3811 void ItaniumCXXABI::emitCXXStructor(const CXXMethodDecl *MD,
3812  StructorType Type) {
3813  auto *CD = dyn_cast<CXXConstructorDecl>(MD);
3814  const CXXDestructorDecl *DD = CD ? nullptr : cast<CXXDestructorDecl>(MD);
3815 
3816  StructorCodegen CGType = getCodegenToUse(CGM, MD);
3817 
3818  if (Type == StructorType::Complete) {
3819  GlobalDecl CompleteDecl;
3820  GlobalDecl BaseDecl;
3821  if (CD) {
3822  CompleteDecl = GlobalDecl(CD, Ctor_Complete);
3823  BaseDecl = GlobalDecl(CD, Ctor_Base);
3824  } else {
3825  CompleteDecl = GlobalDecl(DD, Dtor_Complete);
3826  BaseDecl = GlobalDecl(DD, Dtor_Base);
3827  }
3828 
3829  if (CGType == StructorCodegen::Alias || CGType == StructorCodegen::COMDAT) {
3830  emitConstructorDestructorAlias(CGM, CompleteDecl, BaseDecl);
3831  return;
3832  }
3833 
3834  if (CGType == StructorCodegen::RAUW) {
3835  StringRef MangledName = CGM.getMangledName(CompleteDecl);
3836  auto *Aliasee = CGM.GetAddrOfGlobal(BaseDecl);
3837  CGM.addReplacement(MangledName, Aliasee);
3838  return;
3839  }
3840  }
3841 
3842  // The base destructor is equivalent to the base destructor of its
3843  // base class if there is exactly one non-virtual base class with a
3844  // non-trivial destructor, there are no fields with a non-trivial
3845  // destructor, and the body of the destructor is trivial.
3846  if (DD && Type == StructorType::Base && CGType != StructorCodegen::COMDAT &&
3848  return;
3849 
3850  // FIXME: The deleting destructor is equivalent to the selected operator
3851  // delete if:
3852  // * either the delete is a destroying operator delete or the destructor
3853  // would be trivial if it weren't virtual,
3854  // * the conversion from the 'this' parameter to the first parameter of the
3855  // destructor is equivalent to a bitcast,
3856  // * the destructor does not have an implicit "this" return, and
3857  // * the operator delete has the same calling convention and IR function type
3858  // as the destructor.
3859  // In such cases we should try to emit the deleting dtor as an alias to the
3860  // selected 'operator delete'.
3861 
3862  llvm::Function *Fn = CGM.codegenCXXStructor(MD, Type);
3863 
3864  if (CGType == StructorCodegen::COMDAT) {
3865  SmallString<256> Buffer;
3866  llvm::raw_svector_ostream Out(Buffer);
3867  if (DD)
3868  getMangleContext().mangleCXXDtorComdat(DD, Out);
3869  else
3870  getMangleContext().mangleCXXCtorComdat(CD, Out);
3871  llvm::Comdat *C = CGM.getModule().getOrInsertComdat(Out.str());
3872  Fn->setComdat(C);
3873  } else {
3874  CGM.maybeSetTrivialComdat(*MD, *Fn);
3875  }
3876 }
3877 
3878 static llvm::Constant *getBeginCatchFn(CodeGenModule &CGM) {
3879  // void *__cxa_begin_catch(void*);
3880  llvm::FunctionType *FTy = llvm::FunctionType::get(
3881  CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3882 
3883  return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch");
3884 }
3885 
3886 static llvm::Constant *getEndCatchFn(CodeGenModule &CGM) {
3887  // void __cxa_end_catch();
3888  llvm::FunctionType *FTy =
3889  llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
3890 
3891  return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch");
3892 }
3893 
3894 static llvm::Constant *getGetExceptionPtrFn(CodeGenModule &CGM) {
3895  // void *__cxa_get_exception_ptr(void*);
3896  llvm::FunctionType *FTy = llvm::FunctionType::get(
3897  CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3898 
3899  return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr");
3900 }
3901 
3902 namespace {
3903  /// A cleanup to call __cxa_end_catch. In many cases, the caught
3904  /// exception type lets us state definitively that the thrown exception
3905  /// type does not have a destructor. In particular:
3906  /// - Catch-alls tell us nothing, so we have to conservatively
3907  /// assume that the thrown exception might have a destructor.
3908  /// - Catches by reference behave according to their base types.
3909  /// - Catches of non-record types will only trigger for exceptions
3910  /// of non-record types, which never have destructors.
3911  /// - Catches of record types can trigger for arbitrary subclasses
3912  /// of the caught type, so we have to assume the actual thrown
3913  /// exception type might have a throwing destructor, even if the
3914  /// caught type's destructor is trivial or nothrow.
3915  struct CallEndCatch final : EHScopeStack::Cleanup {
3916  CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {}
3917  bool MightThrow;
3918 
3919  void Emit(CodeGenFunction &CGF, Flags flags) override {
3920  if (!MightThrow) {
3922  return;
3923  }
3924 
3926  }
3927  };
3928 }
3929 
3930 /// Emits a call to __cxa_begin_catch and enters a cleanup to call
3931 /// __cxa_end_catch.
3932 ///
3933 /// \param EndMightThrow - true if __cxa_end_catch might throw
3935  llvm::Value *Exn,
3936  bool EndMightThrow) {
3937  llvm::CallInst *call =
3939 
3940  CGF.EHStack.pushCleanup<CallEndCatch>(NormalAndEHCleanup, EndMightThrow);
3941 
3942  return call;
3943 }
3944 
3945 /// A "special initializer" callback for initializing a catch
3946 /// parameter during catch initialization.
3948  const VarDecl &CatchParam,
3949  Address ParamAddr,
3950  SourceLocation Loc) {
3951  // Load the exception from where the landing pad saved it.
3952  llvm::Value *Exn = CGF.getExceptionFromSlot();
3953 
3954  CanQualType CatchType =
3955  CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
3956  llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
3957 
3958  // If we're catching by reference, we can just cast the object
3959  // pointer to the appropriate pointer.
3960  if (isa<ReferenceType>(CatchType)) {
3961  QualType CaughtType = cast<ReferenceType>(CatchType)->getPointeeType();
3962  bool EndCatchMightThrow = CaughtType->isRecordType();
3963 
3964  // __cxa_begin_catch returns the adjusted object pointer.
3965  llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
3966 
3967  // We have no way to tell the personality function that we're
3968  // catching by reference, so if we're catching a pointer,
3969  // __cxa_begin_catch will actually return that pointer by value.
3970  if (const PointerType *PT = dyn_cast<PointerType>(CaughtType)) {
3971  QualType PointeeType = PT->getPointeeType();
3972 
3973  // When catching by reference, generally we should just ignore
3974  // this by-value pointer and use the exception object instead.
3975  if (!PointeeType->isRecordType()) {
3976 
3977  // Exn points to the struct _Unwind_Exception header, which
3978  // we have to skip past in order to reach the exception data.
3979  unsigned HeaderSize =
3981  AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize);
3982 
3983  // However, if we're catching a pointer-to-record type that won't
3984  // work, because the personality function might have adjusted
3985  // the pointer. There's actually no way for us to fully satisfy
3986  // the language/ABI contract here: we can't use Exn because it
3987  // might have the wrong adjustment, but we can't use the by-value
3988  // pointer because it's off by a level of abstraction.
3989  //
3990  // The current solution is to dump the adjusted pointer into an
3991  // alloca, which breaks language semantics (because changing the
3992  // pointer doesn't change the exception) but at least works.
3993  // The better solution would be to filter out non-exact matches
3994  // and rethrow them, but this is tricky because the rethrow
3995  // really needs to be catchable by other sites at this landing
3996  // pad. The best solution is to fix the personality function.
3997  } else {
3998  // Pull the pointer for the reference type off.
3999  llvm::Type *PtrTy =
4000  cast<llvm::PointerType>(LLVMCatchTy)->getElementType();
4001 
4002  // Create the temporary and write the adjusted pointer into it.
4003  Address ExnPtrTmp =
4004  CGF.CreateTempAlloca(PtrTy, CGF.getPointerAlign(), "exn.byref.tmp");
4005  llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4006  CGF.Builder.CreateStore(Casted, ExnPtrTmp);
4007 
4008  // Bind the reference to the temporary.
4009  AdjustedExn = ExnPtrTmp.getPointer();
4010  }
4011  }
4012 
4013  llvm::Value *ExnCast =
4014  CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
4015  CGF.Builder.CreateStore(ExnCast, ParamAddr);
4016  return;
4017  }
4018 
4019  // Scalars and complexes.
4020  TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
4021  if (TEK != TEK_Aggregate) {
4022  llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
4023 
4024  // If the catch type is a pointer type, __cxa_begin_catch returns
4025  // the pointer by value.
4026  if (CatchType->hasPointerRepresentation()) {
4027  llvm::Value *CastExn =
4028  CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
4029 
4030  switch (CatchType.getQualifiers().getObjCLifetime()) {
4032  CastExn = CGF.EmitARCRetainNonBlock(CastExn);
4033  LLVM_FALLTHROUGH;
4034 
4035  case Qualifiers::OCL_None:
4038  CGF.Builder.CreateStore(CastExn, ParamAddr);
4039  return;
4040 
4041  case Qualifiers::OCL_Weak:
4042  CGF.EmitARCInitWeak(ParamAddr, CastExn);
4043  return;
4044  }
4045  llvm_unreachable("bad ownership qualifier!");
4046  }
4047 
4048  // Otherwise, it returns a pointer into the exception object.
4049 
4050  llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
4051  llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4052 
4053  LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType);
4054  LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType);
4055  switch (TEK) {
4056  case TEK_Complex:
4057  CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV,
4058  /*init*/ true);
4059  return;
4060  case TEK_Scalar: {
4061  llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc);
4062  CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
4063  return;
4064  }
4065  case TEK_Aggregate:
4066  llvm_unreachable("evaluation kind filtered out!");
4067  }
4068  llvm_unreachable("bad evaluation kind");
4069  }
4070 
4071  assert(isa<RecordType>(CatchType) && "unexpected catch type!");
4072  auto catchRD = CatchType->getAsCXXRecordDecl();
4073  CharUnits caughtExnAlignment = CGF.CGM.getClassPointerAlignment(catchRD);
4074 
4075  llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
4076 
4077  // Check for a copy expression. If we don't have a copy expression,
4078  // that means a trivial copy is okay.
4079  const Expr *copyExpr = CatchParam.getInit();
4080  if (!copyExpr) {
4081  llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
4082  Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4083  caughtExnAlignment);
4084  LValue Dest = CGF.MakeAddrLValue(ParamAddr, CatchType);
4085  LValue Src = CGF.MakeAddrLValue(adjustedExn, CatchType);
4086  CGF.EmitAggregateCopy(Dest, Src, CatchType, AggValueSlot::DoesNotOverlap);
4087  return;
4088  }
4089 
4090  // We have to call __cxa_get_exception_ptr to get the adjusted
4091  // pointer before copying.
4092  llvm::CallInst *rawAdjustedExn =
4094 
4095  // Cast that to the appropriate type.
4096  Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4097  caughtExnAlignment);
4098 
4099  // The copy expression is defined in terms of an OpaqueValueExpr.
4100  // Find it and map it to the adjusted expression.
4102  opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
4103  CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
4104 
4105  // Call the copy ctor in a terminate scope.
4106  CGF.EHStack.pushTerminate();
4107 
4108  // Perform the copy construction.
4109  CGF.EmitAggExpr(copyExpr,
4110  AggValueSlot::forAddr(ParamAddr, Qualifiers(),
4115 
4116  // Leave the terminate scope.
4117  CGF.EHStack.popTerminate();
4118 
4119  // Undo the opaque value mapping.
4120  opaque.pop();
4121 
4122  // Finally we can call __cxa_begin_catch.
4123  CallBeginCatch(CGF, Exn, true);
4124 }
4125 
4126 /// Begins a catch statement by initializing the catch variable and
4127 /// calling __cxa_begin_catch.
4128 void ItaniumCXXABI::emitBeginCatch(CodeGenFunction &CGF,
4129  const CXXCatchStmt *S) {
4130  // We have to be very careful with the ordering of cleanups here:
4131  // C++ [except.throw]p4:
4132  // The destruction [of the exception temporary] occurs
4133  // immediately after the destruction of the object declared in
4134  // the exception-declaration in the handler.
4135  //
4136  // So the precise ordering is:
4137  // 1. Construct catch variable.
4138  // 2. __cxa_begin_catch
4139  // 3. Enter __cxa_end_catch cleanup
4140  // 4. Enter dtor cleanup
4141  //
4142  // We do this by using a slightly abnormal initialization process.
4143  // Delegation sequence:
4144  // - ExitCXXTryStmt opens a RunCleanupsScope
4145  // - EmitAutoVarAlloca creates the variable and debug info
4146  // - InitCatchParam initializes the variable from the exception
4147  // - CallBeginCatch calls __cxa_begin_catch
4148  // - CallBeginCatch enters the __cxa_end_catch cleanup
4149  // - EmitAutoVarCleanups enters the variable destructor cleanup
4150  // - EmitCXXTryStmt emits the code for the catch body
4151  // - EmitCXXTryStmt close the RunCleanupsScope
4152 
4153  VarDecl *CatchParam = S->getExceptionDecl();
4154  if (!CatchParam) {
4155  llvm::Value *Exn = CGF.getExceptionFromSlot();
4156  CallBeginCatch(CGF, Exn, true);
4157  return;
4158  }
4159 
4160  // Emit the local.
4161  CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
4162  InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getBeginLoc());
4163  CGF.EmitAutoVarCleanups(var);
4164 }
4165 
4166 /// Get or define the following function:
4167 /// void @__clang_call_terminate(i8* %exn) nounwind noreturn
4168 /// This code is used only in C++.
4169 static llvm::Constant *getClangCallTerminateFn(CodeGenModule &CGM) {
4170  llvm::FunctionType *fnTy =
4171  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
4172  llvm::Constant *fnRef = CGM.CreateRuntimeFunction(
4173  fnTy, "__clang_call_terminate", llvm::AttributeList(), /*Local=*/true);
4174 
4175  llvm::Function *fn = dyn_cast<llvm::Function>(fnRef);
4176  if (fn && fn->empty()) {
4177  fn->setDoesNotThrow();
4178  fn->setDoesNotReturn();
4179 
4180  // What we really want is to massively penalize inlining without
4181  // forbidding it completely. The difference between that and
4182  // 'noinline' is negligible.
4183  fn->addFnAttr(llvm::Attribute::NoInline);
4184 
4185  // Allow this function to be shared across translation units, but
4186  // we don't want it to turn into an exported symbol.
4187  fn->setLinkage(llvm::Function::LinkOnceODRLinkage);
4188  fn->setVisibility(llvm::Function::HiddenVisibility);
4189  if (CGM.supportsCOMDAT())
4190  fn->setComdat(CGM.getModule().getOrInsertComdat(fn->getName()));
4191 
4192  // Set up the function.
4193  llvm::BasicBlock *entry =
4195  CGBuilderTy builder(CGM, entry);
4196 
4197  // Pull the exception pointer out of the parameter list.
4198  llvm::Value *exn = &*fn->arg_begin();
4199 
4200  // Call __cxa_begin_catch(exn).
4201  llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
4202  catchCall->setDoesNotThrow();
4203  catchCall->setCallingConv(CGM.getRuntimeCC());
4204 
4205  // Call std::terminate().
4206  llvm::CallInst *termCall = builder.CreateCall(CGM.getTerminateFn());
4207  termCall->setDoesNotThrow();
4208  termCall->setDoesNotReturn();
4209  termCall->setCallingConv(CGM.getRuntimeCC());
4210 
4211  // std::terminate cannot return.
4212  builder.CreateUnreachable();
4213  }
4214 
4215  return fnRef;
4216 }
4217 
4218 llvm::CallInst *
4219 ItaniumCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
4220  llvm::Value *Exn) {
4221  // In C++, we want to call __cxa_begin_catch() before terminating.
4222  if (Exn) {
4223  assert(CGF.CGM.getLangOpts().CPlusPlus);
4224  return CGF.EmitNounwindRuntimeCall(getClangCallTerminateFn(CGF.CGM), Exn);
4225  }
4226  return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
4227 }
4228 
4229 std::pair<llvm::Value *, const CXXRecordDecl *>
4230 ItaniumCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
4231  const CXXRecordDecl *RD) {
4232  return {CGF.GetVTablePtr(This, CGM.Int8PtrTy, RD), RD};
4233 }
4234 
4235 void WebAssemblyCXXABI::emitBeginCatch(CodeGenFunction &CGF,
4236  const CXXCatchStmt *C) {
4237  if (CGF.getTarget().hasFeature("exception-handling"))
4238  CGF.EHStack.pushCleanup<CatchRetScope>(
4239  NormalCleanup, cast<llvm::CatchPadInst>(CGF.CurrentFuncletPad));
4240  ItaniumCXXABI::emitBeginCatch(CGF, C);
4241 }
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:284
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:1024
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
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F)
Set the LLVM function attributes (sext, zext, etc).
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2543
Complete object ctor.
Definition: ABI.h:26
QualType getPointeeType() const
Definition: Type.h:2556
CanQualType VoidPtrTy
Definition: ASTContext.h:1043
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:2706
llvm::LLVMContext & getLLVMContext()
The COMDAT used for ctors.
Definition: ABI.h:28
CXXDtorType getDtorType() const
Definition: GlobalDecl.h:76
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.
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:2424
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:6355
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:2918
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:6231
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:1024
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:6122
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:689
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3564
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:2718
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
Definition: CGObjC.cpp:1966
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:3165
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:4020
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:6716
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
struct clang::ThisAdjustment::VirtualAdjustment::@135 Itanium
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:5524
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:6294
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:2816
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:2307
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:6128
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:71
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:248
const Type * getClass() const
Definition: Type.h:2796
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:6058
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:2877
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:2472
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:4405
bool hasAttr() const
Definition: DeclBase.h:531
CanQualType getReturnType() const
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5587
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:1155
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:3686
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.
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:106
static llvm::Constant * getBadTypeidFn(CodeGenFunction &CGF)
void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, llvm::Value *CompletePtr, QualType ElementType)
Definition: CGExprCXX.cpp:1841
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:6779
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:128
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...
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1379
void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function *> CXXThreadLocals, ConstantAddress Guard=ConstantAddress::invalid())
GenerateCXXGlobalInitFunc - Generates code for initializing global variables.
Definition: CGDeclCXX.cpp:622
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:159
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:6117
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
Definition: Type.h:4366
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
struct clang::ReturnAdjustment::VirtualAdjustment::@133 Itanium
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:6097
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:2792
CastKind getCastKind() const
Definition: Expr.h:2936
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:69
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:1015
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:1017
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:2762
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:1777
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:1636
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4356
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:2471
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:2263
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:2352
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:2252
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:1008
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:6138
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:2786
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:321
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:6085
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:75
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:3194
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:2397
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:1024
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:1823
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:2787
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:706
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:2782
CanQualType UnsignedIntTy
Definition: ASTContext.h:1025
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