694 lines · c
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-exception6//7//===----------------------------------------------------------------------===//8//9// This provides an abstract class for C++ code generation. Concrete subclasses10// of this implement code generation for specific C++ ABIs.11//12//===----------------------------------------------------------------------===//13 14#ifndef LLVM_CLANG_LIB_CODEGEN_CGCXXABI_H15#define LLVM_CLANG_LIB_CODEGEN_CGCXXABI_H16 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 MangleContext;35 36namespace CodeGen {37class CGCallee;38class CodeGenFunction;39class CodeGenModule;40struct CatchTypeInfo;41 42/// Implements C++ ABI-specific code generation functions.43class CGCXXABI {44 friend class CodeGenModule;45 46protected:47 CodeGenModule &CGM;48 std::unique_ptr<MangleContext> MangleCtx;49 50 CGCXXABI(CodeGenModule &CGM)51 : CGM(CGM), MangleCtx(CGM.getContext().createMangleContext()) {}52 53protected:54 ImplicitParamDecl *getThisDecl(CodeGenFunction &CGF) {55 return CGF.CXXABIThisDecl;56 }57 llvm::Value *getThisValue(CodeGenFunction &CGF) {58 return CGF.CXXABIThisValue;59 }60 61 Address getThisAddress(CodeGenFunction &CGF);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 bool mayNeedDestruction(const VarDecl *VD) const;84 85 /// Determine whether we will definitely emit this variable with a constant86 /// initializer, either because the language semantics demand it or because87 /// we know that the initializer is a constant.88 // For weak definitions, any initializer available in the current translation89 // is not necessarily reflective of the initializer used; such initializers90 // are ignored unless if InspectInitForWeakDef is true.91 bool92 isEmittedWithConstantInitializer(const VarDecl *VD,93 bool InspectInitForWeakDef = false) const;94 95 virtual bool requiresArrayCookie(const CXXDeleteExpr *E, QualType eltType);96 virtual bool requiresArrayCookie(const CXXNewExpr *E);97 98 /// Determine whether there's something special about the rules of99 /// the ABI tell us that 'this' is a complete object within the100 /// given function. Obvious common logic like being defined on a101 /// final class will have been taken care of by the caller.102 virtual bool isThisCompleteObject(GlobalDecl GD) const = 0;103 104 virtual bool constructorsAndDestructorsReturnThis() const {105 return CGM.getCodeGenOpts().CtorDtorReturnThis;106 }107 108public:109 110 virtual ~CGCXXABI();111 112 /// Gets the mangle context.113 MangleContext &getMangleContext() {114 return *MangleCtx;115 }116 117 /// Returns true if the given constructor or destructor is one of the118 /// kinds that the ABI says returns 'this' (only applies when called119 /// non-virtually for destructors).120 ///121 /// There currently is no way to indicate if a destructor returns 'this'122 /// when called virtually, and code generation does not support the case.123 virtual bool HasThisReturn(GlobalDecl GD) const {124 if (isa<CXXConstructorDecl>(GD.getDecl()) ||125 (isa<CXXDestructorDecl>(GD.getDecl()) &&126 GD.getDtorType() != Dtor_Deleting))127 return constructorsAndDestructorsReturnThis();128 return false;129 }130 131 virtual bool hasMostDerivedReturn(GlobalDecl GD) const { return false; }132 133 virtual bool useSinitAndSterm() const { return false; }134 135 /// Returns true if the target allows calling a function through a pointer136 /// with a different signature than the actual function (or equivalently,137 /// bitcasting a function or function pointer to a different function type).138 /// In principle in the most general case this could depend on the target, the139 /// calling convention, and the actual types of the arguments and return140 /// value. Here it just means whether the signature mismatch could *ever* be141 /// allowed; in other words, does the target do strict checking of signatures142 /// for all calls.143 virtual bool canCallMismatchedFunctionType() const { return true; }144 145 /// If the C++ ABI requires the given type be returned in a particular way,146 /// this method sets RetAI and returns true.147 virtual bool classifyReturnType(CGFunctionInfo &FI) const = 0;148 149 /// Specify how one should pass an argument of a record type.150 enum RecordArgABI {151 /// Pass it using the normal C aggregate rules for the ABI, potentially152 /// introducing extra copies and passing some or all of it in registers.153 RAA_Default = 0,154 155 /// Pass it on the stack using its defined layout. The argument must be156 /// evaluated directly into the correct stack position in the arguments area,157 /// and the call machinery must not move it or introduce extra copies.158 RAA_DirectInMemory,159 160 /// Pass it as a pointer to temporary memory.161 RAA_Indirect162 };163 164 /// Returns how an argument of the given record type should be passed.165 virtual RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const = 0;166 167 /// Returns true if the implicit 'sret' parameter comes after the implicit168 /// 'this' parameter of C++ instance methods.169 virtual bool isSRetParameterAfterThis() const { return false; }170 171 /// Returns true if the ABI permits the argument to be a homogeneous172 /// aggregate.173 virtual bool174 isPermittedToBeHomogeneousAggregate(const CXXRecordDecl *RD) const {175 return true;176 };177 178 /// Find the LLVM type used to represent the given member pointer179 /// type.180 virtual llvm::Type *181 ConvertMemberPointerType(const MemberPointerType *MPT);182 183 /// Load a member function from an object and a member function184 /// pointer. Apply the this-adjustment and set 'This' to the185 /// adjusted value.186 virtual CGCallee EmitLoadOfMemberFunctionPointer(187 CodeGenFunction &CGF, const Expr *E, Address This,188 llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr,189 const MemberPointerType *MPT);190 191 /// Calculate an l-value from an object and a data member pointer.192 virtual llvm::Value *193 EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,194 Address Base, llvm::Value *MemPtr,195 const MemberPointerType *MPT, bool IsInBounds);196 197 /// Perform a derived-to-base, base-to-derived, or bitcast member198 /// pointer conversion.199 virtual llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF,200 const CastExpr *E,201 llvm::Value *Src);202 203 /// Perform a derived-to-base, base-to-derived, or bitcast member204 /// pointer conversion on a constant value.205 virtual llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,206 llvm::Constant *Src);207 208 /// Return true if the given member pointer can be zero-initialized209 /// (in the C++ sense) with an LLVM zeroinitializer.210 virtual bool isZeroInitializable(const MemberPointerType *MPT);211 212 /// Return whether or not a member pointers type is convertible to an IR type.213 virtual bool isMemberPointerConvertible(const MemberPointerType *MPT) const {214 return true;215 }216 217 /// Create a null member pointer of the given type.218 virtual llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);219 220 /// Create a member pointer for the given method.221 virtual llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD);222 223 /// Create a member pointer for the given field.224 virtual llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT,225 CharUnits offset);226 227 /// Create a member pointer for the given member pointer constant.228 virtual llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT);229 230 /// Emit a comparison between two member pointers. Returns an i1.231 virtual llvm::Value *232 EmitMemberPointerComparison(CodeGenFunction &CGF,233 llvm::Value *L,234 llvm::Value *R,235 const MemberPointerType *MPT,236 bool Inequality);237 238 /// Determine if a member pointer is non-null. Returns an i1.239 virtual llvm::Value *240 EmitMemberPointerIsNotNull(CodeGenFunction &CGF,241 llvm::Value *MemPtr,242 const MemberPointerType *MPT);243 244protected:245 /// A utility method for computing the offset required for the given246 /// base-to-derived or derived-to-base member-pointer conversion.247 /// Does not handle virtual conversions (in case we ever fully248 /// support an ABI that allows this). Returns null if no adjustment249 /// is required.250 llvm::Constant *getMemberPointerAdjustment(const CastExpr *E);251 252public:253 virtual void emitVirtualObjectDelete(CodeGenFunction &CGF,254 const CXXDeleteExpr *DE,255 Address Ptr, QualType ElementType,256 const CXXDestructorDecl *Dtor) = 0;257 virtual void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) = 0;258 virtual void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) = 0;259 virtual llvm::GlobalVariable *getThrowInfo(QualType T) { return nullptr; }260 261 /// Determine whether it's possible to emit a vtable for \p RD, even262 /// though we do not know that the vtable has been marked as used by semantic263 /// analysis.264 virtual bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const = 0;265 266 virtual void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) = 0;267 268 virtual llvm::CallInst *269 emitTerminateForUnexpectedException(CodeGenFunction &CGF,270 llvm::Value *Exn);271 272 virtual llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) = 0;273 virtual CatchTypeInfo274 getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType) = 0;275 virtual CatchTypeInfo getCatchAllTypeInfo();276 277 virtual bool shouldTypeidBeNullChecked(QualType SrcRecordTy) = 0;278 virtual void EmitBadTypeidCall(CodeGenFunction &CGF) = 0;279 virtual llvm::Value *EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy,280 Address ThisPtr,281 llvm::Type *StdTypeInfoPtrTy) = 0;282 283 virtual bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,284 QualType SrcRecordTy) = 0;285 virtual bool shouldEmitExactDynamicCast(QualType DestRecordTy) = 0;286 287 virtual llvm::Value *emitDynamicCastCall(CodeGenFunction &CGF, Address Value,288 QualType SrcRecordTy,289 QualType DestTy,290 QualType DestRecordTy,291 llvm::BasicBlock *CastEnd) = 0;292 293 virtual llvm::Value *emitDynamicCastToVoid(CodeGenFunction &CGF,294 Address Value,295 QualType SrcRecordTy) = 0;296 297 struct ExactDynamicCastInfo {298 bool RequiresCastToPrimaryBase;299 CharUnits Offset;300 };301 302 virtual std::optional<ExactDynamicCastInfo>303 getExactDynamicCastInfo(QualType SrcRecordTy, QualType DestTy,304 QualType DestRecordTy) = 0;305 306 /// Emit a dynamic_cast from SrcRecordTy to DestRecordTy. The cast fails if307 /// the dynamic type of Value is not exactly DestRecordTy.308 virtual llvm::Value *emitExactDynamicCast(309 CodeGenFunction &CGF, Address Value, QualType SrcRecordTy,310 QualType DestTy, QualType DestRecordTy,311 const ExactDynamicCastInfo &CastInfo, llvm::BasicBlock *CastSuccess,312 llvm::BasicBlock *CastFail) = 0;313 314 virtual bool EmitBadCastCall(CodeGenFunction &CGF) = 0;315 316 virtual llvm::Value *GetVirtualBaseClassOffset(CodeGenFunction &CGF,317 Address This,318 const CXXRecordDecl *ClassDecl,319 const CXXRecordDecl *BaseClassDecl) = 0;320 321 virtual llvm::BasicBlock *EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,322 const CXXRecordDecl *RD);323 324 /// Emit the code to initialize hidden members required325 /// to handle virtual inheritance, if needed by the ABI.326 virtual void327 initializeHiddenVirtualInheritanceMembers(CodeGenFunction &CGF,328 const CXXRecordDecl *RD) {}329 330 /// Emit constructor variants required by this ABI.331 virtual void EmitCXXConstructors(const CXXConstructorDecl *D) = 0;332 333 /// Additional implicit arguments to add to the beginning (Prefix) and end334 /// (Suffix) of a constructor / destructor arg list.335 ///336 /// Note that Prefix should actually be inserted *after* the first existing337 /// arg; `this` arguments always come first.338 struct AddedStructorArgs {339 struct Arg {340 llvm::Value *Value;341 QualType Type;342 };343 SmallVector<Arg, 1> Prefix;344 SmallVector<Arg, 1> Suffix;345 AddedStructorArgs() = default;346 AddedStructorArgs(SmallVector<Arg, 1> P, SmallVector<Arg, 1> S)347 : Prefix(std::move(P)), Suffix(std::move(S)) {}348 static AddedStructorArgs prefix(SmallVector<Arg, 1> Args) {349 return {std::move(Args), {}};350 }351 static AddedStructorArgs suffix(SmallVector<Arg, 1> Args) {352 return {{}, std::move(Args)};353 }354 };355 356 /// Similar to AddedStructorArgs, but only notes the number of additional357 /// arguments.358 struct AddedStructorArgCounts {359 unsigned Prefix = 0;360 unsigned Suffix = 0;361 AddedStructorArgCounts() = default;362 AddedStructorArgCounts(unsigned P, unsigned S) : Prefix(P), Suffix(S) {}363 static AddedStructorArgCounts prefix(unsigned N) { return {N, 0}; }364 static AddedStructorArgCounts suffix(unsigned N) { return {0, N}; }365 };366 367 /// Build the signature of the given constructor or destructor variant by368 /// adding any required parameters. For convenience, ArgTys has been369 /// initialized with the type of 'this'.370 virtual AddedStructorArgCounts371 buildStructorSignature(GlobalDecl GD,372 SmallVectorImpl<CanQualType> &ArgTys) = 0;373 374 /// Returns true if the given destructor type should be emitted as a linkonce375 /// delegating thunk, regardless of whether the dtor is defined in this TU or376 /// not.377 virtual bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,378 CXXDtorType DT) const = 0;379 380 virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV,381 const CXXDestructorDecl *Dtor,382 CXXDtorType DT) const;383 384 virtual llvm::GlobalValue::LinkageTypes385 getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor,386 CXXDtorType DT) const;387 388 /// Emit destructor variants required by this ABI.389 virtual void EmitCXXDestructors(const CXXDestructorDecl *D) = 0;390 391 /// Get the type of the implicit "this" parameter used by a method. May return392 /// zero if no specific type is applicable, e.g. if the ABI expects the "this"393 /// parameter to point to some artificial offset in a complete object due to394 /// vbases being reordered.395 virtual const CXXRecordDecl *getThisArgumentTypeForMethod(GlobalDecl GD) {396 return cast<CXXMethodDecl>(GD.getDecl())->getParent();397 }398 399 /// Perform ABI-specific "this" argument adjustment required prior to400 /// a call of a virtual function.401 /// The "VirtualCall" argument is true iff the call itself is virtual.402 virtual Address403 adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD,404 Address This, bool VirtualCall) {405 return This;406 }407 408 /// Build a parameter variable suitable for 'this'.409 void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params);410 411 /// Insert any ABI-specific implicit parameters into the parameter list for a412 /// function. This generally involves extra data for constructors and413 /// destructors.414 ///415 /// ABIs may also choose to override the return type, which has been416 /// initialized with the type of 'this' if HasThisReturn(CGF.CurGD) is true or417 /// the formal return type of the function otherwise.418 virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy,419 FunctionArgList &Params) = 0;420 421 /// Get the ABI-specific "this" parameter adjustment to apply in the prologue422 /// of a virtual function.423 virtual CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) {424 return CharUnits::Zero();425 }426 427 /// Emit the ABI-specific prolog for the function.428 virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF) = 0;429 430 virtual AddedStructorArgs431 getImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D,432 CXXCtorType Type, bool ForVirtualBase,433 bool Delegating) = 0;434 435 /// Add any ABI-specific implicit arguments needed to call a constructor.436 ///437 /// \return The number of arguments added at the beginning and end of the438 /// call, which is typically zero or one.439 AddedStructorArgCounts440 addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D,441 CXXCtorType Type, bool ForVirtualBase,442 bool Delegating, CallArgList &Args);443 444 /// Get the implicit (second) parameter that comes after the "this" pointer,445 /// or nullptr if there is isn't one.446 virtual llvm::Value *447 getCXXDestructorImplicitParam(CodeGenFunction &CGF,448 const CXXDestructorDecl *DD, CXXDtorType Type,449 bool ForVirtualBase, bool Delegating) = 0;450 451 /// Emit the destructor call.452 virtual void EmitDestructorCall(CodeGenFunction &CGF,453 const CXXDestructorDecl *DD, CXXDtorType Type,454 bool ForVirtualBase, bool Delegating,455 Address This, QualType ThisTy) = 0;456 457 /// Emits the VTable definitions required for the given record type.458 virtual void emitVTableDefinitions(CodeGenVTables &CGVT,459 const CXXRecordDecl *RD) = 0;460 461 /// Checks if ABI requires extra virtual offset for vtable field.462 virtual bool463 isVirtualOffsetNeededForVTableField(CodeGenFunction &CGF,464 CodeGenFunction::VPtr Vptr) = 0;465 466 /// Checks if ABI requires to initialize vptrs for given dynamic class.467 virtual bool doStructorsInitializeVPtrs(const CXXRecordDecl *VTableClass) = 0;468 469 /// Get the address point of the vtable for the given base subobject.470 virtual llvm::Constant *471 getVTableAddressPoint(BaseSubobject Base,472 const CXXRecordDecl *VTableClass) = 0;473 474 /// Get the address point of the vtable for the given base subobject while475 /// building a constructor or a destructor.476 virtual llvm::Value *477 getVTableAddressPointInStructor(CodeGenFunction &CGF, const CXXRecordDecl *RD,478 BaseSubobject Base,479 const CXXRecordDecl *NearestVBase) = 0;480 481 /// Get the address of the vtable for the given record decl which should be482 /// used for the vptr at the given offset in RD.483 virtual llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,484 CharUnits VPtrOffset) = 0;485 486 /// Build a virtual function pointer in the ABI-specific way.487 virtual CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF,488 GlobalDecl GD, Address This,489 llvm::Type *Ty,490 SourceLocation Loc) = 0;491 492 using DeleteOrMemberCallExpr =493 llvm::PointerUnion<const CXXDeleteExpr *, const CXXMemberCallExpr *>;494 495 /// Emit the ABI-specific virtual destructor call.496 virtual llvm::Value *497 EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor,498 CXXDtorType DtorType, Address This,499 DeleteOrMemberCallExpr E,500 llvm::CallBase **CallOrInvoke) = 0;501 502 virtual void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF,503 GlobalDecl GD,504 CallArgList &CallArgs) {}505 506 /// Emit any tables needed to implement virtual inheritance. For Itanium,507 /// this emits virtual table tables. For the MSVC++ ABI, this emits virtual508 /// base tables.509 virtual void emitVirtualInheritanceTables(const CXXRecordDecl *RD) = 0;510 511 virtual bool exportThunk() = 0;512 virtual void setThunkLinkage(llvm::Function *Thunk, bool ForVTable,513 GlobalDecl GD, bool ReturnAdjustment) = 0;514 515 virtual llvm::Value *516 performThisAdjustment(CodeGenFunction &CGF, Address This,517 const CXXRecordDecl *UnadjustedClass,518 const ThunkInfo &TI) = 0;519 520 virtual llvm::Value *521 performReturnAdjustment(CodeGenFunction &CGF, Address Ret,522 const CXXRecordDecl *UnadjustedClass,523 const ReturnAdjustment &RA) = 0;524 525 virtual void EmitReturnFromThunk(CodeGenFunction &CGF,526 RValue RV, QualType ResultType);527 528 virtual size_t getSrcArgforCopyCtor(const CXXConstructorDecl *,529 FunctionArgList &Args) const = 0;530 531 /// Gets the offsets of all the virtual base pointers in a given class.532 virtual std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD);533 534 /// Gets the pure virtual member call function.535 virtual StringRef GetPureVirtualCallName() = 0;536 537 /// Gets the deleted virtual member call name.538 virtual StringRef GetDeletedVirtualCallName() = 0;539 540 /**************************** Array cookies ******************************/541 542 /// Returns the extra size required in order to store the array543 /// cookie for the given new-expression. May return 0 to indicate that no544 /// array cookie is required.545 ///546 /// Several cases are filtered out before this method is called:547 /// - non-array allocations never need a cookie548 /// - calls to \::operator new(size_t, void*) never need a cookie549 ///550 /// \param expr - the new-expression being allocated.551 virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr);552 553 /// Initialize the array cookie for the given allocation.554 ///555 /// \param NewPtr - a char* which is the presumed-non-null556 /// return value of the allocation function557 /// \param NumElements - the computed number of elements,558 /// potentially collapsed from the multidimensional array case;559 /// always a size_t560 /// \param ElementType - the base element allocated type,561 /// i.e. the allocated type after stripping all array types562 virtual Address InitializeArrayCookie(CodeGenFunction &CGF,563 Address NewPtr,564 llvm::Value *NumElements,565 const CXXNewExpr *expr,566 QualType ElementType);567 568 /// Reads the array cookie associated with the given pointer,569 /// if it has one.570 ///571 /// \param Ptr - a pointer to the first element in the array572 /// \param ElementType - the base element type of elements of the array573 /// \param NumElements - an out parameter which will be initialized574 /// with the number of elements allocated, or zero if there is no575 /// cookie576 /// \param AllocPtr - an out parameter which will be initialized577 /// with a char* pointing to the address returned by the allocation578 /// function579 /// \param CookieSize - an out parameter which will be initialized580 /// with the size of the cookie, or zero if there is no cookie581 virtual void ReadArrayCookie(CodeGenFunction &CGF, Address Ptr,582 const CXXDeleteExpr *expr,583 QualType ElementType, llvm::Value *&NumElements,584 llvm::Value *&AllocPtr, CharUnits &CookieSize);585 586 /// Return whether the given global decl needs a VTT parameter.587 virtual bool NeedsVTTParameter(GlobalDecl GD);588 589protected:590 /// Returns the extra size required in order to store the array591 /// cookie for the given type. Assumes that an array cookie is592 /// required.593 virtual CharUnits getArrayCookieSizeImpl(QualType elementType);594 595 /// Reads the array cookie for an allocation which is known to have one.596 /// This is called by the standard implementation of ReadArrayCookie.597 ///598 /// \param ptr - a pointer to the allocation made for an array, as a char*599 /// \param cookieSize - the computed cookie size of an array600 ///601 /// Other parameters are as above.602 ///603 /// \return a size_t604 virtual llvm::Value *readArrayCookieImpl(CodeGenFunction &IGF, Address ptr,605 CharUnits cookieSize);606 607public:608 609 /*************************** Static local guards ****************************/610 611 /// Emits the guarded initializer and destructor setup for the given612 /// variable, given that it couldn't be emitted as a constant.613 /// If \p PerformInit is false, the initialization has been folded to a614 /// constant and should not be performed.615 ///616 /// The variable may be:617 /// - a static local variable618 /// - a static data member of a class template instantiation619 virtual void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D,620 llvm::GlobalVariable *DeclPtr,621 bool PerformInit) = 0;622 623 /// Emit code to force the execution of a destructor during global624 /// teardown. The default implementation of this uses atexit.625 ///626 /// \param Dtor - a function taking a single pointer argument627 /// \param Addr - a pointer to pass to the destructor function.628 virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,629 llvm::FunctionCallee Dtor,630 llvm::Constant *Addr) = 0;631 632 /*************************** thread_local initialization ********************/633 634 /// Emits ABI-required functions necessary to initialize thread_local635 /// variables in this translation unit.636 ///637 /// \param CXXThreadLocals - The thread_local declarations in this translation638 /// unit.639 /// \param CXXThreadLocalInits - If this translation unit contains any640 /// non-constant initialization or non-trivial destruction for641 /// thread_local variables, a list of functions to perform the642 /// initialization.643 virtual void EmitThreadLocalInitFuncs(644 CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,645 ArrayRef<llvm::Function *> CXXThreadLocalInits,646 ArrayRef<const VarDecl *> CXXThreadLocalInitVars) = 0;647 648 // Determine if references to thread_local global variables can be made649 // directly or require access through a thread wrapper function.650 virtual bool usesThreadWrapperFunction(const VarDecl *VD) const = 0;651 652 /// Emit a reference to a non-local thread_local variable (including653 /// triggering the initialization of all thread_local variables in its654 /// translation unit).655 virtual LValue EmitThreadLocalVarDeclLValue(CodeGenFunction &CGF,656 const VarDecl *VD,657 QualType LValType) = 0;658 659 /// Emit a single constructor/destructor with the given type from a C++660 /// constructor Decl.661 virtual void emitCXXStructor(GlobalDecl GD) = 0;662 663 /// Load a vtable from This, an object of polymorphic type RD, or from one of664 /// its virtual bases if it does not have its own vtable. Returns the vtable665 /// and the class from which the vtable was loaded.666 virtual std::pair<llvm::Value *, const CXXRecordDecl *>667 LoadVTablePtr(CodeGenFunction &CGF, Address This,668 const CXXRecordDecl *RD) = 0;669};670 671// Create an instance of a C++ ABI class:672 673/// Creates an Itanium-family ABI.674CGCXXABI *CreateItaniumCXXABI(CodeGenModule &CGM);675 676/// Creates a Microsoft-family ABI.677CGCXXABI *CreateMicrosoftCXXABI(CodeGenModule &CGM);678 679struct CatchRetScope final : EHScopeStack::Cleanup {680 llvm::CatchPadInst *CPI;681 682 CatchRetScope(llvm::CatchPadInst *CPI) : CPI(CPI) {}683 684 void Emit(CodeGenFunction &CGF, Flags flags) override {685 llvm::BasicBlock *BB = CGF.createBasicBlock("catchret.dest");686 CGF.Builder.CreateCatchRet(CPI, BB);687 CGF.EmitBlock(BB);688 }689};690}691}692 693#endif694