3af717d661
Derived from #92480. This PR supports parsing of the DO CONCURRENT REDUCE clause in Fortran 2023. Following the style of the OpenMP parser in MLIR, the front end accepts both arbitrary operations and procedures for the REDUCE clause. But later Semantics can notify type errors and resolve procedure names.
277 lines
12 KiB
C++
277 lines
12 KiB
C++
//===-- lib/Parser/openacc-parsers.cpp ------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Top-level grammar specification for OpenACC 3.3.
|
|
|
|
#include "basic-parsers.h"
|
|
#include "expr-parsers.h"
|
|
#include "misc-parsers.h"
|
|
#include "stmt-parser.h"
|
|
#include "token-parsers.h"
|
|
#include "type-parser-implementation.h"
|
|
#include "flang/Parser/parse-tree.h"
|
|
|
|
// OpenACC Directives and Clauses
|
|
namespace Fortran::parser {
|
|
|
|
constexpr auto startAccLine{skipStuffBeforeStatement >>
|
|
("!$ACC "_sptok || "C$ACC "_sptok || "*$ACC "_sptok)};
|
|
constexpr auto endAccLine{space >> endOfLine};
|
|
|
|
// Autogenerated clauses parser. Information is taken from ACC.td and the
|
|
// parser is generated by tablegen.
|
|
// Scalar value parsers are provided by Flang directly. Specific value parsers
|
|
// are provided below.
|
|
#define GEN_FLANG_CLAUSES_PARSER
|
|
#include "llvm/Frontend/OpenACC/ACC.inc"
|
|
|
|
TYPE_PARSER(
|
|
construct<AccObject>(designator) || construct<AccObject>("/" >> name / "/"))
|
|
|
|
TYPE_PARSER(construct<AccObjectList>(nonemptyList(Parser<AccObject>{})))
|
|
|
|
TYPE_PARSER(construct<AccObjectListWithModifier>(
|
|
maybe(Parser<AccDataModifier>{}), Parser<AccObjectList>{}))
|
|
|
|
TYPE_PARSER(construct<AccObjectListWithReduction>(
|
|
Parser<ReductionOperator>{} / ":", Parser<AccObjectList>{}))
|
|
|
|
// 2.16 (3249) wait-argument is:
|
|
// [devnum : int-expr :] [queues :] int-expr-list
|
|
TYPE_PARSER(construct<AccWaitArgument>(maybe("DEVNUM:" >> scalarIntExpr / ":"),
|
|
"QUEUES:" >> nonemptyList(scalarIntExpr) || nonemptyList(scalarIntExpr)))
|
|
|
|
// 2.9 (1984-1986) size-expr is one of:
|
|
// * (represented as an empty std::optional<ScalarIntExpr>)
|
|
// int-expr
|
|
TYPE_PARSER(construct<AccSizeExpr>(scalarIntExpr) ||
|
|
construct<AccSizeExpr>("*" >> construct<std::optional<ScalarIntExpr>>()))
|
|
TYPE_PARSER(construct<AccSizeExprList>(nonemptyList(Parser<AccSizeExpr>{})))
|
|
|
|
TYPE_PARSER(sourced(construct<AccDeviceTypeExpr>(
|
|
first("*" >> pure(Fortran::common::OpenACCDeviceType::Star),
|
|
"DEFAULT" >> pure(Fortran::common::OpenACCDeviceType::Default),
|
|
"NVIDIA" >> pure(Fortran::common::OpenACCDeviceType::Nvidia),
|
|
"ACC_DEVICE_NVIDIA" >> pure(Fortran::common::OpenACCDeviceType::Nvidia),
|
|
"RADEON" >> pure(Fortran::common::OpenACCDeviceType::Radeon),
|
|
"HOST" >> pure(Fortran::common::OpenACCDeviceType::Host),
|
|
"MULTICORE" >> pure(Fortran::common::OpenACCDeviceType::Multicore)))))
|
|
|
|
TYPE_PARSER(
|
|
construct<AccDeviceTypeExprList>(nonemptyList(Parser<AccDeviceTypeExpr>{})))
|
|
|
|
// tile size is one of:
|
|
// * (represented as an empty std::optional<ScalarIntExpr>)
|
|
// constant-int-expr
|
|
TYPE_PARSER(construct<AccTileExpr>(scalarIntConstantExpr) ||
|
|
construct<AccTileExpr>(
|
|
"*" >> construct<std::optional<ScalarIntConstantExpr>>()))
|
|
TYPE_PARSER(construct<AccTileExprList>(nonemptyList(Parser<AccTileExpr>{})))
|
|
|
|
// 2.9 (1979-1982) gang-arg is one of :
|
|
// [num:]int-expr
|
|
// dim:int-expr
|
|
// static:size-expr
|
|
TYPE_PARSER(construct<AccGangArg>(construct<AccGangArg::Static>(
|
|
"STATIC: " >> Parser<AccSizeExpr>{})) ||
|
|
construct<AccGangArg>(
|
|
construct<AccGangArg::Dim>("DIM: " >> scalarIntExpr)) ||
|
|
construct<AccGangArg>(
|
|
construct<AccGangArg::Num>(maybe("NUM: "_tok) >> scalarIntExpr)))
|
|
|
|
// 2.9 gang-arg-list
|
|
TYPE_PARSER(
|
|
construct<AccGangArgList>(many(maybe(","_tok) >> Parser<AccGangArg>{})))
|
|
|
|
// 2.9.1 collapse
|
|
TYPE_PARSER(construct<AccCollapseArg>(
|
|
"FORCE:"_tok >> pure(true) || pure(false), scalarIntConstantExpr))
|
|
|
|
// 2.5.15 Reduction, F'2023 R1131, and CUF reduction-op
|
|
// Operator for reduction
|
|
TYPE_PARSER(sourced(construct<ReductionOperator>(
|
|
first("+" >> pure(ReductionOperator::Operator::Plus),
|
|
"*" >> pure(ReductionOperator::Operator::Multiply),
|
|
"MAX" >> pure(ReductionOperator::Operator::Max),
|
|
"MIN" >> pure(ReductionOperator::Operator::Min),
|
|
"IAND" >> pure(ReductionOperator::Operator::Iand),
|
|
"IOR" >> pure(ReductionOperator::Operator::Ior),
|
|
"IEOR" >> pure(ReductionOperator::Operator::Ieor),
|
|
".AND." >> pure(ReductionOperator::Operator::And),
|
|
".OR." >> pure(ReductionOperator::Operator::Or),
|
|
".EQV." >> pure(ReductionOperator::Operator::Eqv),
|
|
".NEQV." >> pure(ReductionOperator::Operator::Neqv)))))
|
|
|
|
// 2.15.1 Bind clause
|
|
TYPE_PARSER(sourced(construct<AccBindClause>(name)) ||
|
|
sourced(construct<AccBindClause>(scalarDefaultCharExpr)))
|
|
|
|
// 2.5.16 Default clause
|
|
TYPE_PARSER(construct<AccDefaultClause>(
|
|
first("NONE" >> pure(llvm::acc::DefaultValue::ACC_Default_none),
|
|
"PRESENT" >> pure(llvm::acc::DefaultValue::ACC_Default_present))))
|
|
|
|
// SELF clause is either a simple optional condition for compute construct
|
|
// or a synonym of the HOST clause for the update directive 2.14.4 holding
|
|
// an object list.
|
|
TYPE_PARSER(construct<AccSelfClause>(Parser<AccObjectList>{}) ||
|
|
construct<AccSelfClause>(scalarLogicalExpr))
|
|
|
|
// Modifier for copyin, copyout, cache and create
|
|
TYPE_PARSER(construct<AccDataModifier>(
|
|
first("ZERO:" >> pure(AccDataModifier::Modifier::Zero),
|
|
"READONLY:" >> pure(AccDataModifier::Modifier::ReadOnly))))
|
|
|
|
// Combined directives
|
|
TYPE_PARSER(sourced(construct<AccCombinedDirective>(
|
|
first("KERNELS LOOP" >> pure(llvm::acc::Directive::ACCD_kernels_loop),
|
|
"PARALLEL LOOP" >> pure(llvm::acc::Directive::ACCD_parallel_loop),
|
|
"SERIAL LOOP" >> pure(llvm::acc::Directive::ACCD_serial_loop)))))
|
|
|
|
// Block directives
|
|
TYPE_PARSER(sourced(construct<AccBlockDirective>(
|
|
first("DATA" >> pure(llvm::acc::Directive::ACCD_data),
|
|
"HOST_DATA" >> pure(llvm::acc::Directive::ACCD_host_data),
|
|
"KERNELS" >> pure(llvm::acc::Directive::ACCD_kernels),
|
|
"PARALLEL" >> pure(llvm::acc::Directive::ACCD_parallel),
|
|
"SERIAL" >> pure(llvm::acc::Directive::ACCD_serial)))))
|
|
|
|
// Standalone directives
|
|
TYPE_PARSER(sourced(construct<AccStandaloneDirective>(
|
|
first("ENTER DATA" >> pure(llvm::acc::Directive::ACCD_enter_data),
|
|
"EXIT DATA" >> pure(llvm::acc::Directive::ACCD_exit_data),
|
|
"INIT" >> pure(llvm::acc::Directive::ACCD_init),
|
|
"SHUTDOWN" >> pure(llvm::acc::Directive::ACCD_shutdown),
|
|
"SET" >> pure(llvm::acc::Directive::ACCD_set),
|
|
"UPDATE" >> pure(llvm::acc::Directive::ACCD_update)))))
|
|
|
|
// Loop directives
|
|
TYPE_PARSER(sourced(construct<AccLoopDirective>(
|
|
first("LOOP" >> pure(llvm::acc::Directive::ACCD_loop)))))
|
|
|
|
TYPE_PARSER(construct<AccBeginLoopDirective>(
|
|
sourced(Parser<AccLoopDirective>{}), Parser<AccClauseList>{}))
|
|
|
|
TYPE_PARSER(construct<AccEndLoop>("END LOOP"_tok))
|
|
|
|
TYPE_PARSER(construct<OpenACCLoopConstruct>(
|
|
sourced(Parser<AccBeginLoopDirective>{} / endAccLine),
|
|
maybe(Parser<DoConstruct>{}),
|
|
maybe(startAccLine >> Parser<AccEndLoop>{} / endAccLine)))
|
|
|
|
// 2.15.1 Routine directive
|
|
TYPE_PARSER(sourced(construct<OpenACCRoutineConstruct>(verbatim("ROUTINE"_tok),
|
|
maybe(parenthesized(name)), Parser<AccClauseList>{})))
|
|
|
|
// 2.10 Cache directive
|
|
TYPE_PARSER(sourced(
|
|
construct<OpenACCCacheConstruct>(sourced(construct<Verbatim>("CACHE"_tok)),
|
|
parenthesized(Parser<AccObjectListWithModifier>{}))))
|
|
|
|
// 2.11 Combined constructs
|
|
TYPE_PARSER(construct<AccBeginCombinedDirective>(
|
|
sourced(Parser<AccCombinedDirective>{}), Parser<AccClauseList>{}))
|
|
|
|
// 2.12 Atomic constructs
|
|
TYPE_PARSER(construct<AccEndAtomic>(startAccLine >> "END ATOMIC"_tok))
|
|
|
|
TYPE_PARSER("ATOMIC" >>
|
|
construct<AccAtomicRead>(verbatim("READ"_tok) / endAccLine,
|
|
statement(assignmentStmt), maybe(Parser<AccEndAtomic>{} / endAccLine)))
|
|
|
|
TYPE_PARSER("ATOMIC" >>
|
|
construct<AccAtomicWrite>(verbatim("WRITE"_tok) / endAccLine,
|
|
statement(assignmentStmt), maybe(Parser<AccEndAtomic>{} / endAccLine)))
|
|
|
|
TYPE_PARSER("ATOMIC" >>
|
|
construct<AccAtomicUpdate>(maybe(verbatim("UPDATE"_tok)) / endAccLine,
|
|
statement(assignmentStmt), maybe(Parser<AccEndAtomic>{} / endAccLine)))
|
|
|
|
TYPE_PARSER("ATOMIC" >>
|
|
construct<AccAtomicCapture>(verbatim("CAPTURE"_tok) / endAccLine,
|
|
statement(assignmentStmt), statement(assignmentStmt),
|
|
Parser<AccEndAtomic>{} / endAccLine))
|
|
|
|
TYPE_PARSER(
|
|
sourced(construct<OpenACCAtomicConstruct>(Parser<AccAtomicRead>{})) ||
|
|
sourced(construct<OpenACCAtomicConstruct>(Parser<AccAtomicCapture>{})) ||
|
|
sourced(construct<OpenACCAtomicConstruct>(Parser<AccAtomicWrite>{})) ||
|
|
sourced(construct<OpenACCAtomicConstruct>(Parser<AccAtomicUpdate>{})))
|
|
|
|
// 2.13 Declare constructs
|
|
TYPE_PARSER(sourced(construct<AccDeclarativeDirective>(
|
|
first("DECLARE" >> pure(llvm::acc::Directive::ACCD_declare)))))
|
|
|
|
// [Clause, [Clause], ...]
|
|
TYPE_PARSER(sourced(construct<AccClauseList>(
|
|
many(maybe(","_tok) >> sourced(Parser<AccClause>{})))))
|
|
|
|
// 2.16.3 Wait directive
|
|
TYPE_PARSER(sourced(construct<OpenACCWaitConstruct>(
|
|
sourced(construct<Verbatim>("WAIT"_tok)),
|
|
maybe(parenthesized(Parser<AccWaitArgument>{})), Parser<AccClauseList>{})))
|
|
|
|
// Block Constructs
|
|
TYPE_PARSER(sourced(construct<AccBeginBlockDirective>(
|
|
sourced(Parser<AccBlockDirective>{}), Parser<AccClauseList>{})))
|
|
|
|
TYPE_PARSER(startAccLine >> sourced(construct<AccEndBlockDirective>("END"_tok >>
|
|
sourced(Parser<AccBlockDirective>{}))))
|
|
|
|
TYPE_PARSER(construct<OpenACCBlockConstruct>(
|
|
Parser<AccBeginBlockDirective>{} / endAccLine, block,
|
|
Parser<AccEndBlockDirective>{} / endAccLine))
|
|
|
|
// Standalone constructs
|
|
TYPE_PARSER(construct<OpenACCStandaloneConstruct>(
|
|
sourced(Parser<AccStandaloneDirective>{}), Parser<AccClauseList>{}))
|
|
|
|
// Standalone declarative constructs
|
|
TYPE_PARSER(construct<OpenACCStandaloneDeclarativeConstruct>(
|
|
sourced(Parser<AccDeclarativeDirective>{}), Parser<AccClauseList>{}))
|
|
|
|
TYPE_PARSER(startAccLine >>
|
|
withMessage("expected OpenACC directive"_err_en_US,
|
|
first(sourced(construct<OpenACCDeclarativeConstruct>(
|
|
Parser<OpenACCStandaloneDeclarativeConstruct>{})),
|
|
sourced(construct<OpenACCDeclarativeConstruct>(
|
|
Parser<OpenACCRoutineConstruct>{})))))
|
|
|
|
TYPE_PARSER(sourced(construct<OpenACCEndConstruct>(
|
|
"END"_tok >> "LOOP"_tok >> pure(llvm::acc::Directive::ACCD_loop))))
|
|
|
|
// OpenACC constructs
|
|
TYPE_CONTEXT_PARSER("OpenACC construct"_en_US,
|
|
startAccLine >>
|
|
withMessage("expected OpenACC directive"_err_en_US,
|
|
first(construct<OpenACCConstruct>(Parser<OpenACCBlockConstruct>{}),
|
|
construct<OpenACCConstruct>(Parser<OpenACCCombinedConstruct>{}),
|
|
construct<OpenACCConstruct>(Parser<OpenACCLoopConstruct>{}),
|
|
construct<OpenACCConstruct>(
|
|
Parser<OpenACCStandaloneConstruct>{}),
|
|
construct<OpenACCConstruct>(Parser<OpenACCCacheConstruct>{}),
|
|
construct<OpenACCConstruct>(Parser<OpenACCWaitConstruct>{}),
|
|
construct<OpenACCConstruct>(Parser<OpenACCAtomicConstruct>{}),
|
|
construct<OpenACCConstruct>(Parser<OpenACCEndConstruct>{}))))
|
|
|
|
TYPE_PARSER(startAccLine >>
|
|
sourced(construct<AccEndCombinedDirective>(sourced("END"_tok >>
|
|
construct<AccCombinedDirective>("KERNELS"_tok >> maybe("LOOP"_tok) >>
|
|
pure(llvm::acc::Directive::ACCD_kernels_loop) ||
|
|
"PARALLEL"_tok >> maybe("LOOP"_tok) >>
|
|
pure(llvm::acc::Directive::ACCD_parallel_loop) ||
|
|
"SERIAL"_tok >> maybe("LOOP"_tok) >>
|
|
pure(llvm::acc::Directive::ACCD_serial_loop))))))
|
|
|
|
TYPE_PARSER(construct<OpenACCCombinedConstruct>(
|
|
sourced(Parser<AccBeginCombinedDirective>{} / endAccLine),
|
|
maybe(Parser<DoConstruct>{}),
|
|
maybe(Parser<AccEndCombinedDirective>{} / endAccLine)))
|
|
|
|
} // namespace Fortran::parser
|