27class AggExprEmitter :
public StmtVisitor<AggExprEmitter> {
38 void withReturnValueSlot(
const Expr *e,
39 llvm::function_ref<RValue(ReturnValueSlot)> fn);
41 AggValueSlot ensureSlot(mlir::Location loc, QualType t) {
42 if (!dest.isIgnored())
45 cgf.cgm.errorNYI(loc,
"Slot for ignored address");
50 AggExprEmitter(CIRGenFunction &cgf, AggValueSlot dest)
51 : cgf(cgf), dest(dest) {}
56 void emitAggLoadOfLValue(
const Expr *e);
58 void emitArrayInit(Address destPtr, cir::ArrayType arrayTy, QualType arrayQTy,
59 Expr *exprToVisit, ArrayRef<Expr *> args,
63 void emitFinalDestCopy(QualType
type,
const LValue &src);
65 void emitCopy(QualType
type,
const AggValueSlot &dest,
66 const AggValueSlot &src);
68 void emitInitializationToLValue(Expr *e, LValue lv);
70 void emitNullInitializationToLValue(mlir::Location loc, LValue lv);
72 void Visit(Expr *e) { StmtVisitor<AggExprEmitter>::Visit(e); }
74 void VisitArraySubscriptExpr(ArraySubscriptExpr *e) {
75 emitAggLoadOfLValue(e);
78 void VisitCallExpr(
const CallExpr *e);
79 void VisitStmtExpr(
const StmtExpr *e) {
80 CIRGenFunction::StmtExprEvaluation eval(cgf);
83 (void)cgf.emitCompoundStmt(*e->
getSubStmt(), &retAlloca, dest);
86 void VisitDeclRefExpr(DeclRefExpr *e) { emitAggLoadOfLValue(e); }
88 void VisitInitListExpr(InitListExpr *e);
89 void VisitCXXConstructExpr(
const CXXConstructExpr *e);
91 void visitCXXParenListOrInitListExpr(Expr *e, ArrayRef<Expr *> args,
92 FieldDecl *initializedFieldInUnion,
94 void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *die) {
95 CIRGenFunction::CXXDefaultInitExprScope Scope(cgf, die);
98 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *e) {
107 case CK_LValueToRValue:
112 "AggExprEmitter: volatile lvalue-to-rvalue cast");
115 case CK_UserDefinedConversion:
116 case CK_ConstructorConversion:
119 "Implicit cast types must be compatible");
124 std::string(
"AggExprEmitter: VisitCastExpr: ") +
129 void VisitStmt(Stmt *
s) {
130 cgf.cgm.errorNYI(
s->getSourceRange(),
131 std::string(
"AggExprEmitter::VisitStmt: ") +
132 s->getStmtClassName());
134 void VisitParenExpr(ParenExpr *pe) {
135 cgf.cgm.errorNYI(pe->
getSourceRange(),
"AggExprEmitter: VisitParenExpr");
137 void VisitGenericSelectionExpr(GenericSelectionExpr *ge) {
139 "AggExprEmitter: VisitGenericSelectionExpr");
141 void VisitCoawaitExpr(CoawaitExpr *e) {
142 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitCoawaitExpr");
144 void VisitCoyieldExpr(CoyieldExpr *e) {
145 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitCoyieldExpr");
147 void VisitUnaryCoawait(UnaryOperator *e) {
148 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitUnaryCoawait");
150 void VisitUnaryExtension(UnaryOperator *e) {
152 "AggExprEmitter: VisitUnaryExtension");
154 void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *e) {
156 "AggExprEmitter: VisitSubstNonTypeTemplateParmExpr");
158 void VisitConstantExpr(ConstantExpr *e) {
159 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitConstantExpr");
161 void VisitMemberExpr(MemberExpr *e) {
162 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitMemberExpr");
164 void VisitUnaryDeref(UnaryOperator *e) {
165 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitUnaryDeref");
167 void VisitStringLiteral(StringLiteral *e) {
168 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitStringLiteral");
170 void VisitCompoundLiteralExpr(CompoundLiteralExpr *e) {
172 "AggExprEmitter: VisitCompoundLiteralExpr");
174 void VisitPredefinedExpr(
const PredefinedExpr *e) {
176 "AggExprEmitter: VisitPredefinedExpr");
178 void VisitBinaryOperator(
const BinaryOperator *e) {
180 "AggExprEmitter: VisitBinaryOperator");
182 void VisitPointerToDataMemberBinaryOperator(
const BinaryOperator *e) {
184 "AggExprEmitter: VisitPointerToDataMemberBinaryOperator");
186 void VisitBinAssign(
const BinaryOperator *e) {
187 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitBinAssign");
189 void VisitBinComma(
const BinaryOperator *e) {
190 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitBinComma");
192 void VisitBinCmp(
const BinaryOperator *e) {
193 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitBinCmp");
195 void VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *e) {
197 "AggExprEmitter: VisitCXXRewrittenBinaryOperator");
199 void VisitObjCMessageExpr(ObjCMessageExpr *e) {
201 "AggExprEmitter: VisitObjCMessageExpr");
203 void VisitObjCIVarRefExpr(ObjCIvarRefExpr *e) {
205 "AggExprEmitter: VisitObjCIVarRefExpr");
208 void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *e) {
210 "AggExprEmitter: VisitDesignatedInitUpdateExpr");
212 void VisitAbstractConditionalOperator(
const AbstractConditionalOperator *e) {
214 "AggExprEmitter: VisitAbstractConditionalOperator");
216 void VisitChooseExpr(
const ChooseExpr *e) {
217 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitChooseExpr");
219 void VisitCXXParenListInitExpr(CXXParenListInitExpr *e) {
221 "AggExprEmitter: VisitCXXParenListInitExpr");
223 void VisitArrayInitLoopExpr(
const ArrayInitLoopExpr *e,
224 llvm::Value *outerBegin =
nullptr) {
226 "AggExprEmitter: VisitArrayInitLoopExpr");
228 void VisitImplicitValueInitExpr(ImplicitValueInitExpr *e) {
230 "AggExprEmitter: VisitImplicitValueInitExpr");
232 void VisitNoInitExpr(NoInitExpr *e) {
233 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitNoInitExpr");
235 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *dae) {
237 "AggExprEmitter: VisitCXXDefaultArgExpr");
239 void VisitCXXInheritedCtorInitExpr(
const CXXInheritedCtorInitExpr *e) {
241 "AggExprEmitter: VisitCXXInheritedCtorInitExpr");
243 void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *e) {
245 "AggExprEmitter: VisitCXXStdInitializerListExpr");
248 void VisitExprWithCleanups(ExprWithCleanups *e) {
250 "AggExprEmitter: VisitExprWithCleanups");
252 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *e) {
254 "AggExprEmitter: VisitCXXScalarValueInitExpr");
256 void VisitCXXTypeidExpr(CXXTypeidExpr *e) {
257 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitCXXTypeidExpr");
259 void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *e) {
261 "AggExprEmitter: VisitMaterializeTemporaryExpr");
263 void VisitOpaqueValueExpr(OpaqueValueExpr *e) {
265 "AggExprEmitter: VisitOpaqueValueExpr");
268 void VisitPseudoObjectExpr(PseudoObjectExpr *e) {
270 "AggExprEmitter: VisitPseudoObjectExpr");
273 void VisitVAArgExpr(VAArgExpr *e) {
274 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitVAArgExpr");
277 void VisitCXXThrowExpr(
const CXXThrowExpr *e) {
278 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitCXXThrowExpr");
280 void VisitAtomicExpr(AtomicExpr *e) {
281 cgf.cgm.errorNYI(e->
getSourceRange(),
"AggExprEmitter: VisitAtomicExpr");
294 if (
auto *ile = dyn_cast<InitListExpr>(e)) {
295 if (ile->getNumInits())
300 if (
const auto *cons = dyn_cast_or_null<CXXConstructExpr>(e))
301 return cons->getConstructor()->isDefaultConstructor() &&
302 cons->getConstructor()->isTrivial();
309void AggExprEmitter::emitAggLoadOfLValue(
const Expr *e) {
315 emitFinalDestCopy(e->
getType(), lv);
318void AggExprEmitter::emitArrayInit(Address destPtr, cir::ArrayType arrayTy,
319 QualType arrayQTy, Expr *e,
320 ArrayRef<Expr *> args, Expr *arrayFiller) {
324 const uint64_t numInitElements = args.size();
326 const QualType elementType =
330 cgf.
cgm.
errorNYI(loc,
"initialized array requires destruction");
336 const mlir::Type cirElementType = cgf.
convertType(elementType);
337 const cir::PointerType cirElementPtrType =
340 auto begin = cir::CastOp::create(builder, loc, cirElementPtrType,
341 cir::CastKind::array_to_ptrdecay,
344 const CharUnits elementSize =
346 const CharUnits elementAlign =
354 mlir::Value element = begin;
361 for (uint64_t i = 0; i != numInitElements; ++i) {
368 const Address address = Address(element, cirElementType, elementAlign);
369 const LValue elementLV = cgf.
makeAddrLValue(address, elementType);
370 emitInitializationToLValue(args[i], elementLV);
373 const uint64_t numArrayElements = arrayTy.getSize();
381 if (numInitElements != numArrayElements &&
382 !(dest.
isZeroed() && hasTrivialFiller &&
385 if (numInitElements) {
387 element = cir::PtrStrideOp::create(builder, loc, cirElementPtrType,
399 cir::ConstantOp numArrayElementsConst = builder.
getConstInt(
400 loc, mlir::cast<cir::IntType>(cgf.
PtrDiffTy), numArrayElements);
401 mlir::Value end = cir::PtrStrideOp::create(builder, loc, cirElementPtrType,
402 begin, numArrayElementsConst);
407 [&](mlir::OpBuilder &
b, mlir::Location loc) {
408 cir::LoadOp currentElement = builder.
createLoad(loc, tmpAddr);
410 cir::CmpOp cmp = cir::CmpOp::create(
411 builder, loc, boolTy, cir::CmpOpKind::ne, currentElement, end);
415 [&](mlir::OpBuilder &
b, mlir::Location loc) {
416 cir::LoadOp currentElement = builder.
createLoad(loc, tmpAddr);
422 Address(currentElement, cirElementType, elementAlign),
425 emitInitializationToLValue(arrayFiller, elementLV);
427 emitNullInitializationToLValue(loc, elementLV);
431 cgf.
cgm.
errorNYI(loc,
"update destructed array element for EH");
437 loc, mlir::cast<cir::IntType>(cgf.
PtrDiffTy), 1);
438 auto nextElement = cir::PtrStrideOp::create(
439 builder, loc, cirElementPtrType, currentElement, one);
448void AggExprEmitter::emitFinalDestCopy(QualType
type,
const LValue &src) {
463 emitCopy(
type, dest, srcAgg);
470void AggExprEmitter::emitCopy(QualType
type,
const AggValueSlot &dest,
471 const AggValueSlot &src) {
483void AggExprEmitter::emitInitializationToLValue(Expr *e, LValue lv) {
484 const QualType
type = lv.getType();
490 return emitNullInitializationToLValue(loc, lv);
496 if (
type->isReferenceType()) {
521void AggExprEmitter::VisitCXXConstructExpr(
const CXXConstructExpr *e) {
526void AggExprEmitter::emitNullInitializationToLValue(mlir::Location loc,
528 const QualType
type = lv.getType();
543 cgf.
cgm.
errorNYI(
"emitStoreThroughBitfieldLValue");
553void AggExprEmitter::VisitLambdaExpr(
LambdaExpr *e) {
556 [[maybe_unused]] LValue slotLV =
563 for (
auto [curField, capture, captureInit] : llvm::zip(
566 llvm::StringRef fieldName = curField->getName();
567 if (capture.capturesVariable()) {
568 assert(!curField->isBitField() &&
"lambdas don't have bitfield members!");
569 ValueDecl *v = capture.getCapturedVar();
572 }
else if (capture.capturesThis()) {
582 if (curField->hasCapturedVLAType())
585 emitInitializationToLValue(captureInit, lv);
589 curField->getType().isDestructedType())
594void AggExprEmitter::VisitCallExpr(
const CallExpr *e) {
601 e, [&](ReturnValueSlot slot) {
return cgf.
emitCallExpr(e, slot); });
604void AggExprEmitter::withReturnValueSlot(
605 const Expr *e, llvm::function_ref<RValue(ReturnValueSlot)> fn) {
609 bool requiresDestruction =
611 if (requiresDestruction)
614 "withReturnValueSlot: return value requiring destruction is NYI");
629 fn(ReturnValueSlot(retAddr));
632void AggExprEmitter::VisitInitListExpr(InitListExpr *e) {
634 llvm_unreachable(
"GNU array range designator extension");
639 visitCXXParenListOrInitListExpr(
643void AggExprEmitter::visitCXXParenListOrInitListExpr(
644 Expr *e, ArrayRef<Expr *> args, FieldDecl *initializedFieldInUnion,
647 const AggValueSlot dest =
651 cir::ArrayType arrayTy =
658 "visitCXXParenListOrInitListExpr variable array type");
664 "visitCXXParenListOrInitListExpr array type");
674 unsigned numInitElements = args.size();
681 unsigned curInitIndex = 0;
684 if (
auto *cxxrd = dyn_cast<CXXRecordDecl>(record)) {
685 assert(numInitElements >= cxxrd->getNumBases() &&
686 "missing initializer for base class");
687 if (cxxrd->getNumBases() > 0) {
689 "visitCXXParenListOrInitListExpr base class init");
696 if (record->isUnion()) {
698 "visitCXXParenListOrInitListExpr union type");
704 for (
const FieldDecl *field : record->fields()) {
706 if (field->getType()->isIncompleteArrayType())
710 if (field->isUnnamedBitField())
716 if (curInitIndex == numInitElements && dest.
isZeroed() &&
724 if (curInitIndex < numInitElements) {
726 CIRGenFunction::SourceLocRAIIObject loc{
727 cgf, cgf.
getLoc(record->getSourceRange())};
728 emitInitializationToLValue(args[curInitIndex++], lv);
737 if (field->getType().isDestructedType()) {
739 "visitCXXParenListOrInitListExpr destructor");
763 getContext().getASTRecordLayout(baseRD).getSize() <=
772 AggExprEmitter(*
this, slot).Visit(
const_cast<Expr *
>(e));
786 assert((record->hasTrivialCopyConstructor() ||
787 record->hasTrivialCopyAssignment() ||
788 record->hasTrivialMoveConstructor() ||
789 record->hasTrivialMoveAssignment() ||
790 record->hasAttr<TrivialABIAttr>() || record->isUnion()) &&
791 "Trying to aggregate-copy a type without a trivial copy/move "
792 "constructor or assignment operator");
794 if (record->isEmpty())
817 typeInfo =
getContext().getTypeInfoDataSizeInChars(ty);
819 typeInfo =
getContext().getTypeInfoInChars(ty);
829 cgm.errorNYI(
"emitAggregateCopy: GC");
831 [[maybe_unused]] cir::CopyOp copyOp =
static bool isTrivialFiller(Expr *e)
__device__ __2f16 float __ockl_bool s
cir::ConditionOp createCondition(mlir::Value condition)
Create a loop condition.
cir::PtrStrideOp createPtrStride(mlir::Location loc, mlir::Value base, mlir::Value stride)
cir::PointerType getPointerTo(mlir::Type ty)
cir::DoWhileOp createDoWhile(mlir::Location loc, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> condBuilder, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> bodyBuilder)
Create a do-while operation.
cir::ConstantOp getConstantInt(mlir::Location loc, mlir::Type ty, int64_t value)
cir::YieldOp createYield(mlir::Location loc, mlir::ValueRange value={})
Create a yield operation.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
QualType getElementType() const
mlir::Value getPointer() const
mlir::Type getElementType() const
clang::CharUnits getAlignment() const
IsZeroed_t isZeroed() const
Overlap_t mayOverlap() const
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed)
Address getAddress() const
cir::ConstantOp getConstInt(mlir::Location loc, llvm::APSInt intVal)
cir::LoadOp createLoad(mlir::Location loc, Address addr, bool isVolatile=false)
static bool hasScalarEvaluationKind(clang::QualType type)
mlir::Type convertType(clang::QualType t)
static cir::TypeEvaluationKind getEvaluationKind(clang::QualType type)
Return the cir::TypeEvaluationKind of QualType type.
CIRGenTypes & getTypes() const
const clang::LangOptions & getLangOpts() const
cir::AllocaOp createTempAlloca(mlir::Type ty, mlir::Location loc, const Twine &name="tmp", mlir::Value arraySize=nullptr, bool insertIntoFnEntryBlock=false)
This creates an alloca and inserts it into the entry block if ArraySize is nullptr,...
RValue emitCallExpr(const clang::CallExpr *e, ReturnValueSlot returnValue=ReturnValueSlot())
LValue emitLValue(const clang::Expr *e)
Emit code to compute a designator that specifies the location of the expression.
void emitStoreOfScalar(mlir::Value value, Address addr, bool isVolatile, clang::QualType ty, bool isInit=false, bool isNontemporal=false)
mlir::Location getLoc(clang::SourceLocation srcLoc)
Helpers to convert Clang's SourceLocation to a MLIR Location.
void emitNullInitialization(mlir::Location loc, Address destPtr, QualType ty)
RValue emitReferenceBindingToExpr(const Expr *e)
Emits a reference binding to the passed in expression.
AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *fd)
void emitCXXConstructExpr(const clang::CXXConstructExpr *e, AggValueSlot dest)
LValue emitAggExprToLValue(const Expr *e)
static bool hasAggregateEvaluationKind(clang::QualType type)
void emitScalarInit(const clang::Expr *init, mlir::Location loc, LValue lvalue, bool capturedByInit=false)
LValue emitLValueForFieldInitialization(LValue base, const clang::FieldDecl *field, llvm::StringRef fieldName)
Like emitLValueForField, excpet that if the Field is a reference, this will return the address of the...
mlir::Value emitScalarExpr(const clang::Expr *e)
Emit the computation of the specified expression of scalar type.
CIRGenBuilderTy & getBuilder()
AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *rd, const CXXRecordDecl *baseRD, bool isVirtual)
Determine whether a base class initialization may overlap some other object.
void emitComplexExprIntoLValue(const Expr *e, LValue dest, bool isInit)
LValue makeAddrLValue(Address addr, QualType ty, AlignmentSource source=AlignmentSource::Type)
std::optional< mlir::Location > currSrcLoc
Use to track source locations across nested visitor traversals.
clang::ASTContext & getContext() const
void emitAggregateCopy(LValue dest, LValue src, QualType eltTy, AggValueSlot::Overlap_t mayOverlap)
Emit an aggregate copy.
void emitStoreThroughLValue(RValue src, LValue dst, bool isInit=false)
Store the specified rvalue into the specified lvalue, where both are guaranteed to the have the same ...
Address createMemTemp(QualType t, mlir::Location loc, const Twine &name="tmp", Address *alloca=nullptr, mlir::OpBuilder::InsertPoint ip={})
Create a temporary memory object of the given type, with appropriate alignmen and cast it to the defa...
void emitAggExpr(const clang::Expr *e, AggValueSlot slot)
DiagnosticBuilder errorNYI(SourceLocation, llvm::StringRef)
Helpers to emit "not yet implemented" error diagnostics.
const clang::LangOptions & getLangOpts() const
mlir::Value emitNullConstant(QualType t, mlir::Location loc)
Return the result of value-initializing the given type, i.e.
llvm::DenseMap< const clang::FieldDecl *, llvm::StringRef > lambdaFieldToName
Keep a map between lambda fields and names, this needs to be per module since lambdas might get gener...
bool isZeroInitializable(clang::QualType ty)
Return whether a type can be zero-initialized (in the C++ sense) with an LLVM zeroinitializer.
Address getAddress() const
static RValue get(mlir::Value v)
const Expr * getSubExpr() const
Expr * getExpr()
Get the initialization expression that will be used.
SourceRange getSourceRange() const LLVM_READONLY
Represents a C++ struct/union/class.
SourceRange getSourceRange() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range of the expression.
SourceRange getSourceRange() const LLVM_READONLY
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
CastKind getCastKind() const
static const char * getCastKindName(CastKind CK)
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
This represents one expression.
Represents a member of a struct/union/class.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
bool hadArrayRangeDesignator() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
const Expr * getInit(unsigned Init) const
ArrayRef< Expr * > inits()
llvm::iterator_range< capture_init_iterator > capture_inits()
Retrieve the initialization expressions for this lambda's captures.
capture_range captures() const
Retrieve this lambda's captures.
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
Represents a struct/union/class.
field_range fields() const
CompoundStmt * getSubStmt()
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isConstantArrayType() const
bool isReferenceType() const
bool isVariableArrayType() const
RecordDecl * castAsRecordDecl() const
bool isAnyComplexType() const
bool isRecordType() const
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
U cast(CodeGen::Address addr)
static bool emitLifetimeMarkers()
static bool aggValueSlotDestructedFlag()
static bool aggValueSlotGC()
static bool aggValueSlotAlias()
static bool opLoadStoreAtomic()
static bool aggEmitFinalDestCopyRValue()
static bool aggValueSlotVolatile()
static bool opScopeCleanupRegion()
static bool cudaSupport()
static bool requiresCleanups()
clang::CharUnits getPointerAlign() const