contrib/llvm/tools/clang/lib/CodeGen/CGCXXABI.h

   1 //===----- CGCXXABI.h - Interface to C++ ABIs -------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This provides an abstract class for C++ code generation. Concrete subclasses
  11 // of this implement code generation for specific C++ ABIs.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_LIB_CODEGEN_CGCXXABI_H
  16 #define LLVM_CLANG_LIB_CODEGEN_CGCXXABI_H
  17
  18 #include "CodeGenFunction.h"
  19 #include "clang/Basic/LLVM.h"
  20
  21 namespace llvm {
  22 class Constant;
  23 class Type;
  24 class Value;
  25 class CallInst;
  26 }
  27
  28 namespace clang {
  29 class CastExpr;
  30 class CXXConstructorDecl;
  31 class CXXDestructorDecl;
  32 class CXXMethodDecl;
  33 class CXXRecordDecl;
  34 class FieldDecl;
  35 class MangleContext;
  36
  37 namespace CodeGen {
  38 class CGCallee;
  39 class CodeGenFunction;
  40 class CodeGenModule;
  41 struct CatchTypeInfo;
  42
  43 /// \brief Implements C++ ABI-specific code generation functions.
  44 class CGCXXABI {
  45 protected:
  46   CodeGenModule &CGM;
  47   std::unique_ptr<MangleContext> MangleCtx;
  48
  49   CGCXXABI(CodeGenModule &CGM)
  50     : CGM(CGM), MangleCtx(CGM.getContext().createMangleContext()) {}
  51
  52 protected:
  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   /// Perform prolog initialization of the parameter variable suitable
  77   /// for 'this' emitted by buildThisParam.
  78   void EmitThisParam(CodeGenFunction &CGF);
  79
  80   ASTContext &getContext() const { return CGM.getContext(); }
  81
  82   virtual bool requiresArrayCookie(const CXXDeleteExpr *E, QualType eltType);
  83   virtual bool requiresArrayCookie(const CXXNewExpr *E);
  84
  85   /// Determine whether there's something special about the rules of
  86   /// the ABI tell us that 'this' is a complete object within the
  87   /// given function.  Obvious common logic like being defined on a
  88   /// final class will have been taken care of by the caller.
  89   virtual bool isThisCompleteObject(GlobalDecl GD) const = 0;
  90
  91 public:
  92
  93   virtual ~CGCXXABI();
  94
  95   /// Gets the mangle context.
  96   MangleContext &getMangleContext() {
  97     return *MangleCtx;
  98   }
  99
 100   /// Returns true if the given constructor or destructor is one of the
 101   /// kinds that the ABI says returns 'this' (only applies when called
 102   /// non-virtually for destructors).
 103   ///
 104   /// There currently is no way to indicate if a destructor returns 'this'
 105   /// when called virtually, and code generation does not support the case.
 106   virtual bool HasThisReturn(GlobalDecl GD) const { return false; }
 107
 108   virtual bool hasMostDerivedReturn(GlobalDecl GD) const { return false; }
 109
 110   /// Returns true if the target allows calling a function through a pointer
 111   /// with a different signature than the actual function (or equivalently,
 112   /// bitcasting a function or function pointer to a different function type).
 113   /// In principle in the most general case this could depend on the target, the
 114   /// calling convention, and the actual types of the arguments and return
 115   /// value. Here it just means whether the signature mismatch could *ever* be
 116   /// allowed; in other words, does the target do strict checking of signatures
 117   /// for all calls.
 118   virtual bool canCallMismatchedFunctionType() const { return true; }
 119
 120   /// If the C++ ABI requires the given type be returned in a particular way,
 121   /// this method sets RetAI and returns true.
 122   virtual bool classifyReturnType(CGFunctionInfo &FI) const = 0;
 123
 124   /// Specify how one should pass an argument of a record type.
 125   enum RecordArgABI {
 126     /// Pass it using the normal C aggregate rules for the ABI, potentially
 127     /// introducing extra copies and passing some or all of it in registers.
 128     RAA_Default = 0,
 129
 130     /// Pass it on the stack using its defined layout.  The argument must be
 131     /// evaluated directly into the correct stack position in the arguments area,
 132     /// and the call machinery must not move it or introduce extra copies.
 133     RAA_DirectInMemory,
 134
 135     /// Pass it as a pointer to temporary memory.
 136     RAA_Indirect
 137   };
 138
 139   /// Returns true if C++ allows us to copy the memory of an object of type RD
 140   /// when it is passed as an argument.
 141   bool canCopyArgument(const CXXRecordDecl *RD) const;
 142
 143   /// Returns how an argument of the given record type should be passed.
 144   virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const = 0;
 145
 146   /// Returns true if the implicit 'sret' parameter comes after the implicit
 147   /// 'this' parameter of C++ instance methods.
 148   virtual bool isSRetParameterAfterThis() const { return false; }
 149
 150   /// Find the LLVM type used to represent the given member pointer
 151   /// type.
 152   virtual llvm::Type *
 153   ConvertMemberPointerType(const MemberPointerType *MPT);
 154
 155   /// Load a member function from an object and a member function
 156   /// pointer.  Apply the this-adjustment and set 'This' to the
 157   /// adjusted value.
 158   virtual CGCallee EmitLoadOfMemberFunctionPointer(
 159       CodeGenFunction &CGF, const Expr *E, Address This,
 160       llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr,
 161       const MemberPointerType *MPT);
 162
 163   /// Calculate an l-value from an object and a data member pointer.
 164   virtual llvm::Value *
 165   EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
 166                                Address Base, llvm::Value *MemPtr,
 167                                const MemberPointerType *MPT);
 168
 169   /// Perform a derived-to-base, base-to-derived, or bitcast member
 170   /// pointer conversion.
 171   virtual llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,
 172                                                    const CastExpr *E,
 173                                                    llvm::Value *Src);
 174
 175   /// Perform a derived-to-base, base-to-derived, or bitcast member
 176   /// pointer conversion on a constant value.
 177   virtual llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
 178                                                       llvm::Constant *Src);
 179
 180   /// Return true if the given member pointer can be zero-initialized
 181   /// (in the C++ sense) with an LLVM zeroinitializer.
 182   virtual bool isZeroInitializable(const MemberPointerType *MPT);
 183
 184   /// Return whether or not a member pointers type is convertible to an IR type.
 185   virtual bool isMemberPointerConvertible(const MemberPointerType *MPT) const {
 186     return true;
 187   }
 188
 189   /// Create a null member pointer of the given type.
 190   virtual llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);
 191
 192   /// Create a member pointer for the given method.
 193   virtual llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD);
 194
 195   /// Create a member pointer for the given field.
 196   virtual llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,
 197                                                 CharUnits offset);
 198
 199   /// Create a member pointer for the given member pointer constant.
 200   virtual llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT);
 201
 202   /// Emit a comparison between two member pointers.  Returns an i1.
 203   virtual llvm::Value *
 204   EmitMemberPointerComparison(CodeGenFunction &CGF,
 205                               llvm::Value *L,
 206                               llvm::Value *R,
 207                               const MemberPointerType *MPT,
 208                               bool Inequality);
 209
 210   /// Determine if a member pointer is non-null.  Returns an i1.
 211   virtual llvm::Value *
 212   EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
 213                              llvm::Value *MemPtr,
 214                              const MemberPointerType *MPT);
 215
 216 protected:
 217   /// A utility method for computing the offset required for the given
 218   /// base-to-derived or derived-to-base member-pointer conversion.
 219   /// Does not handle virtual conversions (in case we ever fully
 220   /// support an ABI that allows this).  Returns null if no adjustment
 221   /// is required.
 222   llvm::Constant *getMemberPointerAdjustment(const CastExpr *E);
 223
 224   /// \brief Computes the non-virtual adjustment needed for a member pointer
 225   /// conversion along an inheritance path stored in an APValue.  Unlike
 226   /// getMemberPointerAdjustment(), the adjustment can be negative if the path
 227   /// is from a derived type to a base type.
 228   CharUnits getMemberPointerPathAdjustment(const APValue &MP);
 229
 230 public:
 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   /// \brief 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   /// Build the signature of the given constructor or destructor variant by
 295   /// adding any required parameters.  For convenience, ArgTys has been
 296   /// initialized with the type of 'this'.
 297   virtual void buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
 298                                       SmallVectorImpl<CanQualType> &ArgTys) = 0;
 299
 300   /// Returns true if the given destructor type should be emitted as a linkonce
 301   /// delegating thunk, regardless of whether the dtor is defined in this TU or
 302   /// not.
 303   virtual bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
 304                                       CXXDtorType DT) const = 0;
 305
 306   /// Emit destructor variants required by this ABI.
 307   virtual void EmitCXXDestructors(const CXXDestructorDecl *D) = 0;
 308
 309   /// Get the type of the implicit "this" parameter used by a method. May return
 310   /// zero if no specific type is applicable, e.g. if the ABI expects the "this"
 311   /// parameter to point to some artificial offset in a complete object due to
 312   /// vbases being reordered.
 313   virtual const CXXRecordDecl *
 314   getThisArgumentTypeForMethod(const CXXMethodDecl *MD) {
 315     return MD->getParent();
 316   }
 317
 318   /// Perform ABI-specific "this" argument adjustment required prior to
 319   /// a call of a virtual function.
 320   /// The "VirtualCall" argument is true iff the call itself is virtual.
 321   virtual Address
 322   adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD,
 323                                            Address This, bool VirtualCall) {
 324     return This;
 325   }
 326
 327   /// Build a parameter variable suitable for 'this'.
 328   void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params);
 329
 330   /// Insert any ABI-specific implicit parameters into the parameter list for a
 331   /// function.  This generally involves extra data for constructors and
 332   /// destructors.
 333   ///
 334   /// ABIs may also choose to override the return type, which has been
 335   /// initialized with the type of 'this' if HasThisReturn(CGF.CurGD) is true or
 336   /// the formal return type of the function otherwise.
 337   virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,
 338                                          FunctionArgList &Params) = 0;
 339
 340   /// Get the ABI-specific "this" parameter adjustment to apply in the prologue
 341   /// of a virtual function.
 342   virtual CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) {
 343     return CharUnits::Zero();
 344   }
 345
 346   /// Perform ABI-specific "this" parameter adjustment in a virtual function
 347   /// prologue.
 348   virtual llvm::Value *adjustThisParameterInVirtualFunctionPrologue(
 349       CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) {
 350     return This;
 351   }
 352
 353   /// Emit the ABI-specific prolog for the function.
 354   virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF) = 0;
 355
 356   /// Add any ABI-specific implicit arguments needed to call a constructor.
 357   ///
 358   /// \return The number of args added to the call, which is typically zero or
 359   /// one.
 360   virtual unsigned
 361   addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D,
 362                              CXXCtorType Type, bool ForVirtualBase,
 363                              bool Delegating, CallArgList &Args) = 0;
 364
 365   /// Emit the destructor call.
 366   virtual void EmitDestructorCall(CodeGenFunction &CGF,
 367                                   const CXXDestructorDecl *DD, CXXDtorType Type,
 368                                   bool ForVirtualBase, bool Delegating,
 369                                   Address This) = 0;
 370
 371   /// Emits the VTable definitions required for the given record type.
 372   virtual void emitVTableDefinitions(CodeGenVTables &CGVT,
 373                                      const CXXRecordDecl *RD) = 0;
 374
 375   /// Checks if ABI requires extra virtual offset for vtable field.
 376   virtual bool
 377   isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,
 378                                       CodeGenFunction::VPtr Vptr) = 0;
 379
 380   /// Checks if ABI requires to initilize vptrs for given dynamic class.
 381   virtual bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) = 0;
 382
 383   /// Get the address point of the vtable for the given base subobject.
 384   virtual llvm::Constant *
 385   getVTableAddressPoint(BaseSubobject Base,
 386                         const CXXRecordDecl *VTableClass) = 0;
 387
 388   /// Get the address point of the vtable for the given base subobject while
 389   /// building a constructor or a destructor.
 390   virtual llvm::Value *
 391   getVTableAddressPointInStructor(CodeGenFunction &CGF, const CXXRecordDecl *RD,
 392                                   BaseSubobject Base,
 393                                   const CXXRecordDecl *NearestVBase) = 0;
 394
 395   /// Get the address point of the vtable for the given base subobject while
 396   /// building a constexpr.
 397   virtual llvm::Constant *
 398   getVTableAddressPointForConstExpr(BaseSubobject Base,
 399                                     const CXXRecordDecl *VTableClass) = 0;
 400
 401   /// Get the address of the vtable for the given record decl which should be
 402   /// used for the vptr at the given offset in RD.
 403   virtual llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
 404                                                 CharUnits VPtrOffset) = 0;
 405
 406   /// Build a virtual function pointer in the ABI-specific way.
 407   virtual CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF,
 408                                              GlobalDecl GD,
 409                                              Address This,
 410                                              llvm::Type *Ty,
 411                                              SourceLocation Loc) = 0;
 412
 413   /// Emit the ABI-specific virtual destructor call.
 414   virtual llvm::Value *
 415   EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor,
 416                             CXXDtorType DtorType, Address This,
 417                             const CXXMemberCallExpr *CE) = 0;
 418
 419   virtual void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF,
 420                                                 GlobalDecl GD,
 421                                                 CallArgList &CallArgs) {}
 422
 423   /// Emit any tables needed to implement virtual inheritance.  For Itanium,
 424   /// this emits virtual table tables.  For the MSVC++ ABI, this emits virtual
 425   /// base tables.
 426   virtual void emitVirtualInheritanceTables(const CXXRecordDecl *RD) = 0;
 427
 428   virtual void setThunkLinkage(llvm::Function *Thunk, bool ForVTable,
 429                                GlobalDecl GD, bool ReturnAdjustment) = 0;
 430
 431   virtual llvm::Value *performThisAdjustment(CodeGenFunction &CGF,
 432                                              Address This,
 433                                              const ThisAdjustment &TA) = 0;
 434
 435   virtual llvm::Value *performReturnAdjustment(CodeGenFunction &CGF,
 436                                                Address Ret,
 437                                                const ReturnAdjustment &RA) = 0;
 438
 439   virtual void EmitReturnFromThunk(CodeGenFunction &CGF,
 440                                    RValue RV, QualType ResultType);
 441
 442   virtual size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,
 443                                       FunctionArgList &Args) const = 0;
 444
 445   /// Gets the offsets of all the virtual base pointers in a given class.
 446   virtual std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD);
 447
 448   /// Gets the pure virtual member call function.
 449   virtual StringRef GetPureVirtualCallName() = 0;
 450
 451   /// Gets the deleted virtual member call name.
 452   virtual StringRef GetDeletedVirtualCallName() = 0;
 453
 454   /**************************** Array cookies ******************************/
 455
 456   /// Returns the extra size required in order to store the array
 457   /// cookie for the given new-expression.  May return 0 to indicate that no
 458   /// array cookie is required.
 459   ///
 460   /// Several cases are filtered out before this method is called:
 461   ///   - non-array allocations never need a cookie
 462   ///   - calls to \::operator new(size_t, void*) never need a cookie
 463   ///
 464   /// \param expr - the new-expression being allocated.
 465   virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr);
 466
 467   /// Initialize the array cookie for the given allocation.
 468   ///
 469   /// \param NewPtr - a char* which is the presumed-non-null
 470   ///   return value of the allocation function
 471   /// \param NumElements - the computed number of elements,
 472   ///   potentially collapsed from the multidimensional array case;
 473   ///   always a size_t
 474   /// \param ElementType - the base element allocated type,
 475   ///   i.e. the allocated type after stripping all array types
 476   virtual Address InitializeArrayCookie(CodeGenFunction &CGF,
 477                                         Address NewPtr,
 478                                         llvm::Value *NumElements,
 479                                         const CXXNewExpr *expr,
 480                                         QualType ElementType);
 481
 482   /// Reads the array cookie associated with the given pointer,
 483   /// if it has one.
 484   ///
 485   /// \param Ptr - a pointer to the first element in the array
 486   /// \param ElementType - the base element type of elements of the array
 487   /// \param NumElements - an out parameter which will be initialized
 488   ///   with the number of elements allocated, or zero if there is no
 489   ///   cookie
 490   /// \param AllocPtr - an out parameter which will be initialized
 491   ///   with a char* pointing to the address returned by the allocation
 492   ///   function
 493   /// \param CookieSize - an out parameter which will be initialized
 494   ///   with the size of the cookie, or zero if there is no cookie
 495   virtual void ReadArrayCookie(CodeGenFunction &CGF, Address Ptr,
 496                                const CXXDeleteExpr *expr,
 497                                QualType ElementType, llvm::Value *&NumElements,
 498                                llvm::Value *&AllocPtr, CharUnits &CookieSize);
 499
 500   /// Return whether the given global decl needs a VTT parameter.
 501   virtual bool NeedsVTTParameter(GlobalDecl GD);
 502
 503 protected:
 504   /// Returns the extra size required in order to store the array
 505   /// cookie for the given type.  Assumes that an array cookie is
 506   /// required.
 507   virtual CharUnits getArrayCookieSizeImpl(QualType elementType);
 508
 509   /// Reads the array cookie for an allocation which is known to have one.
 510   /// This is called by the standard implementation of ReadArrayCookie.
 511   ///
 512   /// \param ptr - a pointer to the allocation made for an array, as a char*
 513   /// \param cookieSize - the computed cookie size of an array
 514   ///
 515   /// Other parameters are as above.
 516   ///
 517   /// \return a size_t
 518   virtual llvm::Value *readArrayCookieImpl(CodeGenFunction &IGF, Address ptr,
 519                                            CharUnits cookieSize);
 520
 521 public:
 522
 523   /*************************** Static local guards ****************************/
 524
 525   /// Emits the guarded initializer and destructor setup for the given
 526   /// variable, given that it couldn't be emitted as a constant.
 527   /// If \p PerformInit is false, the initialization has been folded to a
 528   /// constant and should not be performed.
 529   ///
 530   /// The variable may be:
 531   ///   - a static local variable
 532   ///   - a static data member of a class template instantiation
 533   virtual void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,
 534                                llvm::GlobalVariable *DeclPtr,
 535                                bool PerformInit) = 0;
 536
 537   /// Emit code to force the execution of a destructor during global
 538   /// teardown.  The default implementation of this uses atexit.
 539   ///
 540   /// \param Dtor - a function taking a single pointer argument
 541   /// \param Addr - a pointer to pass to the destructor function.
 542   virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
 543                                   llvm::Constant *Dtor,
 544                                   llvm::Constant *Addr) = 0;
 545
 546   /*************************** thread_local initialization ********************/
 547
 548   /// Emits ABI-required functions necessary to initialize thread_local
 549   /// variables in this translation unit.
 550   ///
 551   /// \param CXXThreadLocals - The thread_local declarations in this translation
 552   ///        unit.
 553   /// \param CXXThreadLocalInits - If this translation unit contains any
 554   ///        non-constant initialization or non-trivial destruction for
 555   ///        thread_local variables, a list of functions to perform the
 556   ///        initialization.
 557   virtual void EmitThreadLocalInitFuncs(
 558       CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
 559       ArrayRef<llvm::Function *> CXXThreadLocalInits,
 560       ArrayRef<const VarDecl *> CXXThreadLocalInitVars) = 0;
 561
 562   // Determine if references to thread_local global variables can be made
 563   // directly or require access through a thread wrapper function.
 564   virtual bool usesThreadWrapperFunction() const = 0;
 565
 566   /// Emit a reference to a non-local thread_local variable (including
 567   /// triggering the initialization of all thread_local variables in its
 568   /// translation unit).
 569   virtual LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,
 570                                               const VarDecl *VD,
 571                                               QualType LValType) = 0;
 572
 573   /// Emit a single constructor/destructor with the given type from a C++
 574   /// constructor Decl.
 575   virtual void emitCXXStructor(const CXXMethodDecl *MD, StructorType Type) = 0;
 576 };
 577
 578 // Create an instance of a C++ ABI class:
 579
 580 /// Creates an Itanium-family ABI.
 581 CGCXXABI *CreateItaniumCXXABI(CodeGenModule &CGM);
 582
 583 /// Creates a Microsoft-family ABI.
 584 CGCXXABI *CreateMicrosoftCXXABI(CodeGenModule &CGM);
 585
 586 }
 587 }
 588
 589 #endif