clang  9.0.0svn
ItaniumCXXABI.cpp
Go to the documentation of this file.
1 //===------- ItaniumCXXABI.cpp - Emit LLVM Code from ASTs for a Module ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This provides C++ code generation targeting the Itanium C++ ABI. The class
10 // in this file generates structures that follow the Itanium C++ ABI, which is
11 // documented at:
12 // http://www.codesourcery.com/public/cxx-abi/abi.html
13 // http://www.codesourcery.com/public/cxx-abi/abi-eh.html
14 //
15 // It also supports the closely-related ARM ABI, documented at:
16 // http://infocenter.arm.com/help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf
17 //
18 //===----------------------------------------------------------------------===//
19 
20 #include "CGCXXABI.h"
21 #include "CGCleanup.h"
22 #include "CGRecordLayout.h"
23 #include "CGVTables.h"
24 #include "CodeGenFunction.h"
25 #include "CodeGenModule.h"
26 #include "TargetInfo.h"
28 #include "clang/AST/Mangle.h"
29 #include "clang/AST/Type.h"
30 #include "clang/AST/StmtCXX.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/GlobalValue.h"
33 #include "llvm/IR/Instructions.h"
34 #include "llvm/IR/Intrinsics.h"
35 #include "llvm/IR/Value.h"
36 #include "llvm/Support/ScopedPrinter.h"
37 
38 using namespace clang;
39 using namespace CodeGen;
40 
41 namespace {
42 class ItaniumCXXABI : public CodeGen::CGCXXABI {
43  /// VTables - All the vtables which have been defined.
44  llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> VTables;
45 
46 protected:
47  bool UseARMMethodPtrABI;
48  bool UseARMGuardVarABI;
49  bool Use32BitVTableOffsetABI;
50 
51  ItaniumMangleContext &getMangleContext() {
52  return cast<ItaniumMangleContext>(CodeGen::CGCXXABI::getMangleContext());
53  }
54 
55 public:
56  ItaniumCXXABI(CodeGen::CodeGenModule &CGM,
57  bool UseARMMethodPtrABI = false,
58  bool UseARMGuardVarABI = false) :
59  CGCXXABI(CGM), UseARMMethodPtrABI(UseARMMethodPtrABI),
60  UseARMGuardVarABI(UseARMGuardVarABI),
61  Use32BitVTableOffsetABI(false) { }
62 
63  bool classifyReturnType(CGFunctionInfo &FI) const override;
64 
65  bool passClassIndirect(const CXXRecordDecl *RD) const {
66  return !canCopyArgument(RD);
67  }
68 
69  RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override {
70  // If C++ prohibits us from making a copy, pass by address.
71  if (passClassIndirect(RD))
72  return RAA_Indirect;
73  return RAA_Default;
74  }
75 
76  bool isThisCompleteObject(GlobalDecl GD) const override {
77  // The Itanium ABI has separate complete-object vs. base-object
78  // variants of both constructors and destructors.
79  if (isa<CXXDestructorDecl>(GD.getDecl())) {
80  switch (GD.getDtorType()) {
81  case Dtor_Complete:
82  case Dtor_Deleting:
83  return true;
84 
85  case Dtor_Base:
86  return false;
87 
88  case Dtor_Comdat:
89  llvm_unreachable("emitting dtor comdat as function?");
90  }
91  llvm_unreachable("bad dtor kind");
92  }
93  if (isa<CXXConstructorDecl>(GD.getDecl())) {
94  switch (GD.getCtorType()) {
95  case Ctor_Complete:
96  return true;
97 
98  case Ctor_Base:
99  return false;
100 
101  case Ctor_CopyingClosure:
102  case Ctor_DefaultClosure:
103  llvm_unreachable("closure ctors in Itanium ABI?");
104 
105  case Ctor_Comdat:
106  llvm_unreachable("emitting ctor comdat as function?");
107  }
108  llvm_unreachable("bad dtor kind");
109  }
110 
111  // No other kinds.
112  return false;
113  }
114 
115  bool isZeroInitializable(const MemberPointerType *MPT) override;
116 
117  llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;
118 
119  CGCallee
120  EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
121  const Expr *E,
122  Address This,
123  llvm::Value *&ThisPtrForCall,
124  llvm::Value *MemFnPtr,
125  const MemberPointerType *MPT) override;
126 
127  llvm::Value *
128  EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
129  Address Base,
130  llvm::Value *MemPtr,
131  const MemberPointerType *MPT) override;
132 
133  llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
134  const CastExpr *E,
135  llvm::Value *Src) override;
136  llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
137  llvm::Constant *Src) override;
138 
139  llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override;
140 
141  llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD) override;
142  llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
143  CharUnits offset) override;
144  llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override;
145  llvm::Constant *BuildMemberPointer(const CXXMethodDecl *MD,
147 
148  llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF,
149  llvm::Value *L, llvm::Value *R,
150  const MemberPointerType *MPT,
151  bool Inequality) override;
152 
153  llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
154  llvm::Value *Addr,
155  const MemberPointerType *MPT) override;
156 
157  void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
158  Address Ptr, QualType ElementType,
159  const CXXDestructorDecl *Dtor) override;
160 
161  /// Itanium says that an _Unwind_Exception has to be "double-word"
162  /// aligned (and thus the end of it is also so-aligned), meaning 16
163  /// bytes. Of course, that was written for the actual Itanium,
164  /// which is a 64-bit platform. Classically, the ABI doesn't really
165  /// specify the alignment on other platforms, but in practice
166  /// libUnwind declares the struct with __attribute__((aligned)), so
167  /// we assume that alignment here. (It's generally 16 bytes, but
168  /// some targets overwrite it.)
169  CharUnits getAlignmentOfExnObject() {
170  auto align = CGM.getContext().getTargetDefaultAlignForAttributeAligned();
171  return CGM.getContext().toCharUnitsFromBits(align);
172  }
173 
174  void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
175  void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
176 
177  void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
178 
179  llvm::CallInst *
180  emitTerminateForUnexpectedException(CodeGenFunction &CGF,
181  llvm::Value *Exn) override;
182 
183  void EmitFundamentalRTTIDescriptors(const CXXRecordDecl *RD);
184  llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override;
186  getAddrOfCXXCatchHandlerType(QualType Ty,
187  QualType CatchHandlerType) override {
188  return CatchTypeInfo{getAddrOfRTTIDescriptor(Ty), 0};
189  }
190 
191  bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy) override;
192  void EmitBadTypeidCall(CodeGenFunction &CGF) override;
193  llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
194  Address ThisPtr,
195  llvm::Type *StdTypeInfoPtrTy) override;
196 
197  bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
198  QualType SrcRecordTy) override;
199 
200  llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
201  QualType SrcRecordTy, QualType DestTy,
202  QualType DestRecordTy,
203  llvm::BasicBlock *CastEnd) override;
204 
205  llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
206  QualType SrcRecordTy,
207  QualType DestTy) override;
208 
209  bool EmitBadCastCall(CodeGenFunction &CGF) override;
210 
211  llvm::Value *
212  GetVirtualBaseClassOffset(CodeGenFunction &CGF, Address This,
213  const CXXRecordDecl *ClassDecl,
214  const CXXRecordDecl *BaseClassDecl) override;
215 
216  void EmitCXXConstructors(const CXXConstructorDecl *D) override;
217 
218  AddedStructorArgs
219  buildStructorSignature(GlobalDecl GD,
220  SmallVectorImpl<CanQualType> &ArgTys) override;
221 
222  bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
223  CXXDtorType DT) const override {
224  // Itanium does not emit any destructor variant as an inline thunk.
225  // Delegating may occur as an optimization, but all variants are either
226  // emitted with external linkage or as linkonce if they are inline and used.
227  return false;
228  }
229 
230  void EmitCXXDestructors(const CXXDestructorDecl *D) override;
231 
232  void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
233  FunctionArgList &Params) override;
234 
235  void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override;
236 
237  AddedStructorArgs
238  addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D,
239  CXXCtorType Type, bool ForVirtualBase,
240  bool Delegating, CallArgList &Args) override;
241 
242  void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD,
243  CXXDtorType Type, bool ForVirtualBase,
244  bool Delegating, Address This) override;
245 
246  void emitVTableDefinitions(CodeGenVTables &CGVT,
247  const CXXRecordDecl *RD) override;
248 
249  bool isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
250  CodeGenFunction::VPtr Vptr) override;
251 
252  bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) override {
253  return true;
254  }
255 
256  llvm::Constant *
257  getVTableAddressPoint(BaseSubobject Base,
258  const CXXRecordDecl *VTableClass) override;
259 
260  llvm::Value *getVTableAddressPointInStructor(
261  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
262  BaseSubobject Base, const CXXRecordDecl *NearestVBase) override;
263 
264  llvm::Value *getVTableAddressPointInStructorWithVTT(
265  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass,
266  BaseSubobject Base, const CXXRecordDecl *NearestVBase);
267 
268  llvm::Constant *
269  getVTableAddressPointForConstExpr(BaseSubobject Base,
270  const CXXRecordDecl *VTableClass) override;
271 
272  llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
273  CharUnits VPtrOffset) override;
274 
275  CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
276  Address This, llvm::Type *Ty,
277  SourceLocation Loc) override;
278 
279  llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
280  const CXXDestructorDecl *Dtor,
281  CXXDtorType DtorType,
282  Address This,
283  const CXXMemberCallExpr *CE) override;
284 
285  void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override;
286 
287  bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const override;
288  bool canSpeculativelyEmitVTableAsBaseClass(const CXXRecordDecl *RD) const;
289 
290  void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, GlobalDecl GD,
291  bool ReturnAdjustment) override {
292  // Allow inlining of thunks by emitting them with available_externally
293  // linkage together with vtables when needed.
294  if (ForVTable && !Thunk->hasLocalLinkage())
295  Thunk->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
296  CGM.setGVProperties(Thunk, GD);
297  }
298 
299  bool exportThunk() override { return true; }
300 
301  llvm::Value *performThisAdjustment(CodeGenFunction &CGF, Address This,
302  const ThisAdjustment &TA) override;
303 
304  llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
305  const ReturnAdjustment &RA) override;
306 
307  size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
308  FunctionArgList &Args) const override {
309  assert(!Args.empty() && "expected the arglist to not be empty!");
310  return Args.size() - 1;
311  }
312 
313  StringRef GetPureVirtualCallName() override { return "__cxa_pure_virtual"; }
314  StringRef GetDeletedVirtualCallName() override
315  { return "__cxa_deleted_virtual"; }
316 
317  CharUnits getArrayCookieSizeImpl(QualType elementType) override;
318  Address InitializeArrayCookie(CodeGenFunction &CGF,
319  Address NewPtr,
320  llvm::Value *NumElements,
321  const CXXNewExpr *expr,
322  QualType ElementType) override;
323  llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF,
324  Address allocPtr,
325  CharUnits cookieSize) override;
326 
327  void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
328  llvm::GlobalVariable *DeclPtr,
329  bool PerformInit) override;
330  void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
331  llvm::FunctionCallee dtor,
332  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(GlobalDecl GD) 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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(GlobalDecl(DtorD, Dtor_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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee Fn = getBadTypeidFn(CGF);
1317  llvm::CallBase *Call = CGF.EmitRuntimeCallOrInvoke(Fn);
1318  Call->setDoesNotReturn();
1319  CGF.Builder.CreateUnreachable();
1320 }
1321 
1322 llvm::Value *ItaniumCXXABI::EmitTypeid(CodeGenFunction &CGF,
1323  QualType SrcRecordTy,
1324  Address ThisPtr,
1325  llvm::Type *StdTypeInfoPtrTy) {
1326  auto *ClassDecl =
1327  cast<CXXRecordDecl>(SrcRecordTy->getAs<RecordType>()->getDecl());
1328  llvm::Value *Value =
1329  CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo(), ClassDecl);
1330 
1331  // Load the type info.
1332  Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
1333  return CGF.Builder.CreateAlignedLoad(Value, CGF.getPointerAlign());
1334 }
1335 
1336 bool ItaniumCXXABI::shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
1337  QualType SrcRecordTy) {
1338  return SrcIsPtr;
1339 }
1340 
1341 llvm::Value *ItaniumCXXABI::EmitDynamicCastCall(
1342  CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
1343  QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd) {
1344  llvm::Type *PtrDiffLTy =
1346  llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1347 
1348  llvm::Value *SrcRTTI =
1349  CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1350  llvm::Value *DestRTTI =
1351  CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1352 
1353  // Compute the offset hint.
1354  const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
1355  const CXXRecordDecl *DestDecl = DestRecordTy->getAsCXXRecordDecl();
1356  llvm::Value *OffsetHint = llvm::ConstantInt::get(
1357  PtrDiffLTy,
1358  computeOffsetHint(CGF.getContext(), SrcDecl, DestDecl).getQuantity());
1359 
1360  // Emit the call to __dynamic_cast.
1361  llvm::Value *Value = ThisAddr.getPointer();
1362  Value = CGF.EmitCastToVoidPtr(Value);
1363 
1364  llvm::Value *args[] = {Value, SrcRTTI, DestRTTI, OffsetHint};
1365  Value = CGF.EmitNounwindRuntimeCall(getItaniumDynamicCastFn(CGF), args);
1366  Value = CGF.Builder.CreateBitCast(Value, DestLTy);
1367 
1368  /// C++ [expr.dynamic.cast]p9:
1369  /// A failed cast to reference type throws std::bad_cast
1370  if (DestTy->isReferenceType()) {
1371  llvm::BasicBlock *BadCastBlock =
1372  CGF.createBasicBlock("dynamic_cast.bad_cast");
1373 
1374  llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1375  CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1376 
1377  CGF.EmitBlock(BadCastBlock);
1378  EmitBadCastCall(CGF);
1379  }
1380 
1381  return Value;
1382 }
1383 
1384 llvm::Value *ItaniumCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF,
1385  Address ThisAddr,
1386  QualType SrcRecordTy,
1387  QualType DestTy) {
1388  llvm::Type *PtrDiffLTy =
1390  llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1391 
1392  auto *ClassDecl =
1393  cast<CXXRecordDecl>(SrcRecordTy->getAs<RecordType>()->getDecl());
1394  // Get the vtable pointer.
1395  llvm::Value *VTable = CGF.GetVTablePtr(ThisAddr, PtrDiffLTy->getPointerTo(),
1396  ClassDecl);
1397 
1398  // Get the offset-to-top from the vtable.
1399  llvm::Value *OffsetToTop =
1400  CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL);
1401  OffsetToTop =
1402  CGF.Builder.CreateAlignedLoad(OffsetToTop, CGF.getPointerAlign(),
1403  "offset.to.top");
1404 
1405  // Finally, add the offset to the pointer.
1406  llvm::Value *Value = ThisAddr.getPointer();
1407  Value = CGF.EmitCastToVoidPtr(Value);
1408  Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop);
1409 
1410  return CGF.Builder.CreateBitCast(Value, DestLTy);
1411 }
1412 
1413 bool ItaniumCXXABI::EmitBadCastCall(CodeGenFunction &CGF) {
1414  llvm::FunctionCallee Fn = getBadCastFn(CGF);
1415  llvm::CallBase *Call = CGF.EmitRuntimeCallOrInvoke(Fn);
1416  Call->setDoesNotReturn();
1417  CGF.Builder.CreateUnreachable();
1418  return true;
1419 }
1420 
1421 llvm::Value *
1422 ItaniumCXXABI::GetVirtualBaseClassOffset(CodeGenFunction &CGF,
1423  Address This,
1424  const CXXRecordDecl *ClassDecl,
1425  const CXXRecordDecl *BaseClassDecl) {
1426  llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy, ClassDecl);
1427  CharUnits VBaseOffsetOffset =
1428  CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(ClassDecl,
1429  BaseClassDecl);
1430 
1431  llvm::Value *VBaseOffsetPtr =
1432  CGF.Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(),
1433  "vbase.offset.ptr");
1434  VBaseOffsetPtr = CGF.Builder.CreateBitCast(VBaseOffsetPtr,
1435  CGM.PtrDiffTy->getPointerTo());
1436 
1437  llvm::Value *VBaseOffset =
1438  CGF.Builder.CreateAlignedLoad(VBaseOffsetPtr, CGF.getPointerAlign(),
1439  "vbase.offset");
1440 
1441  return VBaseOffset;
1442 }
1443 
1444 void ItaniumCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) {
1445  // Just make sure we're in sync with TargetCXXABI.
1446  assert(CGM.getTarget().getCXXABI().hasConstructorVariants());
1447 
1448  // The constructor used for constructing this as a base class;
1449  // ignores virtual bases.
1450  CGM.EmitGlobal(GlobalDecl(D, Ctor_Base));
1451 
1452  // The constructor used for constructing this as a complete class;
1453  // constructs the virtual bases, then calls the base constructor.
1454  if (!D->getParent()->isAbstract()) {
1455  // We don't need to emit the complete ctor if the class is abstract.
1456  CGM.EmitGlobal(GlobalDecl(D, Ctor_Complete));
1457  }
1458 }
1459 
1461 ItaniumCXXABI::buildStructorSignature(GlobalDecl GD,
1462  SmallVectorImpl<CanQualType> &ArgTys) {
1463  ASTContext &Context = getContext();
1464 
1465  // All parameters are already in place except VTT, which goes after 'this'.
1466  // These are Clang types, so we don't need to worry about sret yet.
1467 
1468  // Check if we need to add a VTT parameter (which has type void **).
1469  if ((isa<CXXConstructorDecl>(GD.getDecl()) ? GD.getCtorType() == Ctor_Base
1470  : GD.getDtorType() == Dtor_Base) &&
1471  cast<CXXMethodDecl>(GD.getDecl())->getParent()->getNumVBases() != 0) {
1472  ArgTys.insert(ArgTys.begin() + 1,
1473  Context.getPointerType(Context.VoidPtrTy));
1474  return AddedStructorArgs::prefix(1);
1475  }
1476  return AddedStructorArgs{};
1477 }
1478 
1479 void ItaniumCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) {
1480  // The destructor used for destructing this as a base class; ignores
1481  // virtual bases.
1482  CGM.EmitGlobal(GlobalDecl(D, Dtor_Base));
1483 
1484  // The destructor used for destructing this as a most-derived class;
1485  // call the base destructor and then destructs any virtual bases.
1486  CGM.EmitGlobal(GlobalDecl(D, Dtor_Complete));
1487 
1488  // The destructor in a virtual table is always a 'deleting'
1489  // destructor, which calls the complete destructor and then uses the
1490  // appropriate operator delete.
1491  if (D->isVirtual())
1492  CGM.EmitGlobal(GlobalDecl(D, Dtor_Deleting));
1493 }
1494 
1495 void ItaniumCXXABI::addImplicitStructorParams(CodeGenFunction &CGF,
1496  QualType &ResTy,
1497  FunctionArgList &Params) {
1498  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
1499  assert(isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD));
1500 
1501  // Check if we need a VTT parameter as well.
1502  if (NeedsVTTParameter(CGF.CurGD)) {
1503  ASTContext &Context = getContext();
1504 
1505  // FIXME: avoid the fake decl
1506  QualType T = Context.getPointerType(Context.VoidPtrTy);
1507  auto *VTTDecl = ImplicitParamDecl::Create(
1508  Context, /*DC=*/nullptr, MD->getLocation(), &Context.Idents.get("vtt"),
1510  Params.insert(Params.begin() + 1, VTTDecl);
1511  getStructorImplicitParamDecl(CGF) = VTTDecl;
1512  }
1513 }
1514 
1515 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
1516  // Naked functions have no prolog.
1517  if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>())
1518  return;
1519 
1520  /// Initialize the 'this' slot. In the Itanium C++ ABI, no prologue
1521  /// adjustments are required, because they are all handled by thunks.
1522  setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
1523 
1524  /// Initialize the 'vtt' slot if needed.
1525  if (getStructorImplicitParamDecl(CGF)) {
1526  getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
1527  CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
1528  }
1529 
1530  /// If this is a function that the ABI specifies returns 'this', initialize
1531  /// the return slot to 'this' at the start of the function.
1532  ///
1533  /// Unlike the setting of return types, this is done within the ABI
1534  /// implementation instead of by clients of CGCXXABI because:
1535  /// 1) getThisValue is currently protected
1536  /// 2) in theory, an ABI could implement 'this' returns some other way;
1537  /// HasThisReturn only specifies a contract, not the implementation
1538  if (HasThisReturn(CGF.CurGD))
1539  CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1540 }
1541 
1542 CGCXXABI::AddedStructorArgs ItaniumCXXABI::addImplicitConstructorArgs(
1544  bool ForVirtualBase, bool Delegating, CallArgList &Args) {
1545  if (!NeedsVTTParameter(GlobalDecl(D, Type)))
1546  return AddedStructorArgs{};
1547 
1548  // Insert the implicit 'vtt' argument as the second argument.
1549  llvm::Value *VTT =
1550  CGF.GetVTTParameter(GlobalDecl(D, Type), ForVirtualBase, Delegating);
1551  QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1552  Args.insert(Args.begin() + 1, CallArg(RValue::get(VTT), VTTTy));
1553  return AddedStructorArgs::prefix(1); // Added one arg.
1554 }
1555 
1556 void ItaniumCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
1557  const CXXDestructorDecl *DD,
1558  CXXDtorType Type, bool ForVirtualBase,
1559  bool Delegating, Address This) {
1560  GlobalDecl GD(DD, Type);
1561  llvm::Value *VTT = CGF.GetVTTParameter(GD, ForVirtualBase, Delegating);
1562  QualType VTTTy = getContext().getPointerType(getContext().VoidPtrTy);
1563 
1564  CGCallee Callee;
1565  if (getContext().getLangOpts().AppleKext &&
1566  Type != Dtor_Base && DD->isVirtual())
1567  Callee = CGF.BuildAppleKextVirtualDestructorCall(DD, Type, DD->getParent());
1568  else
1569  Callee = CGCallee::forDirect(CGM.getAddrOfCXXStructor(GD), GD);
1570 
1571  CGF.EmitCXXDestructorCall(GD, Callee, This.getPointer(), VTT, VTTTy, nullptr);
1572 }
1573 
1574 void ItaniumCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT,
1575  const CXXRecordDecl *RD) {
1576  llvm::GlobalVariable *VTable = getAddrOfVTable(RD, CharUnits());
1577  if (VTable->hasInitializer())
1578  return;
1579 
1580  ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
1581  const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
1582  llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
1583  llvm::Constant *RTTI =
1584  CGM.GetAddrOfRTTIDescriptor(CGM.getContext().getTagDeclType(RD));
1585 
1586  // Create and set the initializer.
1587  ConstantInitBuilder Builder(CGM);
1588  auto Components = Builder.beginStruct();
1589  CGVT.createVTableInitializer(Components, VTLayout, RTTI);
1590  Components.finishAndSetAsInitializer(VTable);
1591 
1592  // Set the correct linkage.
1593  VTable->setLinkage(Linkage);
1594 
1595  if (CGM.supportsCOMDAT() && VTable->isWeakForLinker())
1596  VTable->setComdat(CGM.getModule().getOrInsertComdat(VTable->getName()));
1597 
1598  // Set the right visibility.
1599  CGM.setGVProperties(VTable, RD);
1600 
1601  // If this is the magic class __cxxabiv1::__fundamental_type_info,
1602  // we will emit the typeinfo for the fundamental types. This is the
1603  // same behaviour as GCC.
1604  const DeclContext *DC = RD->getDeclContext();
1605  if (RD->getIdentifier() &&
1606  RD->getIdentifier()->isStr("__fundamental_type_info") &&
1607  isa<NamespaceDecl>(DC) && cast<NamespaceDecl>(DC)->getIdentifier() &&
1608  cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
1609  DC->getParent()->isTranslationUnit())
1610  EmitFundamentalRTTIDescriptors(RD);
1611 
1612  if (!VTable->isDeclarationForLinker())
1613  CGM.EmitVTableTypeMetadata(VTable, VTLayout);
1614 }
1615 
1616 bool ItaniumCXXABI::isVirtualOffsetNeededForVTableField(
1618  if (Vptr.NearestVBase == nullptr)
1619  return false;
1620  return NeedsVTTParameter(CGF.CurGD);
1621 }
1622 
1623 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructor(
1624  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1625  const CXXRecordDecl *NearestVBase) {
1626 
1627  if ((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1628  NeedsVTTParameter(CGF.CurGD)) {
1629  return getVTableAddressPointInStructorWithVTT(CGF, VTableClass, Base,
1630  NearestVBase);
1631  }
1632  return getVTableAddressPoint(Base, VTableClass);
1633 }
1634 
1635 llvm::Constant *
1636 ItaniumCXXABI::getVTableAddressPoint(BaseSubobject Base,
1637  const CXXRecordDecl *VTableClass) {
1638  llvm::GlobalValue *VTable = getAddrOfVTable(VTableClass, CharUnits());
1639 
1640  // Find the appropriate vtable within the vtable group, and the address point
1641  // within that vtable.
1642  VTableLayout::AddressPointLocation AddressPoint =
1643  CGM.getItaniumVTableContext()
1644  .getVTableLayout(VTableClass)
1645  .getAddressPoint(Base);
1646  llvm::Value *Indices[] = {
1647  llvm::ConstantInt::get(CGM.Int32Ty, 0),
1648  llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.VTableIndex),
1649  llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.AddressPointIndex),
1650  };
1651 
1652  return llvm::ConstantExpr::getGetElementPtr(VTable->getValueType(), VTable,
1653  Indices, /*InBounds=*/true,
1654  /*InRangeIndex=*/1);
1655 }
1656 
1657 llvm::Value *ItaniumCXXABI::getVTableAddressPointInStructorWithVTT(
1658  CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base,
1659  const CXXRecordDecl *NearestVBase) {
1660  assert((Base.getBase()->getNumVBases() || NearestVBase != nullptr) &&
1661  NeedsVTTParameter(CGF.CurGD) && "This class doesn't have VTT");
1662 
1663  // Get the secondary vpointer index.
1664  uint64_t VirtualPointerIndex =
1665  CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base);
1666 
1667  /// Load the VTT.
1668  llvm::Value *VTT = CGF.LoadCXXVTT();
1669  if (VirtualPointerIndex)
1670  VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1671 
1672  // And load the address point from the VTT.
1673  return CGF.Builder.CreateAlignedLoad(VTT, CGF.getPointerAlign());
1674 }
1675 
1676 llvm::Constant *ItaniumCXXABI::getVTableAddressPointForConstExpr(
1677  BaseSubobject Base, const CXXRecordDecl *VTableClass) {
1678  return getVTableAddressPoint(Base, VTableClass);
1679 }
1680 
1681 llvm::GlobalVariable *ItaniumCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
1682  CharUnits VPtrOffset) {
1683  assert(VPtrOffset.isZero() && "Itanium ABI only supports zero vptr offsets");
1684 
1685  llvm::GlobalVariable *&VTable = VTables[RD];
1686  if (VTable)
1687  return VTable;
1688 
1689  // Queue up this vtable for possible deferred emission.
1690  CGM.addDeferredVTable(RD);
1691 
1692  SmallString<256> Name;
1693  llvm::raw_svector_ostream Out(Name);
1694  getMangleContext().mangleCXXVTable(RD, Out);
1695 
1696  const VTableLayout &VTLayout =
1697  CGM.getItaniumVTableContext().getVTableLayout(RD);
1698  llvm::Type *VTableType = CGM.getVTables().getVTableType(VTLayout);
1699 
1700  // Use pointer alignment for the vtable. Otherwise we would align them based
1701  // on the size of the initializer which doesn't make sense as only single
1702  // values are read.
1703  unsigned PAlign = CGM.getTarget().getPointerAlign(0);
1704 
1705  VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
1706  Name, VTableType, llvm::GlobalValue::ExternalLinkage,
1707  getContext().toCharUnitsFromBits(PAlign).getQuantity());
1708  VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1709 
1710  CGM.setGVProperties(VTable, RD);
1711 
1712  return VTable;
1713 }
1714 
1715 CGCallee ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
1716  GlobalDecl GD,
1717  Address This,
1718  llvm::Type *Ty,
1719  SourceLocation Loc) {
1720  Ty = Ty->getPointerTo()->getPointerTo();
1721  auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
1722  llvm::Value *VTable = CGF.GetVTablePtr(This, Ty, MethodDecl->getParent());
1723 
1724  uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);
1725  llvm::Value *VFunc;
1726  if (CGF.ShouldEmitVTableTypeCheckedLoad(MethodDecl->getParent())) {
1727  VFunc = CGF.EmitVTableTypeCheckedLoad(
1728  MethodDecl->getParent(), VTable,
1729  VTableIndex * CGM.getContext().getTargetInfo().getPointerWidth(0) / 8);
1730  } else {
1731  CGF.EmitTypeMetadataCodeForVCall(MethodDecl->getParent(), VTable, Loc);
1732 
1733  llvm::Value *VFuncPtr =
1734  CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
1735  auto *VFuncLoad =
1736  CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1737 
1738  // Add !invariant.load md to virtual function load to indicate that
1739  // function didn't change inside vtable.
1740  // It's safe to add it without -fstrict-vtable-pointers, but it would not
1741  // help in devirtualization because it will only matter if we will have 2
1742  // the same virtual function loads from the same vtable load, which won't
1743  // happen without enabled devirtualization with -fstrict-vtable-pointers.
1744  if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1745  CGM.getCodeGenOpts().StrictVTablePointers)
1746  VFuncLoad->setMetadata(
1747  llvm::LLVMContext::MD_invariant_load,
1748  llvm::MDNode::get(CGM.getLLVMContext(),
1750  VFunc = VFuncLoad;
1751  }
1752 
1753  CGCallee Callee(GD, VFunc);
1754  return Callee;
1755 }
1756 
1757 llvm::Value *ItaniumCXXABI::EmitVirtualDestructorCall(
1758  CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType,
1759  Address This, const CXXMemberCallExpr *CE) {
1760  assert(CE == nullptr || CE->arg_begin() == CE->arg_end());
1761  assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
1762 
1763  GlobalDecl GD(Dtor, DtorType);
1764  const CGFunctionInfo *FInfo =
1765  &CGM.getTypes().arrangeCXXStructorDeclaration(GD);
1766  llvm::FunctionType *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
1767  CGCallee Callee = CGCallee::forVirtual(CE, GD, This, Ty);
1768 
1769  CGF.EmitCXXDestructorCall(GD, Callee, This.getPointer(), nullptr, QualType(),
1770  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::canSpeculativelyEmitVTableAsBaseClass(
1781  const CXXRecordDecl *RD) const {
1782  // We don't emit available_externally vtables if we are in -fapple-kext mode
1783  // because kext mode does not permit devirtualization.
1784  if (CGM.getLangOpts().AppleKext)
1785  return false;
1786 
1787  // If the vtable is hidden then it is not safe to emit an available_externally
1788  // copy of vtable.
1789  if (isVTableHidden(RD))
1790  return false;
1791 
1792  if (CGM.getCodeGenOpts().ForceEmitVTables)
1793  return true;
1794 
1795  // If we don't have any not emitted inline virtual function then we are safe
1796  // to emit an available_externally copy of vtable.
1797  // FIXME we can still emit a copy of the vtable if we
1798  // can emit definition of the inline functions.
1799  if (hasAnyUnusedVirtualInlineFunction(RD))
1800  return false;
1801 
1802  // For a class with virtual bases, we must also be able to speculatively
1803  // emit the VTT, because CodeGen doesn't have separate notions of "can emit
1804  // the vtable" and "can emit the VTT". For a base subobject, this means we
1805  // need to be able to emit non-virtual base vtables.
1806  if (RD->getNumVBases()) {
1807  for (const auto &B : RD->bases()) {
1808  auto *BRD = B.getType()->getAsCXXRecordDecl();
1809  assert(BRD && "no class for base specifier");
1810  if (B.isVirtual() || !BRD->isDynamicClass())
1811  continue;
1812  if (!canSpeculativelyEmitVTableAsBaseClass(BRD))
1813  return false;
1814  }
1815  }
1816 
1817  return true;
1818 }
1819 
1820 bool ItaniumCXXABI::canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const {
1821  if (!canSpeculativelyEmitVTableAsBaseClass(RD))
1822  return false;
1823 
1824  // For a complete-object vtable (or more specifically, for the VTT), we need
1825  // to be able to speculatively emit the vtables of all dynamic virtual bases.
1826  for (const auto &B : RD->vbases()) {
1827  auto *BRD = B.getType()->getAsCXXRecordDecl();
1828  assert(BRD && "no class for base specifier");
1829  if (!BRD->isDynamicClass())
1830  continue;
1831  if (!canSpeculativelyEmitVTableAsBaseClass(BRD))
1832  return false;
1833  }
1834 
1835  return true;
1836 }
1838  Address InitialPtr,
1839  int64_t NonVirtualAdjustment,
1840  int64_t VirtualAdjustment,
1841  bool IsReturnAdjustment) {
1842  if (!NonVirtualAdjustment && !VirtualAdjustment)
1843  return InitialPtr.getPointer();
1844 
1845  Address V = CGF.Builder.CreateElementBitCast(InitialPtr, CGF.Int8Ty);
1846 
1847  // In a base-to-derived cast, the non-virtual adjustment is applied first.
1848  if (NonVirtualAdjustment && !IsReturnAdjustment) {
1850  CharUnits::fromQuantity(NonVirtualAdjustment));
1851  }
1852 
1853  // Perform the virtual adjustment if we have one.
1854  llvm::Value *ResultPtr;
1855  if (VirtualAdjustment) {
1856  llvm::Type *PtrDiffTy =
1858 
1859  Address VTablePtrPtr = CGF.Builder.CreateElementBitCast(V, CGF.Int8PtrTy);
1860  llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
1861 
1862  llvm::Value *OffsetPtr =
1863  CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
1864 
1865  OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
1866 
1867  // Load the adjustment offset from the vtable.
1868  llvm::Value *Offset =
1869  CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1870 
1871  // Adjust our pointer.
1872  ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getPointer(), Offset);
1873  } else {
1874  ResultPtr = V.getPointer();
1875  }
1876 
1877  // In a derived-to-base conversion, the non-virtual adjustment is
1878  // applied second.
1879  if (NonVirtualAdjustment && IsReturnAdjustment) {
1880  ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ResultPtr,
1881  NonVirtualAdjustment);
1882  }
1883 
1884  // Cast back to the original type.
1885  return CGF.Builder.CreateBitCast(ResultPtr, InitialPtr.getType());
1886 }
1887 
1888 llvm::Value *ItaniumCXXABI::performThisAdjustment(CodeGenFunction &CGF,
1889  Address This,
1890  const ThisAdjustment &TA) {
1891  return performTypeAdjustment(CGF, This, TA.NonVirtual,
1893  /*IsReturnAdjustment=*/false);
1894 }
1895 
1896 llvm::Value *
1897 ItaniumCXXABI::performReturnAdjustment(CodeGenFunction &CGF, Address Ret,
1898  const ReturnAdjustment &RA) {
1899  return performTypeAdjustment(CGF, Ret, RA.NonVirtual,
1901  /*IsReturnAdjustment=*/true);
1902 }
1903 
1904 void ARMCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
1905  RValue RV, QualType ResultType) {
1906  if (!isa<CXXDestructorDecl>(CGF.CurGD.getDecl()))
1907  return ItaniumCXXABI::EmitReturnFromThunk(CGF, RV, ResultType);
1908 
1909  // Destructor thunks in the ARM ABI have indeterminate results.
1911  RValue Undef = RValue::get(llvm::UndefValue::get(T));
1912  return ItaniumCXXABI::EmitReturnFromThunk(CGF, Undef, ResultType);
1913 }
1914 
1915 /************************** Array allocation cookies **************************/
1916 
1917 CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1918  // The array cookie is a size_t; pad that up to the element alignment.
1919  // The cookie is actually right-justified in that space.
1920  return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
1921  CGM.getContext().getTypeAlignInChars(elementType));
1922 }
1923 
1924 Address ItaniumCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
1925  Address NewPtr,
1926  llvm::Value *NumElements,
1927  const CXXNewExpr *expr,
1928  QualType ElementType) {
1929  assert(requiresArrayCookie(expr));
1930 
1931  unsigned AS = NewPtr.getAddressSpace();
1932 
1933  ASTContext &Ctx = getContext();
1934  CharUnits SizeSize = CGF.getSizeSize();
1935 
1936  // The size of the cookie.
1937  CharUnits CookieSize =
1938  std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
1939  assert(CookieSize == getArrayCookieSizeImpl(ElementType));
1940 
1941  // Compute an offset to the cookie.
1942  Address CookiePtr = NewPtr;
1943  CharUnits CookieOffset = CookieSize - SizeSize;
1944  if (!CookieOffset.isZero())
1945  CookiePtr = CGF.Builder.CreateConstInBoundsByteGEP(CookiePtr, CookieOffset);
1946 
1947  // Write the number of elements into the appropriate slot.
1948  Address NumElementsPtr =
1949  CGF.Builder.CreateElementBitCast(CookiePtr, CGF.SizeTy);
1950  llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
1951 
1952  // Handle the array cookie specially in ASan.
1953  if (CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) && AS == 0 &&
1955  CGM.getCodeGenOpts().SanitizeAddressPoisonCustomArrayCookie)) {
1956  // The store to the CookiePtr does not need to be instrumented.
1957  CGM.getSanitizerMetadata()->disableSanitizerForInstruction(SI);
1958  llvm::FunctionType *FTy =
1959  llvm::FunctionType::get(CGM.VoidTy, NumElementsPtr.getType(), false);
1960  llvm::FunctionCallee F =
1961  CGM.CreateRuntimeFunction(FTy, "__asan_poison_cxx_array_cookie");
1962  CGF.Builder.CreateCall(F, NumElementsPtr.getPointer());
1963  }
1964 
1965  // Finally, compute a pointer to the actual data buffer by skipping
1966  // over the cookie completely.
1967  return CGF.Builder.CreateConstInBoundsByteGEP(NewPtr, CookieSize);
1968 }
1969 
1970 llvm::Value *ItaniumCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
1971  Address allocPtr,
1972  CharUnits cookieSize) {
1973  // The element size is right-justified in the cookie.
1974  Address numElementsPtr = allocPtr;
1975  CharUnits numElementsOffset = cookieSize - CGF.getSizeSize();
1976  if (!numElementsOffset.isZero())
1977  numElementsPtr =
1978  CGF.Builder.CreateConstInBoundsByteGEP(numElementsPtr, numElementsOffset);
1979 
1980  unsigned AS = allocPtr.getAddressSpace();
1981  numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
1982  if (!CGM.getLangOpts().Sanitize.has(SanitizerKind::Address) || AS != 0)
1983  return CGF.Builder.CreateLoad(numElementsPtr);
1984  // In asan mode emit a function call instead of a regular load and let the
1985  // run-time deal with it: if the shadow is properly poisoned return the
1986  // cookie, otherwise return 0 to avoid an infinite loop calling DTORs.
1987  // We can't simply ignore this load using nosanitize metadata because
1988  // the metadata may be lost.
1989  llvm::FunctionType *FTy =
1990  llvm::FunctionType::get(CGF.SizeTy, CGF.SizeTy->getPointerTo(0), false);
1991  llvm::FunctionCallee F =
1992  CGM.CreateRuntimeFunction(FTy, "__asan_load_cxx_array_cookie");
1993  return CGF.Builder.CreateCall(F, numElementsPtr.getPointer());
1994 }
1995 
1996 CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1997  // ARM says that the cookie is always:
1998  // struct array_cookie {
1999  // std::size_t element_size; // element_size != 0
2000  // std::size_t element_count;
2001  // };
2002  // But the base ABI doesn't give anything an alignment greater than
2003  // 8, so we can dismiss this as typical ABI-author blindness to
2004  // actual language complexity and round up to the element alignment.
2005  return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),
2006  CGM.getContext().getTypeAlignInChars(elementType));
2007 }
2008 
2009 Address ARMCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
2010  Address newPtr,
2011  llvm::Value *numElements,
2012  const CXXNewExpr *expr,
2013  QualType elementType) {
2014  assert(requiresArrayCookie(expr));
2015 
2016  // The cookie is always at the start of the buffer.
2017  Address cookie = newPtr;
2018 
2019  // The first element is the element size.
2020  cookie = CGF.Builder.CreateElementBitCast(cookie, CGF.SizeTy);
2021  llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
2022  getContext().getTypeSizeInChars(elementType).getQuantity());
2023  CGF.Builder.CreateStore(elementSize, cookie);
2024 
2025  // The second element is the element count.
2026  cookie = CGF.Builder.CreateConstInBoundsGEP(cookie, 1);
2027  CGF.Builder.CreateStore(numElements, cookie);
2028 
2029  // Finally, compute a pointer to the actual data buffer by skipping
2030  // over the cookie completely.
2031  CharUnits cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);
2032  return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2033 }
2034 
2035 llvm::Value *ARMCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
2036  Address allocPtr,
2037  CharUnits cookieSize) {
2038  // The number of elements is at offset sizeof(size_t) relative to
2039  // the allocated pointer.
2040  Address numElementsPtr
2041  = CGF.Builder.CreateConstInBoundsByteGEP(allocPtr, CGF.getSizeSize());
2042 
2043  numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
2044  return CGF.Builder.CreateLoad(numElementsPtr);
2045 }
2046 
2047 /*********************** Static local initialization **************************/
2048 
2049 static llvm::FunctionCallee getGuardAcquireFn(CodeGenModule &CGM,
2050  llvm::PointerType *GuardPtrTy) {
2051  // int __cxa_guard_acquire(__guard *guard_object);
2052  llvm::FunctionType *FTy =
2053  llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
2054  GuardPtrTy, /*isVarArg=*/false);
2055  return CGM.CreateRuntimeFunction(
2056  FTy, "__cxa_guard_acquire",
2057  llvm::AttributeList::get(CGM.getLLVMContext(),
2058  llvm::AttributeList::FunctionIndex,
2059  llvm::Attribute::NoUnwind));
2060 }
2061 
2062 static llvm::FunctionCallee getGuardReleaseFn(CodeGenModule &CGM,
2063  llvm::PointerType *GuardPtrTy) {
2064  // void __cxa_guard_release(__guard *guard_object);
2065  llvm::FunctionType *FTy =
2066  llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
2067  return CGM.CreateRuntimeFunction(
2068  FTy, "__cxa_guard_release",
2069  llvm::AttributeList::get(CGM.getLLVMContext(),
2070  llvm::AttributeList::FunctionIndex,
2071  llvm::Attribute::NoUnwind));
2072 }
2073 
2074 static llvm::FunctionCallee getGuardAbortFn(CodeGenModule &CGM,
2075  llvm::PointerType *GuardPtrTy) {
2076  // void __cxa_guard_abort(__guard *guard_object);
2077  llvm::FunctionType *FTy =
2078  llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
2079  return CGM.CreateRuntimeFunction(
2080  FTy, "__cxa_guard_abort",
2081  llvm::AttributeList::get(CGM.getLLVMContext(),
2082  llvm::AttributeList::FunctionIndex,
2083  llvm::Attribute::NoUnwind));
2084 }
2085 
2086 namespace {
2087  struct CallGuardAbort final : EHScopeStack::Cleanup {
2088  llvm::GlobalVariable *Guard;
2089  CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {}
2090 
2091  void Emit(CodeGenFunction &CGF, Flags flags) override {
2092  CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()),
2093  Guard);
2094  }
2095  };
2096 }
2097 
2098 /// The ARM code here follows the Itanium code closely enough that we
2099 /// just special-case it at particular places.
2100 void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
2101  const VarDecl &D,
2102  llvm::GlobalVariable *var,
2103  bool shouldPerformInit) {
2104  CGBuilderTy &Builder = CGF.Builder;
2105 
2106  // Inline variables that weren't instantiated from variable templates have
2107  // partially-ordered initialization within their translation unit.
2108  bool NonTemplateInline =
2109  D.isInline() &&
2111 
2112  // We only need to use thread-safe statics for local non-TLS variables and
2113  // inline variables; other global initialization is always single-threaded
2114  // or (through lazy dynamic loading in multiple threads) unsequenced.
2115  bool threadsafe = getContext().getLangOpts().ThreadsafeStatics &&
2116  (D.isLocalVarDecl() || NonTemplateInline) &&
2117  !D.getTLSKind();
2118 
2119  // If we have a global variable with internal linkage and thread-safe statics
2120  // are disabled, we can just let the guard variable be of type i8.
2121  bool useInt8GuardVariable = !threadsafe && var->hasInternalLinkage();
2122 
2123  llvm::IntegerType *guardTy;
2124  CharUnits guardAlignment;
2125  if (useInt8GuardVariable) {
2126  guardTy = CGF.Int8Ty;
2127  guardAlignment = CharUnits::One();
2128  } else {
2129  // Guard variables are 64 bits in the generic ABI and size width on ARM
2130  // (i.e. 32-bit on AArch32, 64-bit on AArch64).
2131  if (UseARMGuardVarABI) {
2132  guardTy = CGF.SizeTy;
2133  guardAlignment = CGF.getSizeAlign();
2134  } else {
2135  guardTy = CGF.Int64Ty;
2136  guardAlignment = CharUnits::fromQuantity(
2137  CGM.getDataLayout().getABITypeAlignment(guardTy));
2138  }
2139  }
2140  llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
2141 
2142  // Create the guard variable if we don't already have it (as we
2143  // might if we're double-emitting this function body).
2144  llvm::GlobalVariable *guard = CGM.getStaticLocalDeclGuardAddress(&D);
2145  if (!guard) {
2146  // Mangle the name for the guard.
2147  SmallString<256> guardName;
2148  {
2149  llvm::raw_svector_ostream out(guardName);
2150  getMangleContext().mangleStaticGuardVariable(&D, out);
2151  }
2152 
2153  // Create the guard variable with a zero-initializer.
2154  // Just absorb linkage and visibility from the guarded variable.
2155  guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
2156  false, var->getLinkage(),
2157  llvm::ConstantInt::get(guardTy, 0),
2158  guardName.str());
2159  guard->setDSOLocal(var->isDSOLocal());
2160  guard->setVisibility(var->getVisibility());
2161  // If the variable is thread-local, so is its guard variable.
2162  guard->setThreadLocalMode(var->getThreadLocalMode());
2163  guard->setAlignment(guardAlignment.getQuantity());
2164 
2165  // The ABI says: "It is suggested that it be emitted in the same COMDAT
2166  // group as the associated data object." In practice, this doesn't work for
2167  // non-ELF and non-Wasm object formats, so only do it for ELF and Wasm.
2168  llvm::Comdat *C = var->getComdat();
2169  if (!D.isLocalVarDecl() && C &&
2170  (CGM.getTarget().getTriple().isOSBinFormatELF() ||
2171  CGM.getTarget().getTriple().isOSBinFormatWasm())) {
2172  guard->setComdat(C);
2173  // An inline variable's guard function is run from the per-TU
2174  // initialization function, not via a dedicated global ctor function, so
2175  // we can't put it in a comdat.
2176  if (!NonTemplateInline)
2177  CGF.CurFn->setComdat(C);
2178  } else if (CGM.supportsCOMDAT() && guard->isWeakForLinker()) {
2179  guard->setComdat(CGM.getModule().getOrInsertComdat(guard->getName()));
2180  }
2181 
2182  CGM.setStaticLocalDeclGuardAddress(&D, guard);
2183  }
2184 
2185  Address guardAddr = Address(guard, guardAlignment);
2186 
2187  // Test whether the variable has completed initialization.
2188  //
2189  // Itanium C++ ABI 3.3.2:
2190  // The following is pseudo-code showing how these functions can be used:
2191  // if (obj_guard.first_byte == 0) {
2192  // if ( __cxa_guard_acquire (&obj_guard) ) {
2193  // try {
2194  // ... initialize the object ...;
2195  // } catch (...) {
2196  // __cxa_guard_abort (&obj_guard);
2197  // throw;
2198  // }
2199  // ... queue object destructor with __cxa_atexit() ...;
2200  // __cxa_guard_release (&obj_guard);
2201  // }
2202  // }
2203 
2204  // Load the first byte of the guard variable.
2205  llvm::LoadInst *LI =
2206  Builder.CreateLoad(Builder.CreateElementBitCast(guardAddr, CGM.Int8Ty));
2207 
2208  // Itanium ABI:
2209  // An implementation supporting thread-safety on multiprocessor
2210  // systems must also guarantee that references to the initialized
2211  // object do not occur before the load of the initialization flag.
2212  //
2213  // In LLVM, we do this by marking the load Acquire.
2214  if (threadsafe)
2215  LI->setAtomic(llvm::AtomicOrdering::Acquire);
2216 
2217  // For ARM, we should only check the first bit, rather than the entire byte:
2218  //
2219  // ARM C++ ABI 3.2.3.1:
2220  // To support the potential use of initialization guard variables
2221  // as semaphores that are the target of ARM SWP and LDREX/STREX
2222  // synchronizing instructions we define a static initialization
2223  // guard variable to be a 4-byte aligned, 4-byte word with the
2224  // following inline access protocol.
2225  // #define INITIALIZED 1
2226  // if ((obj_guard & INITIALIZED) != INITIALIZED) {
2227  // if (__cxa_guard_acquire(&obj_guard))
2228  // ...
2229  // }
2230  //
2231  // and similarly for ARM64:
2232  //
2233  // ARM64 C++ ABI 3.2.2:
2234  // This ABI instead only specifies the value bit 0 of the static guard
2235  // variable; all other bits are platform defined. Bit 0 shall be 0 when the
2236  // variable is not initialized and 1 when it is.
2237  llvm::Value *V =
2238  (UseARMGuardVarABI && !useInt8GuardVariable)
2239  ? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))
2240  : LI;
2241  llvm::Value *NeedsInit = Builder.CreateIsNull(V, "guard.uninitialized");
2242 
2243  llvm::BasicBlock *InitCheckBlock = CGF.createBasicBlock("init.check");
2244  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("init.end");
2245 
2246  // Check if the first byte of the guard variable is zero.
2247  CGF.EmitCXXGuardedInitBranch(NeedsInit, InitCheckBlock, EndBlock,
2249 
2250  CGF.EmitBlock(InitCheckBlock);
2251 
2252  // Variables used when coping with thread-safe statics and exceptions.
2253  if (threadsafe) {
2254  // Call __cxa_guard_acquire.
2255  llvm::Value *V
2256  = CGF.EmitNounwindRuntimeCall(getGuardAcquireFn(CGM, guardPtrTy), guard);
2257 
2258  llvm::BasicBlock *InitBlock = CGF.createBasicBlock("init");
2259 
2260  Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
2261  InitBlock, EndBlock);
2262 
2263  // Call __cxa_guard_abort along the exceptional edge.
2264  CGF.EHStack.pushCleanup<CallGuardAbort>(EHCleanup, guard);
2265 
2266  CGF.EmitBlock(InitBlock);
2267  }
2268 
2269  // Emit the initializer and add a global destructor if appropriate.
2270  CGF.EmitCXXGlobalVarDeclInit(D, var, shouldPerformInit);
2271 
2272  if (threadsafe) {
2273  // Pop the guard-abort cleanup if we pushed one.
2274  CGF.PopCleanupBlock();
2275 
2276  // Call __cxa_guard_release. This cannot throw.
2277  CGF.EmitNounwindRuntimeCall(getGuardReleaseFn(CGM, guardPtrTy),
2278  guardAddr.getPointer());
2279  } else {
2280  Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guardAddr);
2281  }
2282 
2283  CGF.EmitBlock(EndBlock);
2284 }
2285 
2286 /// Register a global destructor using __cxa_atexit.
2288  llvm::FunctionCallee dtor,
2289  llvm::Constant *addr, bool TLS) {
2290  const char *Name = "__cxa_atexit";
2291  if (TLS) {
2292  const llvm::Triple &T = CGF.getTarget().getTriple();
2293  Name = T.isOSDarwin() ? "_tlv_atexit" : "__cxa_thread_atexit";
2294  }
2295 
2296  // We're assuming that the destructor function is something we can
2297  // reasonably call with the default CC. Go ahead and cast it to the
2298  // right prototype.
2299  llvm::Type *dtorTy =
2300  llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
2301 
2302  // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
2303  llvm::Type *paramTys[] = { dtorTy, CGF.Int8PtrTy, CGF.Int8PtrTy };
2304  llvm::FunctionType *atexitTy =
2305  llvm::FunctionType::get(CGF.IntTy, paramTys, false);
2306 
2307  // Fetch the actual function.
2308  llvm::FunctionCallee atexit = CGF.CGM.CreateRuntimeFunction(atexitTy, Name);
2309  if (llvm::Function *fn = dyn_cast<llvm::Function>(atexit.getCallee()))
2310  fn->setDoesNotThrow();
2311 
2312  // Create a variable that binds the atexit to this shared object.
2313  llvm::Constant *handle =
2314  CGF.CGM.CreateRuntimeVariable(CGF.Int8Ty, "__dso_handle");
2315  auto *GV = cast<llvm::GlobalValue>(handle->stripPointerCasts());
2316  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
2317 
2318  if (!addr)
2319  // addr is null when we are trying to register a dtor annotated with
2320  // __attribute__((destructor)) in a constructor function. Using null here is
2321  // okay because this argument is just passed back to the destructor
2322  // function.
2323  addr = llvm::Constant::getNullValue(CGF.Int8PtrTy);
2324 
2325  llvm::Value *args[] = {llvm::ConstantExpr::getBitCast(
2326  cast<llvm::Constant>(dtor.getCallee()), dtorTy),
2327  llvm::ConstantExpr::getBitCast(addr, CGF.Int8PtrTy),
2328  handle};
2329  CGF.EmitNounwindRuntimeCall(atexit, args);
2330 }
2331 
2332 void CodeGenModule::registerGlobalDtorsWithAtExit() {
2333  for (const auto I : DtorsUsingAtExit) {
2334  int Priority = I.first;
2335  const llvm::TinyPtrVector<llvm::Function *> &Dtors = I.second;
2336 
2337  // Create a function that registers destructors that have the same priority.
2338  //
2339  // Since constructor functions are run in non-descending order of their
2340  // priorities, destructors are registered in non-descending order of their
2341  // priorities, and since destructor functions are run in the reverse order
2342  // of their registration, destructor functions are run in non-ascending
2343  // order of their priorities.
2344  CodeGenFunction CGF(*this);
2345  std::string GlobalInitFnName =
2346  std::string("__GLOBAL_init_") + llvm::to_string(Priority);
2347  llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
2348  llvm::Function *GlobalInitFn = CreateGlobalInitOrDestructFunction(
2349  FTy, GlobalInitFnName, getTypes().arrangeNullaryFunction(),
2350  SourceLocation());
2351  ASTContext &Ctx = getContext();
2352  QualType ReturnTy = Ctx.VoidTy;
2353  QualType FunctionTy = Ctx.getFunctionType(ReturnTy, llvm::None, {});
2356  &Ctx.Idents.get(GlobalInitFnName), FunctionTy, nullptr, SC_Static,
2357  false, false);
2358  CGF.StartFunction(GlobalDecl(FD), ReturnTy, GlobalInitFn,
2359  getTypes().arrangeNullaryFunction(), FunctionArgList(),
2361 
2362  for (auto *Dtor : Dtors) {
2363  // Register the destructor function calling __cxa_atexit if it is
2364  // available. Otherwise fall back on calling atexit.
2365  if (getCodeGenOpts().CXAAtExit)
2366  emitGlobalDtorWithCXAAtExit(CGF, Dtor, nullptr, false);
2367  else
2368  CGF.registerGlobalDtorWithAtExit(Dtor);
2369  }
2370 
2371  CGF.FinishFunction();
2372  AddGlobalCtor(GlobalInitFn, Priority, nullptr);
2373  }
2374 }
2375 
2376 /// Register a global destructor as best as we know how.
2377 void ItaniumCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
2378  llvm::FunctionCallee dtor,
2379  llvm::Constant *addr) {
2380  if (D.isNoDestroy(CGM.getContext()))
2381  return;
2382 
2383  // Use __cxa_atexit if available.
2384  if (CGM.getCodeGenOpts().CXAAtExit)
2385  return emitGlobalDtorWithCXAAtExit(CGF, dtor, addr, D.getTLSKind());
2386 
2387  if (D.getTLSKind())
2388  CGM.ErrorUnsupported(&D, "non-trivial TLS destruction");
2389 
2390  // In Apple kexts, we want to add a global destructor entry.
2391  // FIXME: shouldn't this be guarded by some variable?
2392  if (CGM.getLangOpts().AppleKext) {
2393  // Generate a global destructor entry.
2394  return CGM.AddCXXDtorEntry(dtor, addr);
2395  }
2396 
2397  CGF.registerGlobalDtorWithAtExit(D, dtor, addr);
2398 }
2399 
2400 static bool isThreadWrapperReplaceable(const VarDecl *VD,
2401  CodeGen::CodeGenModule &CGM) {
2402  assert(!VD->isStaticLocal() && "static local VarDecls don't need wrappers!");
2403  // Darwin prefers to have references to thread local variables to go through
2404  // the thread wrapper instead of directly referencing the backing variable.
2405  return VD->getTLSKind() == VarDecl::TLS_Dynamic &&
2406  CGM.getTarget().getTriple().isOSDarwin();
2407 }
2408 
2409 /// Get the appropriate linkage for the wrapper function. This is essentially
2410 /// the weak form of the variable's linkage; every translation unit which needs
2411 /// the wrapper emits a copy, and we want the linker to merge them.
2412 static llvm::GlobalValue::LinkageTypes
2414  llvm::GlobalValue::LinkageTypes VarLinkage =
2415  CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false);
2416 
2417  // For internal linkage variables, we don't need an external or weak wrapper.
2418  if (llvm::GlobalValue::isLocalLinkage(VarLinkage))
2419  return VarLinkage;
2420 
2421  // If the thread wrapper is replaceable, give it appropriate linkage.
2422  if (isThreadWrapperReplaceable(VD, CGM))
2423  if (!llvm::GlobalVariable::isLinkOnceLinkage(VarLinkage) &&
2424  !llvm::GlobalVariable::isWeakODRLinkage(VarLinkage))
2425  return VarLinkage;
2426  return llvm::GlobalValue::WeakODRLinkage;
2427 }
2428 
2429 llvm::Function *
2430 ItaniumCXXABI::getOrCreateThreadLocalWrapper(const VarDecl *VD,
2431  llvm::Value *Val) {
2432  // Mangle the name for the thread_local wrapper function.
2433  SmallString<256> WrapperName;
2434  {
2435  llvm::raw_svector_ostream Out(WrapperName);
2436  getMangleContext().mangleItaniumThreadLocalWrapper(VD, Out);
2437  }
2438 
2439  // FIXME: If VD is a definition, we should regenerate the function attributes
2440  // before returning.
2441  if (llvm::Value *V = CGM.getModule().getNamedValue(WrapperName))
2442  return cast<llvm::Function>(V);
2443 
2444  QualType RetQT = VD->getType();
2445  if (RetQT->isReferenceType())
2446  RetQT = RetQT.getNonReferenceType();
2447 
2448  const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
2449  getContext().getPointerType(RetQT), FunctionArgList());
2450 
2451  llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);
2452  llvm::Function *Wrapper =
2454  WrapperName.str(), &CGM.getModule());
2455 
2456  CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, Wrapper);
2457 
2458  if (VD->hasDefinition())
2459  CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Wrapper);
2460 
2461  // Always resolve references to the wrapper at link time.
2462  if (!Wrapper->hasLocalLinkage())
2463  if (!isThreadWrapperReplaceable(VD, CGM) ||
2464  llvm::GlobalVariable::isLinkOnceLinkage(Wrapper->getLinkage()) ||
2465  llvm::GlobalVariable::isWeakODRLinkage(Wrapper->getLinkage()) ||
2467  Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);
2468 
2469  if (isThreadWrapperReplaceable(VD, CGM)) {
2470  Wrapper->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2471  Wrapper->addFnAttr(llvm::Attribute::NoUnwind);
2472  }
2473  return Wrapper;
2474 }
2475 
2476 void ItaniumCXXABI::EmitThreadLocalInitFuncs(
2477  CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
2478  ArrayRef<llvm::Function *> CXXThreadLocalInits,
2479  ArrayRef<const VarDecl *> CXXThreadLocalInitVars) {
2480  llvm::Function *InitFunc = nullptr;
2481 
2482  // Separate initializers into those with ordered (or partially-ordered)
2483  // initialization and those with unordered initialization.
2485  llvm::SmallDenseMap<const VarDecl *, llvm::Function *> UnorderedInits;
2486  for (unsigned I = 0; I != CXXThreadLocalInits.size(); ++I) {
2488  CXXThreadLocalInitVars[I]->getTemplateSpecializationKind()))
2489  UnorderedInits[CXXThreadLocalInitVars[I]->getCanonicalDecl()] =
2490  CXXThreadLocalInits[I];
2491  else
2492  OrderedInits.push_back(CXXThreadLocalInits[I]);
2493  }
2494 
2495  if (!OrderedInits.empty()) {
2496  // Generate a guarded initialization function.
2497  llvm::FunctionType *FTy =
2498  llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
2499  const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2500  InitFunc = CGM.CreateGlobalInitOrDestructFunction(FTy, "__tls_init", FI,
2501  SourceLocation(),
2502  /*TLS=*/true);
2503  llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
2504  CGM.getModule(), CGM.Int8Ty, /*isConstant=*/false,
2506  llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
2507  Guard->setThreadLocal(true);
2508 
2509  CharUnits GuardAlign = CharUnits::One();
2510  Guard->setAlignment(GuardAlign.getQuantity());
2511 
2513  InitFunc, OrderedInits, ConstantAddress(Guard, GuardAlign));
2514  // On Darwin platforms, use CXX_FAST_TLS calling convention.
2515  if (CGM.getTarget().getTriple().isOSDarwin()) {
2516  InitFunc->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2517  InitFunc->addFnAttr(llvm::Attribute::NoUnwind);
2518  }
2519  }
2520 
2521  // Emit thread wrappers.
2522  for (const VarDecl *VD : CXXThreadLocals) {
2523  llvm::GlobalVariable *Var =
2524  cast<llvm::GlobalVariable>(CGM.GetGlobalValue(CGM.getMangledName(VD)));
2525  llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Var);
2526 
2527  // Some targets require that all access to thread local variables go through
2528  // the thread wrapper. This means that we cannot attempt to create a thread
2529  // wrapper or a thread helper.
2530  if (isThreadWrapperReplaceable(VD, CGM) && !VD->hasDefinition()) {
2531  Wrapper->setLinkage(llvm::Function::ExternalLinkage);
2532  continue;
2533  }
2534 
2535  // Mangle the name for the thread_local initialization function.
2536  SmallString<256> InitFnName;
2537  {
2538  llvm::raw_svector_ostream Out(InitFnName);
2539  getMangleContext().mangleItaniumThreadLocalInit(VD, Out);
2540  }
2541 
2542  llvm::FunctionType *InitFnTy = llvm::FunctionType::get(CGM.VoidTy, false);
2543 
2544  // If we have a definition for the variable, emit the initialization
2545  // function as an alias to the global Init function (if any). Otherwise,
2546  // produce a declaration of the initialization function.
2547  llvm::GlobalValue *Init = nullptr;
2548  bool InitIsInitFunc = false;
2549  if (VD->hasDefinition()) {
2550  InitIsInitFunc = true;
2551  llvm::Function *InitFuncToUse = InitFunc;
2553  InitFuncToUse = UnorderedInits.lookup(VD->getCanonicalDecl());
2554  if (InitFuncToUse)
2555  Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),
2556  InitFuncToUse);
2557  } else {
2558  // Emit a weak global function referring to the initialization function.
2559  // This function will not exist if the TU defining the thread_local
2560  // variable in question does not need any dynamic initialization for
2561  // its thread_local variables.
2562  Init = llvm::Function::Create(InitFnTy,
2563  llvm::GlobalVariable::ExternalWeakLinkage,
2564  InitFnName.str(), &CGM.getModule());
2565  const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
2567  cast<llvm::Function>(Init));
2568  }
2569 
2570  if (Init) {
2571  Init->setVisibility(Var->getVisibility());
2572  Init->setDSOLocal(Var->isDSOLocal());
2573  }
2574 
2575  llvm::LLVMContext &Context = CGM.getModule().getContext();
2576  llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Wrapper);
2577  CGBuilderTy Builder(CGM, Entry);
2578  if (InitIsInitFunc) {
2579  if (Init) {
2580  llvm::CallInst *CallVal = Builder.CreateCall(InitFnTy, Init);
2581  if (isThreadWrapperReplaceable(VD, CGM)) {
2582  CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2583  llvm::Function *Fn =
2584  cast<llvm::Function>(cast<llvm::GlobalAlias>(Init)->getAliasee());
2585  Fn->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
2586  }
2587  }
2588  } else {
2589  // Don't know whether we have an init function. Call it if it exists.
2590  llvm::Value *Have = Builder.CreateIsNotNull(Init);
2591  llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2592  llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
2593  Builder.CreateCondBr(Have, InitBB, ExitBB);
2594 
2595  Builder.SetInsertPoint(InitBB);
2596  Builder.CreateCall(InitFnTy, Init);
2597  Builder.CreateBr(ExitBB);
2598 
2599  Builder.SetInsertPoint(ExitBB);
2600  }
2601 
2602  // For a reference, the result of the wrapper function is a pointer to
2603  // the referenced object.
2604  llvm::Value *Val = Var;
2605  if (VD->getType()->isReferenceType()) {
2606  CharUnits Align = CGM.getContext().getDeclAlign(VD);
2607  Val = Builder.CreateAlignedLoad(Val, Align);
2608  }
2609  if (Val->getType() != Wrapper->getReturnType())
2611  Val, Wrapper->getReturnType(), "");
2612  Builder.CreateRet(Val);
2613  }
2614 }
2615 
2616 LValue ItaniumCXXABI::EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
2617  const VarDecl *VD,
2618  QualType LValType) {
2619  llvm::Value *Val = CGF.CGM.GetAddrOfGlobalVar(VD);
2620  llvm::Function *Wrapper = getOrCreateThreadLocalWrapper(VD, Val);
2621 
2622  llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
2623  CallVal->setCallingConv(Wrapper->getCallingConv());
2624 
2625  LValue LV;
2626  if (VD->getType()->isReferenceType())
2627  LV = CGF.MakeNaturalAlignAddrLValue(CallVal, LValType);
2628  else
2629  LV = CGF.MakeAddrLValue(CallVal, LValType,
2630  CGF.getContext().getDeclAlign(VD));
2631  // FIXME: need setObjCGCLValueClass?
2632  return LV;
2633 }
2634 
2635 /// Return whether the given global decl needs a VTT parameter, which it does
2636 /// if it's a base constructor or destructor with virtual bases.
2637 bool ItaniumCXXABI::NeedsVTTParameter(GlobalDecl GD) {
2638  const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2639 
2640  // We don't have any virtual bases, just return early.
2641  if (!MD->getParent()->getNumVBases())
2642  return false;
2643 
2644  // Check if we have a base constructor.
2645  if (isa<CXXConstructorDecl>(MD) && GD.getCtorType() == Ctor_Base)
2646  return true;
2647 
2648  // Check if we have a base destructor.
2649  if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
2650  return true;
2651 
2652  return false;
2653 }
2654 
2655 namespace {
2656 class ItaniumRTTIBuilder {
2657  CodeGenModule &CGM; // Per-module state.
2658  llvm::LLVMContext &VMContext;
2659  const ItaniumCXXABI &CXXABI; // Per-module state.
2660 
2661  /// Fields - The fields of the RTTI descriptor currently being built.
2663 
2664  /// GetAddrOfTypeName - Returns the mangled type name of the given type.
2665  llvm::GlobalVariable *
2666  GetAddrOfTypeName(QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage);
2667 
2668  /// GetAddrOfExternalRTTIDescriptor - Returns the constant for the RTTI
2669  /// descriptor of the given type.
2670  llvm::Constant *GetAddrOfExternalRTTIDescriptor(QualType Ty);
2671 
2672  /// BuildVTablePointer - Build the vtable pointer for the given type.
2673  void BuildVTablePointer(const Type *Ty);
2674 
2675  /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
2676  /// inheritance, according to the Itanium C++ ABI, 2.9.5p6b.
2677  void BuildSIClassTypeInfo(const CXXRecordDecl *RD);
2678 
2679  /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
2680  /// classes with bases that do not satisfy the abi::__si_class_type_info
2681  /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
2682  void BuildVMIClassTypeInfo(const CXXRecordDecl *RD);
2683 
2684  /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct, used
2685  /// for pointer types.
2686  void BuildPointerTypeInfo(QualType PointeeTy);
2687 
2688  /// BuildObjCObjectTypeInfo - Build the appropriate kind of
2689  /// type_info for an object type.
2690  void BuildObjCObjectTypeInfo(const ObjCObjectType *Ty);
2691 
2692  /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
2693  /// struct, used for member pointer types.
2694  void BuildPointerToMemberTypeInfo(const MemberPointerType *Ty);
2695 
2696 public:
2697  ItaniumRTTIBuilder(const ItaniumCXXABI &ABI)
2698  : CGM(ABI.CGM), VMContext(CGM.getModule().getContext()), CXXABI(ABI) {}
2699 
2700  // Pointer type info flags.
2701  enum {
2702  /// PTI_Const - Type has const qualifier.
2703  PTI_Const = 0x1,
2704 
2705  /// PTI_Volatile - Type has volatile qualifier.
2706  PTI_Volatile = 0x2,
2707 
2708  /// PTI_Restrict - Type has restrict qualifier.
2709  PTI_Restrict = 0x4,
2710 
2711  /// PTI_Incomplete - Type is incomplete.
2712  PTI_Incomplete = 0x8,
2713 
2714  /// PTI_ContainingClassIncomplete - Containing class is incomplete.
2715  /// (in pointer to member).
2716  PTI_ContainingClassIncomplete = 0x10,
2717 
2718  /// PTI_TransactionSafe - Pointee is transaction_safe function (C++ TM TS).
2719  //PTI_TransactionSafe = 0x20,
2720 
2721  /// PTI_Noexcept - Pointee is noexcept function (C++1z).
2722  PTI_Noexcept = 0x40,
2723  };
2724 
2725  // VMI type info flags.
2726  enum {
2727  /// VMI_NonDiamondRepeat - Class has non-diamond repeated inheritance.
2728  VMI_NonDiamondRepeat = 0x1,
2729 
2730  /// VMI_DiamondShaped - Class is diamond shaped.
2731  VMI_DiamondShaped = 0x2
2732  };
2733 
2734  // Base class type info flags.
2735  enum {
2736  /// BCTI_Virtual - Base class is virtual.
2737  BCTI_Virtual = 0x1,
2738 
2739  /// BCTI_Public - Base class is public.
2740  BCTI_Public = 0x2
2741  };
2742 
2743  /// BuildTypeInfo - Build the RTTI type info struct for the given type, or
2744  /// link to an existing RTTI descriptor if one already exists.
2745  llvm::Constant *BuildTypeInfo(QualType Ty);
2746 
2747  /// BuildTypeInfo - Build the RTTI type info struct for the given type.
2748  llvm::Constant *BuildTypeInfo(
2749  QualType Ty,
2750  llvm::GlobalVariable::LinkageTypes Linkage,
2751  llvm::GlobalValue::VisibilityTypes Visibility,
2752  llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass);
2753 };
2754 }
2755 
2756 llvm::GlobalVariable *ItaniumRTTIBuilder::GetAddrOfTypeName(
2757  QualType Ty, llvm::GlobalVariable::LinkageTypes Linkage) {
2758  SmallString<256> Name;
2759  llvm::raw_svector_ostream Out(Name);
2760  CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out);
2761 
2762  // We know that the mangled name of the type starts at index 4 of the
2763  // mangled name of the typename, so we can just index into it in order to
2764  // get the mangled name of the type.
2765  llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
2766  Name.substr(4));
2767  auto Align = CGM.getContext().getTypeAlignInChars(CGM.getContext().CharTy);
2768 
2769  llvm::GlobalVariable *GV = CGM.CreateOrReplaceCXXRuntimeVariable(
2770  Name, Init->getType(), Linkage, Align.getQuantity());
2771 
2772  GV->setInitializer(Init);
2773 
2774  return GV;
2775 }
2776 
2777 llvm::Constant *
2778 ItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(QualType Ty) {
2779  // Mangle the RTTI name.
2780  SmallString<256> Name;
2781  llvm::raw_svector_ostream Out(Name);
2782  CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
2783 
2784  // Look for an existing global.
2785  llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name);
2786 
2787  if (!GV) {
2788  // Create a new global variable.
2789  // Note for the future: If we would ever like to do deferred emission of
2790  // RTTI, check if emitting vtables opportunistically need any adjustment.
2791 
2792  GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
2793  /*Constant=*/true,
2795  Name);
2796  const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
2797  CGM.setGVProperties(GV, RD);
2798  }
2799 
2800  return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
2801 }
2802 
2803 /// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type
2804 /// info for that type is defined in the standard library.
2806  // Itanium C++ ABI 2.9.2:
2807  // Basic type information (e.g. for "int", "bool", etc.) will be kept in
2808  // the run-time support library. Specifically, the run-time support
2809  // library should contain type_info objects for the types X, X* and
2810  // X const*, for every X in: void, std::nullptr_t, bool, wchar_t, char,
2811  // unsigned char, signed char, short, unsigned short, int, unsigned int,
2812  // long, unsigned long, long long, unsigned long long, float, double,
2813  // long double, char16_t, char32_t, and the IEEE 754r decimal and
2814  // half-precision floating point types.
2815  //
2816  // GCC also emits RTTI for __int128.
2817  // FIXME: We do not emit RTTI information for decimal types here.
2818 
2819  // Types added here must also be added to EmitFundamentalRTTIDescriptors.
2820  switch (Ty->getKind()) {
2821  case BuiltinType::Void:
2822  case BuiltinType::NullPtr:
2823  case BuiltinType::Bool:
2824  case BuiltinType::WChar_S:
2825  case BuiltinType::WChar_U:
2826  case BuiltinType::Char_U:
2827  case BuiltinType::Char_S:
2828  case BuiltinType::UChar:
2829  case BuiltinType::SChar:
2830  case BuiltinType::Short:
2831  case BuiltinType::UShort:
2832  case BuiltinType::Int:
2833  case BuiltinType::UInt:
2834  case BuiltinType::Long:
2835  case BuiltinType::ULong:
2836  case BuiltinType::LongLong:
2837  case BuiltinType::ULongLong:
2838  case BuiltinType::Half:
2839  case BuiltinType::Float:
2840  case BuiltinType::Double:
2841  case BuiltinType::LongDouble:
2842  case BuiltinType::Float16:
2843  case BuiltinType::Float128:
2844  case BuiltinType::Char8:
2845  case BuiltinType::Char16:
2846  case BuiltinType::Char32:
2847  case BuiltinType::Int128:
2848  case BuiltinType::UInt128:
2849  return true;
2850 
2851 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2852  case BuiltinType::Id:
2853 #include "clang/Basic/OpenCLImageTypes.def"
2854 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2855  case BuiltinType::Id:
2856 #include "clang/Basic/OpenCLExtensionTypes.def"
2857  case BuiltinType::OCLSampler:
2858  case BuiltinType::OCLEvent:
2859  case BuiltinType::OCLClkEvent:
2860  case BuiltinType::OCLQueue:
2861  case BuiltinType::OCLReserveID:
2862  case BuiltinType::ShortAccum:
2863  case BuiltinType::Accum:
2864  case BuiltinType::LongAccum:
2865  case BuiltinType::UShortAccum:
2866  case BuiltinType::UAccum:
2867  case BuiltinType::ULongAccum:
2868  case BuiltinType::ShortFract:
2869  case BuiltinType::Fract:
2870  case BuiltinType::LongFract:
2871  case BuiltinType::UShortFract:
2872  case BuiltinType::UFract:
2873  case BuiltinType::ULongFract:
2874  case BuiltinType::SatShortAccum:
2875  case BuiltinType::SatAccum:
2876  case BuiltinType::SatLongAccum:
2877  case BuiltinType::SatUShortAccum:
2878  case BuiltinType::SatUAccum:
2879  case BuiltinType::SatULongAccum:
2880  case BuiltinType::SatShortFract:
2881  case BuiltinType::SatFract:
2882  case BuiltinType::SatLongFract:
2883  case BuiltinType::SatUShortFract:
2884  case BuiltinType::SatUFract:
2885  case BuiltinType::SatULongFract:
2886  return false;
2887 
2888  case BuiltinType::Dependent:
2889 #define BUILTIN_TYPE(Id, SingletonId)
2890 #define PLACEHOLDER_TYPE(Id, SingletonId) \
2891  case BuiltinType::Id:
2892 #include "clang/AST/BuiltinTypes.def"
2893  llvm_unreachable("asking for RRTI for a placeholder type!");
2894 
2895  case BuiltinType::ObjCId:
2896  case BuiltinType::ObjCClass:
2897  case BuiltinType::ObjCSel:
2898  llvm_unreachable("FIXME: Objective-C types are unsupported!");
2899  }
2900 
2901  llvm_unreachable("Invalid BuiltinType Kind!");
2902 }
2903 
2904 static bool TypeInfoIsInStandardLibrary(const PointerType *PointerTy) {
2905  QualType PointeeTy = PointerTy->getPointeeType();
2906  const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(PointeeTy);
2907  if (!BuiltinTy)
2908  return false;
2909 
2910  // Check the qualifiers.
2911  Qualifiers Quals = PointeeTy.getQualifiers();
2912  Quals.removeConst();
2913 
2914  if (!Quals.empty())
2915  return false;
2916 
2917  return TypeInfoIsInStandardLibrary(BuiltinTy);
2918 }
2919 
2920 /// IsStandardLibraryRTTIDescriptor - Returns whether the type
2921 /// information for the given type exists in the standard library.
2923  // Type info for builtin types is defined in the standard library.
2924  if (const BuiltinType *BuiltinTy = dyn_cast<BuiltinType>(Ty))
2925  return TypeInfoIsInStandardLibrary(BuiltinTy);
2926 
2927  // Type info for some pointer types to builtin types is defined in the
2928  // standard library.
2929  if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
2930  return TypeInfoIsInStandardLibrary(PointerTy);
2931 
2932  return false;
2933 }
2934 
2935 /// ShouldUseExternalRTTIDescriptor - Returns whether the type information for
2936 /// the given type exists somewhere else, and that we should not emit the type
2937 /// information in this translation unit. Assumes that it is not a
2938 /// standard-library type.
2940  QualType Ty) {
2941  ASTContext &Context = CGM.getContext();
2942 
2943  // If RTTI is disabled, assume it might be disabled in the
2944  // translation unit that defines any potential key function, too.
2945  if (!Context.getLangOpts().RTTI) return false;
2946 
2947  if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2948  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
2949  if (!RD->hasDefinition())
2950  return false;
2951 
2952  if (!RD->isDynamicClass())
2953  return false;
2954 
2955  // FIXME: this may need to be reconsidered if the key function
2956  // changes.
2957  // N.B. We must always emit the RTTI data ourselves if there exists a key
2958  // function.
2959  bool IsDLLImport = RD->hasAttr<DLLImportAttr>();
2960 
2961  // Don't import the RTTI but emit it locally.
2962  if (CGM.getTriple().isWindowsGNUEnvironment() && IsDLLImport)
2963  return false;
2964 
2965  if (CGM.getVTables().isVTableExternal(RD))
2966  return IsDLLImport && !CGM.getTriple().isWindowsItaniumEnvironment()
2967  ? false
2968  : true;
2969 
2970  if (IsDLLImport)
2971  return true;
2972  }
2973 
2974  return false;
2975 }
2976 
2977 /// IsIncompleteClassType - Returns whether the given record type is incomplete.
2978 static bool IsIncompleteClassType(const RecordType *RecordTy) {
2979  return !RecordTy->getDecl()->isCompleteDefinition();
2980 }
2981 
2982 /// ContainsIncompleteClassType - Returns whether the given type contains an
2983 /// incomplete class type. This is true if
2984 ///
2985 /// * The given type is an incomplete class type.
2986 /// * The given type is a pointer type whose pointee type contains an
2987 /// incomplete class type.
2988 /// * The given type is a member pointer type whose class is an incomplete
2989 /// class type.
2990 /// * The given type is a member pointer type whoise pointee type contains an
2991 /// incomplete class type.
2992 /// is an indirect or direct pointer to an incomplete class type.
2994  if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
2995  if (IsIncompleteClassType(RecordTy))
2996  return true;
2997  }
2998 
2999  if (const PointerType *PointerTy = dyn_cast<PointerType>(Ty))
3000  return ContainsIncompleteClassType(PointerTy->getPointeeType());
3001 
3002  if (const MemberPointerType *MemberPointerTy =
3003  dyn_cast<MemberPointerType>(Ty)) {
3004  // Check if the class type is incomplete.
3005  const RecordType *ClassType = cast<RecordType>(MemberPointerTy->getClass());
3006  if (IsIncompleteClassType(ClassType))
3007  return true;
3008 
3009  return ContainsIncompleteClassType(MemberPointerTy->getPointeeType());
3010  }
3011 
3012  return false;
3013 }
3014 
3015 // CanUseSingleInheritance - Return whether the given record decl has a "single,
3016 // public, non-virtual base at offset zero (i.e. the derived class is dynamic
3017 // iff the base is)", according to Itanium C++ ABI, 2.95p6b.
3018 static bool CanUseSingleInheritance(const CXXRecordDecl *RD) {
3019  // Check the number of bases.
3020  if (RD->getNumBases() != 1)
3021  return false;
3022 
3023  // Get the base.
3025 
3026  // Check that the base is not virtual.
3027  if (Base->isVirtual())
3028  return false;
3029 
3030  // Check that the base is public.
3031  if (Base->getAccessSpecifier() != AS_public)
3032  return false;
3033 
3034  // Check that the class is dynamic iff the base is.
3035  const CXXRecordDecl *BaseDecl =
3036  cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3037  if (!BaseDecl->isEmpty() &&
3038  BaseDecl->isDynamicClass() != RD->isDynamicClass())
3039  return false;
3040 
3041  return true;
3042 }
3043 
3044 void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) {
3045  // abi::__class_type_info.
3046  static const char * const ClassTypeInfo =
3047  "_ZTVN10__cxxabiv117__class_type_infoE";
3048  // abi::__si_class_type_info.
3049  static const char * const SIClassTypeInfo =
3050  "_ZTVN10__cxxabiv120__si_class_type_infoE";
3051  // abi::__vmi_class_type_info.
3052  static const char * const VMIClassTypeInfo =
3053  "_ZTVN10__cxxabiv121__vmi_class_type_infoE";
3054 
3055  const char *VTableName = nullptr;
3056 
3057  switch (Ty->getTypeClass()) {
3058 #define TYPE(Class, Base)
3059 #define ABSTRACT_TYPE(Class, Base)
3060 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3061 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3062 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
3063 #include "clang/AST/TypeNodes.def"
3064  llvm_unreachable("Non-canonical and dependent types shouldn't get here");
3065 
3066  case Type::LValueReference:
3067  case Type::RValueReference:
3068  llvm_unreachable("References shouldn't get here");
3069 
3070  case Type::Auto:
3071  case Type::DeducedTemplateSpecialization:
3072  llvm_unreachable("Undeduced type shouldn't get here");
3073 
3074  case Type::Pipe:
3075  llvm_unreachable("Pipe types shouldn't get here");
3076 
3077  case Type::Builtin:
3078  // GCC treats vector and complex types as fundamental types.
3079  case Type::Vector:
3080  case Type::ExtVector:
3081  case Type::Complex:
3082  case Type::Atomic:
3083  // FIXME: GCC treats block pointers as fundamental types?!
3084  case Type::BlockPointer:
3085  // abi::__fundamental_type_info.
3086  VTableName = "_ZTVN10__cxxabiv123__fundamental_type_infoE";
3087  break;
3088 
3089  case Type::ConstantArray:
3090  case Type::IncompleteArray:
3091  case Type::VariableArray:
3092  // abi::__array_type_info.
3093  VTableName = "_ZTVN10__cxxabiv117__array_type_infoE";
3094  break;
3095 
3096  case Type::FunctionNoProto:
3097  case Type::FunctionProto:
3098  // abi::__function_type_info.
3099  VTableName = "_ZTVN10__cxxabiv120__function_type_infoE";
3100  break;
3101 
3102  case Type::Enum:
3103  // abi::__enum_type_info.
3104  VTableName = "_ZTVN10__cxxabiv116__enum_type_infoE";
3105  break;
3106 
3107  case Type::Record: {
3108  const CXXRecordDecl *RD =
3109  cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
3110 
3111  if (!RD->hasDefinition() || !RD->getNumBases()) {
3112  VTableName = ClassTypeInfo;
3113  } else if (CanUseSingleInheritance(RD)) {
3114  VTableName = SIClassTypeInfo;
3115  } else {
3116  VTableName = VMIClassTypeInfo;
3117  }
3118 
3119  break;
3120  }
3121 
3122  case Type::ObjCObject:
3123  // Ignore protocol qualifiers.
3124  Ty = cast<ObjCObjectType>(Ty)->getBaseType().getTypePtr();
3125 
3126  // Handle id and Class.
3127  if (isa<BuiltinType>(Ty)) {
3128  VTableName = ClassTypeInfo;
3129  break;
3130  }
3131 
3132  assert(isa<ObjCInterfaceType>(Ty));
3133  LLVM_FALLTHROUGH;
3134 
3135  case Type::ObjCInterface:
3136  if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
3137  VTableName = SIClassTypeInfo;
3138  } else {
3139  VTableName = ClassTypeInfo;
3140  }
3141  break;
3142 
3143  case Type::ObjCObjectPointer:
3144  case Type::Pointer:
3145  // abi::__pointer_type_info.
3146  VTableName = "_ZTVN10__cxxabiv119__pointer_type_infoE";
3147  break;
3148 
3149  case Type::MemberPointer:
3150  // abi::__pointer_to_member_type_info.
3151  VTableName = "_ZTVN10__cxxabiv129__pointer_to_member_type_infoE";
3152  break;
3153  }
3154 
3155  llvm::Constant *VTable =
3156  CGM.getModule().getOrInsertGlobal(VTableName, CGM.Int8PtrTy);
3157  CGM.setDSOLocal(cast<llvm::GlobalValue>(VTable->stripPointerCasts()));
3158 
3159  llvm::Type *PtrDiffTy =
3161 
3162  // The vtable address point is 2.
3163  llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
3164  VTable =
3165  llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
3166  VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
3167 
3168  Fields.push_back(VTable);
3169 }
3170 
3171 /// Return the linkage that the type info and type info name constants
3172 /// should have for the given type.
3173 static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
3174  QualType Ty) {
3175  // Itanium C++ ABI 2.9.5p7:
3176  // In addition, it and all of the intermediate abi::__pointer_type_info
3177  // structs in the chain down to the abi::__class_type_info for the
3178  // incomplete class type must be prevented from resolving to the
3179  // corresponding type_info structs for the complete class type, possibly
3180  // by making them local static objects. Finally, a dummy class RTTI is
3181  // generated for the incomplete type that will not resolve to the final
3182  // complete class RTTI (because the latter need not exist), possibly by
3183  // making it a local static object.
3186 
3187  switch (Ty->getLinkage()) {
3188  case NoLinkage:
3189  case InternalLinkage:
3190  case UniqueExternalLinkage:
3192 
3193  case VisibleNoLinkage:
3194  case ModuleInternalLinkage:
3195  case ModuleLinkage:
3196  case ExternalLinkage:
3197  // RTTI is not enabled, which means that this type info struct is going
3198  // to be used for exception handling. Give it linkonce_odr linkage.
3199  if (!CGM.getLangOpts().RTTI)
3200  return llvm::GlobalValue::LinkOnceODRLinkage;
3201 
3202  if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
3203  const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
3204  if (RD->hasAttr<WeakAttr>())
3205  return llvm::GlobalValue::WeakODRLinkage;
3206  if (CGM.getTriple().isWindowsItaniumEnvironment())
3207  if (RD->hasAttr<DLLImportAttr>() &&
3210  // MinGW always uses LinkOnceODRLinkage for type info.
3211  if (RD->isDynamicClass() &&
3212  !CGM.getContext()
3213  .getTargetInfo()
3214  .getTriple()
3215  .isWindowsGNUEnvironment())
3216  return CGM.getVTableLinkage(RD);
3217  }
3218 
3219  return llvm::GlobalValue::LinkOnceODRLinkage;
3220  }
3221 
3222  llvm_unreachable("Invalid linkage!");
3223 }
3224 
3225 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty) {
3226  // We want to operate on the canonical type.
3227  Ty = Ty.getCanonicalType();
3228 
3229  // Check if we've already emitted an RTTI descriptor for this type.
3230  SmallString<256> Name;
3231  llvm::raw_svector_ostream Out(Name);
3232  CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
3233 
3234  llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name);
3235  if (OldGV && !OldGV->isDeclaration()) {
3236  assert(!OldGV->hasAvailableExternallyLinkage() &&
3237  "available_externally typeinfos not yet implemented");
3238 
3239  return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy);
3240  }
3241 
3242  // Check if there is already an external RTTI descriptor for this type.
3245  return GetAddrOfExternalRTTIDescriptor(Ty);
3246 
3247  // Emit the standard library with external linkage.
3248  llvm::GlobalVariable::LinkageTypes Linkage = getTypeInfoLinkage(CGM, Ty);
3249 
3250  // Give the type_info object and name the formal visibility of the
3251  // type itself.
3252  llvm::GlobalValue::VisibilityTypes llvmVisibility;
3253  if (llvm::GlobalValue::isLocalLinkage(Linkage))
3254  // If the linkage is local, only default visibility makes sense.
3255  llvmVisibility = llvm::GlobalValue::DefaultVisibility;
3256  else if (CXXABI.classifyRTTIUniqueness(Ty, Linkage) ==
3257  ItaniumCXXABI::RUK_NonUniqueHidden)
3258  llvmVisibility = llvm::GlobalValue::HiddenVisibility;
3259  else
3260  llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
3261 
3262  llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass =
3263  llvm::GlobalValue::DefaultStorageClass;
3264  if (CGM.getTriple().isWindowsItaniumEnvironment()) {
3265  auto RD = Ty->getAsCXXRecordDecl();
3266  if (RD && RD->hasAttr<DLLExportAttr>())
3267  DLLStorageClass = llvm::GlobalValue::DLLExportStorageClass;
3268  }
3269 
3270  return BuildTypeInfo(Ty, Linkage, llvmVisibility, DLLStorageClass);
3271 }
3272 
3273 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(
3274  QualType Ty,
3275  llvm::GlobalVariable::LinkageTypes Linkage,
3276  llvm::GlobalValue::VisibilityTypes Visibility,
3277  llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass) {
3278  // Add the vtable pointer.
3279  BuildVTablePointer(cast<Type>(Ty));
3280 
3281  // And the name.
3282  llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, Linkage);
3283  llvm::Constant *TypeNameField;
3284 
3285  // If we're supposed to demote the visibility, be sure to set a flag
3286  // to use a string comparison for type_info comparisons.
3287  ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
3288  CXXABI.classifyRTTIUniqueness(Ty, Linkage);
3289  if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
3290  // The flag is the sign bit, which on ARM64 is defined to be clear
3291  // for global pointers. This is very ARM64-specific.
3292  TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
3293  llvm::Constant *flag =
3294  llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
3295  TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
3296  TypeNameField =
3297  llvm::ConstantExpr::getIntToPtr(TypeNameField, CGM.Int8PtrTy);
3298  } else {
3299  TypeNameField = llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy);
3300  }
3301  Fields.push_back(TypeNameField);
3302 
3303  switch (Ty->getTypeClass()) {
3304 #define TYPE(Class, Base)
3305 #define ABSTRACT_TYPE(Class, Base)
3306 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3307 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3308 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
3309 #include "clang/AST/TypeNodes.def"
3310  llvm_unreachable("Non-canonical and dependent types shouldn't get here");
3311 
3312  // GCC treats vector types as fundamental types.
3313  case Type::Builtin:
3314  case Type::Vector:
3315  case Type::ExtVector:
3316  case Type::Complex:
3317  case Type::BlockPointer:
3318  // Itanium C++ ABI 2.9.5p4:
3319  // abi::__fundamental_type_info adds no data members to std::type_info.
3320  break;
3321 
3322  case Type::LValueReference:
3323  case Type::RValueReference:
3324  llvm_unreachable("References shouldn't get here");
3325 
3326  case Type::Auto:
3327  case Type::DeducedTemplateSpecialization:
3328  llvm_unreachable("Undeduced type shouldn't get here");
3329 
3330  case Type::Pipe:
3331  llvm_unreachable("Pipe type shouldn't get here");
3332 
3333  case Type::ConstantArray:
3334  case Type::IncompleteArray:
3335  case Type::VariableArray:
3336  // Itanium C++ ABI 2.9.5p5:
3337  // abi::__array_type_info adds no data members to std::type_info.
3338  break;
3339 
3340  case Type::FunctionNoProto:
3341  case Type::FunctionProto:
3342  // Itanium C++ ABI 2.9.5p5:
3343  // abi::__function_type_info adds no data members to std::type_info.
3344  break;
3345 
3346  case Type::Enum:
3347  // Itanium C++ ABI 2.9.5p5:
3348  // abi::__enum_type_info adds no data members to std::type_info.
3349  break;
3350 
3351  case Type::Record: {
3352  const CXXRecordDecl *RD =
3353  cast<CXXRecordDecl>(cast<RecordType>(Ty)->getDecl());
3354  if (!RD->hasDefinition() || !RD->getNumBases()) {
3355  // We don't need to emit any fields.
3356  break;
3357  }
3358 
3359  if (CanUseSingleInheritance(RD))
3360  BuildSIClassTypeInfo(RD);
3361  else
3362  BuildVMIClassTypeInfo(RD);
3363 
3364  break;
3365  }
3366 
3367  case Type::ObjCObject:
3368  case Type::ObjCInterface:
3369  BuildObjCObjectTypeInfo(cast<ObjCObjectType>(Ty));
3370  break;
3371 
3372  case Type::ObjCObjectPointer:
3373  BuildPointerTypeInfo(cast<ObjCObjectPointerType>(Ty)->getPointeeType());
3374  break;
3375 
3376  case Type::Pointer:
3377  BuildPointerTypeInfo(cast<PointerType>(Ty)->getPointeeType());
3378  break;
3379 
3380  case Type::MemberPointer:
3381  BuildPointerToMemberTypeInfo(cast<MemberPointerType>(Ty));
3382  break;
3383 
3384  case Type::Atomic:
3385  // No fields, at least for the moment.
3386  break;
3387  }
3388 
3389  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);
3390 
3391  SmallString<256> Name;
3392  llvm::raw_svector_ostream Out(Name);
3393  CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
3394  llvm::Module &M = CGM.getModule();
3395  llvm::GlobalVariable *OldGV = M.getNamedGlobal(Name);
3396  llvm::GlobalVariable *GV =
3397  new llvm::GlobalVariable(M, Init->getType(),
3398  /*Constant=*/true, Linkage, Init, Name);
3399 
3400  // If there's already an old global variable, replace it with the new one.
3401  if (OldGV) {
3402  GV->takeName(OldGV);
3403  llvm::Constant *NewPtr =
3404  llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
3405  OldGV->replaceAllUsesWith(NewPtr);
3406  OldGV->eraseFromParent();
3407  }
3408 
3409  if (CGM.supportsCOMDAT() && GV->isWeakForLinker())
3410  GV->setComdat(M.getOrInsertComdat(GV->getName()));
3411 
3412  CharUnits Align =
3414  GV->setAlignment(Align.getQuantity());
3415 
3416  // The Itanium ABI specifies that type_info objects must be globally
3417  // unique, with one exception: if the type is an incomplete class
3418  // type or a (possibly indirect) pointer to one. That exception
3419  // affects the general case of comparing type_info objects produced
3420  // by the typeid operator, which is why the comparison operators on
3421  // std::type_info generally use the type_info name pointers instead
3422  // of the object addresses. However, the language's built-in uses
3423  // of RTTI generally require class types to be complete, even when
3424  // manipulating pointers to those class types. This allows the
3425  // implementation of dynamic_cast to rely on address equality tests,
3426  // which is much faster.
3427 
3428  // All of this is to say that it's important that both the type_info
3429  // object and the type_info name be uniqued when weakly emitted.
3430 
3431  TypeName->setVisibility(Visibility);
3432  CGM.setDSOLocal(TypeName);
3433 
3434  GV->setVisibility(Visibility);
3435  CGM.setDSOLocal(GV);
3436 
3437  TypeName->setDLLStorageClass(DLLStorageClass);
3438  GV->setDLLStorageClass(DLLStorageClass);
3439 
3440  return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
3441 }
3442 
3443 /// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info
3444 /// for the given Objective-C object type.
3445 void ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) {
3446  // Drop qualifiers.
3447  const Type *T = OT->getBaseType().getTypePtr();
3448  assert(isa<BuiltinType>(T) || isa<ObjCInterfaceType>(T));
3449 
3450  // The builtin types are abi::__class_type_infos and don't require
3451  // extra fields.
3452  if (isa<BuiltinType>(T)) return;
3453 
3454  ObjCInterfaceDecl *Class = cast<ObjCInterfaceType>(T)->getDecl();
3455  ObjCInterfaceDecl *Super = Class->getSuperClass();
3456 
3457  // Root classes are also __class_type_info.
3458  if (!Super) return;
3459 
3460  QualType SuperTy = CGM.getContext().getObjCInterfaceType(Super);
3461 
3462  // Everything else is single inheritance.
3463  llvm::Constant *BaseTypeInfo =
3464  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(SuperTy);
3465  Fields.push_back(BaseTypeInfo);
3466 }
3467 
3468 /// BuildSIClassTypeInfo - Build an abi::__si_class_type_info, used for single
3469 /// inheritance, according to the Itanium C++ ABI, 2.95p6b.
3470 void ItaniumRTTIBuilder::BuildSIClassTypeInfo(const CXXRecordDecl *RD) {
3471  // Itanium C++ ABI 2.9.5p6b:
3472  // It adds to abi::__class_type_info a single member pointing to the
3473  // type_info structure for the base type,
3474  llvm::Constant *BaseTypeInfo =
3475  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(RD->bases_begin()->getType());
3476  Fields.push_back(BaseTypeInfo);
3477 }
3478 
3479 namespace {
3480  /// SeenBases - Contains virtual and non-virtual bases seen when traversing
3481  /// a class hierarchy.
3482  struct SeenBases {
3483  llvm::SmallPtrSet<const CXXRecordDecl *, 16> NonVirtualBases;
3484  llvm::SmallPtrSet<const CXXRecordDecl *, 16> VirtualBases;
3485  };
3486 }
3487 
3488 /// ComputeVMIClassTypeInfoFlags - Compute the value of the flags member in
3489 /// abi::__vmi_class_type_info.
3490 ///
3492  SeenBases &Bases) {
3493 
3494  unsigned Flags = 0;
3495 
3496  const CXXRecordDecl *BaseDecl =
3497  cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
3498 
3499  if (Base->isVirtual()) {
3500  // Mark the virtual base as seen.
3501  if (!Bases.VirtualBases.insert(BaseDecl).second) {
3502  // If this virtual base has been seen before, then the class is diamond
3503  // shaped.
3504  Flags |= ItaniumRTTIBuilder::VMI_DiamondShaped;
3505  } else {
3506  if (Bases.NonVirtualBases.count(BaseDecl))
3507  Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3508  }
3509  } else {
3510  // Mark the non-virtual base as seen.
3511  if (!Bases.NonVirtualBases.insert(BaseDecl).second) {
3512  // If this non-virtual base has been seen before, then the class has non-
3513  // diamond shaped repeated inheritance.
3514  Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3515  } else {
3516  if (Bases.VirtualBases.count(BaseDecl))
3517  Flags |= ItaniumRTTIBuilder::VMI_NonDiamondRepeat;
3518  }
3519  }
3520 
3521  // Walk all bases.
3522  for (const auto &I : BaseDecl->bases())
3523  Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3524 
3525  return Flags;
3526 }
3527 
3528 static unsigned ComputeVMIClassTypeInfoFlags(const CXXRecordDecl *RD) {
3529  unsigned Flags = 0;
3530  SeenBases Bases;
3531 
3532  // Walk all bases.
3533  for (const auto &I : RD->bases())
3534  Flags |= ComputeVMIClassTypeInfoFlags(&I, Bases);
3535 
3536  return Flags;
3537 }
3538 
3539 /// BuildVMIClassTypeInfo - Build an abi::__vmi_class_type_info, used for
3540 /// classes with bases that do not satisfy the abi::__si_class_type_info
3541 /// constraints, according ti the Itanium C++ ABI, 2.9.5p5c.
3542 void ItaniumRTTIBuilder::BuildVMIClassTypeInfo(const CXXRecordDecl *RD) {
3543  llvm::Type *UnsignedIntLTy =
3545 
3546  // Itanium C++ ABI 2.9.5p6c:
3547  // __flags is a word with flags describing details about the class
3548  // structure, which may be referenced by using the __flags_masks
3549  // enumeration. These flags refer to both direct and indirect bases.
3550  unsigned Flags = ComputeVMIClassTypeInfoFlags(RD);
3551  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3552 
3553  // Itanium C++ ABI 2.9.5p6c:
3554  // __base_count is a word with the number of direct proper base class
3555  // descriptions that follow.
3556  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases()));
3557 
3558  if (!RD->getNumBases())
3559  return;
3560 
3561  // Now add the base class descriptions.
3562 
3563  // Itanium C++ ABI 2.9.5p6c:
3564  // __base_info[] is an array of base class descriptions -- one for every
3565  // direct proper base. Each description is of the type:
3566  //
3567  // struct abi::__base_class_type_info {
3568  // public:
3569  // const __class_type_info *__base_type;
3570  // long __offset_flags;
3571  //
3572  // enum __offset_flags_masks {
3573  // __virtual_mask = 0x1,
3574  // __public_mask = 0x2,
3575  // __offset_shift = 8
3576  // };
3577  // };
3578 
3579  // If we're in mingw and 'long' isn't wide enough for a pointer, use 'long
3580  // long' instead of 'long' for __offset_flags. libstdc++abi uses long long on
3581  // LLP64 platforms.
3582  // FIXME: Consider updating libc++abi to match, and extend this logic to all
3583  // LLP64 platforms.
3584  QualType OffsetFlagsTy = CGM.getContext().LongTy;
3585  const TargetInfo &TI = CGM.getContext().getTargetInfo();
3586  if (TI.getTriple().isOSCygMing() && TI.getPointerWidth(0) > TI.getLongWidth())
3587  OffsetFlagsTy = CGM.getContext().LongLongTy;
3588  llvm::Type *OffsetFlagsLTy =
3589  CGM.getTypes().ConvertType(OffsetFlagsTy);
3590 
3591  for (const auto &Base : RD->bases()) {
3592  // The __base_type member points to the RTTI for the base type.
3593  Fields.push_back(ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(Base.getType()));
3594 
3595  const CXXRecordDecl *BaseDecl =
3596  cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
3597 
3598  int64_t OffsetFlags = 0;
3599 
3600  // All but the lower 8 bits of __offset_flags are a signed offset.
3601  // For a non-virtual base, this is the offset in the object of the base
3602  // subobject. For a virtual base, this is the offset in the virtual table of
3603  // the virtual base offset for the virtual base referenced (negative).
3604  CharUnits Offset;
3605  if (Base.isVirtual())
3606  Offset =
3608  else {
3609  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3610  Offset = Layout.getBaseClassOffset(BaseDecl);
3611  };
3612 
3613  OffsetFlags = uint64_t(Offset.getQuantity()) << 8;
3614 
3615  // The low-order byte of __offset_flags contains flags, as given by the
3616  // masks from the enumeration __offset_flags_masks.
3617  if (Base.isVirtual())
3618  OffsetFlags |= BCTI_Virtual;
3619  if (Base.getAccessSpecifier() == AS_public)
3620  OffsetFlags |= BCTI_Public;
3621 
3622  Fields.push_back(llvm::ConstantInt::get(OffsetFlagsLTy, OffsetFlags));
3623  }
3624 }
3625 
3626 /// Compute the flags for a __pbase_type_info, and remove the corresponding
3627 /// pieces from \p Type.
3628 static unsigned extractPBaseFlags(ASTContext &Ctx, QualType &Type) {
3629  unsigned Flags = 0;
3630 
3631  if (Type.isConstQualified())
3632  Flags |= ItaniumRTTIBuilder::PTI_Const;
3633  if (Type.isVolatileQualified())
3634  Flags |= ItaniumRTTIBuilder::PTI_Volatile;
3635  if (Type.isRestrictQualified())
3636  Flags |= ItaniumRTTIBuilder::PTI_Restrict;
3637  Type = Type.getUnqualifiedType();
3638 
3639  // Itanium C++ ABI 2.9.5p7:
3640  // When the abi::__pbase_type_info is for a direct or indirect pointer to an
3641  // incomplete class type, the incomplete target type flag is set.
3642  if (ContainsIncompleteClassType(Type))
3643  Flags |= ItaniumRTTIBuilder::PTI_Incomplete;
3644 
3645  if (auto *Proto = Type->getAs<FunctionProtoType>()) {
3646  if (Proto->isNothrow()) {
3647  Flags |= ItaniumRTTIBuilder::PTI_Noexcept;
3648  Type = Ctx.getFunctionTypeWithExceptionSpec(Type, EST_None);
3649  }
3650  }
3651 
3652  return Flags;
3653 }
3654 
3655 /// BuildPointerTypeInfo - Build an abi::__pointer_type_info struct,
3656 /// used for pointer types.
3657 void ItaniumRTTIBuilder::BuildPointerTypeInfo(QualType PointeeTy) {
3658  // Itanium C++ ABI 2.9.5p7:
3659  // __flags is a flag word describing the cv-qualification and other
3660  // attributes of the type pointed to
3661  unsigned Flags = extractPBaseFlags(CGM.getContext(), PointeeTy);
3662 
3663  llvm::Type *UnsignedIntLTy =
3665  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3666 
3667  // Itanium C++ ABI 2.9.5p7:
3668  // __pointee is a pointer to the std::type_info derivation for the
3669  // unqualified type being pointed to.
3670  llvm::Constant *PointeeTypeInfo =
3671  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(PointeeTy);
3672  Fields.push_back(PointeeTypeInfo);
3673 }
3674 
3675 /// BuildPointerToMemberTypeInfo - Build an abi::__pointer_to_member_type_info
3676 /// struct, used for member pointer types.
3677 void
3678 ItaniumRTTIBuilder::BuildPointerToMemberTypeInfo(const MemberPointerType *Ty) {
3679  QualType PointeeTy = Ty->getPointeeType();
3680 
3681  // Itanium C++ ABI 2.9.5p7:
3682  // __flags is a flag word describing the cv-qualification and other
3683  // attributes of the type pointed to.
3684  unsigned Flags = extractPBaseFlags(CGM.getContext(), PointeeTy);
3685 
3686  const RecordType *ClassType = cast<RecordType>(Ty->getClass());
3687  if (IsIncompleteClassType(ClassType))
3688  Flags |= PTI_ContainingClassIncomplete;
3689 
3690  llvm::Type *UnsignedIntLTy =
3692  Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3693 
3694  // Itanium C++ ABI 2.9.5p7:
3695  // __pointee is a pointer to the std::type_info derivation for the
3696  // unqualified type being pointed to.
3697  llvm::Constant *PointeeTypeInfo =
3698  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(PointeeTy);
3699  Fields.push_back(PointeeTypeInfo);
3700 
3701  // Itanium C++ ABI 2.9.5p9:
3702  // __context is a pointer to an abi::__class_type_info corresponding to the
3703  // class type containing the member pointed to
3704  // (e.g., the "A" in "int A::*").
3705  Fields.push_back(
3706  ItaniumRTTIBuilder(CXXABI).BuildTypeInfo(QualType(ClassType, 0)));
3707 }
3708 
3709 llvm::Constant *ItaniumCXXABI::getAddrOfRTTIDescriptor(QualType Ty) {
3710  return ItaniumRTTIBuilder(*this).BuildTypeInfo(Ty);
3711 }
3712 
3713 void ItaniumCXXABI::EmitFundamentalRTTIDescriptors(const CXXRecordDecl *RD) {
3714  // Types added here must also be added to TypeInfoIsInStandardLibrary.
3715  QualType FundamentalTypes[] = {
3716  getContext().VoidTy, getContext().NullPtrTy,
3717  getContext().BoolTy, getContext().WCharTy,
3718  getContext().CharTy, getContext().UnsignedCharTy,
3719  getContext().SignedCharTy, getContext().ShortTy,
3720  getContext().UnsignedShortTy, getContext().IntTy,
3721  getContext().UnsignedIntTy, getContext().LongTy,
3722  getContext().UnsignedLongTy, getContext().LongLongTy,
3723  getContext().UnsignedLongLongTy, getContext().Int128Ty,
3724  getContext().UnsignedInt128Ty, getContext().HalfTy,
3725  getContext().FloatTy, getContext().DoubleTy,
3726  getContext().LongDoubleTy, getContext().Float128Ty,
3727  getContext().Char8Ty, getContext().Char16Ty,
3728  getContext().Char32Ty
3729  };
3730  llvm::GlobalValue::DLLStorageClassTypes DLLStorageClass =
3731  RD->hasAttr<DLLExportAttr>()
3732  ? llvm::GlobalValue::DLLExportStorageClass
3733  : llvm::GlobalValue::DefaultStorageClass;
3734  llvm::GlobalValue::VisibilityTypes Visibility =
3736  for (const QualType &FundamentalType : FundamentalTypes) {
3737  QualType PointerType = getContext().getPointerType(FundamentalType);
3738  QualType PointerTypeConst = getContext().getPointerType(
3739  FundamentalType.withConst());
3740  for (QualType Type : {FundamentalType, PointerType, PointerTypeConst})
3741  ItaniumRTTIBuilder(*this).BuildTypeInfo(
3743  Visibility, DLLStorageClass);
3744  }
3745 }
3746 
3747 /// What sort of uniqueness rules should we use for the RTTI for the
3748 /// given type?
3749 ItaniumCXXABI::RTTIUniquenessKind ItaniumCXXABI::classifyRTTIUniqueness(
3750  QualType CanTy, llvm::GlobalValue::LinkageTypes Linkage) const {
3751  if (shouldRTTIBeUnique())
3752  return RUK_Unique;
3753 
3754  // It's only necessary for linkonce_odr or weak_odr linkage.
3755  if (Linkage != llvm::GlobalValue::LinkOnceODRLinkage &&
3756  Linkage != llvm::GlobalValue::WeakODRLinkage)
3757  return RUK_Unique;
3758 
3759  // It's only necessary with default visibility.
3760  if (CanTy->getVisibility() != DefaultVisibility)
3761  return RUK_Unique;
3762 
3763  // If we're not required to publish this symbol, hide it.
3764  if (Linkage == llvm::GlobalValue::LinkOnceODRLinkage)
3765  return RUK_NonUniqueHidden;
3766 
3767  // If we're required to publish this symbol, as we might be under an
3768  // explicit instantiation, leave it with default visibility but
3769  // enable string-comparisons.
3770  assert(Linkage == llvm::GlobalValue::WeakODRLinkage);
3771  return RUK_NonUniqueVisible;
3772 }
3773 
3774 // Find out how to codegen the complete destructor and constructor
3775 namespace {
3776 enum class StructorCodegen { Emit, RAUW, Alias, COMDAT };
3777 }
3779  const CXXMethodDecl *MD) {
3780  if (!CGM.getCodeGenOpts().CXXCtorDtorAliases)
3781  return StructorCodegen::Emit;
3782 
3783  // The complete and base structors are not equivalent if there are any virtual
3784  // bases, so emit separate functions.
3785  if (MD->getParent()->getNumVBases())
3786  return StructorCodegen::Emit;
3787 
3788  GlobalDecl AliasDecl;
3789  if (const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3790  AliasDecl = GlobalDecl(DD, Dtor_Complete);
3791  } else {
3792  const auto *CD = cast<CXXConstructorDecl>(MD);
3793  AliasDecl = GlobalDecl(CD, Ctor_Complete);
3794  }
3795  llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3796 
3797  if (llvm::GlobalValue::isDiscardableIfUnused(Linkage))
3798  return StructorCodegen::RAUW;
3799 
3800  // FIXME: Should we allow available_externally aliases?
3801  if (!llvm::GlobalAlias::isValidLinkage(Linkage))
3802  return StructorCodegen::RAUW;
3803 
3804  if (llvm::GlobalValue::isWeakForLinker(Linkage)) {
3805  // Only ELF and wasm support COMDATs with arbitrary names (C5/D5).
3806  if (CGM.getTarget().getTriple().isOSBinFormatELF() ||
3807  CGM.getTarget().getTriple().isOSBinFormatWasm())
3808  return StructorCodegen::COMDAT;
3809  return StructorCodegen::Emit;
3810  }
3811 
3812  return StructorCodegen::Alias;
3813 }
3814 
3816  GlobalDecl AliasDecl,
3817  GlobalDecl TargetDecl) {
3818  llvm::GlobalValue::LinkageTypes Linkage = CGM.getFunctionLinkage(AliasDecl);
3819 
3820  StringRef MangledName = CGM.getMangledName(AliasDecl);
3821  llvm::GlobalValue *Entry = CGM.GetGlobalValue(MangledName);
3822  if (Entry && !Entry->isDeclaration())
3823  return;
3824 
3825  auto *Aliasee = cast<llvm::GlobalValue>(CGM.GetAddrOfGlobal(TargetDecl));
3826 
3827  // Create the alias with no name.
3828  auto *Alias = llvm::GlobalAlias::create(Linkage, "", Aliasee);
3829 
3830  // Constructors and destructors are always unnamed_addr.
3831  Alias->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3832 
3833  // Switch any previous uses to the alias.
3834  if (Entry) {
3835  assert(Entry->getType() == Aliasee->getType() &&
3836  "declaration exists with different type");
3837  Alias->takeName(Entry);
3838  Entry->replaceAllUsesWith(Alias);
3839  Entry->eraseFromParent();
3840  } else {
3841  Alias->setName(MangledName);
3842  }
3843 
3844  // Finally, set up the alias with its proper name and attributes.
3845  CGM.SetCommonAttributes(AliasDecl, Alias);
3846 }
3847 
3848 void ItaniumCXXABI::emitCXXStructor(GlobalDecl GD) {
3849  auto *MD = cast<CXXMethodDecl>(GD.getDecl());
3850  auto *CD = dyn_cast<CXXConstructorDecl>(MD);
3851  const CXXDestructorDecl *DD = CD ? nullptr : cast<CXXDestructorDecl>(MD);
3852 
3853  StructorCodegen CGType = getCodegenToUse(CGM, MD);
3854 
3855  if (CD ? GD.getCtorType() == Ctor_Complete
3856  : GD.getDtorType() == Dtor_Complete) {
3857  GlobalDecl BaseDecl;
3858  if (CD)
3859  BaseDecl = GD.getWithCtorType(Ctor_Base);
3860  else
3861  BaseDecl = GD.getWithDtorType(Dtor_Base);
3862 
3863  if (CGType == StructorCodegen::Alias || CGType == StructorCodegen::COMDAT) {
3864  emitConstructorDestructorAlias(CGM, GD, BaseDecl);
3865  return;
3866  }
3867 
3868  if (CGType == StructorCodegen::RAUW) {
3869  StringRef MangledName = CGM.getMangledName(GD);
3870  auto *Aliasee = CGM.GetAddrOfGlobal(BaseDecl);
3871  CGM.addReplacement(MangledName, Aliasee);
3872  return;
3873  }
3874  }
3875 
3876  // The base destructor is equivalent to the base destructor of its
3877  // base class if there is exactly one non-virtual base class with a
3878  // non-trivial destructor, there are no fields with a non-trivial
3879  // destructor, and the body of the destructor is trivial.
3880  if (DD && GD.getDtorType() == Dtor_Base &&
3881  CGType != StructorCodegen::COMDAT &&
3883  return;
3884 
3885  // FIXME: The deleting destructor is equivalent to the selected operator
3886  // delete if:
3887  // * either the delete is a destroying operator delete or the destructor
3888  // would be trivial if it weren't virtual,
3889  // * the conversion from the 'this' parameter to the first parameter of the
3890  // destructor is equivalent to a bitcast,
3891  // * the destructor does not have an implicit "this" return, and
3892  // * the operator delete has the same calling convention and IR function type
3893  // as the destructor.
3894  // In such cases we should try to emit the deleting dtor as an alias to the
3895  // selected 'operator delete'.
3896 
3897  llvm::Function *Fn = CGM.codegenCXXStructor(GD);
3898 
3899  if (CGType == StructorCodegen::COMDAT) {
3900  SmallString<256> Buffer;
3901  llvm::raw_svector_ostream Out(Buffer);
3902  if (DD)
3903  getMangleContext().mangleCXXDtorComdat(DD, Out);
3904  else
3905  getMangleContext().mangleCXXCtorComdat(CD, Out);
3906  llvm::Comdat *C = CGM.getModule().getOrInsertComdat(Out.str());
3907  Fn->setComdat(C);
3908  } else {
3909  CGM.maybeSetTrivialComdat(*MD, *Fn);
3910  }
3911 }
3912 
3913 static llvm::FunctionCallee getBeginCatchFn(CodeGenModule &CGM) {
3914  // void *__cxa_begin_catch(void*);
3915  llvm::FunctionType *FTy = llvm::FunctionType::get(
3916  CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3917 
3918  return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch");
3919 }
3920 
3921 static llvm::FunctionCallee getEndCatchFn(CodeGenModule &CGM) {
3922  // void __cxa_end_catch();
3923  llvm::FunctionType *FTy =
3924  llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
3925 
3926  return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch");
3927 }
3928 
3929 static llvm::FunctionCallee getGetExceptionPtrFn(CodeGenModule &CGM) {
3930  // void *__cxa_get_exception_ptr(void*);
3931  llvm::FunctionType *FTy = llvm::FunctionType::get(
3932  CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
3933 
3934  return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr");
3935 }
3936 
3937 namespace {
3938  /// A cleanup to call __cxa_end_catch. In many cases, the caught
3939  /// exception type lets us state definitively that the thrown exception
3940  /// type does not have a destructor. In particular:
3941  /// - Catch-alls tell us nothing, so we have to conservatively
3942  /// assume that the thrown exception might have a destructor.
3943  /// - Catches by reference behave according to their base types.
3944  /// - Catches of non-record types will only trigger for exceptions
3945  /// of non-record types, which never have destructors.
3946  /// - Catches of record types can trigger for arbitrary subclasses
3947  /// of the caught type, so we have to assume the actual thrown
3948  /// exception type might have a throwing destructor, even if the
3949  /// caught type's destructor is trivial or nothrow.
3950  struct CallEndCatch final : EHScopeStack::Cleanup {
3951  CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {}
3952  bool MightThrow;
3953 
3954  void Emit(CodeGenFunction &CGF, Flags flags) override {
3955  if (!MightThrow) {
3957  return;
3958  }
3959 
3961  }
3962  };
3963 }
3964 
3965 /// Emits a call to __cxa_begin_catch and enters a cleanup to call
3966 /// __cxa_end_catch.
3967 ///
3968 /// \param EndMightThrow - true if __cxa_end_catch might throw
3970  llvm::Value *Exn,
3971  bool EndMightThrow) {
3972  llvm::CallInst *call =
3974 
3975  CGF.EHStack.pushCleanup<CallEndCatch>(NormalAndEHCleanup, EndMightThrow);
3976 
3977  return call;
3978 }
3979 
3980 /// A "special initializer" callback for initializing a catch
3981 /// parameter during catch initialization.
3983  const VarDecl &CatchParam,
3984  Address ParamAddr,
3985  SourceLocation Loc) {
3986  // Load the exception from where the landing pad saved it.
3987  llvm::Value *Exn = CGF.getExceptionFromSlot();
3988 
3989  CanQualType CatchType =
3990  CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
3991  llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
3992 
3993  // If we're catching by reference, we can just cast the object
3994  // pointer to the appropriate pointer.
3995  if (isa<ReferenceType>(CatchType)) {
3996  QualType CaughtType = cast<ReferenceType>(CatchType)->getPointeeType();
3997  bool EndCatchMightThrow = CaughtType->isRecordType();
3998 
3999  // __cxa_begin_catch returns the adjusted object pointer.
4000  llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
4001 
4002  // We have no way to tell the personality function that we're
4003  // catching by reference, so if we're catching a pointer,
4004  // __cxa_begin_catch will actually return that pointer by value.
4005  if (const PointerType *PT = dyn_cast<PointerType>(CaughtType)) {
4006  QualType PointeeType = PT->getPointeeType();
4007 
4008  // When catching by reference, generally we should just ignore
4009  // this by-value pointer and use the exception object instead.
4010  if (!PointeeType->isRecordType()) {
4011 
4012  // Exn points to the struct _Unwind_Exception header, which
4013  // we have to skip past in order to reach the exception data.
4014  unsigned HeaderSize =
4016  AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize);
4017 
4018  // However, if we're catching a pointer-to-record type that won't
4019  // work, because the personality function might have adjusted
4020  // the pointer. There's actually no way for us to fully satisfy
4021  // the language/ABI contract here: we can't use Exn because it
4022  // might have the wrong adjustment, but we can't use the by-value
4023  // pointer because it's off by a level of abstraction.
4024  //
4025  // The current solution is to dump the adjusted pointer into an
4026  // alloca, which breaks language semantics (because changing the
4027  // pointer doesn't change the exception) but at least works.
4028  // The better solution would be to filter out non-exact matches
4029  // and rethrow them, but this is tricky because the rethrow
4030  // really needs to be catchable by other sites at this landing
4031  // pad. The best solution is to fix the personality function.
4032  } else {
4033  // Pull the pointer for the reference type off.
4034  llvm::Type *PtrTy =
4035  cast<llvm::PointerType>(LLVMCatchTy)->getElementType();
4036 
4037  // Create the temporary and write the adjusted pointer into it.
4038  Address ExnPtrTmp =
4039  CGF.CreateTempAlloca(PtrTy, CGF.getPointerAlign(), "exn.byref.tmp");
4040  llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4041  CGF.Builder.CreateStore(Casted, ExnPtrTmp);
4042 
4043  // Bind the reference to the temporary.
4044  AdjustedExn = ExnPtrTmp.getPointer();
4045  }
4046  }
4047 
4048  llvm::Value *ExnCast =
4049  CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
4050  CGF.Builder.CreateStore(ExnCast, ParamAddr);
4051  return;
4052  }
4053 
4054  // Scalars and complexes.
4055  TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
4056  if (TEK != TEK_Aggregate) {
4057  llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
4058 
4059  // If the catch type is a pointer type, __cxa_begin_catch returns
4060  // the pointer by value.
4061  if (CatchType->hasPointerRepresentation()) {
4062  llvm::Value *CastExn =
4063  CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
4064 
4065  switch (CatchType.getQualifiers().getObjCLifetime()) {
4067  CastExn = CGF.EmitARCRetainNonBlock(CastExn);
4068  LLVM_FALLTHROUGH;
4069 
4070  case Qualifiers::OCL_None:
4073  CGF.Builder.CreateStore(CastExn, ParamAddr);
4074  return;
4075 
4076  case Qualifiers::OCL_Weak:
4077  CGF.EmitARCInitWeak(ParamAddr, CastExn);
4078  return;
4079  }
4080  llvm_unreachable("bad ownership qualifier!");
4081  }
4082 
4083  // Otherwise, it returns a pointer into the exception object.
4084 
4085  llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
4086  llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4087 
4088  LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType);
4089  LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType);
4090  switch (TEK) {
4091  case TEK_Complex:
4092  CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV,
4093  /*init*/ true);
4094  return;
4095  case TEK_Scalar: {
4096  llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc);
4097  CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
4098  return;
4099  }
4100  case TEK_Aggregate:
4101  llvm_unreachable("evaluation kind filtered out!");
4102  }
4103  llvm_unreachable("bad evaluation kind");
4104  }
4105 
4106  assert(isa<RecordType>(CatchType) && "unexpected catch type!");
4107  auto catchRD = CatchType->getAsCXXRecordDecl();
4108  CharUnits caughtExnAlignment = CGF.CGM.getClassPointerAlignment(catchRD);
4109 
4110  llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
4111 
4112  // Check for a copy expression. If we don't have a copy expression,
4113  // that means a trivial copy is okay.
4114  const Expr *copyExpr = CatchParam.getInit();
4115  if (!copyExpr) {
4116  llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
4117  Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4118  caughtExnAlignment);
4119  LValue Dest = CGF.MakeAddrLValue(ParamAddr, CatchType);
4120  LValue Src = CGF.MakeAddrLValue(adjustedExn, CatchType);
4121  CGF.EmitAggregateCopy(Dest, Src, CatchType, AggValueSlot::DoesNotOverlap);
4122  return;
4123  }
4124 
4125  // We have to call __cxa_get_exception_ptr to get the adjusted
4126  // pointer before copying.
4127  llvm::CallInst *rawAdjustedExn =
4129 
4130  // Cast that to the appropriate type.
4131  Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4132  caughtExnAlignment);
4133 
4134  // The copy expression is defined in terms of an OpaqueValueExpr.
4135  // Find it and map it to the adjusted expression.
4137  opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
4138  CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
4139 
4140  // Call the copy ctor in a terminate scope.
4141  CGF.EHStack.pushTerminate();
4142 
4143  // Perform the copy construction.
4144  CGF.EmitAggExpr(copyExpr,
4145  AggValueSlot::forAddr(ParamAddr, Qualifiers(),
4150 
4151  // Leave the terminate scope.
4152  CGF.EHStack.popTerminate();
4153 
4154  // Undo the opaque value mapping.
4155  opaque.pop();
4156 
4157  // Finally we can call __cxa_begin_catch.
4158  CallBeginCatch(CGF, Exn, true);
4159 }
4160 
4161 /// Begins a catch statement by initializing the catch variable and
4162 /// calling __cxa_begin_catch.
4163 void ItaniumCXXABI::emitBeginCatch(CodeGenFunction &CGF,
4164  const CXXCatchStmt *S) {
4165  // We have to be very careful with the ordering of cleanups here:
4166  // C++ [except.throw]p4:
4167  // The destruction [of the exception temporary] occurs
4168  // immediately after the destruction of the object declared in
4169  // the exception-declaration in the handler.
4170  //
4171  // So the precise ordering is:
4172  // 1. Construct catch variable.
4173  // 2. __cxa_begin_catch
4174  // 3. Enter __cxa_end_catch cleanup
4175  // 4. Enter dtor cleanup
4176  //
4177  // We do this by using a slightly abnormal initialization process.
4178  // Delegation sequence:
4179  // - ExitCXXTryStmt opens a RunCleanupsScope
4180  // - EmitAutoVarAlloca creates the variable and debug info
4181  // - InitCatchParam initializes the variable from the exception
4182  // - CallBeginCatch calls __cxa_begin_catch
4183  // - CallBeginCatch enters the __cxa_end_catch cleanup
4184  // - EmitAutoVarCleanups enters the variable destructor cleanup
4185  // - EmitCXXTryStmt emits the code for the catch body
4186  // - EmitCXXTryStmt close the RunCleanupsScope
4187 
4188  VarDecl *CatchParam = S->getExceptionDecl();
4189  if (!CatchParam) {
4190  llvm::Value *Exn = CGF.getExceptionFromSlot();
4191  CallBeginCatch(CGF, Exn, true);
4192  return;
4193  }
4194 
4195  // Emit the local.
4196  CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
4197  InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getBeginLoc());
4198  CGF.EmitAutoVarCleanups(var);
4199 }
4200 
4201 /// Get or define the following function:
4202 /// void @__clang_call_terminate(i8* %exn) nounwind noreturn
4203 /// This code is used only in C++.
4204 static llvm::FunctionCallee getClangCallTerminateFn(CodeGenModule &CGM) {
4205  llvm::FunctionType *fnTy =
4206  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
4207  llvm::FunctionCallee fnRef = CGM.CreateRuntimeFunction(
4208  fnTy, "__clang_call_terminate", llvm::AttributeList(), /*IsLocal=*/true);
4209  llvm::Function *fn =
4210  cast<llvm::Function>(fnRef.getCallee()->stripPointerCasts());
4211  if (fn->empty()) {
4212  fn->setDoesNotThrow();
4213  fn->setDoesNotReturn();
4214 
4215  // What we really want is to massively penalize inlining without
4216  // forbidding it completely. The difference between that and
4217  // 'noinline' is negligible.
4218  fn->addFnAttr(llvm::Attribute::NoInline);
4219 
4220  // Allow this function to be shared across translation units, but
4221  // we don't want it to turn into an exported symbol.
4222  fn->setLinkage(llvm::Function::LinkOnceODRLinkage);
4223  fn->setVisibility(llvm::Function::HiddenVisibility);
4224  if (CGM.supportsCOMDAT())
4225  fn->setComdat(CGM.getModule().getOrInsertComdat(fn->getName()));
4226 
4227  // Set up the function.
4228  llvm::BasicBlock *entry =
4230  CGBuilderTy builder(CGM, entry);
4231 
4232  // Pull the exception pointer out of the parameter list.
4233  llvm::Value *exn = &*fn->arg_begin();
4234 
4235  // Call __cxa_begin_catch(exn).
4236  llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
4237  catchCall->setDoesNotThrow();
4238  catchCall->setCallingConv(CGM.getRuntimeCC());
4239 
4240  // Call std::terminate().
4241  llvm::CallInst *termCall = builder.CreateCall(CGM.getTerminateFn());
4242  termCall->setDoesNotThrow();
4243  termCall->setDoesNotReturn();
4244  termCall->setCallingConv(CGM.getRuntimeCC());
4245 
4246  // std::terminate cannot return.
4247  builder.CreateUnreachable();
4248  }
4249  return fnRef;
4250 }
4251 
4252 llvm::CallInst *
4253 ItaniumCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
4254  llvm::Value *Exn) {
4255  // In C++, we want to call __cxa_begin_catch() before terminating.
4256  if (Exn) {
4257  assert(CGF.CGM.getLangOpts().CPlusPlus);
4258  return CGF.EmitNounwindRuntimeCall(getClangCallTerminateFn(CGF.CGM), Exn);
4259  }
4260  return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
4261 }
4262 
4263 std::pair<llvm::Value *, const CXXRecordDecl *>
4264 ItaniumCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
4265  const CXXRecordDecl *RD) {
4266  return {CGF.GetVTablePtr(This, CGM.Int8PtrTy, RD), RD};
4267 }
4268 
4269 void WebAssemblyCXXABI::emitBeginCatch(CodeGenFunction &CGF,
4270  const CXXCatchStmt *C) {
4271  if (CGF.getTarget().hasFeature("exception-handling"))
4272  CGF.EHStack.pushCleanup<CatchRetScope>(
4273  NormalCleanup, cast<llvm::CatchPadInst>(CGF.CurrentFuncletPad));
4274  ItaniumCXXABI::emitBeginCatch(CGF, C);
4275 }
static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD)
void pushTerminate()
Push a terminate handler on the stack.
Definition: CGCleanup.cpp:252
Address CreateConstInBoundsGEP(Address Addr, uint64_t Index, const llvm::Twine &Name="")
Given addr = T* ...
Definition: CGBuilder.h:216
The generic AArch64 ABI is also a modified version of the Itanium ABI, but it has fewer divergences t...
Definition: TargetCXXABI.h:83
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:286
void EmitVTTDefinition(llvm::GlobalVariable *VTT, llvm::GlobalVariable::LinkageTypes Linkage, const CXXRecordDecl *RD)
EmitVTTDefinition - Emit the definition of the given vtable.
Definition: CGVTT.cpp:41
CanQualType LongLongTy
Definition: ASTContext.h:1024
static const Decl * getCanonicalDecl(const Decl *D)
Represents a function declaration or definition.
Definition: Decl.h:1737
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:59
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:2549
Complete object ctor.
Definition: ABI.h:25
QualType getPointeeType() const
Definition: Type.h:2562
CanQualType VoidPtrTy
Definition: ASTContext.h:1043
A (possibly-)qualified type.
Definition: Type.h:639
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:70
base_class_range bases()
Definition: DeclCXX.h:822
llvm::Type * ConvertTypeForMem(QualType T)
const CodeGenOptions & getCodeGenOpts() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:816
Internal linkage according to the Modules TS, but can be referred to from other translation units ind...
Definition: Linkage.h:49
const Expr * getSubExpr() const
Definition: ExprCXX.h:1078
unsigned getLongWidth() const
getLongWidth/Align - Return the size of &#39;signed long&#39; and &#39;unsigned long&#39; for this target...
Definition: TargetInfo.h:398
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:2716
llvm::LLVMContext & getLLVMContext()
The COMDAT used for ctors.
Definition: ABI.h:27
CXXDtorType getDtorType() const
Definition: GlobalDecl.h:75
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:2430
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:966
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:232
No linkage, which means that the entity is unique and can only be referred to from within its scope...
Definition: Linkage.h:26
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:837
C Language Family Type Representation.
bool isRecordType() const
Definition: Type.h:6381
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
bool isVirtual() const
Definition: DeclCXX.h:2093
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:2108
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:244
struct clang::ThisAdjustment::VirtualAdjustment::@133 Itanium
Kind getKind() const
Definition: TargetCXXABI.h:131
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 either trap or call a handler function in the UBSan runtime with the p...
Definition: CGExpr.cpp:2930
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:6257
The base class of the type hierarchy.
Definition: Type.h:1414
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
Definition: ABI.h:110
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:6148
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:115
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:689
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3668
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:2733
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
Definition: CGObjC.cpp:2104
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:2491
bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D)
Try to emit a base destructor as an alias to its primary base-class destructor.
Definition: CGCXX.cpp:33
static llvm::FunctionCallee getBadTypeidFn(CodeGenFunction &CGF)
static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V)
Default closure variant of a ctor.
Definition: ABI.h:29
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3168
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:4102
GlobalDecl getWithCtorType(CXXCtorType Type)
Definition: GlobalDecl.h:107
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:36
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:6768
A this pointer adjustment.
Definition: ABI.h:107
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:432
llvm::FunctionCallee getTerminateFn()
Get the declaration of std::terminate for the platform.
Definition: CGException.cpp:49
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:244
llvm::Value * getPointer() const
Definition: Address.h:37
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1056
bool hasDefinition() const
Definition: DeclCXX.h:775
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:23
static llvm::FunctionCallee getGuardAbortFn(CodeGenModule &CGM, llvm::PointerType *GuardPtrTy)
unsigned getAddressSpace() const
Return the address space that this address resides in.
Definition: Address.h:56
The collection of all-type qualifiers we support.
Definition: Type.h:137
struct clang::ReturnAdjustment::VirtualAdjustment::@131 Itanium
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:702
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:1326
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:358
const TargetInfo & getTarget() const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1035
static llvm::FunctionCallee getBadCastFn(CodeGenFunction &CGF)
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:5550
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:296
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:263
The generic Mips ABI is a modified version of the Itanium ABI.
Definition: TargetCXXABI.h:89
static llvm::FunctionCallee getBeginCatchFn(CodeGenModule &CGM)
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:2775
Parameter for C++ virtual table pointers.
Definition: Decl.h:1503
void removeConst()
Definition: Type.h:256
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2134
bool isReferenceType() const
Definition: Type.h:6320
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:80
A return adjustment.
Definition: ABI.h:41
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:513
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:52
void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)
Call atexit() with a function that passes the given argument to the given function.
Definition: CGDeclCXX.cpp:250
static llvm::FunctionCallee getGuardAcquireFn(CodeGenModule &CGM, llvm::PointerType *GuardPtrTy)
static llvm::FunctionCallee getThrowFn(CodeGenModule &CGM)
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:45
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:2831
static unsigned extractPBaseFlags(ASTContext &Ctx, QualType &Type)
Compute the flags for a __pbase_type_info, and remove the corresponding pieces from Type...
static llvm::FunctionCallee getClangCallTerminateFn(CodeGenModule &CGM)
Get or define the following function: void (i8* exn) nounwind noreturn This code is used only in C++...
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2289
Base object ctor.
Definition: ABI.h:26
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:156
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:37
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:2625
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:271
void setDSOLocal(llvm::GlobalValue *GV) const
The Microsoft ABI is the ABI used by Microsoft Visual Studio (and compatible compilers).
Definition: TargetCXXABI.h:112
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:33
Deleting dtor.
Definition: ABI.h:34
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:66
Visibility getVisibility() const
Determine the visibility of this type.
Definition: Type.h:2313
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:2447
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6154
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:70
const Type * getClass() const
Definition: Type.h:2802
static llvm::FunctionCallee getGuardReleaseFn(CodeGenModule &CGM, llvm::PointerType *GuardPtrTy)
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:6084
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:84
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3041
base_class_iterator bases_begin()
Definition: DeclCXX.h:829
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:1477
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
bool isInstance() const
Definition: DeclCXX.h:2076
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1707
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:105
Represents an ObjC class declaration.
Definition: DeclObjC.h:1171
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1343
GlobalDecl getWithDtorType(CXXDtorType Type)
Definition: GlobalDecl.h:114
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:62
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:1874
This object can be modified without requiring retains or releases.
Definition: Type.h:158
arg_iterator arg_end()
Definition: Expr.h:2636
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:4428
bool hasAttr() const
Definition: DeclBase.h:534
CanQualType getReturnType() const
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5613
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:57
AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)
EmitAutoVarAlloca - Emit the alloca and debug information for a local variable.
Definition: CGDecl.cpp:1359
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1635
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3699
The generic ARM ABI is a modified version of the Itanium ABI proposed by ARM for use on ARM-based pla...
Definition: TargetCXXABI.h:51
bool isDynamicClass() const
Definition: DeclCXX.h:788
const TargetCodeGenInfo & getTargetCodeGenInfo()
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:38
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: StmtCXX.h:43
union clang::ReturnAdjustment::VirtualAdjustment Virtual
Module linkage, which indicates that the entity can be referred to from other translation units withi...
Definition: Linkage.h:55
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:178
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:914
unsigned Offset
Definition: Format.cpp:1709
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
llvm::CallingConv::ID getRuntimeCC() const
Exposes information about the current target.
Definition: TargetInfo.h:161
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:2575
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
CXXDtorType
C++ destructor types.
Definition: ABI.h:33
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:108
void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, llvm::Value *CompletePtr, QualType ElementType)
Definition: CGExprCXX.cpp:1820
const CGFunctionInfo & arrangeNullaryFunction()
A nullary function is a freestanding function of type &#39;void ()&#39;.
Definition: CGCall.cpp:694
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:6831
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:133
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2713
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:49
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:43
ObjCLifetime getObjCLifetime() const
Definition: Type.h:327
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
DeclContext * getDeclContext()
Definition: DeclBase.h:430
static bool IsIncompleteClassType(const RecordType *RecordTy)
IsIncompleteClassType - Returns whether the given record type is incomplete.
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:337
TLSKind getTLSKind() const
Definition: Decl.cpp:1949
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:62
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:158
llvm::LLVMContext & getLLVMContext()
const CXXRecordDecl * getBase() const
getBase - Returns the base class declaration.
Definition: BaseSubobject.h:43
Base object dtor.
Definition: ABI.h:36
QualType getType() const
Definition: Expr.h:130
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:2154
StructorCodegen
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1761
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:624
llvm::Value * EmitCastToVoidPtr(llvm::Value *value)
Emit a cast to void* in the appropriate address space.
Definition: CGExpr.cpp:49
virtual unsigned getSizeOfUnwindException() const
Determines the size of struct _Unwind_Exception on this platform, in 8-bit units. ...
Definition: TargetInfo.cpp:389
Implements C++ ABI-specific semantic analysis functions.
Definition: CXXABI.h:29
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:161
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:169
The COMDAT used for dtors.
Definition: ABI.h:37
static StringRef getIdentifier(const Token &Tok)
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2039
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:34
WatchOS is a modernisation of the iOS ABI, which roughly means it&#39;s the iOS64 ABI ported to 32-bits...
Definition: TargetCXXABI.h:75
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6143
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
Definition: Type.h:4392
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
Definition: ABI.h:44
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:154
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:141
#define false
Definition: stdbool.h:17
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:165
QualType getCanonicalType() const
Definition: Type.h:6123
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:2798
CastKind getCastKind() const
Definition: Expr.h:3087
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1989
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:170
const Decl * getDecl() const
Definition: GlobalDecl.h:68
llvm::GlobalVariable * GetAddrOfVTT(const CXXRecordDecl *RD)
GetAddrOfVTT - Get the address of the VTT for the given record decl.
Definition: CGVTT.cpp:105
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2048
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:24
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:33
All available information about a concrete callee.
Definition: CGCall.h:66
TypeClass getTypeClass() const
Definition: Type.h:1820
int64_t VCallOffsetOffset
The offset (in bytes), relative to the address point, of the virtual call offset. ...
Definition: ABI.h:119
MangleContext & getMangleContext()
Gets the mangle context.
Definition: CGCXXABI.h:96
Complete object dtor.
Definition: ABI.h:35
llvm::Instruction * CurrentFuncletPad
ItaniumVTableContext & getItaniumVTableContext()
Assigning into this object requires a lifetime extension.
Definition: Type.h:171
The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler...
Definition: CGCleanup.h:37
static llvm::FunctionCallee getAllocateExceptionFn(CodeGenModule &CGM)
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
CXXCtorType
C++ constructor types.
Definition: ABI.h:24
The WebAssembly ABI is a modified version of the Itanium ABI.
Definition: TargetCXXABI.h:104
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:358
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.
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This)
Definition: CGClass.cpp:2402
External linkage within a unique namespace.
Definition: Linkage.h:40
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1266
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2249
static llvm::FunctionCallee getItaniumDynamicCastFn(CodeGenFunction &CGF)
void EmitAnyExprToExn(const Expr *E, Address Addr)
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:90
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:69
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:2173
int64_t VBaseOffsetOffset
The offset (in bytes), relative to the address point of the virtual base class offset.
Definition: ABI.h:53
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2768
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:107
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:1098
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:1824
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:797
void EmitAutoVarCleanups(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1943
void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value *> args)
Emits a call or invoke to the given noreturn runtime function.
Definition: CGCall.cpp:3706
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4382
bool empty() const
Definition: Type.h:415
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:2633
Implements C++ ABI-specific code generation functions.
Definition: CGCXXABI.h:43
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:51
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:59
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:31
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false)
Create or return a runtime function declaration with the specified type and name. ...
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:450
void EmitARCInitWeak(Address addr, llvm::Value *value)
i8* @objc_initWeak(i8** addr, i8* value) Returns value.
Definition: CGObjC.cpp:2400
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:191
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:139
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2355
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:2266
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:168
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:6164
true
A convenience builder class for complex constant initializers, especially for anonymous global struct...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
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:470
bool isMemberFunctionPointer() const
Returns true if the member type (i.e.
Definition: Type.h:2792
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:323
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
llvm::Type * ConvertType(QualType T)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6111
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:74
static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF, llvm::FunctionCallee dtor, llvm::Constant *addr, bool TLS)
Register a global destructor using __cxa_atexit.
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:3207
void popTerminate()
Pops a terminate handler off the stack.
Definition: CGCleanup.h:582
No linkage according to the standard, but is visible from other translation units because of types de...
Definition: Linkage.h:44
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:2403
static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr, llvm::FunctionType *FTy)
Definition: CGCall.h:144
bool isGlobalDelete() const
Definition: ExprCXX.h:2275
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:152
uint64_t getPointerAlign(unsigned AddrSpace) const
Definition: TargetInfo.h:361
Copying closure variant of a ctor.
Definition: ABI.h:28
static llvm::FunctionCallee getGetExceptionPtrFn(CodeGenModule &CGM)
static llvm::FunctionCallee getEndCatchFn(CodeGenModule &CGM)
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
Struct with all information about dynamic [sub]class needed to set vptr.
llvm::Function * codegenCXXStructor(GlobalDecl GD)
Definition: CGCXX.cpp:206
void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)
EmitAggregateCopy - Emit an aggregate copy.
Definition: CGExprAgg.cpp:1870
static RValue get(llvm::Value *V)
Definition: CGValue.h:85
Visibility getVisibility() const
Determines the visibility of this entity.
Definition: Decl.h:390
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:2797
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:166
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:146
bool isTranslationUnit() const
Definition: DeclBase.h:1836
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1363
Notes how many arguments were added to the beginning (Prefix) and ending (Suffix) of an arg list...
Definition: CGCXXABI.h:299
static bool IsStandardLibraryRTTIDescriptor(QualType Ty)
IsStandardLibraryRTTIDescriptor - Returns whether the type information for the given type exists in t...
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
static bool CanUseSingleInheritance(const CXXRecordDecl *RD)
Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:163
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value *> args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition: CGCall.cpp:3737
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:262
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:644
base_class_range vbases()
Definition: DeclCXX.h:839
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:2787
SourceLocation getLocation() const
Definition: DeclBase.h:421
QualType getPointeeType() const
Definition: Type.h:2788
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.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1541
bool isNoDestroy(const ASTContext &) const
Do we need to emit an exit-time destructor for this variable?
Definition: Decl.cpp:2493
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:290
const llvm::Triple & getTriple() const