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