clang  14.0.0git
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 #include "clang/AST/Attr.h"
17 
18 using namespace clang;
19 using namespace CodeGen;
20 
22 
24  DiagnosticsEngine &Diags = CGF.CGM.getDiags();
25  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
26  "cannot yet compile %0 in this ABI");
28  DiagID)
29  << S;
30 }
31 
33  return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
34 }
35 
36 llvm::Type *
39 }
40 
42  CodeGenFunction &CGF, const Expr *E, Address This,
43  llvm::Value *&ThisPtrForCall,
44  llvm::Value *MemPtr, const MemberPointerType *MPT) {
45  ErrorUnsupportedABI(CGF, "calls through member pointers");
46 
47  ThisPtrForCall = This.getPointer();
48  const FunctionProtoType *FPT =
50  const auto *RD =
51  cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());
52  llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
53  CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
54  llvm::Constant *FnPtr = llvm::Constant::getNullValue(FTy->getPointerTo());
55  return CGCallee::forDirect(FnPtr, FPT);
56 }
57 
60  Address Base, llvm::Value *MemPtr,
61  const MemberPointerType *MPT) {
62  ErrorUnsupportedABI(CGF, "loads of member pointers");
63  llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())
64  ->getPointerTo(Base.getAddressSpace());
65  return llvm::Constant::getNullValue(Ty);
66 }
67 
69  const CastExpr *E,
70  llvm::Value *Src) {
71  ErrorUnsupportedABI(CGF, "member function pointer conversions");
72  return GetBogusMemberPointer(E->getType());
73 }
74 
76  llvm::Constant *Src) {
77  return GetBogusMemberPointer(E->getType());
78 }
79 
82  llvm::Value *L,
83  llvm::Value *R,
84  const MemberPointerType *MPT,
85  bool Inequality) {
86  ErrorUnsupportedABI(CGF, "member function pointer comparison");
87  return CGF.Builder.getFalse();
88 }
89 
92  llvm::Value *MemPtr,
93  const MemberPointerType *MPT) {
94  ErrorUnsupportedABI(CGF, "member function pointer null testing");
95  return CGF.Builder.getFalse();
96 }
97 
98 llvm::Constant *
100  return GetBogusMemberPointer(QualType(MPT, 0));
101 }
102 
105  MD->getType(), MD->getParent()->getTypeForDecl()));
106 }
107 
109  CharUnits offset) {
110  return GetBogusMemberPointer(QualType(MPT, 0));
111 }
112 
113 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
114  return GetBogusMemberPointer(MPT);
115 }
116 
118  // Fake answer.
119  return true;
120 }
121 
123  const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
124 
125  // FIXME: I'm not entirely sure I like using a fake decl just for code
126  // generation. Maybe we can come up with a better way?
127  auto *ThisDecl = ImplicitParamDecl::Create(
128  CGM.getContext(), nullptr, MD->getLocation(),
129  &CGM.getContext().Idents.get("this"), MD->getThisType(),
131  params.push_back(ThisDecl);
132  CGF.CXXABIThisDecl = ThisDecl;
133 
134  // Compute the presumed alignment of 'this', which basically comes
135  // down to whether we know it's a complete object or not.
136  auto &Layout = CGF.getContext().getASTRecordLayout(MD->getParent());
137  if (MD->getParent()->getNumVBases() == 0 || // avoid vcall in common case
138  MD->getParent()->isEffectivelyFinal() ||
140  CGF.CXXABIThisAlignment = Layout.getAlignment();
141  } else {
142  CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
143  }
144 }
145 
147  return CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
148  "this");
149 }
150 
152  /// Initialize the 'this' slot.
153  assert(getThisDecl(CGF) && "no 'this' variable for function");
154  CGF.CXXABIThisValue = ThisPtr;
155 }
156 
158  RValue RV, QualType ResultType) {
159  assert(!CGF.hasAggregateEvaluationKind(ResultType) &&
160  "cannot handle aggregates");
161  CGF.EmitReturnOfRValue(RV, ResultType);
162 }
163 
166  return CharUnits::Zero();
167  return getArrayCookieSizeImpl(expr->getAllocatedType());
168 }
169 
171  // BOGUS
172  return CharUnits::Zero();
173 }
174 
176  Address NewPtr,
177  llvm::Value *NumElements,
178  const CXXNewExpr *expr,
179  QualType ElementType) {
180  // Should never be called.
181  ErrorUnsupportedABI(CGF, "array cookie initialization");
182  return Address::invalid();
183 }
184 
186  QualType elementType) {
187  // If the class's usual deallocation function takes two arguments,
188  // it needs a cookie.
189  if (expr->doesUsualArrayDeleteWantSize())
190  return true;
191 
192  return elementType.isDestructedType();
193 }
194 
196  // If the class's usual deallocation function takes two arguments,
197  // it needs a cookie.
198  if (expr->doesUsualArrayDeleteWantSize())
199  return true;
200 
201  return expr->getAllocatedType().isDestructedType();
202 }
203 
205  const CXXDeleteExpr *expr, QualType eltTy,
206  llvm::Value *&numElements,
207  llvm::Value *&allocPtr, CharUnits &cookieSize) {
208  // Derive a char* in the same address space as the pointer.
209  ptr = CGF.Builder.CreateElementBitCast(ptr, CGF.Int8Ty);
210 
211  // If we don't need an array cookie, bail out early.
212  if (!requiresArrayCookie(expr, eltTy)) {
213  allocPtr = ptr.getPointer();
214  numElements = nullptr;
215  cookieSize = CharUnits::Zero();
216  return;
217  }
218 
219  cookieSize = getArrayCookieSizeImpl(eltTy);
220  Address allocAddr =
221  CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize);
222  allocPtr = allocAddr.getPointer();
223  numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize);
224 }
225 
227  Address ptr,
228  CharUnits cookieSize) {
229  ErrorUnsupportedABI(CGF, "reading a new[] cookie");
230  return llvm::ConstantInt::get(CGF.SizeTy, 0);
231 }
232 
233 /// Returns the adjustment, in bytes, required for the given
234 /// member-pointer operation. Returns null if no adjustment is
235 /// required.
237  assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
238  E->getCastKind() == CK_BaseToDerivedMemberPointer);
239 
240  QualType derivedType;
241  if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
242  derivedType = E->getSubExpr()->getType();
243  else
244  derivedType = E->getType();
245 
246  const CXXRecordDecl *derivedClass =
247  derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
248 
249  return CGM.GetNonVirtualBaseClassOffset(derivedClass,
250  E->path_begin(),
251  E->path_end());
252 }
253 
254 llvm::BasicBlock *
256  const CXXRecordDecl *RD) {
258  llvm_unreachable("shouldn't be called in this ABI");
259 
260  ErrorUnsupportedABI(CGF, "complete object detection in ctor");
261  return nullptr;
262 }
263 
264 void CGCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
265  const CXXDestructorDecl *Dtor,
266  CXXDtorType DT) const {
267  // Assume the base C++ ABI has no special rules for destructor variants.
268  CGM.setDLLImportDLLExport(GV, Dtor);
269 }
270 
271 llvm::GlobalValue::LinkageTypes CGCXXABI::getCXXDestructorLinkage(
272  GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const {
273  // Delegate back to CGM by default.
275  /*IsConstantVariable=*/false);
276 }
277 
279  return false;
280 }
281 
282 llvm::CallInst *
284  llvm::Value *Exn) {
285  // Just call std::terminate and ignore the violating exception.
286  return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
287 }
288 
290  return CatchTypeInfo{nullptr, 0};
291 }
292 
293 std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
294  return std::vector<CharUnits>();
295 }
296 
299  bool ForVirtualBase, bool Delegating, CallArgList &Args) {
300  AddedStructorArgs AddedArgs =
301  getImplicitConstructorArgs(CGF, D, Type, ForVirtualBase, Delegating);
302  for (size_t i = 0; i < AddedArgs.Prefix.size(); ++i) {
303  Args.insert(Args.begin() + 1 + i,
304  CallArg(RValue::get(AddedArgs.Prefix[i].Value),
305  AddedArgs.Prefix[i].Type));
306  }
307  for (const auto &arg : AddedArgs.Suffix) {
308  Args.add(RValue::get(arg.Value), arg.Type);
309  }
310  return AddedStructorArgCounts(AddedArgs.Prefix.size(),
311  AddedArgs.Suffix.size());
312 }
clang::CodeGen::CGCXXABI::ReadArrayCookie
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:204
clang::CXXMethodDecl::getThisType
QualType getThisType() const
Return the type of the this pointer.
Definition: DeclCXX.cpp:2451
clang::CodeGen::CodeGenTypeCache::SizeTy
llvm::IntegerType * SizeTy
Definition: CodeGenTypeCache.h:50
clang::CodeGen::CGCXXABI::getCXXDestructorLinkage
virtual llvm::GlobalValue::LinkageTypes getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition: CGCXXABI.cpp:271
clang::CXXConstructorDecl
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2401
clang::CodeGen::CGCXXABI::EmitMemberPointerConversion
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:68
clang::CodeGen::RValue
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
Definition: CGValue.h:39
clang::CXXRecordDecl::isEffectivelyFinal
bool isEffectivelyFinal() const
Determine whether it's impossible for a class to be derived from this class.
Definition: DeclCXX.cpp:2020
clang::ImplicitParamDecl::CXXThis
@ CXXThis
Parameter for C++ 'this' argument.
Definition: Decl.h:1616
clang::CodeGen::CGCXXABI::EmitMemberFunctionPointer
virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)
Create a member pointer for the given method.
Definition: CGCXXABI.cpp:103
clang::CodeGen::CGCXXABI::ErrorUnsupportedABI
void ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S)
Issue a diagnostic about unsupported features in the ABI.
Definition: CGCXXABI.cpp:23
clang::CodeGen::CodeGenFunction::CurCodeDecl
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
Definition: CodeGenFunction.h:327
clang::CodeGen::CodeGenFunction::EmitNounwindRuntimeCall
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
clang::IdentifierTable::get
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Definition: IdentifierTable.h:592
clang::CodeGen::CGCXXABI::AddedStructorArgs
Additional implicit arguments to add to the beginning (Prefix) and end (Suffix) of a constructor / de...
Definition: CGCXXABI.h:299
clang::CastExpr::getSubExpr
Expr * getSubExpr()
Definition: Expr.h:3524
clang::ASTContext::getFullLoc
FullSourceLoc getFullLoc(SourceLocation Loc) const
Definition: ASTContext.h:785
clang::CodeGen::CGCXXABI::NeedsVTTParameter
virtual bool NeedsVTTParameter(GlobalDecl GD)
Return whether the given global decl needs a VTT parameter.
Definition: CGCXXABI.cpp:278
clang::CodeGen::CGCXXABI::InitializeArrayCookie
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:175
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
clang::TypeDecl::getTypeForDecl
const Type * getTypeForDecl() const
Definition: Decl.h:3162
Attr.h
clang::GVALinkage
GVALinkage
A more specific kind of linkage than enum Linkage.
Definition: Linkage.h:73
clang::CodeGen::CodeGenModule::getContext
ASTContext & getContext() const
Definition: CodeGenModule.h:702
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:191
clang::CodeGen::CodeGenModule::getLLVMLinkageForDeclarator
llvm::GlobalValue::LinkageTypes getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable)
Returns LLVM linkage for a declarator.
Definition: CodeGenModule.cpp:4643
clang::CodeGen::CGCXXABI::getMemberPointerAdjustment
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:236
clang::CodeGen::CGCXXABI::setCXXABIThisValue
void setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr)
Definition: CGCXXABI.cpp:151
clang::TargetInfo::getCXXABI
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1203
clang::CXXNewExpr
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2139
clang::CodeGen::CallArgList::add
void add(RValue rvalue, QualType type)
Definition: CGCall.h:288
clang::CodeGen::CodeGenFunction::Builder
CGBuilderTy Builder
Definition: CodeGenFunction.h:274
clang::CodeGen::CodeGenTypes::ConvertType
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Definition: CodeGenTypes.cpp:395
clang::CodeGen::CodeGenModule::setDLLImportDLLExport
void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const
Definition: CodeGenModule.cpp:1104
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1490
clang::CodeGen::CodeGenFunction::GetAddrOfLocalVar
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
Definition: CodeGenFunction.h:2679
clang::GlobalDecl
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:55
clang::CodeGen::CGCXXABI::getCatchAllTypeInfo
virtual CatchTypeInfo getCatchAllTypeInfo()
Definition: CGCXXABI.cpp:289
clang::CodeGen::CGCXXABI::readArrayCookieImpl
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:226
clang::CodeGen::CGCXXABI::loadIncomingCXXThis
llvm::Value * loadIncomingCXXThis(CodeGenFunction &CGF)
Loads the incoming C++ this pointer as it was passed by the caller.
Definition: CGCXXABI.cpp:146
clang::CodeGen::CGCXXABI::buildThisParam
void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params)
Build a parameter variable suitable for 'this'.
Definition: CGCXXABI.cpp:122
clang::CodeGen::CGCXXABI::EmitNullMemberPointer
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
Definition: CGCXXABI.cpp:99
clang::ast_matchers::expr
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchersInternal.cpp:889
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4613
clang::CXXCtorType
CXXCtorType
C++ constructor types.
Definition: ABI.h:24
clang::CodeGen::CGCXXABI::EmitMemberPointerComparison
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:81
clang::CodeGen::CGCXXABI::getImplicitConstructorArgs
virtual AddedStructorArgs getImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating)=0
clang::Linkage
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition: Linkage.h:23
clang::CodeGen::CGCXXABI::EmitMemberDataPointer
virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)
Create a member pointer for the given field.
Definition: CGCXXABI.cpp:108
clang::CodeGen::CGCXXABI::addImplicitConstructorArgs
AddedStructorArgCounts addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, CallArgList &Args)
Add any ABI-specific implicit arguments needed to call a constructor.
Definition: CGCXXABI.cpp:297
clang::CXXDtorType
CXXDtorType
C++ destructor types.
Definition: ABI.h:33
clang::MemberPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2847
CGCleanup.h
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7162
clang::DiagnosticsEngine::Error
@ Error
Definition: Diagnostic.h:199
clang::CastExpr::path_begin
path_iterator path_begin()
Definition: Expr.h:3544
clang::CXXDestructorDecl
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2668
clang::CodeGen::CGCXXABI::EmitLoadOfMemberFunctionPointer
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:41
clang::CodeGen::CGCXXABI::~CGCXXABI
virtual ~CGCXXABI()
Definition: CGCXXABI.cpp:21
clang::CodeGen::CodeGenModule::getTypes
CodeGenTypes & getTypes()
Definition: CodeGenModule.h:726
clang::Type::getAsCXXRecordDecl
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1753
clang::CodeGen::CGCXXABI::getVBPtrOffsets
virtual std::vector< CharUnits > getVBPtrOffsets(const CXXRecordDecl *RD)
Gets the offsets of all the virtual base pointers in a given class.
Definition: CGCXXABI.cpp:293
clang::CodeGen::CGBuilderTy::CreateConstInBoundsByteGEP
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:254
clang::CodeGen::CodeGenFunction::getContext
ASTContext & getContext() const
Definition: CodeGenFunction.h:1947
clang::MemberPointerType::getClass
const Type * getClass() const
Definition: Type.h:2861
clang::CharUnits::Zero
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
clang::CodeGen::Address
An aligned address.
Definition: Address.h:24
Base
clang::CodeGen::CGCXXABI::GetBogusMemberPointer
llvm::Constant * GetBogusMemberPointer(QualType T)
Get a null value for unsupported member pointers.
Definition: CGCXXABI.cpp:32
clang::CastExpr::getCastKind
CastKind getCastKind() const
Definition: Expr.h:3518
clang::CodeGen::CGCallee::forDirect
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:135
clang::CodeGen::CodeGenModule::getTarget
const TargetInfo & getTarget() const
Definition: CodeGenModule.h:714
clang::CodeGen::CGCXXABI::setCXXDestructorDLLStorage
virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition: CGCXXABI.cpp:264
clang::CodeGen::CodeGenFunction::CurGD
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
Definition: CodeGenFunction.h:350
clang::CodeGen::CGCXXABI::emitTerminateForUnexpectedException
virtual llvm::CallInst * emitTerminateForUnexpectedException(CodeGenFunction &CGF, llvm::Value *Exn)
Definition: CGCXXABI.cpp:283
clang::CodeGen::CodeGenTypes::GetFunctionType
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1595
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7227
clang::CodeGen::CGCXXABI::EmitMemberPointer
virtual llvm::Constant * EmitMemberPointer(const APValue &MP, QualType MPT)
Create a member pointer for the given member pointer constant.
Definition: CGCXXABI.cpp:113
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:255
clang::CodeGen::CodeGenTypes::arrangeCXXMethodType
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:255
clang::CodeGen::CodeGenModule::getTerminateFn
llvm::FunctionCallee getTerminateFn()
Get the declaration of std::terminate for the platform.
Definition: CGException.cpp:63
clang::CXXRecordDecl::getNumVBases
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:604
clang::CodeGen::Address::getPointer
llvm::Value * getPointer() const
Definition: Address.h:37
clang::CodeGen::CodeGenFunction
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Definition: CodeGenFunction.h:235
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3885
clang::ASTContext::Idents
IdentifierTable & Idents
Definition: ASTContext.h:648
clang::CodeGen::CGCXXABI::AddedStructorArgCounts
Similar to AddedStructorArgs, but only notes the number of additional arguments.
Definition: CGCXXABI.h:319
clang::CodeGen::CodeGenModule::GetNonVirtualBaseClassOffset
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:196
clang::CXXDeleteExpr
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2398
Value
Value
Definition: UninitializedValues.cpp:102
clang::CastExpr::path_end
path_iterator path_end()
Definition: Expr.h:3545
clang::CodeGen::CGCXXABI::requiresArrayCookie
virtual bool requiresArrayCookie(const CXXDeleteExpr *E, QualType eltType)
Definition: CGCXXABI.cpp:185
clang::CodeGen::Address::invalid
static Address invalid()
Definition: Address.h:34
clang::CodeGen::CGCallee
All available information about a concrete callee.
Definition: CGCall.h:67
clang::CodeGen::FunctionArgList
FunctionArgList - Type for representing both the decl and type of parameters to a function.
Definition: CGCall.h:358
clang::CodeGen::CGCXXABI::AddedStructorArgs::Suffix
SmallVector< Arg, 1 > Suffix
Definition: CGCXXABI.h:305
clang::CodeGen::CodeGenFunction::ConvertType
llvm::Type * ConvertType(QualType T)
Definition: CodeGenFunction.cpp:211
clang::CodeGen::CGCXXABI::CGM
CodeGenModule & CGM
Definition: CGCXXABI.h:46
clang::CodeGen::CGCXXABI::EmitReturnFromThunk
virtual void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResultType)
Definition: CGCXXABI.cpp:157
clang::CodeGen::CGCXXABI::EmitMemberPointerIsNotNull
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:91
clang::CodeGen::CodeGenFunction::hasAggregateEvaluationKind
static bool hasAggregateEvaluationKind(QualType T)
Definition: CodeGenFunction.h:2389
clang::TargetCXXABI::hasConstructorVariants
bool hasConstructorVariants() const
Does this ABI have different entrypoints for complete-object and base-subobject constructors?
Definition: TargetCXXABI.h:196
clang::CodeGen::CGBuilderTy::CreateElementBitCast
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:166
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2831
CGCXXABI.h
clang::CodeGen::CGCXXABI::ConvertMemberPointerType
virtual llvm::Type * ConvertMemberPointerType(const MemberPointerType *MPT)
Find the LLVM type used to represent the given member pointer type.
Definition: CGCXXABI.cpp:37
clang::CodeGen::CGCXXABI::EmitMemberDataPointerAddress
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:59
clang::CodeGen::CodeGenFunction::CGM
CodeGenModule & CGM
Definition: CodeGenFunction.h:266
clang::interp::This
bool This(InterpState &S, CodePtr OpPC)
Definition: Interp.h:829
clang::ImplicitParamDecl::Create
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:4869
clang::DiagnosticsEngine::getCustomDiagID
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:866
clang
Definition: CalledOnceCheck.h:17
clang::CodeGen::CGCXXABI::EmitCtorCompleteObjectHandler
virtual llvm::BasicBlock * EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, const CXXRecordDecl *RD)
Definition: CGCXXABI.cpp:255
clang::CodeGen::RValue::get
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
clang::CodeGen::CatchTypeInfo
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
std::arg
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
Definition: complex_cmath.h:40
clang::Expr::getType
QualType getType() const
Definition: Expr.h:141
clang::CodeGen::CodeGenModule::getDiags
DiagnosticsEngine & getDiags() const
Definition: CodeGenModule.h:710
clang::ASTContext::getPointerDiffType
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
Definition: ASTContext.cpp:5756
clang::ASTContext::getASTRecordLayout
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
Definition: RecordLayoutBuilder.cpp:3246
clang::GlobalDecl::getDecl
const Decl * getDecl() const
Definition: GlobalDecl.h:102
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4623
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:687
clang::CodeGen::CallArg
Definition: CGCall.h:219
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::CodeGen::CGCXXABI::isThisCompleteObject
virtual bool isThisCompleteObject(GlobalDecl GD) const =0
Determine whether there's something special about the rules of the ABI tell us that 'this' is a compl...
clang::QualType::isDestructedType
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
Definition: Type.h:1214
clang::CodeGen::CodeGenTypeCache::Int8Ty
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Definition: CodeGenTypeCache.h:37
clang::CodeGen::CGCXXABI::getArrayCookieSizeImpl
virtual CharUnits getArrayCookieSizeImpl(QualType elementType)
Returns the extra size required in order to store the array cookie for the given type.
Definition: CGCXXABI.cpp:170
clang::CastExpr
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3473
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:430
clang::CodeGen::CallArgList
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:264
clang::CodeGen::CGCXXABI::isZeroInitializable
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:117
clang::CodeGen::CGCXXABI::GetArrayCookieSize
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:164
clang::CodeGen::CGCXXABI::AddedStructorArgs::Prefix
SmallVector< Arg, 1 > Prefix
Definition: CGCXXABI.h:304
clang::ASTContext::getMemberPointerType
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 ...
Definition: ASTContext.cpp:3442
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1523
clang::CodeGen::CGCXXABI::getThisDecl
ImplicitParamDecl * getThisDecl(CodeGenFunction &CGF)
Definition: CGCXXABI.h:53
clang::CodeGen::CGBuilderTy::CreateLoad
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:68
clang::CXXMethodDecl::getParent
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2063
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1948