llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-codegen Author: Erich Keane (erichkeane) <details> <summary>Changes</summary> The 'tile' clause shares quite a bit of the rules with 'collapse', so a followup patch will add those tests/behaviors. This patch deals with adding the AST node. The 'tile' clause takes a series of integer constant expressions, or *. The asterisk is now represented by a new OpenACCAsteriskSizeExpr node, else this clause is very similar to others. --- Patch is 56.48 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/110999.diff 41 Files Affected: - (modified) clang/include/clang/AST/ComputeDependence.h (+2) - (modified) clang/include/clang/AST/Expr.h (+35) - (modified) clang/include/clang/AST/JSONNodeDumper.h (+1) - (modified) clang/include/clang/AST/OpenACCClause.h (+29) - (modified) clang/include/clang/AST/RecursiveASTVisitor.h (+1) - (modified) clang/include/clang/AST/TextNodeDumper.h (+1) - (modified) clang/include/clang/Basic/DiagnosticSemaKinds.td (+4) - (modified) clang/include/clang/Basic/OpenACCClauses.def (+1) - (modified) clang/include/clang/Basic/StmtNodes.td (+3) - (modified) clang/include/clang/Parse/Parser.h (+5-2) - (modified) clang/include/clang/Sema/SemaOpenACC.h (+10) - (modified) clang/include/clang/Serialization/ASTBitCodes.h (+3-1) - (modified) clang/lib/AST/ComputeDependence.cpp (+6) - (modified) clang/lib/AST/Expr.cpp (+11) - (modified) clang/lib/AST/ExprClassification.cpp (+1) - (modified) clang/lib/AST/ExprConstant.cpp (+8) - (modified) clang/lib/AST/ItaniumMangle.cpp (+9) - (modified) clang/lib/AST/JSONNodeDumper.cpp (+3) - (modified) clang/lib/AST/OpenACCClause.cpp (+18) - (modified) clang/lib/AST/StmtPrinter.cpp (+4) - (modified) clang/lib/AST/StmtProfile.cpp (+10) - (modified) clang/lib/AST/TextNodeDumper.cpp (+6) - (modified) clang/lib/CodeGen/CGExprScalar.cpp (+4) - (modified) clang/lib/Parse/ParseOpenACC.cpp (+32-16) - (modified) clang/lib/Sema/SemaExceptionSpec.cpp (+2) - (modified) clang/lib/Sema/SemaOpenACC.cpp (+79) - (modified) clang/lib/Sema/TreeTransform.h (+43) - (modified) clang/lib/Serialization/ASTReader.cpp (+9-1) - (modified) clang/lib/Serialization/ASTReaderStmt.cpp (+9) - (modified) clang/lib/Serialization/ASTWriter.cpp (+8-1) - (modified) clang/lib/Serialization/ASTWriterStmt.cpp (+6) - (modified) clang/lib/StaticAnalyzer/Core/ExprEngine.cpp (+1) - (modified) clang/test/AST/ast-print-openacc-loop-construct.cpp (+13) - (modified) clang/test/ParserOpenACC/parse-clauses.c (+6-16) - (modified) clang/test/SemaOpenACC/compute-construct-device_type-clause.c (+1-2) - (modified) clang/test/SemaOpenACC/loop-construct-auto_seq_independent-clauses.c (+6-12) - (modified) clang/test/SemaOpenACC/loop-construct-device_type-clause.c (+2-2) - (added) clang/test/SemaOpenACC/loop-construct-tile-ast.cpp (+231) - (added) clang/test/SemaOpenACC/loop-construct-tile-clause.cpp (+95) - (modified) clang/tools/libclang/CIndex.cpp (+5) - (modified) clang/tools/libclang/CXCursor.cpp (+1) ``````````diff diff --git a/clang/include/clang/AST/ComputeDependence.h b/clang/include/clang/AST/ComputeDependence.h index 6d3a51c379f9df..1a8507cfbf9872 100644 --- a/clang/include/clang/AST/ComputeDependence.h +++ b/clang/include/clang/AST/ComputeDependence.h @@ -107,6 +107,7 @@ class ObjCSubscriptRefExpr; class ObjCIsaExpr; class ObjCIndirectCopyRestoreExpr; class ObjCMessageExpr; +class OpenACCAsteriskSizeExpr; // The following functions are called from constructors of `Expr`, so they // should not access anything beyond basic @@ -203,6 +204,7 @@ ExprDependence computeDependence(ObjCSubscriptRefExpr *E); ExprDependence computeDependence(ObjCIsaExpr *E); ExprDependence computeDependence(ObjCIndirectCopyRestoreExpr *E); ExprDependence computeDependence(ObjCMessageExpr *E); +ExprDependence computeDependence(OpenACCAsteriskSizeExpr *E); } // namespace clang #endif diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h index 66c746cc25040f..57353855c51e7c 100644 --- a/clang/include/clang/AST/Expr.h +++ b/clang/include/clang/AST/Expr.h @@ -2072,6 +2072,41 @@ class PredefinedExpr final } }; +/// This expression type represents an asterisk in an OpenACC Size-Expr, used in +/// the 'tile' and 'gang' clauses. It is of 'int' type, but should not be +/// evaluated. +class OpenACCAsteriskSizeExpr final : public Expr { + friend class ASTStmtReader; + SourceLocation AsteriskLoc; + + OpenACCAsteriskSizeExpr(SourceLocation AsteriskLoc, QualType IntTy) + : Expr(OpenACCAsteriskSizeExprClass, IntTy, VK_PRValue, OK_Ordinary), + AsteriskLoc(AsteriskLoc) {} + + void setAsteriskLocation(SourceLocation Loc) { AsteriskLoc = Loc; } + +public: + static OpenACCAsteriskSizeExpr *Create(const ASTContext &C, + SourceLocation Loc); + static OpenACCAsteriskSizeExpr *CreateEmpty(const ASTContext &C); + + SourceLocation getBeginLoc() const { return AsteriskLoc; } + SourceLocation getEndLoc() const { return AsteriskLoc; } + SourceLocation getLocation() const { return AsteriskLoc; } + + static bool classof(const Stmt *T) { + return T->getStmtClass() == OpenACCAsteriskSizeExprClass; + } + // Iterators + child_range children() { + return child_range(child_iterator(), child_iterator()); + } + + const_child_range children() const { + return const_child_range(const_child_iterator(), const_child_iterator()); + } +}; + // This represents a use of the __builtin_sycl_unique_stable_name, which takes a // type-id, and at CodeGen time emits a unique string representation of the // type in a way that permits us to properly encode information about the SYCL diff --git a/clang/include/clang/AST/JSONNodeDumper.h b/clang/include/clang/AST/JSONNodeDumper.h index 55bd583e304e8b..9422c8fceccfbd 100644 --- a/clang/include/clang/AST/JSONNodeDumper.h +++ b/clang/include/clang/AST/JSONNodeDumper.h @@ -283,6 +283,7 @@ class JSONNodeDumper void VisitDeclRefExpr(const DeclRefExpr *DRE); void VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *E); + void VisitOpenACCAsteriskSizeExpr(const OpenACCAsteriskSizeExpr *E); void VisitPredefinedExpr(const PredefinedExpr *PE); void VisitUnaryOperator(const UnaryOperator *UO); void VisitBinaryOperator(const BinaryOperator *BO); diff --git a/clang/include/clang/AST/OpenACCClause.h b/clang/include/clang/AST/OpenACCClause.h index 90f5b7fc9ab6f4..e4f2e07222a338 100644 --- a/clang/include/clang/AST/OpenACCClause.h +++ b/clang/include/clang/AST/OpenACCClause.h @@ -481,6 +481,35 @@ class OpenACCNumGangsClause final } }; +class OpenACCTileClause final + : public OpenACCClauseWithExprs, + public llvm::TrailingObjects<OpenACCTileClause, Expr *> { + OpenACCTileClause(SourceLocation BeginLoc, SourceLocation LParenLoc, + ArrayRef<Expr *> SizeExprs, SourceLocation EndLoc) + : OpenACCClauseWithExprs(OpenACCClauseKind::Tile, BeginLoc, LParenLoc, + EndLoc) { + std::uninitialized_copy(SizeExprs.begin(), SizeExprs.end(), + getTrailingObjects<Expr *>()); + setExprs(MutableArrayRef(getTrailingObjects<Expr *>(), SizeExprs.size())); + } + +public: + static bool classof(const OpenACCClause *C) { + return C->getClauseKind() == OpenACCClauseKind::Tile; + } + static OpenACCTileClause *Create(const ASTContext &C, SourceLocation BeginLoc, + SourceLocation LParenLoc, + ArrayRef<Expr *> SizeExprs, + SourceLocation EndLoc); + llvm::ArrayRef<Expr *> getSizeExprs() { + return OpenACCClauseWithExprs::getExprs(); + } + + llvm::ArrayRef<Expr *> getSizeExprs() const { + return OpenACCClauseWithExprs::getExprs(); + } +}; + /// Represents one of a handful of clauses that have a single integer /// expression. class OpenACCClauseWithSingleIntExpr : public OpenACCClauseWithExprs { diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h index cd9947f7ab9805..cbbba9e88b7f5b 100644 --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -2867,6 +2867,7 @@ DEF_TRAVERSE_STMT(ParenListExpr, {}) DEF_TRAVERSE_STMT(SYCLUniqueStableNameExpr, { TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())); }) +DEF_TRAVERSE_STMT(OpenACCAsteriskSizeExpr, {}) DEF_TRAVERSE_STMT(PredefinedExpr, {}) DEF_TRAVERSE_STMT(ShuffleVectorExpr, {}) DEF_TRAVERSE_STMT(ConvertVectorExpr, {}) diff --git a/clang/include/clang/AST/TextNodeDumper.h b/clang/include/clang/AST/TextNodeDumper.h index 57100e7ede171c..9c320c8ae3e54c 100644 --- a/clang/include/clang/AST/TextNodeDumper.h +++ b/clang/include/clang/AST/TextNodeDumper.h @@ -410,6 +410,7 @@ class TextNodeDumper void VisitHLSLOutArgExpr(const HLSLOutArgExpr *E); void VisitOpenACCConstructStmt(const OpenACCConstructStmt *S); void VisitOpenACCLoopConstruct(const OpenACCLoopConstruct *S); + void VisitOpenACCAsteriskSizeExpr(const OpenACCAsteriskSizeExpr *S); void VisitEmbedExpr(const EmbedExpr *S); void VisitAtomicExpr(const AtomicExpr *AE); }; diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index dc84110ef78211..552120f6b7c9d3 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -12666,6 +12666,10 @@ def err_acc_loop_spec_conflict def err_acc_collapse_loop_count : Error<"OpenACC 'collapse' clause loop count must be a %select{constant " "expression|positive integer value, evaluated to %1}0">; +def err_acc_size_expr_value + : Error< + "OpenACC 'tile' clause size expression must be %select{an asterisk " + "or a constant expression|positive integer value, evaluated to %1}0">; def err_acc_invalid_in_collapse_loop : Error<"%select{OpenACC '%1' construct|while loop|do loop}0 cannot appear " "in intervening code of a 'loop' with a 'collapse' clause">; diff --git a/clang/include/clang/Basic/OpenACCClauses.def b/clang/include/clang/Basic/OpenACCClauses.def index 19cdfe7672133b..a380e5ae69c418 100644 --- a/clang/include/clang/Basic/OpenACCClauses.def +++ b/clang/include/clang/Basic/OpenACCClauses.def @@ -52,6 +52,7 @@ VISIT_CLAUSE(Private) VISIT_CLAUSE(Reduction) VISIT_CLAUSE(Self) VISIT_CLAUSE(Seq) +VISIT_CLAUSE(Tile) VISIT_CLAUSE(VectorLength) VISIT_CLAUSE(Wait) diff --git a/clang/include/clang/Basic/StmtNodes.td b/clang/include/clang/Basic/StmtNodes.td index 30f2c8f1dbfde8..dc82a4b6d1f777 100644 --- a/clang/include/clang/Basic/StmtNodes.td +++ b/clang/include/clang/Basic/StmtNodes.td @@ -308,5 +308,8 @@ def OpenACCAssociatedStmtConstruct def OpenACCComputeConstruct : StmtNode<OpenACCAssociatedStmtConstruct>; def OpenACCLoopConstruct : StmtNode<OpenACCAssociatedStmtConstruct>; +// OpenACC Additional Expressions. +def OpenACCAsteriskSizeExpr : StmtNode<Expr>; + // HLSL Constructs. def HLSLOutArgExpr : StmtNode<Expr>; diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h index eb8a851da7e04e..93e49d395388a6 100644 --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -3786,10 +3786,13 @@ class Parser : public CodeCompletionHandler { OpenACCIntExprParseResult ParseOpenACCAsyncArgument(OpenACCDirectiveKind DK, OpenACCClauseKind CK, SourceLocation Loc); + /// Parses the 'size-expr', which is an integral value, or an asterisk. - bool ParseOpenACCSizeExpr(); + /// Asterisk is represented by a OpenACCAsteriskSizeExpr + ExprResult ParseOpenACCSizeExpr(OpenACCClauseKind CK); /// Parses a comma delimited list of 'size-expr's. - bool ParseOpenACCSizeExprList(); + bool ParseOpenACCSizeExprList(OpenACCClauseKind CK, + llvm::SmallVectorImpl<Expr *> &SizeExprs); /// Parses a 'gang-arg-list', used for the 'gang' clause. bool ParseOpenACCGangArgList(SourceLocation GangLoc); /// Parses a 'gang-arg', used for the 'gang' clause. diff --git a/clang/include/clang/Sema/SemaOpenACC.h b/clang/include/clang/Sema/SemaOpenACC.h index 26564835fa1af6..d25c52ec3be43a 100644 --- a/clang/include/clang/Sema/SemaOpenACC.h +++ b/clang/include/clang/Sema/SemaOpenACC.h @@ -179,6 +179,7 @@ class SemaOpenACC : public SemaBase { assert((ClauseKind == OpenACCClauseKind::NumGangs || ClauseKind == OpenACCClauseKind::NumWorkers || ClauseKind == OpenACCClauseKind::Async || + ClauseKind == OpenACCClauseKind::Tile || ClauseKind == OpenACCClauseKind::VectorLength) && "Parsed clause kind does not have a int exprs"); @@ -224,6 +225,7 @@ class SemaOpenACC : public SemaBase { assert((ClauseKind == OpenACCClauseKind::NumGangs || ClauseKind == OpenACCClauseKind::NumWorkers || ClauseKind == OpenACCClauseKind::Async || + ClauseKind == OpenACCClauseKind::Tile || ClauseKind == OpenACCClauseKind::VectorLength) && "Parsed clause kind does not have a int exprs"); @@ -335,6 +337,7 @@ class SemaOpenACC : public SemaBase { assert((ClauseKind == OpenACCClauseKind::NumGangs || ClauseKind == OpenACCClauseKind::NumWorkers || ClauseKind == OpenACCClauseKind::Async || + ClauseKind == OpenACCClauseKind::Tile || ClauseKind == OpenACCClauseKind::VectorLength) && "Parsed clause kind does not have a int exprs"); Details = IntExprDetails{{IntExprs.begin(), IntExprs.end()}}; @@ -343,6 +346,7 @@ class SemaOpenACC : public SemaBase { assert((ClauseKind == OpenACCClauseKind::NumGangs || ClauseKind == OpenACCClauseKind::NumWorkers || ClauseKind == OpenACCClauseKind::Async || + ClauseKind == OpenACCClauseKind::Tile || ClauseKind == OpenACCClauseKind::VectorLength) && "Parsed clause kind does not have a int exprs"); Details = IntExprDetails{std::move(IntExprs)}; @@ -522,6 +526,12 @@ class SemaOpenACC : public SemaBase { SourceLocation RBLoc); /// Checks the loop depth value for a collapse clause. ExprResult CheckCollapseLoopCount(Expr *LoopCount); + /// Checks a single size expr for a tile clause. 'gang' could possibly call + /// this, but has slightly stricter rules as to valid values. + ExprResult CheckTileSizeExpr(Expr *SizeExpr); + + ExprResult BuildOpenACCAsteriskSizeExpr(SourceLocation AsteriskLoc); + ExprResult ActOnOpenACCAsteriskSizeExpr(SourceLocation AsteriskLoc); /// Helper type to restore the state of various 'loop' constructs when we run /// into a loop (for, etc) inside the construct. diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h index 1af1f4a10db290..4b79d4b7711905 100644 --- a/clang/include/clang/Serialization/ASTBitCodes.h +++ b/clang/include/clang/Serialization/ASTBitCodes.h @@ -2002,12 +2002,14 @@ enum StmtCode { // SYCLUniqueStableNameExpr EXPR_SYCL_UNIQUE_STABLE_NAME, - // OpenACC Constructs + // OpenACC Constructs/Exprs STMT_OPENACC_COMPUTE_CONSTRUCT, STMT_OPENACC_LOOP_CONSTRUCT, + EXPR_OPENACC_ASTERISK_SIZE, // HLSL Constructs EXPR_HLSL_OUT_ARG, + }; /// The kinds of designators that can occur in a diff --git a/clang/lib/AST/ComputeDependence.cpp b/clang/lib/AST/ComputeDependence.cpp index 6ef49790481aca..8c79df8317a2ec 100644 --- a/clang/lib/AST/ComputeDependence.cpp +++ b/clang/lib/AST/ComputeDependence.cpp @@ -958,3 +958,9 @@ ExprDependence clang::computeDependence(ObjCMessageExpr *E) { D |= A->getDependence(); return D; } + +ExprDependence clang::computeDependence(OpenACCAsteriskSizeExpr *E) { + // This represents a simple asterisk as typed, so cannot be dependent in any + // way. + return ExprDependence::None; +} diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index 2e463fc00c6b68..9ecbf121e3fc0d 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -3640,6 +3640,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, case SYCLUniqueStableNameExprClass: case PackIndexingExprClass: case HLSLOutArgExprClass: + case OpenACCAsteriskSizeExprClass: // These never have a side-effect. return false; @@ -5408,3 +5409,13 @@ HLSLOutArgExpr *HLSLOutArgExpr::Create(const ASTContext &C, QualType Ty, HLSLOutArgExpr *HLSLOutArgExpr::CreateEmpty(const ASTContext &C) { return new (C) HLSLOutArgExpr(EmptyShell()); } + +OpenACCAsteriskSizeExpr *OpenACCAsteriskSizeExpr::Create(const ASTContext &C, + SourceLocation Loc) { + return new (C) OpenACCAsteriskSizeExpr(Loc, C.IntTy); +} + +OpenACCAsteriskSizeExpr * +OpenACCAsteriskSizeExpr::CreateEmpty(const ASTContext &C) { + return new (C) OpenACCAsteriskSizeExpr({}, C.IntTy); +} diff --git a/clang/lib/AST/ExprClassification.cpp b/clang/lib/AST/ExprClassification.cpp index 9d97633309ada2..3f37d06cc8f3a0 100644 --- a/clang/lib/AST/ExprClassification.cpp +++ b/clang/lib/AST/ExprClassification.cpp @@ -471,6 +471,7 @@ static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) { case Expr::CoyieldExprClass: return ClassifyInternal(Ctx, cast<CoroutineSuspendExpr>(E)->getResumeExpr()); case Expr::SYCLUniqueStableNameExprClass: + case Expr::OpenACCAsteriskSizeExprClass: return Cl::CL_PRValue; break; diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index 3a73cea97fcc32..4d5af96093cfeb 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -11873,6 +11873,13 @@ class IntExprEvaluator return Success(E->getValue(), E); } + bool VisitOpenACCAsteriskSizeExpr(const OpenACCAsteriskSizeExpr *E) { + // This should not be evaluated during constant expr evaluation, as it + // should always be in an unevaluated context (the args list of a 'gang' or + // 'tile' clause). + return Error(E); + } + bool VisitUnaryReal(const UnaryOperator *E); bool VisitUnaryImag(const UnaryOperator *E); @@ -16908,6 +16915,7 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) { case Expr::GNUNullExprClass: case Expr::SourceLocExprClass: case Expr::EmbedExprClass: + case Expr::OpenACCAsteriskSizeExprClass: return NoDiag(); case Expr::PackIndexingExprClass: diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp index 70ed9cb0736f59..769a863c2b6764 100644 --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -5745,6 +5745,15 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity, case Expr::HLSLOutArgExprClass: llvm_unreachable( "cannot mangle hlsl temporary value; mangling wrong thing?"); + case Expr::OpenACCAsteriskSizeExprClass: { + // We shouldn't ever be able to get here, but diagnose anyway. + DiagnosticsEngine &Diags = Context.getDiags(); + unsigned DiagID = Diags.getCustomDiagID( + DiagnosticsEngine::Error, + "cannot yet mangle OpenACC Asterisk Size expression"); + Diags.Report(DiagID); + return; + } } if (AsTemplateArg && !IsPrimaryExpr) diff --git a/clang/lib/AST/JSONNodeDumper.cpp b/clang/lib/AST/JSONNodeDumper.cpp index 565f1e05710c87..ddbe2136a671f3 100644 --- a/clang/lib/AST/JSONNodeDumper.cpp +++ b/clang/lib/AST/JSONNodeDumper.cpp @@ -1354,6 +1354,9 @@ void JSONNodeDumper::VisitSYCLUniqueStableNameExpr( createQualType(E->getTypeSourceInfo()->getType())); } +void JSONNodeDumper::VisitOpenACCAsteriskSizeExpr( + const OpenACCAsteriskSizeExpr *E) {} + void JSONNodeDumper::VisitPredefinedExpr(const PredefinedExpr *PE) { JOS.attribute("name", PredefinedExpr::getIdentKindName(PE->getIdentKind())); } diff --git a/clang/lib/AST/OpenACCClause.cpp b/clang/lib/AST/OpenACCClause.cpp index d864ded33e8d1f..0b34ed6189593e 100644 --- a/clang/lib/AST/OpenACCClause.cpp +++ b/clang/lib/AST/OpenACCClause.cpp @@ -24,6 +24,7 @@ bool OpenACCClauseWithParams::classof(const OpenACCClause *C) { } bool OpenACCClauseWithExprs::classof(const OpenACCClause *C) { return OpenACCWaitClause::classof(C) || OpenACCNumGangsClause::classof(C) || + OpenACCTileClause::classof(C) || OpenACCClauseWithSingleIntExpr::classof(C) || OpenACCClauseWithVarList::classof(C); } @@ -221,6 +222,16 @@ OpenACCNumGangsClause *OpenACCNumGangsClause::Create(const ASTContext &C, return new (Mem) OpenACCNumGangsClause(BeginLoc, LParenLoc, IntExprs, EndLoc); } +OpenACCTileClause *OpenACCTileClause::Create(const ASTContext &C, + SourceLocation BeginLoc, + SourceLocation LParenLoc, + ArrayRef<Expr *> SizeExprs, + SourceLocation EndLoc) { + void *Mem = + C.Allocate(OpenACCTileClause::totalSizeToAlloc<Expr *>(SizeExprs.size())); + return new (Mem) OpenACCTileClause(BeginLoc, LParenLoc, SizeExprs, EndLoc); +} + OpenACCPrivateClause *OpenACCPrivateClause::Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, @@ -420,6 +431,13 @@ void OpenACCClausePrinter::VisitNumGangsClause(const OpenACCNumGangsClause &C) { OS << ")"; } +void OpenACCClausePrinter::VisitTileClause(const OpenACCTileClause &C) { + OS << "tile("; + llvm::interleaveComma(C.getSizeExprs(), OS, + [&](const Expr *E) { printExpr(E); }); + OS << ")"; +} + void OpenACCClausePrinter::VisitNumWorkersClause( const OpenACCNumWorkersClause &C) { OS << "num_workers("; diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp index e1b5bec7a50d0a..641f7b52de6dfb 100644 --- a/clang/lib/AST/StmtPrinter.cpp +++ b/clang/lib/AST/StmtPrinter.cpp @@ -1309,6 +1309,10 @@ void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) { OS << PredefinedExpr::getIdentKindName(Node->getIdentKind()); } +void StmtPrinter::VisitOpenACCAsteriskSizeExpr(OpenACCAsteriskSizeExpr *Node) { + OS << '*'; +} + void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) { CharacterLiteral::print(Node->getValue(), Node->getKind(), OS); } diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp index c3812844ab8a31..299ac005c7fdb9 100644 --- a/clang/lib/AST/StmtProfile.cpp +++ b/clang/lib/AST/StmtProfile.cpp @@ -1360,6 +1360,11 @@ void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) { ID.AddInteger(llvm::to_underlying(S->getIdentKind())); } +void StmtProfiler::VisitOpenACCAsteriskSizeExpr( + const OpenACCAsteriskSizeExpr *S) { + VisitExpr(S); +} + void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) { VisitExpr(S); S->getValue().Profile(ID); @@ -2552,6 +2557,11 @@ void OpenACCClauseProfiler::VisitNumGangsClause( Profiler.VisitStmt(E); } +void OpenACCClauseProfiler::VisitTileClause(const OpenACCTileClause &Clause) { + for (auto *E : Clause.getSizeExprs()) + Profiler.VisitStm... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/110999 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
