vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
302 lines
13 KiB
C++
302 lines
13 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 {
|
|
|
|
// Only need to handle ! line comments because prescanning normalizes the
|
|
// other types of line comments from fixed form.
|
|
constexpr auto startAccLine{skipStuffBeforeStatement >>
|
|
withMessage(
|
|
"expected OpenACC directive sentinel: !$ACC, C$ACC, or *$ACC"_err_en_US,
|
|
"!$ACC "_sptok)};
|
|
constexpr auto endAccLine{space >>
|
|
recovery(
|
|
withMessage("expected end of OpenACC directive"_err_en_US, endOfLine),
|
|
SkipTo<'\n'>{} || ok)};
|
|
|
|
// 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>{}) / lookAhead(")"_tok) ||
|
|
construct<AccSelfClause>(scalarLogicalExpr / lookAhead(")"_tok)) ||
|
|
construct<AccSelfClause>(
|
|
recovery(fail<std::optional<ScalarLogicalExpr>>(
|
|
"logical expression or object list expected"_err_en_US),
|
|
SkipTo<')'>{} >> pure<std::optional<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),
|
|
Parser<AccClauseList>{} / endAccLine,
|
|
statement(assignmentStmt),
|
|
maybe(Parser<AccEndAtomic>{} / endAccLine)))
|
|
|
|
TYPE_PARSER("ATOMIC" >> construct<AccAtomicWrite>(verbatim("WRITE"_tok),
|
|
Parser<AccClauseList>{} / endAccLine,
|
|
statement(assignmentStmt),
|
|
maybe(Parser<AccEndAtomic>{} / endAccLine)))
|
|
|
|
TYPE_PARSER("ATOMIC" >>
|
|
construct<AccAtomicUpdate>(maybe(verbatim("UPDATE"_tok)),
|
|
Parser<AccClauseList>{} / endAccLine, statement(assignmentStmt),
|
|
maybe(Parser<AccEndAtomic>{} / endAccLine)))
|
|
|
|
TYPE_PARSER("ATOMIC" >>
|
|
construct<AccAtomicCapture>(verbatim("CAPTURE"_tok),
|
|
Parser<AccClauseList>{} / 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 >>
|
|
recovery(sourced(Parser<AccBlockDirective>{}),
|
|
construct<AccBlockDirective>(pure(
|
|
llvm::acc::Directive::ACCD_data))))))
|
|
|
|
TYPE_PARSER(construct<OpenACCBlockConstruct>(
|
|
Parser<AccBeginBlockDirective>{} / endAccLine, block,
|
|
// NB, This allows mismatched directives, but semantics checks that they
|
|
// match.
|
|
recovery(withMessage("expected OpenACC end block directive"_err_en_US,
|
|
attempt(Parser<AccEndBlockDirective>{} / endAccLine)),
|
|
construct<AccEndBlockDirective>(construct<AccBlockDirective>(
|
|
pure(llvm::acc::Directive::ACCD_data))))))
|
|
|
|
// 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,
|
|
// Combined constructs before block constructs so we try to match
|
|
// the longest possible match first.
|
|
first(
|
|
construct<OpenACCConstruct>(Parser<OpenACCCombinedConstruct>{}),
|
|
construct<OpenACCConstruct>(Parser<OpenACCBlockConstruct>{}),
|
|
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
|