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