18#include "mlir/IR/Location.h"
28 bool suppressNewContext)
39 switch (
type->getTypeClass()) {
40#define TYPE(name, parent)
41#define ABSTRACT_TYPE(name, parent)
42#define NON_CANONICAL_TYPE(name, parent) case Type::name:
43#define DEPENDENT_TYPE(name, parent) case Type::name:
44#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
45#include "clang/AST/TypeNodes.inc"
46 llvm_unreachable(
"non-canonical or dependent type in IR-generation");
49 case Type::DeducedTemplateSpecialization:
50 llvm_unreachable(
"undeduced type in IR-generation");
55 case Type::BlockPointer:
56 case Type::LValueReference:
57 case Type::RValueReference:
58 case Type::MemberPointer:
61 case Type::ConstantMatrix:
62 case Type::FunctionProto:
63 case Type::FunctionNoProto:
65 case Type::ObjCObjectPointer:
68 case Type::HLSLAttributedResource:
69 case Type::HLSLInlineSpirv:
77 case Type::ConstantArray:
78 case Type::IncompleteArray:
79 case Type::VariableArray:
81 case Type::ObjCObject:
82 case Type::ObjCInterface:
83 case Type::ArrayParameter:
91 llvm_unreachable(
"unknown type kind!");
96 return cgm.getTypes().convertTypeForMem(t);
100 return cgm.getTypes().convertType(t);
110 return mlir::FileLineColLoc::get(builder.getStringAttr(filename),
114 assert(
currSrcLoc &&
"expected to inherit some source location");
125 mlir::Attribute metadata;
132 return builder.getUnknownLoc();
137 mlir::Attribute metadata;
164 ignoreCaseStmts =
true;
167 return std::any_of(
s->child_begin(),
s->child_end(),
168 [=](
const Stmt *subStmt) {
169 return containsLabel(subStmt, ignoreCaseStmts);
178 llvm::APSInt resultInt;
182 resultBool = resultInt.getBoolValue();
190 llvm::APSInt &resultInt,
198 llvm::APSInt intValue = result.
Val.
getInt();
202 resultInt = intValue;
206void CIRGenFunction::emitAndUpdateRetAlloca(
QualType type, mlir::Location loc,
208 if (!
type->isVoidType()) {
216void CIRGenFunction::declare(mlir::Value addrVal,
const Decl *var, QualType ty,
217 mlir::Location loc, CharUnits alignment,
220 assert(!
symbolTable.count(var) &&
"not supposed to be available just yet");
222 auto allocaOp = addrVal.getDefiningOp<cir::AllocaOp>();
223 assert(allocaOp &&
"expected cir::AllocaOp");
227 if (ty->isReferenceType() || ty.isConstQualified())
237 auto applyCleanup = [&]() {
245 if (returnBlock !=
nullptr) {
248 mlir::OpBuilder::InsertionGuard guard(builder);
249 builder.setInsertionPointToEnd(returnBlock);
250 (void)emitReturn(*returnLoc);
253 auto insertCleanupAndLeave = [&](mlir::Block *insPt) {
254 mlir::OpBuilder::InsertionGuard guard(builder);
255 builder.setInsertionPointToEnd(insPt);
267 builder.create<cir::BrOp>(insPt->back().
getLoc(), cleanupBlock);
268 if (!cleanupBlock->mightHaveTerminator()) {
269 mlir::OpBuilder::InsertionGuard guard(builder);
270 builder.setInsertionPointToEnd(cleanupBlock);
271 builder.create<cir::YieldOp>(localScope->endLoc);
275 if (localScope->
depth == 0) {
277 if (returnBlock !=
nullptr) {
278 if (returnBlock->getUses().empty()) {
279 returnBlock->erase();
283 for (mlir::BlockOperand &blockUse : returnBlock->getUses()) {
284 cir::BrOp brOp = mlir::cast<cir::BrOp>(blockUse.getOwner());
285 brOp.setSuccessor(cleanupBlock);
289 builder.create<cir::BrOp>(*returnLoc, returnBlock);
293 emitImplicitReturn();
300 if (!localScope->
isTernary() && !insPt->mightHaveTerminator()) {
301 !retVal ? builder.create<cir::YieldOp>(localScope->endLoc)
302 : builder.create<cir::YieldOp>(localScope->endLoc, retVal);
312 insertCleanupAndLeave(cleanupBlock);
317 mlir::Block *curBlock = builder.getBlock();
320 if (curBlock->mightHaveTerminator() && curBlock->getTerminator())
324 bool entryBlock = builder.getInsertionBlock()->isEntryBlock();
325 if (!entryBlock && curBlock->empty()) {
327 if (returnBlock !=
nullptr && returnBlock->getUses().empty())
328 returnBlock->erase();
334 builder.create<cir::BrOp>(curBlock->back().
getLoc(), cleanupBlock);
339 insertCleanupAndLeave(curBlock);
342cir::ReturnOp CIRGenFunction::LexicalScope::emitReturn(mlir::Location loc) {
345 if (!cgf.curFn.getFunctionType().hasVoidReturn()) {
347 auto value = builder.create<cir::LoadOp>(
348 loc, cgf.curFn.getFunctionType().getReturnType(), *cgf.fnRetAlloca);
349 return builder.create<cir::ReturnOp>(loc,
352 return builder.create<cir::ReturnOp>(loc);
362 return classDecl->hasTrivialDestructor();
366void CIRGenFunction::LexicalScope::emitImplicitReturn() {
367 CIRGenBuilderTy &builder = cgf.getBuilder();
368 LexicalScope *localScope = cgf.curLexScope;
377 if (cgf.getLangOpts().CPlusPlus && !fd->hasImplicitReturnZero() &&
378 !cgf.sawAsmBlock && !fd->getReturnType()->isVoidType() &&
379 builder.getInsertionBlock()) {
380 bool shouldEmitUnreachable =
381 cgf.cgm.getCodeGenOpts().StrictReturn ||
384 if (shouldEmitUnreachable) {
386 if (cgf.cgm.getCodeGenOpts().OptimizationLevel == 0)
387 builder.create<cir::TrapOp>(localScope->endLoc);
389 builder.create<cir::UnreachableOp>(localScope->endLoc);
390 builder.clearInsertionPoint();
395 (void)emitReturn(localScope->endLoc);
399 cir::FuncOp fn, cir::FuncType funcType,
403 "CIRGenFunction can only be used for one function at a time");
409 const auto *fd = dyn_cast_or_null<FunctionDecl>(d);
414 mlir::Block *entryBB = &fn.getBlocks().front();
415 builder.setInsertionPointToStart(entryBB);
419 for (
const auto nameValue : llvm::zip(args, entryBB->getArguments())) {
420 const VarDecl *paramVar = std::get<0>(nameValue);
421 mlir::Value paramVal = std::get<1>(nameValue);
424 paramVal.setLoc(paramLoc);
426 mlir::Value addrVal =
431 declare(addrVal, paramVar, paramVar->
getType(), paramLoc, alignment,
440 cgm.errorNYI(fd->getSourceRange(),
"Function argument demotion");
444 mlir::Location fnBodyBegin =
getLoc(fd->getBody()->getBeginLoc());
445 builder.CIRBaseBuilderTy::createStore(fnBodyBegin, paramVal, addrVal);
447 assert(builder.getInsertionBlock() &&
"Should be valid");
452 emitAndUpdateRetAlloca(returnType,
getLoc(fd->getBody()->getEndLoc()),
453 getContext().getTypeAlignInChars(returnType));
455 if (isa_and_nonnull<CXXMethodDecl>(d) &&
457 cgm.getCXXABI().emitInstanceFunctionProlog(loc, *
this);
460 if (md->getParent()->isLambda() && md->getOverloadedOperator() == OO_Call) {
462 curFn.setLambda(
true);
487 for (
auto *fd : md->getParent()->fields()) {
488 if (fd->hasCapturedVLAType())
489 cgm.errorNYI(loc,
"lambda captured VLA type");
521 if (
const CompoundStmt *block = dyn_cast<CompoundStmt>(body))
532 for (mlir::Block &block : func.getBlocks()) {
533 if (block.empty() && block.getUses().empty())
534 blocksToDelete.push_back(&block);
536 for (mlir::Block *block : blocksToDelete)
541 cir::FuncType funcType) {
546 Stmt *body = funcDecl->getBody();
551 : builder.getUnknownLoc()};
554 return clangLoc.isValid() ?
getLoc(clangLoc) : builder.getUnknownLoc();
556 const mlir::Location fusedLoc = mlir::FusedLoc::get(
558 {validMLIRLoc(bodyRange.
getBegin()), validMLIRLoc(bodyRange.
getEnd())});
559 mlir::Block *entryBB = fn.addEntryBlock();
576 funcDecl->hasAttr<CUDAGlobalAttr>()) {
596 llvm_unreachable(
"no definition for normal function");
599 if (mlir::failed(fn.verifyBody()))
614 assert((
cgm.getTarget().getCXXABI().hasConstructorVariants() ||
616 "can only generate complete ctor for this ABI");
619 cgm.getTarget().getCXXABI().hasConstructorVariants()) {
625 Stmt *body = ctor->getBody(definition);
626 assert(definition == ctor &&
"emitting wrong constructor body");
628 if (isa_and_nonnull<CXXTryStmt>(body)) {
629 cgm.errorNYI(ctor->getSourceRange(),
"emitConstructorBody: try body");
644 if (mlir::failed(
emitStmt(body,
true))) {
645 cgm.errorNYI(ctor->getSourceRange(),
646 "emitConstructorBody: emit body statement failed.");
680 const bool isTryBody = isa_and_nonnull<CXXTryStmt>(body);
694 llvm_unreachable(
"not expecting a unified dtor");
696 llvm_unreachable(
"not expecting a COMDAT");
698 llvm_unreachable(
"already handled deleting case");
701 assert((body ||
getTarget().getCXXABI().isMicrosoft()) &&
702 "can't emit a dtor without a body for non-Microsoft ABIs");
727 assert(dtor->
isImplicit() &&
"bodyless dtor not implicit");
752 CharUnits align =
cgm.getNaturalTypeAlignment(ty, &baseInfo);
759 CharUnits alignment =
cgm.getNaturalTypeAlignment(ty, &baseInfo);
768 QualType retTy = fd->getReturnType();
770 const auto *md = dyn_cast<CXXMethodDecl>(fd);
771 if (md && md->isInstance()) {
772 if (
cgm.getCXXABI().hasThisReturn(gd))
773 cgm.errorNYI(fd->getSourceRange(),
"this return");
774 else if (
cgm.getCXXABI().hasMostDerivedReturn(gd))
775 cgm.errorNYI(fd->getSourceRange(),
"most derived return");
776 cgm.getCXXABI().buildThisParam(*
this, args);
779 if (
const auto *cd = dyn_cast<CXXConstructorDecl>(fd))
780 if (cd->getInheritedConstructor())
781 cgm.errorNYI(fd->getSourceRange(),
782 "buildFunctionArgList: inherited constructor");
784 for (
auto *param : fd->parameters())
785 args.push_back(param);
788 cgm.getCXXABI().addImplicitStructorParams(*
this, retTy, args);
801 std::string(
"l-value not implemented for '") +
804 case Expr::ArraySubscriptExprClass:
806 case Expr::UnaryOperatorClass:
808 case Expr::StringLiteralClass:
810 case Expr::MemberExprClass:
812 case Expr::CompoundLiteralExprClass:
814 case Expr::BinaryOperatorClass:
816 case Expr::CompoundAssignOperatorClass: {
820 "CompoundAssignOperator with AtomicType");
828 case Expr::CallExprClass:
829 case Expr::CXXMemberCallExprClass:
830 case Expr::CXXOperatorCallExprClass:
831 case Expr::UserDefinedLiteralClass:
833 case Expr::ParenExprClass:
835 case Expr::DeclRefExprClass:
837 case Expr::CStyleCastExprClass:
838 case Expr::CXXStaticCastExprClass:
839 case Expr::CXXDynamicCastExprClass:
840 case Expr::ImplicitCastExprClass:
842 case Expr::MaterializeTemporaryExprClass:
849 llvm::raw_svector_ostream
out(buffer);
851 return std::string(
out.str());
871 cgm.errorNYI(loc,
"Cast the dest ptr to the appropriate i8 pointer type");
880 "emitNullInitialization for zero size VariableArrayType");
890 if (!
cgm.getTypes().isZeroInitializable(ty)) {
891 cgm.errorNYI(loc,
"type is not zero initializable");
898 const mlir::Value zeroValue = builder.getNullValue(
convertType(ty), loc);
899 builder.createStore(loc, zeroValue, destPtr);
906 if (ce->
getCastKind() == CK_UncheckedDerivedToBase)
916 if (ice->isGLValue())
938 uint64_t countFromCLAs = 1;
941 auto cirArrayType = mlir::dyn_cast<cir::ArrayType>(addr.
getElementType());
943 while (cirArrayType) {
945 countFromCLAs *= cirArrayType.getSize();
949 mlir::dyn_cast<cir::ArrayType>(cirArrayType.getElementType());
953 "CIR and Clang types are out-of-sync");
960 cgm.errorNYI(*
currSrcLoc,
"length for non-array underlying types");
969 SourceLocation assumptionLoc, int64_t alignment, mlir::Value offsetValue) {
971 return cir::AssumeAlignedOp::create(builder,
getLoc(assumptionLoc), ptrValue,
972 alignment, offsetValue);
977 int64_t alignment, mlir::Value offsetValue) {
987 assert(
type->isVariablyModifiedType() &&
988 "Must pass variably modified type to EmitVLASizes!");
993 assert(
type->isVariablyModifiedType());
997 case Type::CountAttributed:
998 case Type::PackIndexing:
999 case Type::ArrayParameter:
1000 case Type::HLSLAttributedResource:
1001 case Type::HLSLInlineSpirv:
1002 case Type::PredefinedSugar:
1003 cgm.errorNYI(
"CIRGenFunction::emitVariablyModifiedType");
1006#define TYPE(Class, Base)
1007#define ABSTRACT_TYPE(Class, Base)
1008#define NON_CANONICAL_TYPE(Class, Base)
1009#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1010#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
1011#include "clang/AST/TypeNodes.inc"
1013 "dependent type must be resolved before the CIR codegen");
1019 case Type::ExtVector:
1020 case Type::ConstantMatrix:
1024 case Type::TemplateSpecialization:
1025 case Type::ObjCTypeParam:
1026 case Type::ObjCObject:
1027 case Type::ObjCInterface:
1028 case Type::ObjCObjectPointer:
1030 llvm_unreachable(
"type class is never variably-modified!");
1032 case Type::Adjusted:
1044 case Type::BlockPointer:
1048 case Type::LValueReference:
1049 case Type::RValueReference:
1053 case Type::MemberPointer:
1057 case Type::ConstantArray:
1058 case Type::IncompleteArray:
1063 case Type::VariableArray: {
1064 cgm.errorNYI(
"CIRGenFunction::emitVariablyModifiedType VLA");
1068 case Type::FunctionProto:
1069 case Type::FunctionNoProto:
1075 case Type::UnaryTransform:
1076 case Type::Attributed:
1077 case Type::BTFTagAttributed:
1078 case Type::SubstTemplateTypeParm:
1079 case Type::MacroQualified:
1085 case Type::Decltype:
1087 case Type::DeducedTemplateSpecialization:
1091 case Type::TypeOfExpr:
1104 }
while (
type->isVariablyModifiedType());
1108 if (
getContext().getBuiltinVaListType()->isArrayType())
Defines the clang::Expr interface and subclasses for C++ expressions.
__device__ __2f16 float __ockl_bool s
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
SourceManager & getSourceManager()
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
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.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
mlir::Type getElementType() const
void forceCleanup()
Force the emission of cleanups now, instead of waiting until this object is destroyed.
static bool isConstructorDelegationValid(const clang::CXXConstructorDecl *ctor)
Checks whether the given constructor is a valid subject for the complete-to-base constructor delegati...
mlir::Type convertType(clang::QualType t)
static cir::TypeEvaluationKind getEvaluationKind(clang::QualType type)
Return the cir::TypeEvaluationKind of QualType type.
clang::GlobalDecl curGD
The GlobalDecl for the current function being compiled or the global variable currently being initial...
EHScopeStack::stable_iterator prologueCleanupDepth
The cleanup depth enclosing all the cleanups associated with the parameters.
cir::FuncOp generateCode(clang::GlobalDecl gd, cir::FuncOp fn, cir::FuncType funcType)
Address emitPointerWithAlignment(const clang::Expr *expr, LValueBaseInfo *baseInfo=nullptr)
Given an expression with a pointer type, emit the value and compute our best estimate of the alignmen...
void emitVariablyModifiedType(QualType ty)
RValue emitLoadOfLValue(LValue lv, SourceLocation loc)
Given an expression that represents a value lvalue, this method emits the address of the lvalue,...
const clang::LangOptions & getLangOpts() const
LValue makeNaturalAlignPointeeAddrLValue(mlir::Value v, clang::QualType t)
Given a value of type T* that may not be to a complete object, construct an l-vlaue withi the natural...
LValue emitMemberExpr(const MemberExpr *e)
const TargetInfo & getTarget() const
LValue emitLValue(const clang::Expr *e)
Emit code to compute a designator that specifies the location of the expression.
const clang::Decl * curFuncDecl
Address loadCXXThisAddress()
LValue emitLValueForLambdaField(const FieldDecl *field)
std::string getCounterRefTmpAsString()
LValue makeNaturalAlignAddrLValue(mlir::Value val, QualType ty)
bool constantFoldsToSimpleInteger(const clang::Expr *cond, llvm::APSInt &resultInt, bool allowLabels=false)
If the specified expression does not fold to a constant, or if it does fold but contains a label,...
LValue emitComplexCompoundAssignmentLValue(const CompoundAssignOperator *e)
mlir::Location getLoc(clang::SourceLocation srcLoc)
Helpers to convert Clang's SourceLocation to a MLIR Location.
bool constantFoldsToBool(const clang::Expr *cond, bool &resultBool, bool allowLabels=false)
If the specified expression does not fold to a constant, or if it does but contains a label,...
LValue emitStringLiteralLValue(const StringLiteral *e)
void emitDelegateCXXConstructorCall(const clang::CXXConstructorDecl *ctor, clang::CXXCtorType ctorType, const FunctionArgList &args, clang::SourceLocation loc)
mlir::Value emitArrayLength(const clang::ArrayType *arrayType, QualType &baseType, Address &addr)
Computes the length of an array in elements, as well as the base element type and a properly-typed fi...
void emitNullInitialization(mlir::Location loc, Address destPtr, QualType ty)
LValue emitArraySubscriptExpr(const clang::ArraySubscriptExpr *e)
llvm::ScopedHashTableScope< const clang::Decl *, mlir::Value > SymTableScopeTy
EHScopeStack ehStack
Tracks function scope overall cleanup handling.
std::optional< mlir::Value > fnRetAlloca
The compiler-generated variable that holds the return value.
void emitImplicitAssignmentOperatorBody(FunctionArgList &args)
mlir::Type convertTypeForMem(QualType t)
clang::QualType buildFunctionArgList(clang::GlobalDecl gd, FunctionArgList &args)
void emitCtorPrologue(const clang::CXXConstructorDecl *ctor, clang::CXXCtorType ctorType, FunctionArgList &args)
This routine generates necessary code to initialize base classes and non-static data members belongin...
mlir::Value emitAlloca(llvm::StringRef name, mlir::Type ty, mlir::Location loc, clang::CharUnits alignment, bool insertIntoFnEntryBlock, mlir::Value arraySize=nullptr)
LValue emitCompoundAssignmentLValue(const clang::CompoundAssignOperator *e)
Address returnValue
The temporary alloca to hold the return value.
void finishFunction(SourceLocation endLoc)
mlir::LogicalResult emitFunctionBody(const clang::Stmt *body)
std::string getCounterAggTmpAsString()
LValue emitUnaryOpLValue(const clang::UnaryOperator *e)
clang::FieldDecl * lambdaThisCaptureField
const clang::Decl * curCodeDecl
This is the inner-most code context, which includes blocks.
void emitConstructorBody(FunctionArgList &args)
LValue emitCallExprLValue(const clang::CallExpr *e)
cir::FuncOp curFn
The function for which code is currently being generated.
bool shouldNullCheckClassCastValue(const CastExpr *ce)
LValue emitBinaryOperatorLValue(const BinaryOperator *e)
void startFunction(clang::GlobalDecl gd, clang::QualType returnType, cir::FuncOp fn, cir::FuncType funcType, FunctionArgList args, clang::SourceLocation loc, clang::SourceLocation startLoc)
Emit code for the start of a function.
CIRGenModule & getCIRGenModule()
unsigned counterRefTmp
Hold counters for incrementally naming temporaries.
mlir::MLIRContext & getMLIRContext()
void emitDestructorBody(FunctionArgList &args)
Emits the body of the current destructor.
LValue emitCastLValue(const CastExpr *e)
Casts are never lvalues unless that cast is to a reference type.
bool containsLabel(const clang::Stmt *s, bool ignoreCaseStmts=false)
Return true if the statement contains a label in it.
LValue emitDeclRefLValue(const clang::DeclRefExpr *e)
llvm::DenseMap< const clang::ValueDecl *, clang::FieldDecl * > lambdaCaptureFields
mlir::Value emitAlignmentAssumption(mlir::Value ptrValue, QualType ty, SourceLocation loc, SourceLocation assumptionLoc, int64_t alignment, mlir::Value offsetValue=nullptr)
LValue makeAddrLValue(Address addr, QualType ty, AlignmentSource source=AlignmentSource::Type)
void emitCXXDestructorCall(const CXXDestructorDecl *dd, CXXDtorType type, bool forVirtualBase, bool delegating, Address thisAddr, QualType thisTy)
void emitLambdaStaticInvokeBody(const CXXMethodDecl *md)
CIRGenFunction(CIRGenModule &cgm, CIRGenBuilderTy &builder, bool suppressNewContext=false)
std::optional< mlir::Location > currSrcLoc
Use to track source locations across nested visitor traversals.
LValue emitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *e)
clang::ASTContext & getContext() const
void setAddrOfLocalVar(const clang::VarDecl *vd, Address addr)
Set the address of a local variable.
mlir::Value cxxabiThisValue
mlir::LogicalResult emitStmt(const clang::Stmt *s, bool useCurrentScope, llvm::ArrayRef< const Attr * > attrs={})
void popCleanupBlocks(EHScopeStack::stable_iterator oldCleanupStackDepth)
Takes the old cleanup stack size and emits the cleanup blocks that have been added.
Address emitVAListRef(const Expr *e)
Build a "reference" to a va_list; this is either the address or the value of the expression,...
mlir::LogicalResult emitCompoundStmtWithoutScope(const clang::CompoundStmt &s, Address *lastValue=nullptr, AggValueSlot slot=AggValueSlot::ignored())
void emitIgnoredExpr(const clang::Expr *e)
Emit code to compute the specified expression, ignoring the result.
LValue emitCompoundLiteralLValue(const CompoundLiteralExpr *e)
This class organizes the cross-function state that is used while generating CIR code.
DiagnosticBuilder errorNYI(SourceLocation, llvm::StringRef)
Helpers to emit "not yet implemented" error diagnostics.
Type for representing both the decl and type of parameters to a function.
Address getAddress() const
mlir::Value getPointer() const
mlir::Value getValue() const
Return the value of this scalar value.
Represents a C++ destructor within a class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
QualType getFunctionObjectParameterType() const
bool isAbstract() const
Determine whether this class has a pure virtual function.
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
CastKind getCastKind() const
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
CompoundStmt - This represents a group of statements like { stmt stmt }.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks,...
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Represents a function declaration or definition.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
GlobalDecl - represents a global declaration.
const Decl * getDecl() const
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Represents an unpacked "presumed" location which can be presented to the user.
unsigned getColumn() const
Return the presumed column number of this location.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
A (possibly-)qualified type.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
const char * getStmtClassName() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isAnyComplexType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
Represents a variable declaration or definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
static std::string getVersionedTmpName(llvm::StringRef name, unsigned cnt)
static bool mayDropFunctionReturn(const ASTContext &astContext, QualType returnType)
static void eraseEmptyAndUnusedBlocks(cir::FuncOp func)
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
CXXCtorType
C++ constructor types.
@ Ctor_Base
Base object ctor.
@ Ctor_Complete
Complete object ctor.
bool isa(CodeGen::Address addr)
CXXDtorType
C++ destructor types.
@ Dtor_Comdat
The COMDAT used for dtors.
@ Dtor_Unified
GCC-style unified dtor.
@ Dtor_Base
Base object dtor.
@ Dtor_Complete
Complete object dtor.
@ Dtor_Deleting
Deleting dtor.
U cast(CodeGen::Address addr)
static bool vtableInitialization()
static bool constructABIArgDirectExtend()
static bool dtorCleanups()
static bool runCleanupsScope()
static bool emitTypeCheck()
static bool generateDebugInfo()
static bool incrementProfileCounter()
Represents a scope, including function bodies, compound statements, and the substatements of if/while...
LexicalScope(CIRGenFunction &cgf, mlir::Location loc, mlir::Block *eb)
mlir::Block * getCleanupBlock(mlir::OpBuilder &builder)
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.