1//===----- CGCXXABI.h - Interface to C++ ABIs -------------------*- C++ -*-===//
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 an abstract class for C++ code generation. Concrete subclasses
10// of this implement code generation for specific C++ ABIs.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_LIB_CODEGEN_CGCXXABI_H
15#define LLVM_CLANG_LIB_CODEGEN_CGCXXABI_H
16
17#include "CodeGenFunction.h"
18#include "clang/Basic/LLVM.h"
19#include "clang/CodeGen/CodeGenABITypes.h"
20
21namespace llvm {
22class Constant;
23class Type;
24class Value;
25class CallInst;
26}
27
28namespace clang {
29class CastExpr;
30class CXXConstructorDecl;
31class CXXDestructorDecl;
32class CXXMethodDecl;
33class CXXRecordDecl;
34class FieldDecl;
35class MangleContext;
36
37namespace CodeGen {
38class CGCallee;
39class CodeGenFunction;
40class CodeGenModule;
41struct CatchTypeInfo;
42
43/// Implements C++ ABI-specific code generation functions.
44class CGCXXABI {
45protected:
46  CodeGenModule &CGM;
47  std::unique_ptr<MangleContext> MangleCtx;
48
49  CGCXXABI(CodeGenModule &CGM)
50    : CGM(CGM), MangleCtx(CGM.getContext().createMangleContext()) {}
51
52protected:
53  ImplicitParamDecl *getThisDecl(CodeGenFunction &CGF) {
54    return CGF.CXXABIThisDecl;
55  }
56  llvm::Value *getThisValue(CodeGenFunction &CGF) {
57    return CGF.CXXABIThisValue;
58  }
59  Address getThisAddress(CodeGenFunction &CGF) {
60    return Address(CGF.CXXABIThisValue, CGF.CXXABIThisAlignment);
61  }
62
63  /// Issue a diagnostic about unsupported features in the ABI.
64  void ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S);
65
66  /// Get a null value for unsupported member pointers.
67  llvm::Constant *GetBogusMemberPointer(QualType T);
68
69  ImplicitParamDecl *&getStructorImplicitParamDecl(CodeGenFunction &CGF) {
70    return CGF.CXXStructorImplicitParamDecl;
71  }
72  llvm::Value *&getStructorImplicitParamValue(CodeGenFunction &CGF) {
73    return CGF.CXXStructorImplicitParamValue;
74  }
75
76  /// Loads the incoming C++ this pointer as it was passed by the caller.
77  llvm::Value *loadIncomingCXXThis(CodeGenFunction &CGF);
78
79  void setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr);
80
81  ASTContext &getContext() const { return CGM.getContext(); }
82
83  virtual bool requiresArrayCookie(const CXXDeleteExpr *E, QualType eltType);
84  virtual bool requiresArrayCookie(const CXXNewExpr *E);
85
86  /// Determine whether there's something special about the rules of
87  /// the ABI tell us that 'this' is a complete object within the
88  /// given function.  Obvious common logic like being defined on a
89  /// final class will have been taken care of by the caller.
90  virtual bool isThisCompleteObject(GlobalDecl GD) const = 0;
91
92public:
93
94  virtual ~CGCXXABI();
95
96  /// Gets the mangle context.
97  MangleContext &getMangleContext() {
98    return *MangleCtx;
99  }
100
101  /// Returns true if the given constructor or destructor is one of the
102  /// kinds that the ABI says returns 'this' (only applies when called
103  /// non-virtually for destructors).
104  ///
105  /// There currently is no way to indicate if a destructor returns 'this'
106  /// when called virtually, and code generation does not support the case.
107  virtual bool HasThisReturn(GlobalDecl GD) const { return false; }
108
109  virtual bool hasMostDerivedReturn(GlobalDecl GD) const { return false; }
110
111  virtual bool useSinitAndSterm() const { return false; }
112
113  /// Returns true if the target allows calling a function through a pointer
114  /// with a different signature than the actual function (or equivalently,
115  /// bitcasting a function or function pointer to a different function type).
116  /// In principle in the most general case this could depend on the target, the
117  /// calling convention, and the actual types of the arguments and return
118  /// value. Here it just means whether the signature mismatch could *ever* be
119  /// allowed; in other words, does the target do strict checking of signatures
120  /// for all calls.
121  virtual bool canCallMismatchedFunctionType() const { return true; }
122
123  /// If the C++ ABI requires the given type be returned in a particular way,
124  /// this method sets RetAI and returns true.
125  virtual bool classifyReturnType(CGFunctionInfo &FI) const = 0;
126
127  /// Specify how one should pass an argument of a record type.
128  enum RecordArgABI {
129    /// Pass it using the normal C aggregate rules for the ABI, potentially
130    /// introducing extra copies and passing some or all of it in registers.
131    RAA_Default = 0,
132
133    /// Pass it on the stack using its defined layout.  The argument must be
134    /// evaluated directly into the correct stack position in the arguments area,
135    /// and the call machinery must not move it or introduce extra copies.
136    RAA_DirectInMemory,
137
138    /// Pass it as a pointer to temporary memory.
139    RAA_Indirect
140  };
141
142  /// Returns how an argument of the given record type should be passed.
143  virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const = 0;
144
145  /// Returns true if the implicit 'sret' parameter comes after the implicit
146  /// 'this' parameter of C++ instance methods.
147  virtual bool isSRetParameterAfterThis() const { return false; }
148
149  /// Returns true if the ABI permits the argument to be a homogeneous
150  /// aggregate.
151  virtual bool
152  isPermittedToBeHomogeneousAggregate(const CXXRecordDecl *RD) const {
153    return true;
154  };
155
156  /// Find the LLVM type used to represent the given member pointer
157  /// type.
158  virtual llvm::Type *
159  ConvertMemberPointerType(const MemberPointerType *MPT);
160
161  /// Load a member function from an object and a member function
162  /// pointer.  Apply the this-adjustment and set 'This' to the
163  /// adjusted value.
164  virtual CGCallee EmitLoadOfMemberFunctionPointer(
165      CodeGenFunction &CGF, const Expr *E, Address This,
166      llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr,
167      const MemberPointerType *MPT);
168
169  /// Calculate an l-value from an object and a data member pointer.
170  virtual llvm::Value *
171  EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
172                               Address Base, llvm::Value *MemPtr,
173                               const MemberPointerType *MPT);
174
175  /// Perform a derived-to-base, base-to-derived, or bitcast member
176  /// pointer conversion.
177  virtual llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
178                                                   const CastExpr *E,
179                                                   llvm::Value *Src);
180
181  /// Perform a derived-to-base, base-to-derived, or bitcast member
182  /// pointer conversion on a constant value.
183  virtual llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
184                                                      llvm::Constant *Src);
185
186  /// Return true if the given member pointer can be zero-initialized
187  /// (in the C++ sense) with an LLVM zeroinitializer.
188  virtual bool isZeroInitializable(const MemberPointerType *MPT);
189
190  /// Return whether or not a member pointers type is convertible to an IR type.
191  virtual bool isMemberPointerConvertible(const MemberPointerType *MPT) const {
192    return true;
193  }
194
195  /// Create a null member pointer of the given type.
196  virtual llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);
197
198  /// Create a member pointer for the given method.
199  virtual llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD);
200
201  /// Create a member pointer for the given field.
202  virtual llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
203                                                CharUnits offset);
204
205  /// Create a member pointer for the given member pointer constant.
206  virtual llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT);
207
208  /// Emit a comparison between two member pointers.  Returns an i1.
209  virtual llvm::Value *
210  EmitMemberPointerComparison(CodeGenFunction &CGF,
211                              llvm::Value *L,
212                              llvm::Value *R,
213                              const MemberPointerType *MPT,
214                              bool Inequality);
215
216  /// Determine if a member pointer is non-null.  Returns an i1.
217  virtual llvm::Value *
218  EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
219                             llvm::Value *MemPtr,
220                             const MemberPointerType *MPT);
221
222protected:
223  /// A utility method for computing the offset required for the given
224  /// base-to-derived or derived-to-base member-pointer conversion.
225  /// Does not handle virtual conversions (in case we ever fully
226  /// support an ABI that allows this).  Returns null if no adjustment
227  /// is required.
228  llvm::Constant *getMemberPointerAdjustment(const CastExpr *E);
229
230public:
231  virtual void emitVirtualObjectDelete(CodeGenFunction &CGF,
232                                       const CXXDeleteExpr *DE,
233                                       Address Ptr, QualType ElementType,
234                                       const CXXDestructorDecl *Dtor) = 0;
235  virtual void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) = 0;
236  virtual void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) = 0;
237  virtual llvm::GlobalVariable *getThrowInfo(QualType T) { return nullptr; }
238
239  /// Determine whether it's possible to emit a vtable for \p RD, even
240  /// though we do not know that the vtable has been marked as used by semantic
241  /// analysis.
242  virtual bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const = 0;
243
244  virtual void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) = 0;
245
246  virtual llvm::CallInst *
247  emitTerminateForUnexpectedException(CodeGenFunction &CGF,
248                                      llvm::Value *Exn);
249
250  virtual llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) = 0;
251  virtual CatchTypeInfo
252  getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType) = 0;
253  virtual CatchTypeInfo getCatchAllTypeInfo();
254
255  virtual bool shouldTypeidBeNullChecked(bool IsDeref,
256                                         QualType SrcRecordTy) = 0;
257  virtual void EmitBadTypeidCall(CodeGenFunction &CGF) = 0;
258  virtual llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,
259                                  Address ThisPtr,
260                                  llvm::Type *StdTypeInfoPtrTy) = 0;
261
262  virtual bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
263                                                  QualType SrcRecordTy) = 0;
264
265  virtual llvm::Value *
266  EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
267                      QualType SrcRecordTy, QualType DestTy,
268                      QualType DestRecordTy, llvm::BasicBlock *CastEnd) = 0;
269
270  virtual llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF,
271                                             Address Value,
272                                             QualType SrcRecordTy,
273                                             QualType DestTy) = 0;
274
275  virtual bool EmitBadCastCall(CodeGenFunction &CGF) = 0;
276
277  virtual llvm::Value *GetVirtualBaseClassOffset(CodeGenFunction &CGF,
278                                                 Address This,
279                                                 const CXXRecordDecl *ClassDecl,
280                                        const CXXRecordDecl *BaseClassDecl) = 0;
281
282  virtual llvm::BasicBlock *EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
283                                                          const CXXRecordDecl *RD);
284
285  /// Emit the code to initialize hidden members required
286  /// to handle virtual inheritance, if needed by the ABI.
287  virtual void
288  initializeHiddenVirtualInheritanceMembers(CodeGenFunction &CGF,
289                                            const CXXRecordDecl *RD) {}
290
291  /// Emit constructor variants required by this ABI.
292  virtual void EmitCXXConstructors(const CXXConstructorDecl *D) = 0;
293
294  /// Additional implicit arguments to add to the beginning (Prefix) and end
295  /// (Suffix) of a constructor / destructor arg list.
296  ///
297  /// Note that Prefix should actually be inserted *after* the first existing
298  /// arg; `this` arguments always come first.
299  struct AddedStructorArgs {
300    struct Arg {
301      llvm::Value *Value;
302      QualType Type;
303    };
304    SmallVector<Arg, 1> Prefix;
305    SmallVector<Arg, 1> Suffix;
306    AddedStructorArgs() = default;
307    AddedStructorArgs(SmallVector<Arg, 1> P, SmallVector<Arg, 1> S)
308        : Prefix(std::move(P)), Suffix(std::move(S)) {}
309    static AddedStructorArgs prefix(SmallVector<Arg, 1> Args) {
310      return {std::move(Args), {}};
311    }
312    static AddedStructorArgs suffix(SmallVector<Arg, 1> Args) {
313      return {{}, std::move(Args)};
314    }
315  };
316
317  /// Similar to AddedStructorArgs, but only notes the number of additional
318  /// arguments.
319  struct AddedStructorArgCounts {
320    unsigned Prefix = 0;
321    unsigned Suffix = 0;
322    AddedStructorArgCounts() = default;
323    AddedStructorArgCounts(unsigned P, unsigned S) : Prefix(P), Suffix(S) {}
324    static AddedStructorArgCounts prefix(unsigned N) { return {N, 0}; }
325    static AddedStructorArgCounts suffix(unsigned N) { return {0, N}; }
326  };
327
328  /// Build the signature of the given constructor or destructor variant by
329  /// adding any required parameters.  For convenience, ArgTys has been
330  /// initialized with the type of 'this'.
331  virtual AddedStructorArgCounts
332  buildStructorSignature(GlobalDecl GD,
333                         SmallVectorImpl<CanQualType> &ArgTys) = 0;
334
335  /// Returns true if the given destructor type should be emitted as a linkonce
336  /// delegating thunk, regardless of whether the dtor is defined in this TU or
337  /// not.
338  virtual bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
339                                      CXXDtorType DT) const = 0;
340
341  virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
342                                          const CXXDestructorDecl *Dtor,
343                                          CXXDtorType DT) const;
344
345  virtual llvm::GlobalValue::LinkageTypes
346  getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor,
347                          CXXDtorType DT) const;
348
349  /// Emit destructor variants required by this ABI.
350  virtual void EmitCXXDestructors(const CXXDestructorDecl *D) = 0;
351
352  /// Get the type of the implicit "this" parameter used by a method. May return
353  /// zero if no specific type is applicable, e.g. if the ABI expects the "this"
354  /// parameter to point to some artificial offset in a complete object due to
355  /// vbases being reordered.
356  virtual const CXXRecordDecl *
357  getThisArgumentTypeForMethod(const CXXMethodDecl *MD) {
358    return MD->getParent();
359  }
360
361  /// Perform ABI-specific "this" argument adjustment required prior to
362  /// a call of a virtual function.
363  /// The "VirtualCall" argument is true iff the call itself is virtual.
364  virtual Address
365  adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD,
366                                           Address This, bool VirtualCall) {
367    return This;
368  }
369
370  /// Build a parameter variable suitable for 'this'.
371  void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params);
372
373  /// Insert any ABI-specific implicit parameters into the parameter list for a
374  /// function.  This generally involves extra data for constructors and
375  /// destructors.
376  ///
377  /// ABIs may also choose to override the return type, which has been
378  /// initialized with the type of 'this' if HasThisReturn(CGF.CurGD) is true or
379  /// the formal return type of the function otherwise.
380  virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
381                                         FunctionArgList &Params) = 0;
382
383  /// Get the ABI-specific "this" parameter adjustment to apply in the prologue
384  /// of a virtual function.
385  virtual CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) {
386    return CharUnits::Zero();
387  }
388
389  /// Emit the ABI-specific prolog for the function.
390  virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF) = 0;
391
392  virtual AddedStructorArgs
393  getImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D,
394                             CXXCtorType Type, bool ForVirtualBase,
395                             bool Delegating) = 0;
396
397  /// Add any ABI-specific implicit arguments needed to call a constructor.
398  ///
399  /// \return The number of arguments added at the beginning and end of the
400  /// call, which is typically zero or one.
401  AddedStructorArgCounts
402  addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D,
403                             CXXCtorType Type, bool ForVirtualBase,
404                             bool Delegating, CallArgList &Args);
405
406  /// Get the implicit (second) parameter that comes after the "this" pointer,
407  /// or nullptr if there is isn't one.
408  virtual llvm::Value *
409  getCXXDestructorImplicitParam(CodeGenFunction &CGF,
410                                const CXXDestructorDecl *DD, CXXDtorType Type,
411                                bool ForVirtualBase, bool Delegating) = 0;
412
413  /// Emit the destructor call.
414  virtual void EmitDestructorCall(CodeGenFunction &CGF,
415                                  const CXXDestructorDecl *DD, CXXDtorType Type,
416                                  bool ForVirtualBase, bool Delegating,
417                                  Address This, QualType ThisTy) = 0;
418
419  /// Emits the VTable definitions required for the given record type.
420  virtual void emitVTableDefinitions(CodeGenVTables &CGVT,
421                                     const CXXRecordDecl *RD) = 0;
422
423  /// Checks if ABI requires extra virtual offset for vtable field.
424  virtual bool
425  isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
426                                      CodeGenFunction::VPtr Vptr) = 0;
427
428  /// Checks if ABI requires to initialize vptrs for given dynamic class.
429  virtual bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) = 0;
430
431  /// Get the address point of the vtable for the given base subobject.
432  virtual llvm::Constant *
433  getVTableAddressPoint(BaseSubobject Base,
434                        const CXXRecordDecl *VTableClass) = 0;
435
436  /// Get the address point of the vtable for the given base subobject while
437  /// building a constructor or a destructor.
438  virtual llvm::Value *
439  getVTableAddressPointInStructor(CodeGenFunction &CGF, const CXXRecordDecl *RD,
440                                  BaseSubobject Base,
441                                  const CXXRecordDecl *NearestVBase) = 0;
442
443  /// Get the address point of the vtable for the given base subobject while
444  /// building a constexpr.
445  virtual llvm::Constant *
446  getVTableAddressPointForConstExpr(BaseSubobject Base,
447                                    const CXXRecordDecl *VTableClass) = 0;
448
449  /// Get the address of the vtable for the given record decl which should be
450  /// used for the vptr at the given offset in RD.
451  virtual llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
452                                                CharUnits VPtrOffset) = 0;
453
454  /// Build a virtual function pointer in the ABI-specific way.
455  virtual CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF,
456                                             GlobalDecl GD, Address This,
457                                             llvm::Type *Ty,
458                                             SourceLocation Loc) = 0;
459
460  using DeleteOrMemberCallExpr =
461      llvm::PointerUnion<const CXXDeleteExpr *, const CXXMemberCallExpr *>;
462
463  /// Emit the ABI-specific virtual destructor call.
464  virtual llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
465                                                 const CXXDestructorDecl *Dtor,
466                                                 CXXDtorType DtorType,
467                                                 Address This,
468                                                 DeleteOrMemberCallExpr E) = 0;
469
470  virtual void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF,
471                                                GlobalDecl GD,
472                                                CallArgList &CallArgs) {}
473
474  /// Emit any tables needed to implement virtual inheritance.  For Itanium,
475  /// this emits virtual table tables.  For the MSVC++ ABI, this emits virtual
476  /// base tables.
477  virtual void emitVirtualInheritanceTables(const CXXRecordDecl *RD) = 0;
478
479  virtual bool exportThunk() = 0;
480  virtual void setThunkLinkage(llvm::Function *Thunk, bool ForVTable,
481                               GlobalDecl GD, bool ReturnAdjustment) = 0;
482
483  virtual llvm::Value *performThisAdjustment(CodeGenFunction &CGF,
484                                             Address This,
485                                             const ThisAdjustment &TA) = 0;
486
487  virtual llvm::Value *performReturnAdjustment(CodeGenFunction &CGF,
488                                               Address Ret,
489                                               const ReturnAdjustment &RA) = 0;
490
491  virtual void EmitReturnFromThunk(CodeGenFunction &CGF,
492                                   RValue RV, QualType ResultType);
493
494  virtual size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
495                                      FunctionArgList &Args) const = 0;
496
497  /// Gets the offsets of all the virtual base pointers in a given class.
498  virtual std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD);
499
500  /// Gets the pure virtual member call function.
501  virtual StringRef GetPureVirtualCallName() = 0;
502
503  /// Gets the deleted virtual member call name.
504  virtual StringRef GetDeletedVirtualCallName() = 0;
505
506  /**************************** Array cookies ******************************/
507
508  /// Returns the extra size required in order to store the array
509  /// cookie for the given new-expression.  May return 0 to indicate that no
510  /// array cookie is required.
511  ///
512  /// Several cases are filtered out before this method is called:
513  ///   - non-array allocations never need a cookie
514  ///   - calls to \::operator new(size_t, void*) never need a cookie
515  ///
516  /// \param expr - the new-expression being allocated.
517  virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr);
518
519  /// Initialize the array cookie for the given allocation.
520  ///
521  /// \param NewPtr - a char* which is the presumed-non-null
522  ///   return value of the allocation function
523  /// \param NumElements - the computed number of elements,
524  ///   potentially collapsed from the multidimensional array case;
525  ///   always a size_t
526  /// \param ElementType - the base element allocated type,
527  ///   i.e. the allocated type after stripping all array types
528  virtual Address InitializeArrayCookie(CodeGenFunction &CGF,
529                                        Address NewPtr,
530                                        llvm::Value *NumElements,
531                                        const CXXNewExpr *expr,
532                                        QualType ElementType);
533
534  /// Reads the array cookie associated with the given pointer,
535  /// if it has one.
536  ///
537  /// \param Ptr - a pointer to the first element in the array
538  /// \param ElementType - the base element type of elements of the array
539  /// \param NumElements - an out parameter which will be initialized
540  ///   with the number of elements allocated, or zero if there is no
541  ///   cookie
542  /// \param AllocPtr - an out parameter which will be initialized
543  ///   with a char* pointing to the address returned by the allocation
544  ///   function
545  /// \param CookieSize - an out parameter which will be initialized
546  ///   with the size of the cookie, or zero if there is no cookie
547  virtual void ReadArrayCookie(CodeGenFunction &CGF, Address Ptr,
548                               const CXXDeleteExpr *expr,
549                               QualType ElementType, llvm::Value *&NumElements,
550                               llvm::Value *&AllocPtr, CharUnits &CookieSize);
551
552  /// Return whether the given global decl needs a VTT parameter.
553  virtual bool NeedsVTTParameter(GlobalDecl GD);
554
555protected:
556  /// Returns the extra size required in order to store the array
557  /// cookie for the given type.  Assumes that an array cookie is
558  /// required.
559  virtual CharUnits getArrayCookieSizeImpl(QualType elementType);
560
561  /// Reads the array cookie for an allocation which is known to have one.
562  /// This is called by the standard implementation of ReadArrayCookie.
563  ///
564  /// \param ptr - a pointer to the allocation made for an array, as a char*
565  /// \param cookieSize - the computed cookie size of an array
566  ///
567  /// Other parameters are as above.
568  ///
569  /// \return a size_t
570  virtual llvm::Value *readArrayCookieImpl(CodeGenFunction &IGF, Address ptr,
571                                           CharUnits cookieSize);
572
573public:
574
575  /*************************** Static local guards ****************************/
576
577  /// Emits the guarded initializer and destructor setup for the given
578  /// variable, given that it couldn't be emitted as a constant.
579  /// If \p PerformInit is false, the initialization has been folded to a
580  /// constant and should not be performed.
581  ///
582  /// The variable may be:
583  ///   - a static local variable
584  ///   - a static data member of a class template instantiation
585  virtual void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
586                               llvm::GlobalVariable *DeclPtr,
587                               bool PerformInit) = 0;
588
589  /// Emit code to force the execution of a destructor during global
590  /// teardown.  The default implementation of this uses atexit.
591  ///
592  /// \param Dtor - a function taking a single pointer argument
593  /// \param Addr - a pointer to pass to the destructor function.
594  virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
595                                  llvm::FunctionCallee Dtor,
596                                  llvm::Constant *Addr) = 0;
597
598  /*************************** thread_local initialization ********************/
599
600  /// Emits ABI-required functions necessary to initialize thread_local
601  /// variables in this translation unit.
602  ///
603  /// \param CXXThreadLocals - The thread_local declarations in this translation
604  ///        unit.
605  /// \param CXXThreadLocalInits - If this translation unit contains any
606  ///        non-constant initialization or non-trivial destruction for
607  ///        thread_local variables, a list of functions to perform the
608  ///        initialization.
609  virtual void EmitThreadLocalInitFuncs(
610      CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
611      ArrayRef<llvm::Function *> CXXThreadLocalInits,
612      ArrayRef<const VarDecl *> CXXThreadLocalInitVars) = 0;
613
614  // Determine if references to thread_local global variables can be made
615  // directly or require access through a thread wrapper function.
616  virtual bool usesThreadWrapperFunction(const VarDecl *VD) const = 0;
617
618  /// Emit a reference to a non-local thread_local variable (including
619  /// triggering the initialization of all thread_local variables in its
620  /// translation unit).
621  virtual LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
622                                              const VarDecl *VD,
623                                              QualType LValType) = 0;
624
625  /// Emit a single constructor/destructor with the given type from a C++
626  /// constructor Decl.
627  virtual void emitCXXStructor(GlobalDecl GD) = 0;
628
629  /// Load a vtable from This, an object of polymorphic type RD, or from one of
630  /// its virtual bases if it does not have its own vtable. Returns the vtable
631  /// and the class from which the vtable was loaded.
632  virtual std::pair<llvm::Value *, const CXXRecordDecl *>
633  LoadVTablePtr(CodeGenFunction &CGF, Address This,
634                const CXXRecordDecl *RD) = 0;
635};
636
637// Create an instance of a C++ ABI class:
638
639/// Creates an Itanium-family ABI.
640CGCXXABI *CreateItaniumCXXABI(CodeGenModule &CGM);
641
642/// Creates a Microsoft-family ABI.
643CGCXXABI *CreateMicrosoftCXXABI(CodeGenModule &CGM);
644
645struct CatchRetScope final : EHScopeStack::Cleanup {
646  llvm::CatchPadInst *CPI;
647
648  CatchRetScope(llvm::CatchPadInst *CPI) : CPI(CPI) {}
649
650  void Emit(CodeGenFunction &CGF, Flags flags) override {
651    llvm::BasicBlock *BB = CGF.createBasicBlock("catchret.dest");
652    CGF.Builder.CreateCatchRet(CPI, BB);
653    CGF.EmitBlock(BB);
654  }
655};
656}
657}
658
659#endif
660