llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-flang-driver @llvm/pr-subscribers-flang-openmp Author: Krzysztof Parzyszek (kparzysz) <details> <summary>Changes</summary> It's unsigned now. Giving it a separate type would make the code clearer, and it would make it easier to change the effective type if it's ever needed. --- <sub>Stack created with <a href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub> --- Patch is 354.94 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/219820.diff 17 Files Affected: - (modified) clang/lib/AST/StmtPrinter.cpp (+6-3) - (modified) flang/lib/Frontend/CompilerInvocation.cpp (+2-1) - (modified) llvm/include/llvm/Frontend/OpenMP/ConstructDecompositionT.h (+3-3) - (modified) llvm/include/llvm/Frontend/OpenMP/OMP.h (+11-9) - (modified) llvm/include/llvm/Frontend/OpenMP/OMPDescriptors.h (+10-10) - (added) llvm/include/llvm/Frontend/OpenMP/OMPVersion.h (+61) - (modified) llvm/lib/Frontend/OpenMP/DirectiveNameParser.cpp (+2-2) - (modified) llvm/lib/Frontend/OpenMP/OMP.cpp (+9-7) - (modified) llvm/lib/Frontend/OpenMP/OMPDescriptors.cpp (+9-9) - (modified) llvm/lib/Frontend/OpenMP/OMPDescriptors.inc (+788-788) - (modified) llvm/test/TableGen/directive1.td (+13-13) - (modified) llvm/test/TableGen/directive2.td (+12-12) - (modified) llvm/unittests/Frontend/OpenMPDecompositionTest.cpp (+1-1) - (modified) llvm/unittests/Frontend/OpenMPDirectiveNameParserTest.cpp (+4-3) - (modified) llvm/unittests/Frontend/OpenMPDirectiveNameTest.cpp (+5-5) - (modified) llvm/unittests/Frontend/OpenMPParsingTest.cpp (+9-7) - (modified) llvm/utils/TableGen/Basic/DirectiveEmitter.cpp (+28-17) ``````````diff diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp index 31d670842ff87..3cab31a300028 100644 --- a/clang/lib/AST/StmtPrinter.cpp +++ b/clang/lib/AST/StmtPrinter.cpp @@ -780,7 +780,8 @@ void StmtPrinter::VisitOMPCanonicalLoop(OMPCanonicalLoop *Node) { void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S, bool ForceNoStmt) { unsigned OpenMPVersion = - Context ? Context->getLangOpts().OpenMP : llvm::omp::FallbackVersion; + Context ? Context->getLangOpts().OpenMP + : static_cast<unsigned>(llvm::omp::FallbackVersion); OMPClausePrinter Printer(OS, Policy, OpenMPVersion); ArrayRef<OMPClause *> Clauses = S->clauses(); for (auto *Clause : Clauses) @@ -1026,7 +1027,8 @@ void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) { void StmtPrinter::VisitOMPCancellationPointDirective( OMPCancellationPointDirective *Node) { unsigned OpenMPVersion = - Context ? Context->getLangOpts().OpenMP : llvm::omp::FallbackVersion; + Context ? Context->getLangOpts().OpenMP + : static_cast<unsigned>(llvm::omp::FallbackVersion); Indent() << "#pragma omp cancellation point " << getOpenMPDirectiveName(Node->getCancelRegion(), OpenMPVersion); PrintOMPExecutableDirective(Node); @@ -1034,7 +1036,8 @@ void StmtPrinter::VisitOMPCancellationPointDirective( void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) { unsigned OpenMPVersion = - Context ? Context->getLangOpts().OpenMP : llvm::omp::FallbackVersion; + Context ? Context->getLangOpts().OpenMP + : static_cast<unsigned>(llvm::omp::FallbackVersion); Indent() << "#pragma omp cancel " << getOpenMPDirectiveName(Node->getCancelRegion(), OpenMPVersion); PrintOMPExecutableDirective(Node); diff --git a/flang/lib/Frontend/CompilerInvocation.cpp b/flang/lib/Frontend/CompilerInvocation.cpp index 988f8cb65d176..933446771dddc 100644 --- a/flang/lib/Frontend/CompilerInvocation.cpp +++ b/flang/lib/Frontend/CompilerInvocation.cpp @@ -1305,7 +1305,8 @@ static bool parseOpenMPArgs(CompilerInvocation &res, llvm::opt::ArgList &args, res.getFrontendOpts().features.Enable( Fortran::common::LanguageFeature::OpenMP); if (auto *arg = args.getLastArg(clang::options::OPT_fopenmp_version_EQ)) { - llvm::ArrayRef<unsigned> ompVersions = llvm::omp::getOpenMPVersions(); + llvm::ArrayRef<llvm::omp::Version> ompVersions = + llvm::omp::getOpenMPVersions(); unsigned oldVersions[] = {11, 20, 25, 30}; unsigned version = 0; diff --git a/llvm/include/llvm/Frontend/OpenMP/ConstructDecompositionT.h b/llvm/include/llvm/Frontend/OpenMP/ConstructDecompositionT.h index d252f222f73d0..7bd55875eec45 100644 --- a/llvm/include/llvm/Frontend/OpenMP/ConstructDecompositionT.h +++ b/llvm/include/llvm/Frontend/OpenMP/ConstructDecompositionT.h @@ -97,7 +97,7 @@ struct ConstructDecompositionT { using ClauseSet = std::unordered_set<const ClauseTy *>; - ConstructDecompositionT(uint32_t ver, HelperType &helper, + ConstructDecompositionT(llvm::omp::Version ver, HelperType &helper, llvm::omp::Directive dir, llvm::ArrayRef<ClauseTy> clauses) : version(ver), helper(helper), inputDirective(dir) { @@ -263,7 +263,7 @@ struct ConstructDecompositionT { applyClause(const tomp::clause::ThreadLimitT<TypeTy, IdTy, ExprTy> &clause, const ClauseTy *); - uint32_t version; + llvm::omp::Version version; HelperType &helper; llvm::omp::Directive inputDirective; tomp::ListT<const ClauseTy *> inputClauses; @@ -277,7 +277,7 @@ struct ConstructDecompositionT { // Deduction guide template <typename ClauseType, typename HelperType> -ConstructDecompositionT(uint32_t, HelperType &, llvm::omp::Directive, +ConstructDecompositionT(llvm::omp::Version, HelperType &, llvm::omp::Directive, llvm::ArrayRef<ClauseType>) -> ConstructDecompositionT<ClauseType, HelperType>; diff --git a/llvm/include/llvm/Frontend/OpenMP/OMP.h b/llvm/include/llvm/Frontend/OpenMP/OMP.h index f31b5d7f587ea..6740643021995 100644 --- a/llvm/include/llvm/Frontend/OpenMP/OMP.h +++ b/llvm/include/llvm/Frontend/OpenMP/OMP.h @@ -13,14 +13,17 @@ #ifndef LLVM_FRONTEND_OPENMP_OMP_H #define LLVM_FRONTEND_OPENMP_OMP_H -#include "llvm/Frontend/OpenMP/OMP.h.inc" #include "llvm/Support/Compiler.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/Bitset.h" +#include "llvm/ADT/DenseMapInfo.h" #include "llvm/ADT/Sequence.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" +#include "llvm/Frontend/OpenMP/OMPVersion.h" + +#include "llvm/Frontend/OpenMP/OMP.h.inc" namespace llvm::omp { template <typename Enum, size_t Size> struct EnumSet; @@ -187,7 +190,7 @@ static constexpr inline bool canHaveIterator(Clause C) { } // Can clause C create a private copy of a variable. -static constexpr inline bool isPrivatizingClause(Clause C, unsigned Version) { +static constexpr inline bool isPrivatizingClause(Clause C, Version V) { switch (C) { case OMPC_firstprivate: case OMPC_in_reduction: @@ -201,17 +204,16 @@ static constexpr inline bool isPrivatizingClause(Clause C, unsigned Version) { case OMPC_induction: case OMPC_is_device_ptr: case OMPC_use_device_ptr: - return Version >= 60; + return V >= 60; default: return false; } } -static constexpr inline bool isDataSharingAttributeClause(Clause C, - unsigned Version) { +static constexpr inline bool isDataSharingAttributeClause(Clause C, Version V) { // The "Version" parameter is in case the result is version-depenent // in the future. - (void)Version; + (void)V; switch (C) { case OMPC_detach: case OMPC_firstprivate: @@ -244,12 +246,12 @@ static constexpr inline bool isEndClause(Clause C) { } } -static constexpr unsigned FallbackVersion = 52; -LLVM_ABI ArrayRef<unsigned> getOpenMPVersions(); +static constexpr Version FallbackVersion(52); +LLVM_ABI ArrayRef<Version> getOpenMPVersions(); /// Can directive D, under some circumstances, create a private copy /// of a variable in given OpenMP version? -LLVM_ABI bool isPrivatizingConstruct(Directive D, unsigned Version); +LLVM_ABI bool isPrivatizingConstruct(Directive D, Version V); LLVM_ABI ArrayRef<StringRef> getReservedLocatorNames(); diff --git a/llvm/include/llvm/Frontend/OpenMP/OMPDescriptors.h b/llvm/include/llvm/Frontend/OpenMP/OMPDescriptors.h index 1cb2a273287b0..f09f35b58d204 100644 --- a/llvm/include/llvm/Frontend/OpenMP/OMPDescriptors.h +++ b/llvm/include/llvm/Frontend/OpenMP/OMPDescriptors.h @@ -62,7 +62,7 @@ struct Modifier : public Base { }; } // namespace details -template <typename DetailsTy> using DetailsMap = DenseMap<unsigned, DetailsTy>; +template <typename DetailsTy> using DetailsMap = DenseMap<Version, DetailsTy>; template <typename DetailsTy> struct Descriptor { Descriptor(const Descriptor &) = default; @@ -73,9 +73,9 @@ template <typename DetailsTy> struct Descriptor { StringRef getName() const { return Name; } const DetailsMap<DetailsTy> &getDetails() const { return Details; } - SmallVector<unsigned> getVersions() const { - SmallVector<unsigned> Vs; - for (unsigned V : llvm::omp::getOpenMPVersions()) { + SmallVector<Version> getVersions() const { + SmallVector<Version> Vs; + for (Version V : llvm::omp::getOpenMPVersions()) { if (auto F = Details.find(V); F != Details.end()) Vs.push_back(V); } @@ -92,16 +92,16 @@ template <typename DetailsTy> struct Descriptor { struct Clause : public Descriptor<details::Clause> { using Base = Descriptor<details::Clause>; using Base::Base; - LLVM_ABI Properties getProperties(unsigned V) const; - LLVM_ABI Directives getDirectives(unsigned V) const; - LLVM_ABI Modifiers getModifiers(unsigned V) const; + LLVM_ABI Properties getProperties(Version V) const; + LLVM_ABI Directives getDirectives(Version V) const; + LLVM_ABI Modifiers getModifiers(Version V) const; }; struct Modifier : public Descriptor<details::Modifier> { using Base = Descriptor<details::Modifier>; using Base::Base; - LLVM_ABI Properties getProperties(unsigned V) const; - LLVM_ABI Clauses getClauses(unsigned V) const; + LLVM_ABI Properties getProperties(Version V) const; + LLVM_ABI Clauses getClauses(Version V) const; }; } // namespace descriptor @@ -111,7 +111,7 @@ using DescriptorMap = DenseMap<Enum, DescriptorTy>; LLVM_ABI const descriptor::Clause &getDescriptor(llvm::omp::Clause C); LLVM_ABI const descriptor::Modifier &getDescriptor(llvm::omp::Modifier M); -LLVM_ABI Properties getProperties(Clause C, unsigned Version); +LLVM_ABI Properties getProperties(Clause C, Version V); } // namespace llvm::omp #endif // LLVM_FRONTEND_OPENMP_OMPDESCRIPTORS_H diff --git a/llvm/include/llvm/Frontend/OpenMP/OMPVersion.h b/llvm/include/llvm/Frontend/OpenMP/OMPVersion.h new file mode 100644 index 0000000000000..508c14b3df4ab --- /dev/null +++ b/llvm/include/llvm/Frontend/OpenMP/OMPVersion.h @@ -0,0 +1,61 @@ +//===-- OMPVersion.h - OpenMP version definition ------------------ C++ -*-===// +// +// 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 +// +//===----------------------------------------------------------------------===// +// +// This file contains the core set of OpenMP definitions and declarations. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_FRONTEND_OPENMP_OMPVERSION_H +#define LLVM_FRONTEND_OPENMP_OMPVERSION_H + +#include "llvm/ADT/DenseMapInfo.h" + +namespace llvm { +namespace omp { +struct Version { + using value_type = unsigned; + constexpr Version(value_type Ver = 0) : V(Ver) {} + constexpr operator value_type() const { return V; } + constexpr explicit operator bool() const { return V != 0; } + + friend constexpr bool operator<(Version A, Version B); + friend constexpr bool operator==(Version A, Version B); + +private: + value_type V; +}; + +inline constexpr bool operator==(Version A, Version B) { return A.V == B.V; } +inline constexpr bool operator!=(Version A, Version B) { return !(A == B); } +inline constexpr bool operator<(Version A, Version B) { return A.V < B.V; } +inline constexpr bool operator<=(Version A, Version B) { + return A < B || A == B; +} +inline constexpr bool operator>(Version A, Version B) { return !(A <= B); } +inline constexpr bool operator>=(Version A, Version B) { return !(A < B); } + +inline constexpr bool operator==(Version A, int B) { return A == Version(B); } +inline constexpr bool operator==(Version A, unsigned B) { return A == Version(B); } +inline constexpr bool operator!=(Version A, int B) { return A != Version(B); } +inline constexpr bool operator<(Version A, int B) { return A < Version(B); } +inline constexpr bool operator<=(Version A, int B) { return A <= Version(B); } +inline constexpr bool operator>(Version A, int B) { return A > Version(B); } +inline constexpr bool operator>=(Version A, int B) { return A >= Version(B); } +} // namespace omp + +template <> struct DenseMapInfo<omp::Version> { + static unsigned getHashValue(omp::Version V) { + using UnderlyingTy = omp::Version::value_type; + return DenseMapInfo<UnderlyingTy>::getHashValue( + static_cast<UnderlyingTy>(V)); + } + static bool isEqual(omp::Version LHS, omp::Version RHS) { return LHS == RHS; } +}; +} // namespace llvm + +#endif // LLVM_FRONTEND_OPENMP_OMPVERSION_H diff --git a/llvm/lib/Frontend/OpenMP/DirectiveNameParser.cpp b/llvm/lib/Frontend/OpenMP/DirectiveNameParser.cpp index 3f743e27ea37f..f903a8920ad7f 100644 --- a/llvm/lib/Frontend/OpenMP/DirectiveNameParser.cpp +++ b/llvm/lib/Frontend/OpenMP/DirectiveNameParser.cpp @@ -25,8 +25,8 @@ DirectiveNameParser::DirectiveNameParser(SourceLanguage L) { // Parse "ORDERED" as OMPD_ordered_standalone. if (D == OMPD_ordered_blockassoc) continue; - for (unsigned Ver : getOpenMPVersions()) - insertName(getOpenMPDirectiveName(D, Ver), D); + for (Version V : getOpenMPVersions()) + insertName(getOpenMPDirectiveName(D, V), D); } } diff --git a/llvm/lib/Frontend/OpenMP/OMP.cpp b/llvm/lib/Frontend/OpenMP/OMP.cpp index 4e18f49395e4c..b2c1179def297 100644 --- a/llvm/lib/Frontend/OpenMP/OMP.cpp +++ b/llvm/lib/Frontend/OpenMP/OMP.cpp @@ -79,16 +79,16 @@ getFirstCompositeRange(iterator_range<ArrayRef<Directive>::iterator> Leafs) { static void collectPrivatizingConstructs(llvm::SmallSet<Directive, 16> &Constructs, - unsigned Version) { + Version V) { llvm::SmallSet<Clause, 16> Privatizing; for (auto C : clauses()) { - if (isPrivatizingClause(C, Version)) + if (isPrivatizingClause(C, V)) Privatizing.insert(C); } for (auto D : directives()) { bool AllowsPrivatizing = llvm::any_of(Privatizing, [&](Clause C) { - return isAllowedClauseForDirective(D, C, Version); + return isAllowedClauseForDirective(D, C, V); }); if (AllowsPrivatizing) Constructs.insert(D); @@ -209,15 +209,17 @@ bool isCombinedConstruct(Directive D) { return !getLeafConstructs(D).empty() && !isCompositeConstruct(D); } -ArrayRef<unsigned> getOpenMPVersions() { - static unsigned Versions[]{31, 40, 45, 50, 51, 52, 60, 61}; +ArrayRef<Version> getOpenMPVersions() { + // static Version Versions[]{31, 40, 45, 50, 51, 52, 60, 61}; + static Version Versions[]{Version(31), Version(40), Version(45), Version(50), + Version(51), Version(52), Version(60), Version(61)}; return Versions; } -bool isPrivatizingConstruct(Directive D, unsigned Version) { +bool isPrivatizingConstruct(Directive D, Version V) { static llvm::SmallSet<Directive, 16> Privatizing; [[maybe_unused]] static bool Init = - (collectPrivatizingConstructs(Privatizing, Version), true); + (collectPrivatizingConstructs(Privatizing, V), true); // As of OpenMP 6.0, privatizing constructs (with the test being if they // allow a privatizing clause) are: dispatch, distribute, do, for, loop, diff --git a/llvm/lib/Frontend/OpenMP/OMPDescriptors.cpp b/llvm/lib/Frontend/OpenMP/OMPDescriptors.cpp index bfcbcce0b4714..6391f8a21c27e 100644 --- a/llvm/lib/Frontend/OpenMP/OMPDescriptors.cpp +++ b/llvm/lib/Frontend/OpenMP/OMPDescriptors.cpp @@ -36,8 +36,8 @@ const DescriptorMap<Modifier, descriptor::Modifier> &getModifierMap() { #define GET_THING_OR_EMPTY(Thing, Member) \ template <typename DetailsTy> \ - static Thing get##Thing##OrEmpty(const DetailsTy &D, unsigned V) { \ - V = std::max(V, 45u); \ + static Thing get##Thing##OrEmpty(const DetailsTy &D, Version V) { \ + V = std::max(V, Version(45)); \ if (auto Found = D.find(V); Found != D.end()) \ return Found->second.Member; \ return Thing{}; \ @@ -50,19 +50,19 @@ GET_THING_OR_EMPTY(Properties, Props) #undef GET_THING_OR_EMPTY -Properties descriptor::Clause::getProperties(unsigned V) const { +Properties descriptor::Clause::getProperties(Version V) const { return getPropertiesOrEmpty(Details, V); } -Directives descriptor::Clause::getDirectives(unsigned V) const { +Directives descriptor::Clause::getDirectives(Version V) const { return getDirectivesOrEmpty(Details, V); } -Modifiers descriptor::Clause::getModifiers(unsigned V) const { +Modifiers descriptor::Clause::getModifiers(Version V) const { return getModifiersOrEmpty(Details, V); } -Properties descriptor::Modifier::getProperties(unsigned V) const { +Properties descriptor::Modifier::getProperties(Version V) const { return getPropertiesOrEmpty(Details, V); } -Clauses descriptor::Modifier::getClauses(unsigned V) const { +Clauses descriptor::Modifier::getClauses(Version V) const { return getClausesOrEmpty(Details, V); } @@ -74,7 +74,7 @@ const descriptor::Modifier &getDescriptor(llvm::omp::Modifier M) { return getModifierMap().at(M); } -Properties getProperties(Clause C, unsigned Version) { - return getDescriptor(C).getProperties(std::max(Version, 45u)); +Properties getProperties(Clause C, Version V) { + return getDescriptor(C).getProperties(std::max(V, Version(45))); } } // namespace llvm::omp diff --git a/llvm/lib/Frontend/OpenMP/OMPDescriptors.inc b/llvm/lib/Frontend/OpenMP/OMPDescriptors.inc index d4781031e3e1f..3a88a6bd66ca6 100644 --- a/llvm/lib/Frontend/OpenMP/OMPDescriptors.inc +++ b/llvm/lib/Frontend/OpenMP/OMPDescriptors.inc @@ -13,10 +13,10 @@ descriptor::Clause( "absent", { - {51, {{{Property::Unique}}, "absent", {Directive::OMPD_assume, Directive::OMPD_assumes, Directive::OMPD_begin_assumes}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, - {52, {{{Property::Unique}}, "absent", {Directive::OMPD_assume, Directive::OMPD_assumes, Directive::OMPD_begin_assumes}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, - {60, {{{Property::Unique}}, "absent", {Directive::OMPD_assume, Directive::OMPD_assumes, Directive::OMPD_begin_assumes}, SourceLanguage::C | SourceLanguage::Fortran, {Modifier::DirectiveNameModifier}}}, - {61, {{{Property::Unique}}, "absent", {Directive::OMPD_assume, Directive::OMPD_assumes, Directive::OMPD_begin_assumes}, SourceLanguage::C | SourceLanguage::Fortran, {Modifier::DirectiveNameModifier}}}, + {Version(51), {{{Property::Unique}}, "absent", {Directive::OMPD_assume, Directive::OMPD_assumes, Directive::OMPD_begin_assumes}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, + {Version(52), {{{Property::Unique}}, "absent", {Directive::OMPD_assume, Directive::OMPD_assumes, Directive::OMPD_begin_assumes}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, + {Version(60), {{{Property::Unique}}, "absent", {Directive::OMPD_assume, Directive::OMPD_assumes, Directive::OMPD_begin_assumes}, SourceLanguage::C | SourceLanguage::Fortran, {Modifier::DirectiveNameModifier}}}, + {Version(61), {{{Property::Unique}}, "absent", {Directive::OMPD_assume, Directive::OMPD_assumes, Directive::OMPD_begin_assumes}, SourceLanguage::C | SourceLanguage::Fortran, {Modifier::DirectiveNameModifier}}}, } ), }, @@ -25,11 +25,11 @@ descriptor::Clause( "acq_rel", { - {50, {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, - {51, {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, - {52, {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, - {60, {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {Modifier::DirectiveNameModifier}}}, - {61, {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {Modifier::DirectiveNameModifier}}}, + {Version(50), {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, + {Version(51), {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, + {Version(52), {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {}}}, + {Version(60), {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {Modifier::DirectiveNameModifier}}}, + {Version(61), {{{Property::Unique}}, "acq_rel", {Directive::OMPD_atomic, Directive::OMPD_flush}, SourceLanguage::C | SourceLanguage::Fortran, {Modifier::DirectiveNameModifier}}},... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/219820 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
