[flang-commits] [flang] [llvm] [flang][OpenMP] Make OpenMP clause representation language-agnostic (PR #86289)
via flang-commits
flang-commits at lists.llvm.org
Fri Mar 22 07:53:41 PDT 2024
github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code. :warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff 3b3de48fd84b8269d5f45ee0a9dc6b7448368424 f0c8bcbab7c059db63fb7553d2b26787daa5dbeb -- llvm/include/llvm/Frontend/OpenMP/ClauseT.h flang/lib/Lower/OpenMP/ClauseProcessor.cpp flang/lib/Lower/OpenMP/ClauseProcessor.h flang/lib/Lower/OpenMP/Clauses.cpp flang/lib/Lower/OpenMP/Clauses.h flang/lib/Lower/OpenMP/DataSharingProcessor.cpp flang/lib/Lower/OpenMP/OpenMP.cpp flang/lib/Lower/OpenMP/Utils.cpp flang/lib/Lower/OpenMP/Utils.h
``````````
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/flang/lib/Lower/OpenMP/Utils.cpp b/flang/lib/Lower/OpenMP/Utils.cpp
index 2e26c84749..ea8ab1b8ee 100644
--- a/flang/lib/Lower/OpenMP/Utils.cpp
+++ b/flang/lib/Lower/OpenMP/Utils.cpp
@@ -15,8 +15,8 @@
#include <flang/Lower/AbstractConverter.h>
#include <flang/Lower/ConvertType.h>
-#include <flang/Optimizer/Builder/FIRBuilder.h>
#include <flang/Lower/PFTBuilder.h>
+#include <flang/Optimizer/Builder/FIRBuilder.h>
#include <flang/Parser/parse-tree.h>
#include <flang/Parser/tools.h>
#include <flang/Semantics/tools.h>
diff --git a/llvm/include/llvm/Frontend/OpenMP/ClauseT.h b/llvm/include/llvm/Frontend/OpenMP/ClauseT.h
index 88544d6529..db8b9ff74b 100644
--- a/llvm/include/llvm/Frontend/OpenMP/ClauseT.h
+++ b/llvm/include/llvm/Frontend/OpenMP/ClauseT.h
@@ -78,22 +78,18 @@
namespace detail {
// Type trait to determine whether T is a specialization of std::variant.
-template <typename T>
-struct is_variant {
+template <typename T> struct is_variant {
static constexpr bool value = false;
};
-template <typename... Ts>
-struct is_variant<std::variant<Ts...>> {
+template <typename... Ts> struct is_variant<std::variant<Ts...>> {
static constexpr bool value = true;
};
-template <typename T>
-constexpr bool is_variant_v = is_variant<T>::value;
+template <typename T> constexpr bool is_variant_v = is_variant<T>::value;
// Helper utility to create a type which is a union of two given variants.
-template <typename...>
-struct UnionOfTwo;
+template <typename...> struct UnionOfTwo;
template <typename... Types1, typename... Types2>
struct UnionOfTwo<std::variant<Types1...>, std::variant<Types2...>> {
@@ -106,24 +102,20 @@ namespace type {
// Helper utility to create a type which is a union of an arbitrary number
// of variants.
-template <typename...>
-struct Union;
+template <typename...> struct Union;
-template <>
-struct Union<> {
+template <> struct Union<> {
// Legal to define, illegal to instantiate.
using type = std::variant<>;
};
-template <typename T, typename... Ts>
-struct Union<T, Ts...> {
+template <typename T, typename... Ts> struct Union<T, Ts...> {
static_assert(detail::is_variant_v<T>);
using type =
typename detail::UnionOfTwo<T, typename Union<Ts...>::type>::type;
};
-template <typename T>
-using ListT = llvm::SmallVector<T, 0>;
+template <typename T> using ListT = llvm::SmallVector<T, 0>;
// The ObjectT class represents a variable (as defined in the OpenMP spec).
//
@@ -151,16 +143,13 @@ using ListT = llvm::SmallVector<T, 0>;
//
// Note: the ObjectT template is not defined. Any user of it is expected to
// provide their own specialization that conforms to the above requirements.
-template <typename IdType, typename ExprType>
-struct ObjectT;
+template <typename IdType, typename ExprType> struct ObjectT;
-template <typename I, typename E>
-using ObjectListT = ListT<ObjectT<I, E>>;
+template <typename I, typename E> using ObjectListT = ListT<ObjectT<I, E>>;
using DirectiveName = llvm::omp::Directive;
-template <typename I, typename E>
-struct DefinedOperatorT {
+template <typename I, typename E> struct DefinedOperatorT {
struct DefinedOpName {
using WrapperTrait = std::true_type;
ObjectT<I, E> v;
@@ -171,8 +160,7 @@ struct DefinedOperatorT {
std::variant<DefinedOpName, IntrinsicOperator> u;
};
-template <typename E>
-struct RangeT {
+template <typename E> struct RangeT {
// range-specification: begin : end[: step]
using TupleTrait = std::true_type;
std::tuple<E, E, OPT(E)> t;
@@ -185,8 +173,7 @@ struct IteratorSpecifierT {
std::tuple<OPT(TypeType), ObjectT<IdType, ExprType>, RangeT<ExprType>> t;
};
-template <typename I, typename E>
-struct MapperT {
+template <typename I, typename E> struct MapperT {
using MapperIdentifier = ObjectT<I, E>;
using WrapperTrait = std::true_type;
MapperIdentifier v;
@@ -196,8 +183,7 @@ ENUM(MemoryOrder, AcqRel, Acquire, Relaxed, Release, SeqCst);
ENUM(MotionExpectation, Present);
ENUM(TaskDependenceType, In, Out, Inout, Mutexinoutset, Inoutset, Depobj);
-template <typename I, typename E>
-struct LoopIterationT {
+template <typename I, typename E> struct LoopIterationT {
struct Distance {
using TupleTrait = std::true_type;
std::tuple<DefinedOperatorT<I, E>, E> t;
@@ -206,14 +192,12 @@ struct LoopIterationT {
std::tuple<ObjectT<I, E>, OPT(Distance)> t;
};
-template <typename I, typename E>
-struct ProcedureDesignatorT {
+template <typename I, typename E> struct ProcedureDesignatorT {
using WrapperTrait = std::true_type;
ObjectT<I, E> v;
};
-template <typename I, typename E>
-struct ReductionIdentifierT {
+template <typename I, typename E> struct ReductionIdentifierT {
using UnionTrait = std::true_type;
std::variant<DefinedOperatorT<I, E>, ProcedureDesignatorT<I, E>> u;
};
@@ -222,14 +206,11 @@ template <typename T, typename I, typename E>
using IteratorT = ListT<IteratorSpecifierT<T, I, E>>;
} // namespace type
-template <typename T>
-using ListT = type::ListT<T>;
+template <typename T> using ListT = type::ListT<T>;
-template <typename I, typename E>
-using ObjectT = type::ObjectT<I, E>;
+template <typename I, typename E> using ObjectT = type::ObjectT<I, E>;
-template <typename I, typename E>
-using ObjectListT = type::ObjectListT<I, E>;
+template <typename I, typename E> using ObjectListT = type::ObjectListT<I, E>;
template <typename T, typename I, typename E>
using IteratorT = type::IteratorT<T, I, E>;
@@ -245,30 +226,25 @@ ListT<ResultTy> makeList(ContainerTy &&container, FunctionTy &&func) {
}
namespace clause {
-template <typename T, typename I, typename E>
-struct AbsentT {
+template <typename T, typename I, typename E> struct AbsentT {
using List = ListT<type::DirectiveName>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct AcqRelT {
+template <typename T, typename I, typename E> struct AcqRelT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct AcquireT {
+template <typename T, typename I, typename E> struct AcquireT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct AdjustArgsT {
+template <typename T, typename I, typename E> struct AdjustArgsT {
using IncompleteTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct AffinityT {
+template <typename T, typename I, typename E> struct AffinityT {
using Iterator = type::IteratorT<T, I, E>;
using LocatorList = ObjectListT<I, E>;
@@ -276,16 +252,14 @@ struct AffinityT {
std::tuple<OPT(Iterator), LocatorList> t;
};
-template <typename T, typename I, typename E>
-struct AlignT {
+template <typename T, typename I, typename E> struct AlignT {
using Alignment = E;
using WrapperTrait = std::true_type;
Alignment v;
};
-template <typename T, typename I, typename E>
-struct AlignedT {
+template <typename T, typename I, typename E> struct AlignedT {
using Alignment = E;
using List = ObjectListT<I, E>;
@@ -293,11 +267,9 @@ struct AlignedT {
std::tuple<OPT(Alignment), List> t;
};
-template <typename T, typename I, typename E>
-struct AllocatorT;
+template <typename T, typename I, typename E> struct AllocatorT;
-template <typename T, typename I, typename E>
-struct AllocateT {
+template <typename T, typename I, typename E> struct AllocateT {
using AllocatorSimpleModifier = E;
using AllocatorComplexModifier = AllocatorT<T, I, E>;
using AlignModifier = AlignT<T, I, E>;
@@ -309,86 +281,73 @@ struct AllocateT {
t;
};
-template <typename T, typename I, typename E>
-struct AllocatorT {
+template <typename T, typename I, typename E> struct AllocatorT {
using Allocator = E;
using WrapperTrait = std::true_type;
Allocator v;
};
-template <typename T, typename I, typename E>
-struct AppendArgsT {
+template <typename T, typename I, typename E> struct AppendArgsT {
using IncompleteTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct AtT {
+template <typename T, typename I, typename E> struct AtT {
ENUM(ActionTime, Compilation, Execution);
using WrapperTrait = std::true_type;
ActionTime v;
};
-template <typename T, typename I, typename E>
-struct AtomicDefaultMemOrderT {
+template <typename T, typename I, typename E> struct AtomicDefaultMemOrderT {
using MemoryOrder = type::MemoryOrder;
using WrapperTrait = std::true_type;
MemoryOrder v; // Name not provided in spec
};
-template <typename T, typename I, typename E>
-struct BindT {
+template <typename T, typename I, typename E> struct BindT {
ENUM(Binding, Teams, Parallel, Thread);
using WrapperTrait = std::true_type;
Binding v;
};
-template <typename T, typename I, typename E>
-struct CaptureT {
+template <typename T, typename I, typename E> struct CaptureT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct CollapseT {
+template <typename T, typename I, typename E> struct CollapseT {
using N = E;
using WrapperTrait = std::true_type;
N v;
};
-template <typename T, typename I, typename E>
-struct CompareT {
+template <typename T, typename I, typename E> struct CompareT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct ContainsT {
+template <typename T, typename I, typename E> struct ContainsT {
using List = ListT<type::DirectiveName>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct CopyinT {
+template <typename T, typename I, typename E> struct CopyinT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct CopyprivateT {
+template <typename T, typename I, typename E> struct CopyprivateT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct DefaultT {
+template <typename T, typename I, typename E> struct DefaultT {
ENUM(DataSharingAttribute, Firstprivate, None, Private, Shared);
using WrapperTrait = std::true_type;
DataSharingAttribute v;
};
-template <typename T, typename I, typename E>
-struct DefaultmapT {
+template <typename T, typename I, typename E> struct DefaultmapT {
ENUM(ImplicitBehavior, Alloc, To, From, Tofrom, Firstprivate, None, Default,
Present);
ENUM(VariableCategory, Scalar, Aggregate, Pointer, Allocatable);
@@ -396,11 +355,9 @@ struct DefaultmapT {
std::tuple<ImplicitBehavior, OPT(VariableCategory)> t;
};
-template <typename T, typename I, typename E>
-struct DoacrossT;
+template <typename T, typename I, typename E> struct DoacrossT;
-template <typename T, typename I, typename E>
-struct DependT {
+template <typename T, typename I, typename E> struct DependT {
using Iterator = type::IteratorT<T, I, E>;
using LocatorList = ObjectListT<I, E>;
using TaskDependenceType = tomp::type::TaskDependenceType;
@@ -416,46 +373,40 @@ struct DependT {
std::variant<Doacross, WithLocators> u; // Doacross form is legacy
};
-template <typename T, typename I, typename E>
-struct DestroyT {
+template <typename T, typename I, typename E> struct DestroyT {
using DestroyVar = ObjectT<I, E>;
using WrapperTrait = std::true_type;
// DestroyVar can be ommitted in "depobj destroy".
OPT(DestroyVar) v;
};
-template <typename T, typename I, typename E>
-struct DetachT {
+template <typename T, typename I, typename E> struct DetachT {
using EventHandle = ObjectT<I, E>;
using WrapperTrait = std::true_type;
EventHandle v;
};
-template <typename T, typename I, typename E>
-struct DeviceT {
+template <typename T, typename I, typename E> struct DeviceT {
using DeviceDescription = E;
ENUM(DeviceModifier, Ancestor, DeviceNum);
using TupleTrait = std::true_type;
std::tuple<OPT(DeviceModifier), DeviceDescription> t;
};
-template <typename T, typename I, typename E>
-struct DeviceTypeT {
+template <typename T, typename I, typename E> struct DeviceTypeT {
ENUM(DeviceTypeDescription, Any, Host, Nohost);
using WrapperTrait = std::true_type;
DeviceTypeDescription v;
};
-template <typename T, typename I, typename E>
-struct DistScheduleT {
+template <typename T, typename I, typename E> struct DistScheduleT {
ENUM(Kind, Static);
using ChunkSize = E;
using TupleTrait = std::true_type;
std::tuple<Kind, OPT(ChunkSize)> t;
};
-template <typename T, typename I, typename E>
-struct DoacrossT {
+template <typename T, typename I, typename E> struct DoacrossT {
using Vector = ListT<type::LoopIterationT<I, E>>;
ENUM(DependenceType, Source, Sink);
using TupleTrait = std::true_type;
@@ -463,55 +414,47 @@ struct DoacrossT {
std::tuple<DependenceType, Vector> t;
};
-template <typename T, typename I, typename E>
-struct DynamicAllocatorsT {
+template <typename T, typename I, typename E> struct DynamicAllocatorsT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct EnterT {
+template <typename T, typename I, typename E> struct EnterT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct ExclusiveT {
+template <typename T, typename I, typename E> struct ExclusiveT {
using WrapperTrait = std::true_type;
using List = ObjectListT<I, E>;
List v;
};
-template <typename T, typename I, typename E>
-struct FailT {
+template <typename T, typename I, typename E> struct FailT {
using MemoryOrder = type::MemoryOrder;
using WrapperTrait = std::true_type;
MemoryOrder v;
};
-template <typename T, typename I, typename E>
-struct FilterT {
+template <typename T, typename I, typename E> struct FilterT {
using ThreadNum = E;
using WrapperTrait = std::true_type;
ThreadNum v;
};
-template <typename T, typename I, typename E>
-struct FinalT {
+template <typename T, typename I, typename E> struct FinalT {
using Finalize = E;
using WrapperTrait = std::true_type;
Finalize v;
};
-template <typename T, typename I, typename E>
-struct FirstprivateT {
+template <typename T, typename I, typename E> struct FirstprivateT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct FromT {
+template <typename T, typename I, typename E> struct FromT {
using LocatorList = ObjectListT<I, E>;
using Expectation = type::MotionExpectation;
using Mapper = type::MapperT<I, E>;
@@ -521,68 +464,58 @@ struct FromT {
std::tuple<OPT(Expectation), OPT(Mapper), OPT(Iterator), LocatorList> t;
};
-template <typename T, typename I, typename E>
-struct FullT {
+template <typename T, typename I, typename E> struct FullT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct GrainsizeT {
+template <typename T, typename I, typename E> struct GrainsizeT {
ENUM(Prescriptiveness, Strict);
using GrainSize = E;
using TupleTrait = std::true_type;
std::tuple<OPT(Prescriptiveness), GrainSize> t;
};
-template <typename T, typename I, typename E>
-struct HasDeviceAddrT {
+template <typename T, typename I, typename E> struct HasDeviceAddrT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct HintT {
+template <typename T, typename I, typename E> struct HintT {
using HintExpr = E;
using WrapperTrait = std::true_type;
HintExpr v;
};
-template <typename T, typename I, typename E>
-struct HoldsT {
+template <typename T, typename I, typename E> struct HoldsT {
using WrapperTrait = std::true_type;
E v; // No argument name in spec 5.2
};
-template <typename T, typename I, typename E>
-struct IfT {
+template <typename T, typename I, typename E> struct IfT {
using DirectiveNameModifier = type::DirectiveName;
using IfExpression = E;
using TupleTrait = std::true_type;
std::tuple<OPT(DirectiveNameModifier), IfExpression> t;
};
-template <typename T, typename I, typename E>
-struct InbranchT {
+template <typename T, typename I, typename E> struct InbranchT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct InclusiveT {
+template <typename T, typename I, typename E> struct InclusiveT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct IndirectT {
+template <typename T, typename I, typename E> struct IndirectT {
using InvokedByFptr = E;
using WrapperTrait = std::true_type;
InvokedByFptr v;
};
-template <typename T, typename I, typename E>
-struct InitT {
+template <typename T, typename I, typename E> struct InitT {
using ForeignRuntimeId = E;
using InteropVar = ObjectT<I, E>;
using InteropPreference = ListT<ForeignRuntimeId>;
@@ -593,38 +526,33 @@ struct InitT {
std::tuple<OPT(InteropPreference), InteropTypes, InteropVar> t;
};
-template <typename T, typename I, typename E>
-struct InitializerT {
+template <typename T, typename I, typename E> struct InitializerT {
using InitializerExpr = E;
using WrapperTrait = std::true_type;
InitializerExpr v;
};
-template <typename T, typename I, typename E>
-struct InReductionT {
+template <typename T, typename I, typename E> struct InReductionT {
using List = ObjectListT<I, E>;
using ReductionIdentifier = type::ReductionIdentifierT<I, E>;
using TupleTrait = std::true_type;
std::tuple<ReductionIdentifier, List> t;
};
-template <typename T, typename I, typename E>
-struct IsDevicePtrT {
+template <typename T, typename I, typename E> struct IsDevicePtrT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct LastprivateT {
+template <typename T, typename I, typename E> struct LastprivateT {
using List = ObjectListT<I, E>;
ENUM(LastprivateModifier, Conditional);
using TupleTrait = std::true_type;
std::tuple<OPT(LastprivateModifier), List> t;
};
-template <typename T, typename I, typename E>
-struct LinearT {
+template <typename T, typename I, typename E> struct LinearT {
// std::get<type> won't work here due to duplicate types in the tuple.
using List = ObjectListT<I, E>;
using StepSimpleModifier = E;
@@ -638,15 +566,13 @@ struct LinearT {
t;
};
-template <typename T, typename I, typename E>
-struct LinkT {
+template <typename T, typename I, typename E> struct LinkT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct MapT {
+template <typename T, typename I, typename E> struct MapT {
using LocatorList = ObjectListT<I, E>;
ENUM(MapType, To, From, Tofrom, Alloc, Release, Delete);
ENUM(MapTypeModifier, Always, Close, Present);
@@ -660,168 +586,141 @@ struct MapT {
t;
};
-template <typename T, typename I, typename E>
-struct MatchT {
+template <typename T, typename I, typename E> struct MatchT {
using IncompleteTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct MergeableT {
+template <typename T, typename I, typename E> struct MergeableT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct MessageT {
+template <typename T, typename I, typename E> struct MessageT {
using MsgString = E;
using WrapperTrait = std::true_type;
MsgString v;
};
-template <typename T, typename I, typename E>
-struct NocontextT {
+template <typename T, typename I, typename E> struct NocontextT {
using DoNotUpdateContext = E;
using WrapperTrait = std::true_type;
DoNotUpdateContext v;
};
-template <typename T, typename I, typename E>
-struct NogroupT {
+template <typename T, typename I, typename E> struct NogroupT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct NontemporalT {
+template <typename T, typename I, typename E> struct NontemporalT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct NoOpenmpT {
+template <typename T, typename I, typename E> struct NoOpenmpT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct NoOpenmpRoutinesT {
+template <typename T, typename I, typename E> struct NoOpenmpRoutinesT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct NoParallelismT {
+template <typename T, typename I, typename E> struct NoParallelismT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct NotinbranchT {
+template <typename T, typename I, typename E> struct NotinbranchT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct NovariantsT {
+template <typename T, typename I, typename E> struct NovariantsT {
using DoNotUseVariant = E;
using WrapperTrait = std::true_type;
DoNotUseVariant v;
};
-template <typename T, typename I, typename E>
-struct NowaitT {
+template <typename T, typename I, typename E> struct NowaitT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct NumTasksT {
+template <typename T, typename I, typename E> struct NumTasksT {
using NumTasks = E;
ENUM(Prescriptiveness, Strict);
using TupleTrait = std::true_type;
std::tuple<OPT(Prescriptiveness), NumTasks> t;
};
-template <typename T, typename I, typename E>
-struct NumTeamsT {
+template <typename T, typename I, typename E> struct NumTeamsT {
using TupleTrait = std::true_type;
using LowerBound = E;
using UpperBound = E;
std::tuple<OPT(LowerBound), UpperBound> t;
};
-template <typename T, typename I, typename E>
-struct NumThreadsT {
+template <typename T, typename I, typename E> struct NumThreadsT {
using Nthreads = E;
using WrapperTrait = std::true_type;
Nthreads v;
};
-template <typename T, typename I, typename E>
-struct OmpxAttributeT {
+template <typename T, typename I, typename E> struct OmpxAttributeT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct OmpxBareT {
+template <typename T, typename I, typename E> struct OmpxBareT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct OmpxDynCgroupMemT {
+template <typename T, typename I, typename E> struct OmpxDynCgroupMemT {
using WrapperTrait = std::true_type;
E v;
};
-template <typename T, typename I, typename E>
-struct OrderT {
+template <typename T, typename I, typename E> struct OrderT {
ENUM(OrderModifier, Reproducible, Unconstrained);
ENUM(Ordering, Concurrent);
using TupleTrait = std::true_type;
std::tuple<OPT(OrderModifier), Ordering> t;
};
-template <typename T, typename I, typename E>
-struct OrderedT {
+template <typename T, typename I, typename E> struct OrderedT {
using N = E;
using WrapperTrait = std::true_type;
OPT(N) v;
};
-template <typename T, typename I, typename E>
-struct OtherwiseT {
+template <typename T, typename I, typename E> struct OtherwiseT {
using IncompleteTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct PartialT {
+template <typename T, typename I, typename E> struct PartialT {
using UnrollFactor = E;
using WrapperTrait = std::true_type;
OPT(UnrollFactor) v;
};
-template <typename T, typename I, typename E>
-struct PriorityT {
+template <typename T, typename I, typename E> struct PriorityT {
using PriorityValue = E;
using WrapperTrait = std::true_type;
PriorityValue v;
};
-template <typename T, typename I, typename E>
-struct PrivateT {
+template <typename T, typename I, typename E> struct PrivateT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct ProcBindT {
+template <typename T, typename I, typename E> struct ProcBindT {
ENUM(AffinityPolicy, Close, Master, Spread, Primary);
using WrapperTrait = std::true_type;
AffinityPolicy v;
};
-template <typename T, typename I, typename E>
-struct ReadT {
+template <typename T, typename I, typename E> struct ReadT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct ReductionT {
+template <typename T, typename I, typename E> struct ReductionT {
using List = ObjectListT<I, E>;
using ReductionIdentifier = type::ReductionIdentifierT<I, E>;
ENUM(ReductionModifier, Default, Inscan, Task);
@@ -829,30 +728,25 @@ struct ReductionT {
std::tuple<ReductionIdentifier, OPT(ReductionModifier), List> t;
};
-template <typename T, typename I, typename E>
-struct RelaxedT {
+template <typename T, typename I, typename E> struct RelaxedT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct ReleaseT {
+template <typename T, typename I, typename E> struct ReleaseT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct ReverseOffloadT {
+template <typename T, typename I, typename E> struct ReverseOffloadT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct SafelenT {
+template <typename T, typename I, typename E> struct SafelenT {
using Length = E;
using WrapperTrait = std::true_type;
Length v;
};
-template <typename T, typename I, typename E>
-struct ScheduleT {
+template <typename T, typename I, typename E> struct ScheduleT {
ENUM(Kind, Static, Dynamic, Guided, Auto, Runtime);
using ChunkSize = E;
ENUM(OrderingModifier, Monotonic, Nonmonotonic);
@@ -861,66 +755,56 @@ struct ScheduleT {
std::tuple<Kind, OPT(OrderingModifier), OPT(ChunkModifier), OPT(ChunkSize)> t;
};
-template <typename T, typename I, typename E>
-struct SeqCstT {
+template <typename T, typename I, typename E> struct SeqCstT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct SeverityT {
+template <typename T, typename I, typename E> struct SeverityT {
ENUM(SevLevel, Fatal, Warning);
using WrapperTrait = std::true_type;
SevLevel v;
};
-template <typename T, typename I, typename E>
-struct SharedT {
+template <typename T, typename I, typename E> struct SharedT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct SimdT {
+template <typename T, typename I, typename E> struct SimdT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct SimdlenT {
+template <typename T, typename I, typename E> struct SimdlenT {
using Length = E;
using WrapperTrait = std::true_type;
Length v;
};
-template <typename T, typename I, typename E>
-struct SizesT {
+template <typename T, typename I, typename E> struct SizesT {
using SizeList = ListT<E>;
using WrapperTrait = std::true_type;
SizeList v;
};
-template <typename T, typename I, typename E>
-struct TaskReductionT {
+template <typename T, typename I, typename E> struct TaskReductionT {
using List = ObjectListT<I, E>;
using ReductionIdentifier = type::ReductionIdentifierT<I, E>;
using TupleTrait = std::true_type;
std::tuple<ReductionIdentifier, List> t;
};
-template <typename T, typename I, typename E>
-struct ThreadLimitT {
+template <typename T, typename I, typename E> struct ThreadLimitT {
using Threadlim = E;
using WrapperTrait = std::true_type;
Threadlim v;
};
-template <typename T, typename I, typename E>
-struct ThreadsT {
+template <typename T, typename I, typename E> struct ThreadsT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct ToT {
+template <typename T, typename I, typename E> struct ToT {
using LocatorList = ObjectListT<I, E>;
using Expectation = type::MotionExpectation;
using Mapper = type::MapperT<I, E>;
@@ -930,63 +814,53 @@ struct ToT {
std::tuple<OPT(Expectation), OPT(Mapper), OPT(Iterator), LocatorList> t;
};
-template <typename T, typename I, typename E>
-struct UnifiedAddressT {
+template <typename T, typename I, typename E> struct UnifiedAddressT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct UnifiedSharedMemoryT {
+template <typename T, typename I, typename E> struct UnifiedSharedMemoryT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct UniformT {
+template <typename T, typename I, typename E> struct UniformT {
using ParameterList = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
ParameterList v;
};
-template <typename T, typename I, typename E>
-struct UnknownT {
+template <typename T, typename I, typename E> struct UnknownT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct UntiedT {
+template <typename T, typename I, typename E> struct UntiedT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct UpdateT {
+template <typename T, typename I, typename E> struct UpdateT {
using TaskDependenceType = tomp::type::TaskDependenceType;
using WrapperTrait = std::true_type;
OPT(TaskDependenceType) v;
};
-template <typename T, typename I, typename E>
-struct UseT {
+template <typename T, typename I, typename E> struct UseT {
using InteropVar = ObjectT<I, E>;
using WrapperTrait = std::true_type;
InteropVar v;
};
-template <typename T, typename I, typename E>
-struct UseDeviceAddrT {
+template <typename T, typename I, typename E> struct UseDeviceAddrT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct UseDevicePtrT {
+template <typename T, typename I, typename E> struct UseDevicePtrT {
using List = ObjectListT<I, E>;
using WrapperTrait = std::true_type;
List v;
};
-template <typename T, typename I, typename E>
-struct UsesAllocatorsT {
+template <typename T, typename I, typename E> struct UsesAllocatorsT {
using MemSpace = E;
using TraitsArray = ObjectT<I, E>;
using Allocator = E;
@@ -997,18 +871,15 @@ struct UsesAllocatorsT {
Allocators v;
};
-template <typename T, typename I, typename E>
-struct WeakT {
+template <typename T, typename I, typename E> struct WeakT {
using EmptyTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct WhenT {
+template <typename T, typename I, typename E> struct WhenT {
using IncompleteTrait = std::true_type;
};
-template <typename T, typename I, typename E>
-struct WriteT {
+template <typename T, typename I, typename E> struct WriteT {
using EmptyTrait = std::true_type;
};
``````````
</details>
https://github.com/llvm/llvm-project/pull/86289
More information about the flang-commits
mailing list