814 lines
26 KiB
C++
814 lines
26 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Enum Utility Definitions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* From: OpenMPOps.td *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyAccessGroupModifier(AccessGroupModifier val) {
|
|
switch (val) {
|
|
case AccessGroupModifier::cgroup: return "cgroup";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<AccessGroupModifier> symbolizeAccessGroupModifier(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<AccessGroupModifier>>(str)
|
|
.Case("cgroup", AccessGroupModifier::cgroup)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<AccessGroupModifier> symbolizeAccessGroupModifier(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return AccessGroupModifier::cgroup;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseBindKind(ClauseBindKind val) {
|
|
switch (val) {
|
|
case ClauseBindKind::Parallel: return "parallel";
|
|
case ClauseBindKind::Teams: return "teams";
|
|
case ClauseBindKind::Thread: return "thread";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseBindKind> symbolizeClauseBindKind(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseBindKind>>(str)
|
|
.Case("parallel", ClauseBindKind::Parallel)
|
|
.Case("teams", ClauseBindKind::Teams)
|
|
.Case("thread", ClauseBindKind::Thread)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseBindKind> symbolizeClauseBindKind(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseBindKind::Parallel;
|
|
case 1: return ClauseBindKind::Teams;
|
|
case 2: return ClauseBindKind::Thread;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseCancellationConstructType(ClauseCancellationConstructType val) {
|
|
switch (val) {
|
|
case ClauseCancellationConstructType::Parallel: return "parallel";
|
|
case ClauseCancellationConstructType::Loop: return "loop";
|
|
case ClauseCancellationConstructType::Sections: return "sections";
|
|
case ClauseCancellationConstructType::Taskgroup: return "taskgroup";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseCancellationConstructType> symbolizeClauseCancellationConstructType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseCancellationConstructType>>(str)
|
|
.Case("parallel", ClauseCancellationConstructType::Parallel)
|
|
.Case("loop", ClauseCancellationConstructType::Loop)
|
|
.Case("sections", ClauseCancellationConstructType::Sections)
|
|
.Case("taskgroup", ClauseCancellationConstructType::Taskgroup)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseCancellationConstructType> symbolizeClauseCancellationConstructType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseCancellationConstructType::Parallel;
|
|
case 1: return ClauseCancellationConstructType::Loop;
|
|
case 2: return ClauseCancellationConstructType::Sections;
|
|
case 3: return ClauseCancellationConstructType::Taskgroup;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseDepend(ClauseDepend val) {
|
|
switch (val) {
|
|
case ClauseDepend::dependsource: return "dependsource";
|
|
case ClauseDepend::dependsink: return "dependsink";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseDepend> symbolizeClauseDepend(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseDepend>>(str)
|
|
.Case("dependsource", ClauseDepend::dependsource)
|
|
.Case("dependsink", ClauseDepend::dependsink)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseDepend> symbolizeClauseDepend(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseDepend::dependsource;
|
|
case 1: return ClauseDepend::dependsink;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
std::string stringifyClauseMapFlags(ClauseMapFlags symbol) {
|
|
auto val = static_cast<uint32_t>(symbol);
|
|
assert(524287u == (524287u | val) && "invalid bits set in bit enum");
|
|
// Special case for all bits unset.
|
|
if (val == 0) return "none";
|
|
|
|
::llvm::SmallVector<::llvm::StringRef, 2> strs;
|
|
|
|
if (1u == (1u & val))
|
|
strs.push_back("storage");
|
|
|
|
if (2u == (2u & val))
|
|
strs.push_back("to");
|
|
|
|
if (4u == (4u & val))
|
|
strs.push_back("from");
|
|
|
|
if (8u == (8u & val))
|
|
strs.push_back("always");
|
|
|
|
if (16u == (16u & val))
|
|
strs.push_back("del");
|
|
|
|
if (32u == (32u & val))
|
|
strs.push_back("return_param");
|
|
|
|
if (64u == (64u & val))
|
|
strs.push_back("priv");
|
|
|
|
if (128u == (128u & val))
|
|
strs.push_back("literal");
|
|
|
|
if (256u == (256u & val))
|
|
strs.push_back("implicit");
|
|
|
|
if (512u == (512u & val))
|
|
strs.push_back("close");
|
|
|
|
if (1024u == (1024u & val))
|
|
strs.push_back("present");
|
|
|
|
if (2048u == (2048u & val))
|
|
strs.push_back("ompx_hold");
|
|
|
|
if (4096u == (4096u & val))
|
|
strs.push_back("attach");
|
|
|
|
if (8192u == (8192u & val))
|
|
strs.push_back("attach_always");
|
|
|
|
if (16384u == (16384u & val))
|
|
strs.push_back("attach_never");
|
|
|
|
if (32768u == (32768u & val))
|
|
strs.push_back("attach_auto");
|
|
|
|
if (65536u == (65536u & val))
|
|
strs.push_back("ref_ptr");
|
|
|
|
if (131072u == (131072u & val))
|
|
strs.push_back("ref_ptee");
|
|
|
|
if (262144u == (262144u & val))
|
|
strs.push_back("is_device_ptr");
|
|
return ::llvm::join(strs, "|");
|
|
}
|
|
|
|
::std::optional<ClauseMapFlags> symbolizeClauseMapFlags(::llvm::StringRef str) {
|
|
// Special case for all bits unset.
|
|
if (str == "none") return ClauseMapFlags::none;
|
|
|
|
::llvm::SmallVector<::llvm::StringRef, 2> symbols;
|
|
str.split(symbols, "|");
|
|
|
|
uint32_t val = 0;
|
|
for (auto symbol : symbols) {
|
|
auto bit = llvm::StringSwitch<::std::optional<uint32_t>>(symbol.trim())
|
|
.Case("storage", 1)
|
|
.Case("to", 2)
|
|
.Case("from", 4)
|
|
.Case("always", 8)
|
|
.Case("del", 16)
|
|
.Case("return_param", 32)
|
|
.Case("priv", 64)
|
|
.Case("literal", 128)
|
|
.Case("implicit", 256)
|
|
.Case("close", 512)
|
|
.Case("present", 1024)
|
|
.Case("ompx_hold", 2048)
|
|
.Case("attach", 4096)
|
|
.Case("attach_always", 8192)
|
|
.Case("attach_never", 16384)
|
|
.Case("attach_auto", 32768)
|
|
.Case("ref_ptr", 65536)
|
|
.Case("ref_ptee", 131072)
|
|
.Case("is_device_ptr", 262144)
|
|
.Default(::std::nullopt);
|
|
if (bit) { val |= *bit; } else { return ::std::nullopt; }
|
|
}
|
|
return static_cast<ClauseMapFlags>(val);
|
|
}
|
|
|
|
::std::optional<ClauseMapFlags> symbolizeClauseMapFlags(uint32_t value) {
|
|
// Special case for all bits unset.
|
|
if (value == 0) return ClauseMapFlags::none;
|
|
|
|
if (value & ~static_cast<uint32_t>(524287u)) return std::nullopt;
|
|
return static_cast<ClauseMapFlags>(value);
|
|
}
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
std::string stringifyClauseRequires(ClauseRequires symbol) {
|
|
auto val = static_cast<uint32_t>(symbol);
|
|
assert(15u == (15u | val) && "invalid bits set in bit enum");
|
|
// Special case for all bits unset.
|
|
if (val == 0) return "none";
|
|
|
|
::llvm::SmallVector<::llvm::StringRef, 2> strs;
|
|
|
|
if (1u == (1u & val))
|
|
strs.push_back("reverse_offload");
|
|
|
|
if (2u == (2u & val))
|
|
strs.push_back("unified_address");
|
|
|
|
if (4u == (4u & val))
|
|
strs.push_back("unified_shared_memory");
|
|
|
|
if (8u == (8u & val))
|
|
strs.push_back("dynamic_allocators");
|
|
return ::llvm::join(strs, "|");
|
|
}
|
|
|
|
::std::optional<ClauseRequires> symbolizeClauseRequires(::llvm::StringRef str) {
|
|
// Special case for all bits unset.
|
|
if (str == "none") return ClauseRequires::none;
|
|
|
|
::llvm::SmallVector<::llvm::StringRef, 2> symbols;
|
|
str.split(symbols, "|");
|
|
|
|
uint32_t val = 0;
|
|
for (auto symbol : symbols) {
|
|
auto bit = llvm::StringSwitch<::std::optional<uint32_t>>(symbol.trim())
|
|
.Case("reverse_offload", 1)
|
|
.Case("unified_address", 2)
|
|
.Case("unified_shared_memory", 4)
|
|
.Case("dynamic_allocators", 8)
|
|
.Default(::std::nullopt);
|
|
if (bit) { val |= *bit; } else { return ::std::nullopt; }
|
|
}
|
|
return static_cast<ClauseRequires>(val);
|
|
}
|
|
|
|
::std::optional<ClauseRequires> symbolizeClauseRequires(uint32_t value) {
|
|
// Special case for all bits unset.
|
|
if (value == 0) return ClauseRequires::none;
|
|
|
|
if (value & ~static_cast<uint32_t>(15u)) return std::nullopt;
|
|
return static_cast<ClauseRequires>(value);
|
|
}
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseTaskDepend(ClauseTaskDepend val) {
|
|
switch (val) {
|
|
case ClauseTaskDepend::taskdependin: return "taskdependin";
|
|
case ClauseTaskDepend::taskdependout: return "taskdependout";
|
|
case ClauseTaskDepend::taskdependinout: return "taskdependinout";
|
|
case ClauseTaskDepend::taskdependmutexinoutset: return "taskdependmutexinoutset";
|
|
case ClauseTaskDepend::taskdependinoutset: return "taskdependinoutset";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseTaskDepend> symbolizeClauseTaskDepend(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseTaskDepend>>(str)
|
|
.Case("taskdependin", ClauseTaskDepend::taskdependin)
|
|
.Case("taskdependout", ClauseTaskDepend::taskdependout)
|
|
.Case("taskdependinout", ClauseTaskDepend::taskdependinout)
|
|
.Case("taskdependmutexinoutset", ClauseTaskDepend::taskdependmutexinoutset)
|
|
.Case("taskdependinoutset", ClauseTaskDepend::taskdependinoutset)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseTaskDepend> symbolizeClauseTaskDepend(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseTaskDepend::taskdependin;
|
|
case 1: return ClauseTaskDepend::taskdependout;
|
|
case 2: return ClauseTaskDepend::taskdependinout;
|
|
case 3: return ClauseTaskDepend::taskdependmutexinoutset;
|
|
case 4: return ClauseTaskDepend::taskdependinoutset;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyDataSharingClauseType(DataSharingClauseType val) {
|
|
switch (val) {
|
|
case DataSharingClauseType::Private: return "private";
|
|
case DataSharingClauseType::FirstPrivate: return "firstprivate";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<DataSharingClauseType> symbolizeDataSharingClauseType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<DataSharingClauseType>>(str)
|
|
.Case("private", DataSharingClauseType::Private)
|
|
.Case("firstprivate", DataSharingClauseType::FirstPrivate)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<DataSharingClauseType> symbolizeDataSharingClauseType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return DataSharingClauseType::Private;
|
|
case 1: return DataSharingClauseType::FirstPrivate;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyDeclareTargetCaptureClause(DeclareTargetCaptureClause val) {
|
|
switch (val) {
|
|
case DeclareTargetCaptureClause::none: return "none";
|
|
case DeclareTargetCaptureClause::to: return "to";
|
|
case DeclareTargetCaptureClause::link: return "link";
|
|
case DeclareTargetCaptureClause::enter: return "enter";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<DeclareTargetCaptureClause> symbolizeDeclareTargetCaptureClause(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<DeclareTargetCaptureClause>>(str)
|
|
.Case("none", DeclareTargetCaptureClause::none)
|
|
.Case("to", DeclareTargetCaptureClause::to)
|
|
.Case("link", DeclareTargetCaptureClause::link)
|
|
.Case("enter", DeclareTargetCaptureClause::enter)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<DeclareTargetCaptureClause> symbolizeDeclareTargetCaptureClause(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return DeclareTargetCaptureClause::none;
|
|
case 1: return DeclareTargetCaptureClause::to;
|
|
case 2: return DeclareTargetCaptureClause::link;
|
|
case 3: return DeclareTargetCaptureClause::enter;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyDeclareTargetDeviceType(DeclareTargetDeviceType val) {
|
|
switch (val) {
|
|
case DeclareTargetDeviceType::any: return "any";
|
|
case DeclareTargetDeviceType::host: return "host";
|
|
case DeclareTargetDeviceType::nohost: return "nohost";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<DeclareTargetDeviceType> symbolizeDeclareTargetDeviceType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<DeclareTargetDeviceType>>(str)
|
|
.Case("any", DeclareTargetDeviceType::any)
|
|
.Case("host", DeclareTargetDeviceType::host)
|
|
.Case("nohost", DeclareTargetDeviceType::nohost)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<DeclareTargetDeviceType> symbolizeDeclareTargetDeviceType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return DeclareTargetDeviceType::any;
|
|
case 1: return DeclareTargetDeviceType::host;
|
|
case 2: return DeclareTargetDeviceType::nohost;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyFallbackModifier(FallbackModifier val) {
|
|
switch (val) {
|
|
case FallbackModifier::abort: return "abort";
|
|
case FallbackModifier::null: return "null";
|
|
case FallbackModifier::default_mem: return "default_mem";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<FallbackModifier> symbolizeFallbackModifier(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<FallbackModifier>>(str)
|
|
.Case("abort", FallbackModifier::abort)
|
|
.Case("null", FallbackModifier::null)
|
|
.Case("default_mem", FallbackModifier::default_mem)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<FallbackModifier> symbolizeFallbackModifier(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return FallbackModifier::abort;
|
|
case 1: return FallbackModifier::null;
|
|
case 2: return FallbackModifier::default_mem;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseGrainsizeType(ClauseGrainsizeType val) {
|
|
switch (val) {
|
|
case ClauseGrainsizeType::Strict: return "strict";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseGrainsizeType> symbolizeClauseGrainsizeType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseGrainsizeType>>(str)
|
|
.Case("strict", ClauseGrainsizeType::Strict)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseGrainsizeType> symbolizeClauseGrainsizeType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseGrainsizeType::Strict;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyLinearModifier(LinearModifier val) {
|
|
switch (val) {
|
|
case LinearModifier::val: return "val";
|
|
case LinearModifier::ref: return "ref";
|
|
case LinearModifier::uval: return "uval";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<LinearModifier> symbolizeLinearModifier(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<LinearModifier>>(str)
|
|
.Case("val", LinearModifier::val)
|
|
.Case("ref", LinearModifier::ref)
|
|
.Case("uval", LinearModifier::uval)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<LinearModifier> symbolizeLinearModifier(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return LinearModifier::val;
|
|
case 1: return LinearModifier::ref;
|
|
case 2: return LinearModifier::uval;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseMemoryOrderKind(ClauseMemoryOrderKind val) {
|
|
switch (val) {
|
|
case ClauseMemoryOrderKind::Seq_cst: return "seq_cst";
|
|
case ClauseMemoryOrderKind::Acq_rel: return "acq_rel";
|
|
case ClauseMemoryOrderKind::Acquire: return "acquire";
|
|
case ClauseMemoryOrderKind::Release: return "release";
|
|
case ClauseMemoryOrderKind::Relaxed: return "relaxed";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseMemoryOrderKind> symbolizeClauseMemoryOrderKind(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseMemoryOrderKind>>(str)
|
|
.Case("seq_cst", ClauseMemoryOrderKind::Seq_cst)
|
|
.Case("acq_rel", ClauseMemoryOrderKind::Acq_rel)
|
|
.Case("acquire", ClauseMemoryOrderKind::Acquire)
|
|
.Case("release", ClauseMemoryOrderKind::Release)
|
|
.Case("relaxed", ClauseMemoryOrderKind::Relaxed)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseMemoryOrderKind> symbolizeClauseMemoryOrderKind(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseMemoryOrderKind::Seq_cst;
|
|
case 1: return ClauseMemoryOrderKind::Acq_rel;
|
|
case 2: return ClauseMemoryOrderKind::Acquire;
|
|
case 3: return ClauseMemoryOrderKind::Release;
|
|
case 4: return ClauseMemoryOrderKind::Relaxed;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseNumTasksType(ClauseNumTasksType val) {
|
|
switch (val) {
|
|
case ClauseNumTasksType::Strict: return "strict";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseNumTasksType> symbolizeClauseNumTasksType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseNumTasksType>>(str)
|
|
.Case("strict", ClauseNumTasksType::Strict)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseNumTasksType> symbolizeClauseNumTasksType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseNumTasksType::Strict;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseNumThreadsType(ClauseNumThreadsType val) {
|
|
switch (val) {
|
|
case ClauseNumThreadsType::Strict: return "strict";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseNumThreadsType> symbolizeClauseNumThreadsType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseNumThreadsType>>(str)
|
|
.Case("strict", ClauseNumThreadsType::Strict)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseNumThreadsType> symbolizeClauseNumThreadsType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseNumThreadsType::Strict;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseOrderKind(ClauseOrderKind val) {
|
|
switch (val) {
|
|
case ClauseOrderKind::Concurrent: return "concurrent";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseOrderKind> symbolizeClauseOrderKind(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseOrderKind>>(str)
|
|
.Case("concurrent", ClauseOrderKind::Concurrent)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseOrderKind> symbolizeClauseOrderKind(uint32_t value) {
|
|
switch (value) {
|
|
case 1: return ClauseOrderKind::Concurrent;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyOrderModifier(OrderModifier val) {
|
|
switch (val) {
|
|
case OrderModifier::reproducible: return "reproducible";
|
|
case OrderModifier::unconstrained: return "unconstrained";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<OrderModifier> symbolizeOrderModifier(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<OrderModifier>>(str)
|
|
.Case("reproducible", OrderModifier::reproducible)
|
|
.Case("unconstrained", OrderModifier::unconstrained)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<OrderModifier> symbolizeOrderModifier(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return OrderModifier::reproducible;
|
|
case 1: return OrderModifier::unconstrained;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseProcBindKind(ClauseProcBindKind val) {
|
|
switch (val) {
|
|
case ClauseProcBindKind::Primary: return "primary";
|
|
case ClauseProcBindKind::Master: return "master";
|
|
case ClauseProcBindKind::Close: return "close";
|
|
case ClauseProcBindKind::Spread: return "spread";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseProcBindKind> symbolizeClauseProcBindKind(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseProcBindKind>>(str)
|
|
.Case("primary", ClauseProcBindKind::Primary)
|
|
.Case("master", ClauseProcBindKind::Master)
|
|
.Case("close", ClauseProcBindKind::Close)
|
|
.Case("spread", ClauseProcBindKind::Spread)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseProcBindKind> symbolizeClauseProcBindKind(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseProcBindKind::Primary;
|
|
case 1: return ClauseProcBindKind::Master;
|
|
case 2: return ClauseProcBindKind::Close;
|
|
case 3: return ClauseProcBindKind::Spread;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyReductionModifier(ReductionModifier val) {
|
|
switch (val) {
|
|
case ReductionModifier::defaultmod: return "defaultmod";
|
|
case ReductionModifier::inscan: return "inscan";
|
|
case ReductionModifier::task: return "task";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ReductionModifier> symbolizeReductionModifier(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ReductionModifier>>(str)
|
|
.Case("defaultmod", ReductionModifier::defaultmod)
|
|
.Case("inscan", ReductionModifier::inscan)
|
|
.Case("task", ReductionModifier::task)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ReductionModifier> symbolizeReductionModifier(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ReductionModifier::defaultmod;
|
|
case 1: return ReductionModifier::inscan;
|
|
case 2: return ReductionModifier::task;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyClauseScheduleKind(ClauseScheduleKind val) {
|
|
switch (val) {
|
|
case ClauseScheduleKind::Static: return "static";
|
|
case ClauseScheduleKind::Dynamic: return "dynamic";
|
|
case ClauseScheduleKind::Guided: return "guided";
|
|
case ClauseScheduleKind::Auto: return "auto";
|
|
case ClauseScheduleKind::Runtime: return "runtime";
|
|
case ClauseScheduleKind::Distribute: return "distribute";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseScheduleKind> symbolizeClauseScheduleKind(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseScheduleKind>>(str)
|
|
.Case("static", ClauseScheduleKind::Static)
|
|
.Case("dynamic", ClauseScheduleKind::Dynamic)
|
|
.Case("guided", ClauseScheduleKind::Guided)
|
|
.Case("auto", ClauseScheduleKind::Auto)
|
|
.Case("runtime", ClauseScheduleKind::Runtime)
|
|
.Case("distribute", ClauseScheduleKind::Distribute)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseScheduleKind> symbolizeClauseScheduleKind(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseScheduleKind::Static;
|
|
case 1: return ClauseScheduleKind::Dynamic;
|
|
case 2: return ClauseScheduleKind::Guided;
|
|
case 3: return ClauseScheduleKind::Auto;
|
|
case 4: return ClauseScheduleKind::Runtime;
|
|
case 5: return ClauseScheduleKind::Distribute;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyScheduleModifier(ScheduleModifier val) {
|
|
switch (val) {
|
|
case ScheduleModifier::none: return "none";
|
|
case ScheduleModifier::monotonic: return "monotonic";
|
|
case ScheduleModifier::nonmonotonic: return "nonmonotonic";
|
|
case ScheduleModifier::simd: return "simd";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ScheduleModifier> symbolizeScheduleModifier(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ScheduleModifier>>(str)
|
|
.Case("none", ScheduleModifier::none)
|
|
.Case("monotonic", ScheduleModifier::monotonic)
|
|
.Case("nonmonotonic", ScheduleModifier::nonmonotonic)
|
|
.Case("simd", ScheduleModifier::simd)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ScheduleModifier> symbolizeScheduleModifier(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ScheduleModifier::none;
|
|
case 1: return ScheduleModifier::monotonic;
|
|
case 2: return ScheduleModifier::nonmonotonic;
|
|
case 3: return ScheduleModifier::simd;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyTargetExecMode(TargetExecMode val) {
|
|
switch (val) {
|
|
case TargetExecMode::bare: return "bare";
|
|
case TargetExecMode::generic: return "generic";
|
|
case TargetExecMode::spmd: return "spmd";
|
|
case TargetExecMode::no_loop: return "no_loop";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<TargetExecMode> symbolizeTargetExecMode(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<TargetExecMode>>(str)
|
|
.Case("bare", TargetExecMode::bare)
|
|
.Case("generic", TargetExecMode::generic)
|
|
.Case("spmd", TargetExecMode::spmd)
|
|
.Case("no_loop", TargetExecMode::no_loop)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<TargetExecMode> symbolizeTargetExecMode(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return TargetExecMode::bare;
|
|
case 1: return TargetExecMode::generic;
|
|
case 2: return TargetExecMode::spmd;
|
|
case 3: return TargetExecMode::no_loop;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|
|
namespace mlir::omp {
|
|
|
|
::llvm::StringRef stringifyVariableCaptureKind(VariableCaptureKind val) {
|
|
switch (val) {
|
|
case VariableCaptureKind::This: return "This";
|
|
case VariableCaptureKind::ByRef: return "ByRef";
|
|
case VariableCaptureKind::ByCopy: return "ByCopy";
|
|
case VariableCaptureKind::VLAType: return "VLAType";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<VariableCaptureKind> symbolizeVariableCaptureKind(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<VariableCaptureKind>>(str)
|
|
.Case("This", VariableCaptureKind::This)
|
|
.Case("ByRef", VariableCaptureKind::ByRef)
|
|
.Case("ByCopy", VariableCaptureKind::ByCopy)
|
|
.Case("VLAType", VariableCaptureKind::VLAType)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<VariableCaptureKind> symbolizeVariableCaptureKind(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return VariableCaptureKind::This;
|
|
case 1: return VariableCaptureKind::ByRef;
|
|
case 2: return VariableCaptureKind::ByCopy;
|
|
case 3: return VariableCaptureKind::VLAType;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::omp
|