589 lines
22 KiB
C++
589 lines
22 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Enum Utility Definitions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* From: OpenACCOps.td *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyClauseDefaultValue(ClauseDefaultValue val) {
|
|
switch (val) {
|
|
case ClauseDefaultValue::Present: return "present";
|
|
case ClauseDefaultValue::None: return "none";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClauseDefaultValue> symbolizeClauseDefaultValue(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClauseDefaultValue>>(str)
|
|
.Case("present", ClauseDefaultValue::Present)
|
|
.Case("none", ClauseDefaultValue::None)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClauseDefaultValue> symbolizeClauseDefaultValue(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClauseDefaultValue::Present;
|
|
case 1: return ClauseDefaultValue::None;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyCombinedConstructsType(CombinedConstructsType val) {
|
|
switch (val) {
|
|
case CombinedConstructsType::KernelsLoop: return "kernels_loop";
|
|
case CombinedConstructsType::ParallelLoop: return "parallel_loop";
|
|
case CombinedConstructsType::SerialLoop: return "serial_loop";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<CombinedConstructsType> symbolizeCombinedConstructsType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<CombinedConstructsType>>(str)
|
|
.Case("kernels_loop", CombinedConstructsType::KernelsLoop)
|
|
.Case("parallel_loop", CombinedConstructsType::ParallelLoop)
|
|
.Case("serial_loop", CombinedConstructsType::SerialLoop)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<CombinedConstructsType> symbolizeCombinedConstructsType(uint32_t value) {
|
|
switch (value) {
|
|
case 1: return CombinedConstructsType::KernelsLoop;
|
|
case 2: return CombinedConstructsType::ParallelLoop;
|
|
case 3: return CombinedConstructsType::SerialLoop;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyConstruct(Construct val) {
|
|
switch (val) {
|
|
case Construct::acc_construct_parallel: return "acc_construct_parallel";
|
|
case Construct::acc_construct_kernels: return "acc_construct_kernels";
|
|
case Construct::acc_construct_loop: return "acc_construct_loop";
|
|
case Construct::acc_construct_data: return "acc_construct_data";
|
|
case Construct::acc_construct_enter_data: return "acc_construct_enter_data";
|
|
case Construct::acc_construct_exit_data: return "acc_construct_exit_data";
|
|
case Construct::acc_construct_host_data: return "acc_construct_host_data";
|
|
case Construct::acc_construct_atomic: return "acc_construct_atomic";
|
|
case Construct::acc_construct_declare: return "acc_construct_declare";
|
|
case Construct::acc_construct_init: return "acc_construct_init";
|
|
case Construct::acc_construct_shutdown: return "acc_construct_shutdown";
|
|
case Construct::acc_construct_set: return "acc_construct_set";
|
|
case Construct::acc_construct_update: return "acc_construct_update";
|
|
case Construct::acc_construct_routine: return "acc_construct_routine";
|
|
case Construct::acc_construct_wait: return "acc_construct_wait";
|
|
case Construct::acc_construct_runtime_api: return "acc_construct_runtime_api";
|
|
case Construct::acc_construct_serial: return "acc_construct_serial";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<Construct> symbolizeConstruct(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<Construct>>(str)
|
|
.Case("acc_construct_parallel", Construct::acc_construct_parallel)
|
|
.Case("acc_construct_kernels", Construct::acc_construct_kernels)
|
|
.Case("acc_construct_loop", Construct::acc_construct_loop)
|
|
.Case("acc_construct_data", Construct::acc_construct_data)
|
|
.Case("acc_construct_enter_data", Construct::acc_construct_enter_data)
|
|
.Case("acc_construct_exit_data", Construct::acc_construct_exit_data)
|
|
.Case("acc_construct_host_data", Construct::acc_construct_host_data)
|
|
.Case("acc_construct_atomic", Construct::acc_construct_atomic)
|
|
.Case("acc_construct_declare", Construct::acc_construct_declare)
|
|
.Case("acc_construct_init", Construct::acc_construct_init)
|
|
.Case("acc_construct_shutdown", Construct::acc_construct_shutdown)
|
|
.Case("acc_construct_set", Construct::acc_construct_set)
|
|
.Case("acc_construct_update", Construct::acc_construct_update)
|
|
.Case("acc_construct_routine", Construct::acc_construct_routine)
|
|
.Case("acc_construct_wait", Construct::acc_construct_wait)
|
|
.Case("acc_construct_runtime_api", Construct::acc_construct_runtime_api)
|
|
.Case("acc_construct_serial", Construct::acc_construct_serial)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<Construct> symbolizeConstruct(uint64_t value) {
|
|
switch (value) {
|
|
case 0: return Construct::acc_construct_parallel;
|
|
case 1: return Construct::acc_construct_kernels;
|
|
case 2: return Construct::acc_construct_loop;
|
|
case 3: return Construct::acc_construct_data;
|
|
case 4: return Construct::acc_construct_enter_data;
|
|
case 5: return Construct::acc_construct_exit_data;
|
|
case 6: return Construct::acc_construct_host_data;
|
|
case 7: return Construct::acc_construct_atomic;
|
|
case 8: return Construct::acc_construct_declare;
|
|
case 9: return Construct::acc_construct_init;
|
|
case 10: return Construct::acc_construct_shutdown;
|
|
case 11: return Construct::acc_construct_set;
|
|
case 12: return Construct::acc_construct_update;
|
|
case 13: return Construct::acc_construct_routine;
|
|
case 14: return Construct::acc_construct_wait;
|
|
case 15: return Construct::acc_construct_runtime_api;
|
|
case 16: return Construct::acc_construct_serial;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyDataClause(DataClause val) {
|
|
switch (val) {
|
|
case DataClause::acc_copyin: return "acc_copyin";
|
|
case DataClause::acc_copyin_readonly: return "acc_copyin_readonly";
|
|
case DataClause::acc_copy: return "acc_copy";
|
|
case DataClause::acc_copyout: return "acc_copyout";
|
|
case DataClause::acc_copyout_zero: return "acc_copyout_zero";
|
|
case DataClause::acc_present: return "acc_present";
|
|
case DataClause::acc_create: return "acc_create";
|
|
case DataClause::acc_create_zero: return "acc_create_zero";
|
|
case DataClause::acc_delete: return "acc_delete";
|
|
case DataClause::acc_attach: return "acc_attach";
|
|
case DataClause::acc_detach: return "acc_detach";
|
|
case DataClause::acc_no_create: return "acc_no_create";
|
|
case DataClause::acc_private: return "acc_private";
|
|
case DataClause::acc_firstprivate: return "acc_firstprivate";
|
|
case DataClause::acc_deviceptr: return "acc_deviceptr";
|
|
case DataClause::acc_getdeviceptr: return "acc_getdeviceptr";
|
|
case DataClause::acc_update_host: return "acc_update_host";
|
|
case DataClause::acc_update_self: return "acc_update_self";
|
|
case DataClause::acc_update_device: return "acc_update_device";
|
|
case DataClause::acc_use_device: return "acc_use_device";
|
|
case DataClause::acc_reduction: return "acc_reduction";
|
|
case DataClause::acc_declare_device_resident: return "acc_declare_device_resident";
|
|
case DataClause::acc_declare_link: return "acc_declare_link";
|
|
case DataClause::acc_cache: return "acc_cache";
|
|
case DataClause::acc_cache_readonly: return "acc_cache_readonly";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<DataClause> symbolizeDataClause(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<DataClause>>(str)
|
|
.Case("acc_copyin", DataClause::acc_copyin)
|
|
.Case("acc_copyin_readonly", DataClause::acc_copyin_readonly)
|
|
.Case("acc_copy", DataClause::acc_copy)
|
|
.Case("acc_copyout", DataClause::acc_copyout)
|
|
.Case("acc_copyout_zero", DataClause::acc_copyout_zero)
|
|
.Case("acc_present", DataClause::acc_present)
|
|
.Case("acc_create", DataClause::acc_create)
|
|
.Case("acc_create_zero", DataClause::acc_create_zero)
|
|
.Case("acc_delete", DataClause::acc_delete)
|
|
.Case("acc_attach", DataClause::acc_attach)
|
|
.Case("acc_detach", DataClause::acc_detach)
|
|
.Case("acc_no_create", DataClause::acc_no_create)
|
|
.Case("acc_private", DataClause::acc_private)
|
|
.Case("acc_firstprivate", DataClause::acc_firstprivate)
|
|
.Case("acc_deviceptr", DataClause::acc_deviceptr)
|
|
.Case("acc_getdeviceptr", DataClause::acc_getdeviceptr)
|
|
.Case("acc_update_host", DataClause::acc_update_host)
|
|
.Case("acc_update_self", DataClause::acc_update_self)
|
|
.Case("acc_update_device", DataClause::acc_update_device)
|
|
.Case("acc_use_device", DataClause::acc_use_device)
|
|
.Case("acc_reduction", DataClause::acc_reduction)
|
|
.Case("acc_declare_device_resident", DataClause::acc_declare_device_resident)
|
|
.Case("acc_declare_link", DataClause::acc_declare_link)
|
|
.Case("acc_cache", DataClause::acc_cache)
|
|
.Case("acc_cache_readonly", DataClause::acc_cache_readonly)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<DataClause> symbolizeDataClause(uint64_t value) {
|
|
switch (value) {
|
|
case 1: return DataClause::acc_copyin;
|
|
case 2: return DataClause::acc_copyin_readonly;
|
|
case 3: return DataClause::acc_copy;
|
|
case 4: return DataClause::acc_copyout;
|
|
case 5: return DataClause::acc_copyout_zero;
|
|
case 6: return DataClause::acc_present;
|
|
case 7: return DataClause::acc_create;
|
|
case 8: return DataClause::acc_create_zero;
|
|
case 9: return DataClause::acc_delete;
|
|
case 10: return DataClause::acc_attach;
|
|
case 11: return DataClause::acc_detach;
|
|
case 12: return DataClause::acc_no_create;
|
|
case 13: return DataClause::acc_private;
|
|
case 14: return DataClause::acc_firstprivate;
|
|
case 15: return DataClause::acc_deviceptr;
|
|
case 16: return DataClause::acc_getdeviceptr;
|
|
case 17: return DataClause::acc_update_host;
|
|
case 18: return DataClause::acc_update_self;
|
|
case 19: return DataClause::acc_update_device;
|
|
case 20: return DataClause::acc_use_device;
|
|
case 21: return DataClause::acc_reduction;
|
|
case 22: return DataClause::acc_declare_device_resident;
|
|
case 23: return DataClause::acc_declare_link;
|
|
case 24: return DataClause::acc_cache;
|
|
case 25: return DataClause::acc_cache_readonly;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
std::string stringifyDataClauseModifier(DataClauseModifier symbol) {
|
|
auto val = static_cast<uint32_t>(symbol);
|
|
assert(31u == (31u | val) && "invalid bits set in bit enum");
|
|
// Special case for all bits unset.
|
|
if (val == 0) return "none";
|
|
|
|
::llvm::SmallVector<::llvm::StringRef, 2> strs;
|
|
// Print bit enum groups before individual bits
|
|
|
|
if (12u == (12u & val)) {
|
|
strs.push_back("always");
|
|
val &= ~static_cast<uint32_t>(12);
|
|
}
|
|
|
|
if (1u == (1u & val))
|
|
strs.push_back("zero");
|
|
|
|
if (2u == (2u & val))
|
|
strs.push_back("readonly");
|
|
|
|
if (4u == (4u & val))
|
|
strs.push_back("alwaysin");
|
|
|
|
if (8u == (8u & val))
|
|
strs.push_back("alwaysout");
|
|
|
|
if (16u == (16u & val))
|
|
strs.push_back("capture");
|
|
return ::llvm::join(strs, ",");
|
|
}
|
|
|
|
::std::optional<DataClauseModifier> symbolizeDataClauseModifier(::llvm::StringRef str) {
|
|
// Special case for all bits unset.
|
|
if (str == "none") return DataClauseModifier::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("zero", 1)
|
|
.Case("readonly", 2)
|
|
.Case("alwaysin", 4)
|
|
.Case("alwaysout", 8)
|
|
.Case("always", 12)
|
|
.Case("capture", 16)
|
|
.Default(::std::nullopt);
|
|
if (bit) { val |= *bit; } else { return ::std::nullopt; }
|
|
}
|
|
return static_cast<DataClauseModifier>(val);
|
|
}
|
|
|
|
::std::optional<DataClauseModifier> symbolizeDataClauseModifier(uint32_t value) {
|
|
// Special case for all bits unset.
|
|
if (value == 0) return DataClauseModifier::none;
|
|
|
|
if (value & ~static_cast<uint32_t>(31u)) return std::nullopt;
|
|
return static_cast<DataClauseModifier>(value);
|
|
}
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyDeviceType(DeviceType val) {
|
|
switch (val) {
|
|
case DeviceType::None: return "none";
|
|
case DeviceType::Star: return "star";
|
|
case DeviceType::Default: return "default";
|
|
case DeviceType::Host: return "host";
|
|
case DeviceType::Multicore: return "multicore";
|
|
case DeviceType::Nvidia: return "nvidia";
|
|
case DeviceType::Radeon: return "radeon";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<DeviceType> symbolizeDeviceType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<DeviceType>>(str)
|
|
.Case("none", DeviceType::None)
|
|
.Case("star", DeviceType::Star)
|
|
.Case("default", DeviceType::Default)
|
|
.Case("host", DeviceType::Host)
|
|
.Case("multicore", DeviceType::Multicore)
|
|
.Case("nvidia", DeviceType::Nvidia)
|
|
.Case("radeon", DeviceType::Radeon)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<DeviceType> symbolizeDeviceType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return DeviceType::None;
|
|
case 1: return DeviceType::Star;
|
|
case 2: return DeviceType::Default;
|
|
case 3: return DeviceType::Host;
|
|
case 4: return DeviceType::Multicore;
|
|
case 5: return DeviceType::Nvidia;
|
|
case 6: return DeviceType::Radeon;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyGangArgType(GangArgType val) {
|
|
switch (val) {
|
|
case GangArgType::Num: return "Num";
|
|
case GangArgType::Dim: return "Dim";
|
|
case GangArgType::Static: return "Static";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<GangArgType> symbolizeGangArgType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<GangArgType>>(str)
|
|
.Case("Num", GangArgType::Num)
|
|
.Case("Dim", GangArgType::Dim)
|
|
.Case("Static", GangArgType::Static)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<GangArgType> symbolizeGangArgType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return GangArgType::Num;
|
|
case 1: return GangArgType::Dim;
|
|
case 2: return GangArgType::Static;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyLoopParMode(LoopParMode val) {
|
|
switch (val) {
|
|
case LoopParMode::loop_auto: return "loop_auto";
|
|
case LoopParMode::loop_independent: return "loop_independent";
|
|
case LoopParMode::loop_seq: return "loop_seq";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<LoopParMode> symbolizeLoopParMode(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<LoopParMode>>(str)
|
|
.Case("loop_auto", LoopParMode::loop_auto)
|
|
.Case("loop_independent", LoopParMode::loop_independent)
|
|
.Case("loop_seq", LoopParMode::loop_seq)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<LoopParMode> symbolizeLoopParMode(uint32_t value) {
|
|
switch (value) {
|
|
case 1: return LoopParMode::loop_auto;
|
|
case 2: return LoopParMode::loop_independent;
|
|
case 0: return LoopParMode::loop_seq;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyParLevel(ParLevel val) {
|
|
switch (val) {
|
|
case ParLevel::seq: return "seq";
|
|
case ParLevel::gang_dim1: return "gang_dim1";
|
|
case ParLevel::gang_dim2: return "gang_dim2";
|
|
case ParLevel::gang_dim3: return "gang_dim3";
|
|
case ParLevel::worker: return "worker";
|
|
case ParLevel::vector: return "vector";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ParLevel> symbolizeParLevel(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ParLevel>>(str)
|
|
.Case("seq", ParLevel::seq)
|
|
.Case("gang_dim1", ParLevel::gang_dim1)
|
|
.Case("gang_dim2", ParLevel::gang_dim2)
|
|
.Case("gang_dim3", ParLevel::gang_dim3)
|
|
.Case("worker", ParLevel::worker)
|
|
.Case("vector", ParLevel::vector)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ParLevel> symbolizeParLevel(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ParLevel::seq;
|
|
case 1: return ParLevel::gang_dim1;
|
|
case 2: return ParLevel::gang_dim2;
|
|
case 3: return ParLevel::gang_dim3;
|
|
case 4: return ParLevel::worker;
|
|
case 5: return ParLevel::vector;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyRecipeKind(RecipeKind val) {
|
|
switch (val) {
|
|
case RecipeKind::private_recipe: return "private_recipe";
|
|
case RecipeKind::firstprivate_recipe: return "firstprivate_recipe";
|
|
case RecipeKind::reduction_recipe: return "reduction_recipe";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<RecipeKind> symbolizeRecipeKind(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<RecipeKind>>(str)
|
|
.Case("private_recipe", RecipeKind::private_recipe)
|
|
.Case("firstprivate_recipe", RecipeKind::firstprivate_recipe)
|
|
.Case("reduction_recipe", RecipeKind::reduction_recipe)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<RecipeKind> symbolizeRecipeKind(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return RecipeKind::private_recipe;
|
|
case 1: return RecipeKind::firstprivate_recipe;
|
|
case 2: return RecipeKind::reduction_recipe;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
::llvm::StringRef stringifyReductionOperator(ReductionOperator val) {
|
|
switch (val) {
|
|
case ReductionOperator::AccNone: return "none";
|
|
case ReductionOperator::AccAdd: return "add";
|
|
case ReductionOperator::AccMul: return "mul";
|
|
case ReductionOperator::AccMax: return "max";
|
|
case ReductionOperator::AccMin: return "min";
|
|
case ReductionOperator::AccIand: return "iand";
|
|
case ReductionOperator::AccIor: return "ior";
|
|
case ReductionOperator::AccXor: return "xor";
|
|
case ReductionOperator::AccEqv: return "eqv";
|
|
case ReductionOperator::AccNeqv: return "neqv";
|
|
case ReductionOperator::AccLand: return "land";
|
|
case ReductionOperator::AccLor: return "lor";
|
|
case ReductionOperator::AccMaximumf: return "maximumf";
|
|
case ReductionOperator::AccMinimumf: return "minimumf";
|
|
case ReductionOperator::AccMaxnumf: return "maxnumf";
|
|
case ReductionOperator::AccMinnumf: return "minnumf";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ReductionOperator> symbolizeReductionOperator(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ReductionOperator>>(str)
|
|
.Case("none", ReductionOperator::AccNone)
|
|
.Case("add", ReductionOperator::AccAdd)
|
|
.Case("mul", ReductionOperator::AccMul)
|
|
.Case("max", ReductionOperator::AccMax)
|
|
.Case("min", ReductionOperator::AccMin)
|
|
.Case("iand", ReductionOperator::AccIand)
|
|
.Case("ior", ReductionOperator::AccIor)
|
|
.Case("xor", ReductionOperator::AccXor)
|
|
.Case("eqv", ReductionOperator::AccEqv)
|
|
.Case("neqv", ReductionOperator::AccNeqv)
|
|
.Case("land", ReductionOperator::AccLand)
|
|
.Case("lor", ReductionOperator::AccLor)
|
|
.Case("maximumf", ReductionOperator::AccMaximumf)
|
|
.Case("minimumf", ReductionOperator::AccMinimumf)
|
|
.Case("maxnumf", ReductionOperator::AccMaxnumf)
|
|
.Case("minnumf", ReductionOperator::AccMinnumf)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ReductionOperator> symbolizeReductionOperator(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ReductionOperator::AccNone;
|
|
case 1: return ReductionOperator::AccAdd;
|
|
case 2: return ReductionOperator::AccMul;
|
|
case 3: return ReductionOperator::AccMax;
|
|
case 4: return ReductionOperator::AccMin;
|
|
case 5: return ReductionOperator::AccIand;
|
|
case 6: return ReductionOperator::AccIor;
|
|
case 7: return ReductionOperator::AccXor;
|
|
case 8: return ReductionOperator::AccEqv;
|
|
case 9: return ReductionOperator::AccNeqv;
|
|
case 10: return ReductionOperator::AccLand;
|
|
case 11: return ReductionOperator::AccLor;
|
|
case 12: return ReductionOperator::AccMaximumf;
|
|
case 13: return ReductionOperator::AccMinimumf;
|
|
case 14: return ReductionOperator::AccMaxnumf;
|
|
case 15: return ReductionOperator::AccMinnumf;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
std::string stringifyVariableTypeCategory(VariableTypeCategory 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 "uncategorized";
|
|
|
|
::llvm::SmallVector<::llvm::StringRef, 2> strs;
|
|
// Print bit enum groups before individual bits
|
|
|
|
if (14u == (14u & val)) {
|
|
strs.push_back("aggregate");
|
|
val &= ~static_cast<uint32_t>(14);
|
|
}
|
|
|
|
if (1u == (1u & val))
|
|
strs.push_back("scalar");
|
|
|
|
if (2u == (2u & val))
|
|
strs.push_back("array");
|
|
|
|
if (4u == (4u & val))
|
|
strs.push_back("composite");
|
|
|
|
if (8u == (8u & val))
|
|
strs.push_back("nonscalar");
|
|
return ::llvm::join(strs, ",");
|
|
}
|
|
|
|
::std::optional<VariableTypeCategory> symbolizeVariableTypeCategory(::llvm::StringRef str) {
|
|
// Special case for all bits unset.
|
|
if (str == "uncategorized") return VariableTypeCategory::uncategorized;
|
|
|
|
::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("scalar", 1)
|
|
.Case("array", 2)
|
|
.Case("composite", 4)
|
|
.Case("nonscalar", 8)
|
|
.Case("aggregate", 14)
|
|
.Default(::std::nullopt);
|
|
if (bit) { val |= *bit; } else { return ::std::nullopt; }
|
|
}
|
|
return static_cast<VariableTypeCategory>(val);
|
|
}
|
|
|
|
::std::optional<VariableTypeCategory> symbolizeVariableTypeCategory(uint32_t value) {
|
|
// Special case for all bits unset.
|
|
if (value == 0) return VariableTypeCategory::uncategorized;
|
|
|
|
if (value & ~static_cast<uint32_t>(15u)) return std::nullopt;
|
|
return static_cast<VariableTypeCategory>(value);
|
|
}
|
|
|
|
} // namespace mlir::acc
|