llvm/tools/mlir/include/mlir/Dialect/OpenMP/OpenMPOpsEnums.cpp.inc

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Enum Utility Definitions                                                   *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: OpenMPOps.td                                                         *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseCancellationConstructType(ClauseCancellationConstructType val) { … }

::std::optional<ClauseCancellationConstructType> symbolizeClauseCancellationConstructType(::llvm::StringRef str) { … }
::std::optional<ClauseCancellationConstructType> symbolizeClauseCancellationConstructType(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseDepend(ClauseDepend val) { … }

::std::optional<ClauseDepend> symbolizeClauseDepend(::llvm::StringRef str) { … }
::std::optional<ClauseDepend> symbolizeClauseDepend(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
std::string stringifyClauseRequires(ClauseRequires symbol) { … }

::std::optional<ClauseRequires> symbolizeClauseRequires(::llvm::StringRef str) { … }

::std::optional<ClauseRequires> symbolizeClauseRequires(uint32_t value) { … }
} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseTaskDepend(ClauseTaskDepend val) { … }

::std::optional<ClauseTaskDepend> symbolizeClauseTaskDepend(::llvm::StringRef str) { … }
::std::optional<ClauseTaskDepend> symbolizeClauseTaskDepend(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyDataSharingClauseType(DataSharingClauseType val) { … }

::std::optional<DataSharingClauseType> symbolizeDataSharingClauseType(::llvm::StringRef str) { … }
::std::optional<DataSharingClauseType> symbolizeDataSharingClauseType(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyDeclareTargetCaptureClause(DeclareTargetCaptureClause val) { … }

::std::optional<DeclareTargetCaptureClause> symbolizeDeclareTargetCaptureClause(::llvm::StringRef str) { … }
::std::optional<DeclareTargetCaptureClause> symbolizeDeclareTargetCaptureClause(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyDeclareTargetDeviceType(DeclareTargetDeviceType val) { … }

::std::optional<DeclareTargetDeviceType> symbolizeDeclareTargetDeviceType(::llvm::StringRef str) { … }
::std::optional<DeclareTargetDeviceType> symbolizeDeclareTargetDeviceType(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseGrainsizeType(ClauseGrainsizeType val) { … }

::std::optional<ClauseGrainsizeType> symbolizeClauseGrainsizeType(::llvm::StringRef str) { … }
::std::optional<ClauseGrainsizeType> symbolizeClauseGrainsizeType(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseMemoryOrderKind(ClauseMemoryOrderKind val) { … }

::std::optional<ClauseMemoryOrderKind> symbolizeClauseMemoryOrderKind(::llvm::StringRef str) { … }
::std::optional<ClauseMemoryOrderKind> symbolizeClauseMemoryOrderKind(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseNumTasksType(ClauseNumTasksType val) { … }

::std::optional<ClauseNumTasksType> symbolizeClauseNumTasksType(::llvm::StringRef str) { … }
::std::optional<ClauseNumTasksType> symbolizeClauseNumTasksType(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseOrderKind(ClauseOrderKind val) { … }

::std::optional<ClauseOrderKind> symbolizeClauseOrderKind(::llvm::StringRef str) { … }
::std::optional<ClauseOrderKind> symbolizeClauseOrderKind(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyOrderModifier(OrderModifier val) { … }

::std::optional<OrderModifier> symbolizeOrderModifier(::llvm::StringRef str) { … }
::std::optional<OrderModifier> symbolizeOrderModifier(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseProcBindKind(ClauseProcBindKind val) { … }

::std::optional<ClauseProcBindKind> symbolizeClauseProcBindKind(::llvm::StringRef str) { … }
::std::optional<ClauseProcBindKind> symbolizeClauseProcBindKind(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyClauseScheduleKind(ClauseScheduleKind val) { … }

::std::optional<ClauseScheduleKind> symbolizeClauseScheduleKind(::llvm::StringRef str) { … }
::std::optional<ClauseScheduleKind> symbolizeClauseScheduleKind(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyScheduleModifier(ScheduleModifier val) { … }

::std::optional<ScheduleModifier> symbolizeScheduleModifier(::llvm::StringRef str) { … }
::std::optional<ScheduleModifier> symbolizeScheduleModifier(uint32_t value) { … }

} // namespace omp
} // namespace mlir

namespace mlir {
namespace omp {
::llvm::StringRef stringifyVariableCaptureKind(VariableCaptureKind val) { … }

::std::optional<VariableCaptureKind> symbolizeVariableCaptureKind(::llvm::StringRef str) { … }
::std::optional<VariableCaptureKind> symbolizeVariableCaptureKind(uint32_t value) { … }

} // namespace omp
} // namespace mlir