clang 19.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
18using namespace clang;
19using 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
36llvm::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 auto *FPT = MPT->getPointeeType()->castAs<FunctionProtoType>();
49 llvm::Constant *FnPtr = llvm::Constant::getNullValue(
50 llvm::PointerType::getUnqual(CGM.getLLVMContext()));
51 return CGCallee::forDirect(FnPtr, FPT);
52}
53
54llvm::Value *
56 Address Base, llvm::Value *MemPtr,
57 const MemberPointerType *MPT) {
58 ErrorUnsupportedABI(CGF, "loads of member pointers");
59 llvm::Type *Ty =
60 llvm::PointerType::get(CGF.getLLVMContext(), Base.getAddressSpace());
61 return llvm::Constant::getNullValue(Ty);
62}
63
65 const CastExpr *E,
66 llvm::Value *Src) {
67 ErrorUnsupportedABI(CGF, "member function pointer conversions");
68 return GetBogusMemberPointer(E->getType());
69}
70
72 llvm::Constant *Src) {
73 return GetBogusMemberPointer(E->getType());
74}
75
76llvm::Value *
78 llvm::Value *L,
79 llvm::Value *R,
80 const MemberPointerType *MPT,
81 bool Inequality) {
82 ErrorUnsupportedABI(CGF, "member function pointer comparison");
83 return CGF.Builder.getFalse();
84}
85
86llvm::Value *
88 llvm::Value *MemPtr,
89 const MemberPointerType *MPT) {
90 ErrorUnsupportedABI(CGF, "member function pointer null testing");
91 return CGF.Builder.getFalse();
92}
93
94llvm::Constant *
96 return GetBogusMemberPointer(QualType(MPT, 0));
97}
98
101 MD->getType(), MD->getParent()->getTypeForDecl()));
102}
103
105 CharUnits offset) {
106 return GetBogusMemberPointer(QualType(MPT, 0));
107}
108
109llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
110 return GetBogusMemberPointer(MPT);
111}
112
114 // Fake answer.
115 return true;
116}
117
119 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
120
121 // FIXME: I'm not entirely sure I like using a fake decl just for code
122 // generation. Maybe we can come up with a better way?
123 auto *ThisDecl =
125 &CGM.getContext().Idents.get("this"),
127 params.push_back(ThisDecl);
128 CGF.CXXABIThisDecl = ThisDecl;
129
130 // Compute the presumed alignment of 'this', which basically comes
131 // down to whether we know it's a complete object or not.
132 auto &Layout = CGF.getContext().getASTRecordLayout(MD->getParent());
133 if (MD->getParent()->getNumVBases() == 0 || // avoid vcall in common case
134 MD->getParent()->isEffectivelyFinal() ||
136 CGF.CXXABIThisAlignment = Layout.getAlignment();
137 } else {
138 CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
139 }
140}
141
143 return CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
144 "this");
145}
146
147void CGCXXABI::setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr) {
148 /// Initialize the 'this' slot.
149 assert(getThisDecl(CGF) && "no 'this' variable for function");
150 CGF.CXXABIThisValue = ThisPtr;
151}
152
154 if (VD->needsDestruction(getContext()))
155 return true;
156
157 // If the variable has an incomplete class type (or array thereof), it
158 // might need destruction.
159 const Type *T = VD->getType()->getBaseElementTypeUnsafe();
160 if (T->getAs<RecordType>() && T->isIncompleteType())
161 return true;
162
163 return false;
164}
165
167 const VarDecl *VD, bool InspectInitForWeakDef) const {
168 VD = VD->getMostRecentDecl();
169 if (VD->hasAttr<ConstInitAttr>())
170 return true;
171
172 // All later checks examine the initializer specified on the variable. If
173 // the variable is weak, such examination would not be correct.
174 if (!InspectInitForWeakDef && (VD->isWeak() || VD->hasAttr<SelectAnyAttr>()))
175 return false;
176
177 const VarDecl *InitDecl = VD->getInitializingDeclaration();
178 if (!InitDecl)
179 return false;
180
181 // If there's no initializer to run, this is constant initialization.
182 if (!InitDecl->hasInit())
183 return true;
184
185 // If we have the only definition, we don't need a thread wrapper if we
186 // will emit the value as a constant.
187 if (isUniqueGVALinkage(getContext().GetGVALinkageForVariable(VD)))
188 return !mayNeedDestruction(VD) && InitDecl->evaluateValue();
189
190 // Otherwise, we need a thread wrapper unless we know that every
191 // translation unit will emit the value as a constant. We rely on the
192 // variable being constant-initialized in every translation unit if it's
193 // constant-initialized in any translation unit, which isn't actually
194 // guaranteed by the standard but is necessary for sanity.
195 return InitDecl->hasConstantInitialization();
196}
197
199 RValue RV, QualType ResultType) {
200 assert(!CGF.hasAggregateEvaluationKind(ResultType) &&
201 "cannot handle aggregates");
202 CGF.EmitReturnOfRValue(RV, ResultType);
203}
204
207 return CharUnits::Zero();
208 return getArrayCookieSizeImpl(expr->getAllocatedType());
209}
210
212 // BOGUS
213 return CharUnits::Zero();
214}
215
217 Address NewPtr,
218 llvm::Value *NumElements,
219 const CXXNewExpr *expr,
220 QualType ElementType) {
221 // Should never be called.
222 ErrorUnsupportedABI(CGF, "array cookie initialization");
223 return Address::invalid();
224}
225
227 QualType elementType) {
228 // If the class's usual deallocation function takes two arguments,
229 // it needs a cookie.
230 if (expr->doesUsualArrayDeleteWantSize())
231 return true;
232
233 return elementType.isDestructedType();
234}
235
237 // If the class's usual deallocation function takes two arguments,
238 // it needs a cookie.
239 if (expr->doesUsualArrayDeleteWantSize())
240 return true;
241
242 return expr->getAllocatedType().isDestructedType();
243}
244
246 const CXXDeleteExpr *expr, QualType eltTy,
247 llvm::Value *&numElements,
248 llvm::Value *&allocPtr, CharUnits &cookieSize) {
249 // Derive a char* in the same address space as the pointer.
250 ptr = ptr.withElementType(CGF.Int8Ty);
251
252 // If we don't need an array cookie, bail out early.
253 if (!requiresArrayCookie(expr, eltTy)) {
254 allocPtr = ptr.getPointer();
255 numElements = nullptr;
256 cookieSize = CharUnits::Zero();
257 return;
258 }
259
260 cookieSize = getArrayCookieSizeImpl(eltTy);
261 Address allocAddr =
262 CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize);
263 allocPtr = allocAddr.getPointer();
264 numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize);
265}
266
268 Address ptr,
269 CharUnits cookieSize) {
270 ErrorUnsupportedABI(CGF, "reading a new[] cookie");
271 return llvm::ConstantInt::get(CGF.SizeTy, 0);
272}
273
274/// Returns the adjustment, in bytes, required for the given
275/// member-pointer operation. Returns null if no adjustment is
276/// required.
278 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
279 E->getCastKind() == CK_BaseToDerivedMemberPointer);
280
281 QualType derivedType;
282 if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
283 derivedType = E->getSubExpr()->getType();
284 else
285 derivedType = E->getType();
286
287 const CXXRecordDecl *derivedClass =
288 derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
289
290 return CGM.GetNonVirtualBaseClassOffset(derivedClass,
291 E->path_begin(),
292 E->path_end());
293}
294
295llvm::BasicBlock *
297 const CXXRecordDecl *RD) {
299 llvm_unreachable("shouldn't be called in this ABI");
300
301 ErrorUnsupportedABI(CGF, "complete object detection in ctor");
302 return nullptr;
303}
304
305void CGCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
306 const CXXDestructorDecl *Dtor,
307 CXXDtorType DT) const {
308 // Assume the base C++ ABI has no special rules for destructor variants.
309 CGM.setDLLImportDLLExport(GV, Dtor);
310}
311
312llvm::GlobalValue::LinkageTypes CGCXXABI::getCXXDestructorLinkage(
313 GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const {
314 // Delegate back to CGM by default.
316}
317
319 return false;
320}
321
322llvm::CallInst *
324 llvm::Value *Exn) {
325 // Just call std::terminate and ignore the violating exception.
327}
328
330 return CatchTypeInfo{nullptr, 0};
331}
332
333std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
334 return std::vector<CharUnits>();
335}
336
339 bool ForVirtualBase, bool Delegating, CallArgList &Args) {
340 AddedStructorArgs AddedArgs =
341 getImplicitConstructorArgs(CGF, D, Type, ForVirtualBase, Delegating);
342 for (size_t i = 0; i < AddedArgs.Prefix.size(); ++i) {
343 Args.insert(Args.begin() + 1 + i,
344 CallArg(RValue::get(AddedArgs.Prefix[i].Value),
345 AddedArgs.Prefix[i].Type));
346 }
347 for (const auto &arg : AddedArgs.Suffix) {
348 Args.add(RValue::get(arg.Value), arg.Type);
349 }
350 return AddedStructorArgCounts(AddedArgs.Prefix.size(),
351 AddedArgs.Suffix.size());
352}
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
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 ...
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
FullSourceLoc getFullLoc(SourceLocation Loc) const
Definition: ASTContext.h:790
IdentifierTable & Idents
Definition: ASTContext.h:639
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2528
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2481
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2792
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2053
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2179
QualType getThisType() const
Return the type of the this pointer.
Definition: DeclCXX.cpp:2550
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2224
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
bool isEffectivelyFinal() const
Determine whether it's impossible for a class to be derived from this class.
Definition: DeclCXX.cpp:2112
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:633
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3465
path_iterator path_begin()
Definition: Expr.h:3535
CastKind getCastKind() const
Definition: Expr.h:3509
path_iterator path_end()
Definition: Expr.h:3536
Expr * getSubExpr()
Definition: Expr.h:3515
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
An aligned address.
Definition: Address.h:29
static Address invalid()
Definition: Address.h:46
Address withElementType(llvm::Type *ElemTy) const
Return address with different element type, but same pointer and alignment.
Definition: Address.h:100
llvm::Value * getPointer() const
Definition: Address.h:51
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:259
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:71
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:277
virtual std::vector< CharUnits > getVBPtrOffsets(const CXXRecordDecl *RD)
Gets the offsets of all the virtual base pointers in a given class.
Definition: CGCXXABI.cpp:333
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:245
CodeGenModule & CGM
Definition: CGCXXABI.h:47
virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition: CGCXXABI.cpp:305
virtual bool NeedsVTTParameter(GlobalDecl GD)
Return whether the given global decl needs a VTT parameter.
Definition: CGCXXABI.cpp:318
virtual llvm::CallInst * emitTerminateForUnexpectedException(CodeGenFunction &CGF, llvm::Value *Exn)
Definition: CGCXXABI.cpp:323
ImplicitParamDecl * getThisDecl(CodeGenFunction &CGF)
Definition: CGCXXABI.h:54
virtual llvm::Type * ConvertMemberPointerType(const MemberPointerType *MPT)
Find the LLVM type used to represent the given member pointer type.
Definition: CGCXXABI.cpp:37
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
Definition: CGCXXABI.cpp:95
virtual CharUnits getArrayCookieSizeImpl(QualType elementType)
Returns the extra size required in order to store the array cookie for the given type.
Definition: CGCXXABI.cpp:211
virtual void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResultType)
Definition: CGCXXABI.cpp:198
void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params)
Build a parameter variable suitable for 'this'.
Definition: CGCXXABI.cpp:118
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:87
bool isEmittedWithConstantInitializer(const VarDecl *VD, bool InspectInitForWeakDef=false) const
Determine whether we will definitely emit this variable with a constant initializer,...
Definition: CGCXXABI.cpp:166
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:77
virtual llvm::Constant * EmitMemberPointer(const APValue &MP, QualType MPT)
Create a member pointer for the given member pointer constant.
Definition: CGCXXABI.cpp:109
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:267
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:55
virtual bool requiresArrayCookie(const CXXDeleteExpr *E, QualType eltType)
Definition: CGCXXABI.cpp:226
virtual CatchTypeInfo getCatchAllTypeInfo()
Definition: CGCXXABI.cpp:329
bool mayNeedDestruction(const VarDecl *VD) const
Definition: CGCXXABI.cpp:153
virtual llvm::BasicBlock * EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, const CXXRecordDecl *RD)
Definition: CGCXXABI.cpp:296
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...
void setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr)
Definition: CGCXXABI.cpp:147
llvm::Value * loadIncomingCXXThis(CodeGenFunction &CGF)
Loads the incoming C++ this pointer as it was passed by the caller.
Definition: CGCXXABI.cpp:142
void ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S)
Issue a diagnostic about unsupported features in the ABI.
Definition: CGCXXABI.cpp:23
virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)
Create a member pointer for the given field.
Definition: CGCXXABI.cpp:104
llvm::Constant * GetBogusMemberPointer(QualType T)
Get a null value for unsupported member pointers.
Definition: CGCXXABI.cpp:32
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
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:205
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:113
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:337
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:64
virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)
Create a member pointer for the given method.
Definition: CGCXXABI.cpp:99
virtual llvm::GlobalValue::LinkageTypes getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition: CGCXXABI.cpp:312
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:216
ASTContext & getContext() const
Definition: CGCXXABI.h:85
virtual AddedStructorArgs getImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating)=0
All available information about a concrete callee.
Definition: CGCall.h:62
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:129
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:258
void add(RValue rvalue, QualType type)
Definition: CGCall.h:282
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
static bool hasAggregateEvaluationKind(QualType T)
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
llvm::LLVMContext & getLLVMContext()
DiagnosticsEngine & getDiags() const
llvm::GlobalValue::LinkageTypes getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage)
Returns LLVM linkage for a declarator.
const TargetInfo & getTarget() const
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:199
ASTContext & getContext() const
llvm::FunctionCallee getTerminateFn()
Get the declaration of std::terminate for the platform.
Definition: CGException.cpp:63
llvm::LLVMContext & getLLVMContext()
void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
FunctionArgList - Type for representing both the decl and type of parameters to a function.
Definition: CGCall.h:352
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
Definition: CGValue.h:39
static RValue get(llvm::Value *V)
Definition: CGValue.h:89
SourceLocation getLocation() const
Definition: DeclBase.h:444
bool hasAttr() const
Definition: DeclBase.h:582
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1547
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:873
This represents one expression.
Definition: Expr.h:110
QualType getType() const
Definition: Expr.h:142
Represents a prototype with parameter type info, e.g.
Definition: Type.h:4198
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
const Decl * getDecl() const
Definition: GlobalDecl.h:103
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:5322
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:3088
QualType getPointeeType() const
Definition: Type.h:3104
A (possibly-)qualified type.
Definition: Type.h:737
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
Definition: Type.h:1323
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:5091
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:226
bool hasConstructorVariants() const
Does this ABI have different entrypoints for complete-object and base-subobject constructors?
Definition: TargetCXXABI.h:194
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1290
const Type * getTypeForDecl() const
Definition: Decl.h:3381
The base class of the type hierarchy.
Definition: Type.h:1606
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1819
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7719
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:7602
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Definition: Type.cpp:2299
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7652
QualType getType() const
Definition: Decl.h:717
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
Definition: Decl.cpp:5308
Represents a variable declaration or definition.
Definition: Decl.h:918
bool hasInit() const
Definition: Decl.cpp:2395
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2546
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
Definition: Decl.cpp:2616
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition: Decl.cpp:2810
VarDecl * getInitializingDeclaration()
Get the initializing declaration of this variable, if any.
Definition: Decl.cpp:2423
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
Definition: ABI.h:24
GVALinkage
A more specific kind of linkage than enum Linkage.
Definition: Linkage.h:72
bool isUniqueGVALinkage(GVALinkage L)
Do we know that this will be the only definition of this symbol (excluding inlining-only definitions)...
Definition: Linkage.h:86
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition: Linkage.h:24
CXXDtorType
C++ destructor types.
Definition: ABI.h:33
@ CXXThis
Parameter for C++ 'this' argument.
Similar to AddedStructorArgs, but only notes the number of additional arguments.
Definition: CGCXXABI.h:355
Additional implicit arguments to add to the beginning (Prefix) and end (Suffix) of a constructor / de...
Definition: CGCXXABI.h:335
The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler,...
Definition: CGCleanup.h:36
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64