clang  10.0.0svn
CGCXXABI.cpp
Go to the documentation of this file.
1 //===----- CGCXXABI.cpp - Interface to C++ ABIs ---------------------------===//
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 #include "CGCXXABI.h"
15 #include "CGCleanup.h"
16 
17 using namespace clang;
18 using namespace CodeGen;
19 
21 
23  DiagnosticsEngine &Diags = CGF.CGM.getDiags();
24  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
25  "cannot yet compile %0 in this ABI");
27  DiagID)
28  << S;
29 }
30 
32  return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
33 }
34 
35 llvm::Type *
38 }
39 
41  CodeGenFunction &CGF, const Expr *E, Address This,
42  llvm::Value *&ThisPtrForCall,
43  llvm::Value *MemPtr, const MemberPointerType *MPT) {
44  ErrorUnsupportedABI(CGF, "calls through member pointers");
45 
46  ThisPtrForCall = This.getPointer();
47  const FunctionProtoType *FPT =
49  const CXXRecordDecl *RD =
50  cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
51  llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
52  CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
53  llvm::Constant *FnPtr = llvm::Constant::getNullValue(FTy->getPointerTo());
54  return CGCallee::forDirect(FnPtr, FPT);
55 }
56 
59  Address Base, llvm::Value *MemPtr,
60  const MemberPointerType *MPT) {
61  ErrorUnsupportedABI(CGF, "loads of member pointers");
62  llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())
63  ->getPointerTo(Base.getAddressSpace());
64  return llvm::Constant::getNullValue(Ty);
65 }
66 
68  const CastExpr *E,
69  llvm::Value *Src) {
70  ErrorUnsupportedABI(CGF, "member function pointer conversions");
71  return GetBogusMemberPointer(E->getType());
72 }
73 
75  llvm::Constant *Src) {
76  return GetBogusMemberPointer(E->getType());
77 }
78 
81  llvm::Value *L,
82  llvm::Value *R,
83  const MemberPointerType *MPT,
84  bool Inequality) {
85  ErrorUnsupportedABI(CGF, "member function pointer comparison");
86  return CGF.Builder.getFalse();
87 }
88 
91  llvm::Value *MemPtr,
92  const MemberPointerType *MPT) {
93  ErrorUnsupportedABI(CGF, "member function pointer null testing");
94  return CGF.Builder.getFalse();
95 }
96 
97 llvm::Constant *
99  return GetBogusMemberPointer(QualType(MPT, 0));
100 }
101 
104  MD->getType(), MD->getParent()->getTypeForDecl()));
105 }
106 
108  CharUnits offset) {
109  return GetBogusMemberPointer(QualType(MPT, 0));
110 }
111 
112 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
113  return GetBogusMemberPointer(MPT);
114 }
115 
117  // Fake answer.
118  return true;
119 }
120 
122  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
123 
124  // FIXME: I'm not entirely sure I like using a fake decl just for code
125  // generation. Maybe we can come up with a better way?
126  auto *ThisDecl = ImplicitParamDecl::Create(
127  CGM.getContext(), nullptr, MD->getLocation(),
128  &CGM.getContext().Idents.get("this"), MD->getThisType(),
130  params.push_back(ThisDecl);
131  CGF.CXXABIThisDecl = ThisDecl;
132 
133  // Compute the presumed alignment of 'this', which basically comes
134  // down to whether we know it's a complete object or not.
135  auto &Layout = CGF.getContext().getASTRecordLayout(MD->getParent());
136  if (MD->getParent()->getNumVBases() == 0 || // avoid vcall in common case
137  MD->getParent()->hasAttr<FinalAttr>() ||
138  !isThisCompleteObject(CGF.CurGD)) {
139  CGF.CXXABIThisAlignment = Layout.getAlignment();
140  } else {
141  CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
142  }
143 }
144 
146  return CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
147  "this");
148 }
149 
151  /// Initialize the 'this' slot.
152  assert(getThisDecl(CGF) && "no 'this' variable for function");
153  CGF.CXXABIThisValue = ThisPtr;
154 }
155 
157  RValue RV, QualType ResultType) {
158  CGF.EmitReturnOfRValue(RV, ResultType);
159 }
160 
162  if (!requiresArrayCookie(expr))
163  return CharUnits::Zero();
165 }
166 
168  // BOGUS
169  return CharUnits::Zero();
170 }
171 
173  Address NewPtr,
174  llvm::Value *NumElements,
175  const CXXNewExpr *expr,
176  QualType ElementType) {
177  // Should never be called.
178  ErrorUnsupportedABI(CGF, "array cookie initialization");
179  return Address::invalid();
180 }
181 
183  QualType elementType) {
184  // If the class's usual deallocation function takes two arguments,
185  // it needs a cookie.
186  if (expr->doesUsualArrayDeleteWantSize())
187  return true;
188 
189  return elementType.isDestructedType();
190 }
191 
193  // If the class's usual deallocation function takes two arguments,
194  // it needs a cookie.
195  if (expr->doesUsualArrayDeleteWantSize())
196  return true;
197 
198  return expr->getAllocatedType().isDestructedType();
199 }
200 
202  const CXXDeleteExpr *expr, QualType eltTy,
203  llvm::Value *&numElements,
204  llvm::Value *&allocPtr, CharUnits &cookieSize) {
205  // Derive a char* in the same address space as the pointer.
206  ptr = CGF.Builder.CreateElementBitCast(ptr, CGF.Int8Ty);
207 
208  // If we don't need an array cookie, bail out early.
209  if (!requiresArrayCookie(expr, eltTy)) {
210  allocPtr = ptr.getPointer();
211  numElements = nullptr;
212  cookieSize = CharUnits::Zero();
213  return;
214  }
215 
216  cookieSize = getArrayCookieSizeImpl(eltTy);
217  Address allocAddr =
218  CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize);
219  allocPtr = allocAddr.getPointer();
220  numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize);
221 }
222 
224  Address ptr,
225  CharUnits cookieSize) {
226  ErrorUnsupportedABI(CGF, "reading a new[] cookie");
227  return llvm::ConstantInt::get(CGF.SizeTy, 0);
228 }
229 
230 /// Returns the adjustment, in bytes, required for the given
231 /// member-pointer operation. Returns null if no adjustment is
232 /// required.
234  assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
235  E->getCastKind() == CK_BaseToDerivedMemberPointer);
236 
237  QualType derivedType;
238  if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
239  derivedType = E->getSubExpr()->getType();
240  else
241  derivedType = E->getType();
242 
243  const CXXRecordDecl *derivedClass =
244  derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
245 
246  return CGM.GetNonVirtualBaseClassOffset(derivedClass,
247  E->path_begin(),
248  E->path_end());
249 }
250 
252  // TODO: Store base specifiers in APValue member pointer paths so we can
253  // easily reuse CGM.GetNonVirtualBaseClassOffset().
254  const ValueDecl *MPD = MP.getMemberPointerDecl();
257  bool DerivedMember = MP.isMemberPointerToDerivedMember();
258  const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
259  for (unsigned I = 0, N = Path.size(); I != N; ++I) {
260  const CXXRecordDecl *Base = RD;
261  const CXXRecordDecl *Derived = Path[I];
262  if (DerivedMember)
263  std::swap(Base, Derived);
264  ThisAdjustment +=
266  RD = Path[I];
267  }
268  if (DerivedMember)
269  ThisAdjustment = -ThisAdjustment;
270  return ThisAdjustment;
271 }
272 
273 llvm::BasicBlock *
275  const CXXRecordDecl *RD) {
277  llvm_unreachable("shouldn't be called in this ABI");
278 
279  ErrorUnsupportedABI(CGF, "complete object detection in ctor");
280  return nullptr;
281 }
282 
283 void CGCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
284  const CXXDestructorDecl *Dtor,
285  CXXDtorType DT) const {
286  // Assume the base C++ ABI has no special rules for destructor variants.
287  CGM.setDLLImportDLLExport(GV, Dtor);
288 }
289 
290 llvm::GlobalValue::LinkageTypes CGCXXABI::getCXXDestructorLinkage(
291  GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const {
292  // Delegate back to CGM by default.
293  return CGM.getLLVMLinkageForDeclarator(Dtor, Linkage,
294  /*IsConstantVariable=*/false);
295 }
296 
298  return false;
299 }
300 
301 llvm::CallInst *
303  llvm::Value *Exn) {
304  // Just call std::terminate and ignore the violating exception.
305  return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
306 }
307 
309  return CatchTypeInfo{nullptr, 0};
310 }
311 
312 std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
313  return std::vector<CharUnits>();
314 }
virtual llvm::Constant * EmitMemberPointer(const APValue &MP, QualType MPT)
Create a member pointer for the given member pointer constant.
Definition: CGCXXABI.cpp:112
A (possibly-)qualified type.
Definition: Type.h:643
virtual void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResultType)
Definition: CGCXXABI.cpp:156
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:232
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:840
QualType getThisType() const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:2264
virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition: CGCXXABI.cpp:283
const Type * getTypeForDecl() const
Definition: Decl.h:2931
const CGFunctionInfo & arrangeCXXMethodType(const CXXRecordDecl *RD, const FunctionProtoType *FTP, const CXXMethodDecl *MD)
Arrange the argument and result information for a call to an unknown C++ non-static member function o...
Definition: CGCall.cpp:250
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
Parameter for C++ &#39;this&#39; argument.
Definition: Decl.h:1515
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1297
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
virtual llvm::BasicBlock * EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, const CXXRecordDecl *RD)
Definition: CGCXXABI.cpp:274
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6851
A this pointer adjustment.
Definition: ABI.h:107
llvm::FunctionCallee getTerminateFn()
Get the declaration of std::terminate for the platform.
Definition: CGException.cpp:49
Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Given a pointer to i8, adjust it by a given constant offset.
Definition: CGBuilder.h:244
DiagnosticsEngine & getDiags() const
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
llvm::Value * getPointer() const
Definition: Address.h:37
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:23
unsigned getAddressSpace() const
Return the address space that this address resides in.
Definition: Address.h:56
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:772
virtual bool requiresArrayCookie(const CXXDeleteExpr *E, QualType eltType)
Definition: CGCXXABI.cpp:182
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1054
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
virtual bool isThisCompleteObject(GlobalDecl GD) const =0
Determine whether there&#39;s something special about the rules of the ABI tell us that &#39;this&#39; is a compl...
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:52
Expr * getSubExpr()
Definition: Expr.h:3173
IdentifierTable & Idents
Definition: ASTContext.h:569
virtual llvm::Value * EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E, Address Base, llvm::Value *MemPtr, const MemberPointerType *MPT)
Calculate an l-value from an object and a data member pointer.
Definition: CGCXXABI.cpp:58
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:156
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:37
bool doesUsualArrayDeleteWantSize() const
Answers whether the usual array deallocation function for the allocated type expects the size of the ...
Definition: ExprCXX.h:2296
bool hasConstructorVariants() const
Does this ABI have different entrypoints for complete-object and base-subobject constructors?
Definition: TargetCXXABI.h:214
path_iterator path_begin()
Definition: Expr.h:3193
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
const Type * getClass() const
Definition: Type.h:2822
virtual llvm::Value * EmitMemberPointerIsNotNull(CodeGenFunction &CGF, llvm::Value *MemPtr, const MemberPointerType *MPT)
Determine if a member pointer is non-null. Returns an i1.
Definition: CGCXXABI.cpp:90
CodeGenModule & CGM
Definition: CGCXXABI.h:45
ImplicitParamDecl * getThisDecl(CodeGenFunction &CGF)
Definition: CGCXXABI.h:52
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3121
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
virtual llvm::GlobalValue::LinkageTypes getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition: CGCXXABI.cpp:290
virtual llvm::Type * ConvertMemberPointerType(const MemberPointerType *MPT)
Find the LLVM type used to represent the given member pointer type.
Definition: CGCXXABI.cpp:36
virtual bool isZeroInitializable(const MemberPointerType *MPT)
Return true if the given member pointer can be zero-initialized (in the C++ sense) with an LLVM zeroi...
Definition: CGCXXABI.cpp:116
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:4560
bool hasAttr() const
Definition: DeclBase.h:542
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1636
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3719
virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr)
Returns the extra size required in order to store the array cookie for the given new-expression.
Definition: CGCXXABI.cpp:161
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:38
CXXDtorType
C++ destructor types.
Definition: ABI.h:33
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
This represents one expression.
Definition: Expr.h:108
static Address invalid()
Definition: Address.h:34
virtual CharUnits getArrayCookieSizeImpl(QualType elementType)
Returns the extra size required in order to store the array cookie for the given type.
Definition: CGCXXABI.cpp:167
virtual void ReadArrayCookie(CodeGenFunction &CGF, Address Ptr, const CXXDeleteExpr *expr, QualType ElementType, llvm::Value *&NumElements, llvm::Value *&AllocPtr, CharUnits &CookieSize)
Reads the array cookie associated with the given pointer, if it has one.
Definition: CGCXXABI.cpp:201
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:133
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2830
DeclContext * getDeclContext()
Definition: DeclBase.h:438
QualType getType() const
Definition: Expr.h:137
virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)
Create a member pointer for the given method.
Definition: CGCXXABI.cpp:102
ASTContext & getContext() const
Definition: CGCXXABI.h:80
void ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S)
Issue a diagnostic about unsupported features in the ABI.
Definition: CGCXXABI.cpp:22
const TargetInfo & getTarget() const
ASTContext & getContext() const
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:40
The l-value was considered opaque, so the alignment was determined from a type.
virtual llvm::Value * EmitMemberPointerConversion(CodeGenFunction &CGF, const CastExpr *E, llvm::Value *Src)
Perform a derived-to-base, base-to-derived, or bitcast member pointer conversion. ...
Definition: CGCXXABI.cpp:67
virtual bool NeedsVTTParameter(GlobalDecl GD)
Return whether the given global decl needs a VTT parameter.
Definition: CGCXXABI.cpp:297
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr)
Definition: CGCXXABI.cpp:150
CastKind getCastKind() const
Definition: Expr.h:3167
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:2000
const Decl * getDecl() const
Definition: GlobalDecl.h:76
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2114
virtual CatchTypeInfo getCatchAllTypeInfo()
Definition: CGCXXABI.cpp:308
QualType getAllocatedType() const
Definition: ExprCXX.h:2093
llvm::Value * loadIncomingCXXThis(CodeGenFunction &CGF)
Loads the incoming C++ this pointer as it was passed by the caller.
Definition: CGCXXABI.cpp:145
An aligned address.
Definition: Address.h:24
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1157
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:778
All available information about a concrete callee.
Definition: CGCall.h:66
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
Definition: CGCXXABI.cpp:98
bool isMemberPointerToDerivedMember() const
Definition: APValue.cpp:779
The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler...
Definition: CGCleanup.h:37
virtual Address InitializeArrayCookie(CodeGenFunction &CGF, Address NewPtr, llvm::Value *NumElements, const CXXNewExpr *expr, QualType ElementType)
Initialize the array cookie for the given allocation.
Definition: CGCXXABI.cpp:172
llvm::Constant * getMemberPointerAdjustment(const CastExpr *E)
A utility method for computing the offset required for the given base-to-derived or derived-to-base m...
Definition: CGCXXABI.cpp:233
FunctionArgList - Type for representing both the decl and type of parameters to a function...
Definition: CGCall.h:358
virtual llvm::Value * EmitMemberPointerComparison(CodeGenFunction &CGF, llvm::Value *L, llvm::Value *R, const MemberPointerType *MPT, bool Inequality)
Emit a comparison between two member pointers. Returns an i1.
Definition: CGCXXABI.cpp:80
Dataflow Directional Tag Classes.
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2260
virtual llvm::Value * readArrayCookieImpl(CodeGenFunction &IGF, Address ptr, CharUnits cookieSize)
Reads the array cookie for an allocation which is known to have one.
Definition: CGCXXABI.cpp:223
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:69
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2237
void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params)
Build a parameter variable suitable for &#39;this&#39;.
Definition: CGCXXABI.cpp:121
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2788
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:786
path_iterator path_end()
Definition: Expr.h:3194
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4438
virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)
Create a member pointer for the given field.
Definition: CGCXXABI.cpp:107
bool doesUsualArrayDeleteWantSize() const
Answers whether the usual array deallocation function for the allocated type expects the size of the ...
Definition: ExprCXX.h:2199
llvm::Constant * GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd)
Returns the offset from a derived class to a class.
Definition: CGClass.cpp:177
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:76
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
llvm::Type * ConvertType(QualType T)
virtual llvm::CallInst * emitTerminateForUnexpectedException(CodeGenFunction &CGF, llvm::Value *Exn)
Definition: CGCXXABI.cpp:302
virtual CGCallee EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E, Address This, llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr, const MemberPointerType *MPT)
Load a member function from an object and a member function pointer.
Definition: CGCXXABI.cpp:40
GVALinkage
A more specific kind of linkage than enum Linkage.
Definition: Linkage.h:73
virtual std::vector< CharUnits > getVBPtrOffsets(const CXXRecordDecl *RD)
Gets the offsets of all the virtual base pointers in a given class.
Definition: CGCXXABI.cpp:312
QualType getType() const
Definition: Decl.h:647
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
FullSourceLoc getFullLoc(SourceLocation Loc) const
Definition: ASTContext.h:722
llvm::Constant * GetBogusMemberPointer(QualType T)
Get a null value for unsupported member pointers.
Definition: CGCXXABI.cpp:31
llvm::GlobalValue::LinkageTypes getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable)
Returns LLVM linkage for a declarator.
SourceLocation getLocation() const
Definition: DeclBase.h:429
QualType getPointeeType() const
Definition: Type.h:2808
CharUnits getMemberPointerPathAdjustment(const APValue &MP)
Computes the non-virtual adjustment needed for a member pointer conversion along an inheritance path ...
Definition: CGCXXABI.cpp:251
void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1541