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

namespace mlir::ROCDL {

::llvm::StringRef stringifyBufferOOBMode(BufferOOBMode val) {
  switch (val) {
    case BufferOOBMode::Any: return "any";
    case BufferOOBMode::Relaxed: return "relaxed";
    case BufferOOBMode::Strict: return "strict";
  }
  return "";
}

::std::optional<BufferOOBMode> symbolizeBufferOOBMode(::llvm::StringRef str) {
  return ::llvm::StringSwitch<::std::optional<BufferOOBMode>>(str)
      .Case("any", BufferOOBMode::Any)
      .Case("relaxed", BufferOOBMode::Relaxed)
      .Case("strict", BufferOOBMode::Strict)
      .Default(::std::nullopt);
}
::std::optional<BufferOOBMode> symbolizeBufferOOBMode(uint32_t value) {
  switch (value) {
  case 0: return BufferOOBMode::Any;
  case 1: return BufferOOBMode::Relaxed;
  case 2: return BufferOOBMode::Strict;
  default: return ::std::nullopt;
  }
}


} // namespace mlir::ROCDL
namespace mlir::ROCDL {

std::string stringifyGfx12AtomicCachePolicy(Gfx12AtomicCachePolicy symbol) {
  auto val = static_cast<uint32_t>(symbol);
  assert(2147483711u == (2147483711u | 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 (24u == (24u & val)) {
    strs.push_back("scope_sys");
    val &= ~static_cast<uint32_t>(24);
  }

  if (1u == (1u & val))
    strs.push_back("return");

  if (2u == (2u & val))
    strs.push_back("nt");

  if (4u == (4u & val))
    strs.push_back("cascade");

  if (8u == (8u & val))
    strs.push_back("scope_se");

  if (16u == (16u & val))
    strs.push_back("scope_dev");

  if (32u == (32u & val))
    strs.push_back("nv");

  if (2147483648u == (2147483648u & val))
    strs.push_back("volatile");
  return ::llvm::join(strs, "|");
}

::std::optional<Gfx12AtomicCachePolicy> symbolizeGfx12AtomicCachePolicy(::llvm::StringRef str) {
  // Special case for all bits unset.
  if (str == "none") return Gfx12AtomicCachePolicy::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("return", 1)
      .Case("nt", 2)
      .Case("cascade", 4)
      .Case("scope_se", 8)
      .Case("scope_dev", 16)
      .Case("scope_sys", 24)
      .Case("nv", 32)
      .Case("volatile", 2147483648)
      .Default(::std::nullopt);
    if (bit) { val |= *bit; } else { return ::std::nullopt; }
  }
  return static_cast<Gfx12AtomicCachePolicy>(val);
}

::std::optional<Gfx12AtomicCachePolicy> symbolizeGfx12AtomicCachePolicy(uint32_t value) {
  // Special case for all bits unset.
  if (value == 0) return Gfx12AtomicCachePolicy::none;

  if (value & ~static_cast<uint32_t>(2147483711u)) return std::nullopt;
  return static_cast<Gfx12AtomicCachePolicy>(value);
}

} // namespace mlir::ROCDL
namespace mlir::ROCDL {

std::string stringifyGfx12CachePolicy(Gfx12CachePolicy symbol) {
  auto val = static_cast<uint32_t>(symbol);
  assert(2147485823u == (2147485823u | 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 (24u == (24u & val)) {
    strs.push_back("scope_sys");
    val &= ~static_cast<uint32_t>(24);
  }

  if (7u == (7u & val)) {
    strs.push_back("nt_wb");
    val &= ~static_cast<uint32_t>(7);
  }

  if (6u == (6u & val)) {
    strs.push_back("nt_ht");
    val &= ~static_cast<uint32_t>(6);
  }

  if (5u == (5u & val)) {
    strs.push_back("rt_nt");
    val &= ~static_cast<uint32_t>(5);
  }

  if (4u == (4u & val)) {
    strs.push_back("nt_rt");
    val &= ~static_cast<uint32_t>(4);
  }

  if (3u == (3u & val)) {
    strs.push_back("lu");
    val &= ~static_cast<uint32_t>(3);
  }

  if (1u == (1u & val))
    strs.push_back("nt");

  if (2u == (2u & val))
    strs.push_back("ht");

  if (8u == (8u & val))
    strs.push_back("scope_se");

  if (16u == (16u & val))
    strs.push_back("scope_dev");

  if (32u == (32u & val))
    strs.push_back("nv");

  if (64u == (64u & val))
    strs.push_back("swz");

  if (2048u == (2048u & val))
    strs.push_back("scal");

  if (2147483648u == (2147483648u & val))
    strs.push_back("volatile");
  return ::llvm::join(strs, "|");
}

::std::optional<Gfx12CachePolicy> symbolizeGfx12CachePolicy(::llvm::StringRef str) {
  // Special case for all bits unset.
  if (str == "none") return Gfx12CachePolicy::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("nt", 1)
      .Case("ht", 2)
      .Case("lu", 3)
      .Case("nt_rt", 4)
      .Case("rt_nt", 5)
      .Case("nt_ht", 6)
      .Case("nt_wb", 7)
      .Case("scope_se", 8)
      .Case("scope_dev", 16)
      .Case("scope_sys", 24)
      .Case("nv", 32)
      .Case("swz", 64)
      .Case("scal", 2048)
      .Case("volatile", 2147483648)
      .Default(::std::nullopt);
    if (bit) { val |= *bit; } else { return ::std::nullopt; }
  }
  return static_cast<Gfx12CachePolicy>(val);
}

::std::optional<Gfx12CachePolicy> symbolizeGfx12CachePolicy(uint32_t value) {
  // Special case for all bits unset.
  if (value == 0) return Gfx12CachePolicy::none;

  if (value & ~static_cast<uint32_t>(2147485823u)) return std::nullopt;
  return static_cast<Gfx12CachePolicy>(value);
}

} // namespace mlir::ROCDL
namespace mlir::ROCDL {

std::string stringifyGfx942CachePolicy(Gfx942CachePolicy symbol) {
  auto val = static_cast<uint32_t>(symbol);
  assert(2147483675u == (2147483675u | 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("sc0");

  if (2u == (2u & val))
    strs.push_back("nt");

  if (8u == (8u & val))
    strs.push_back("swz");

  if (16u == (16u & val))
    strs.push_back("sc1");

  if (2147483648u == (2147483648u & val))
    strs.push_back("volatile");
  return ::llvm::join(strs, "|");
}

::std::optional<Gfx942CachePolicy> symbolizeGfx942CachePolicy(::llvm::StringRef str) {
  // Special case for all bits unset.
  if (str == "none") return Gfx942CachePolicy::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("sc0", 1)
      .Case("nt", 2)
      .Case("swz", 8)
      .Case("sc1", 16)
      .Case("volatile", 2147483648)
      .Default(::std::nullopt);
    if (bit) { val |= *bit; } else { return ::std::nullopt; }
  }
  return static_cast<Gfx942CachePolicy>(val);
}

::std::optional<Gfx942CachePolicy> symbolizeGfx942CachePolicy(uint32_t value) {
  // Special case for all bits unset.
  if (value == 0) return Gfx942CachePolicy::none;

  if (value & ~static_cast<uint32_t>(2147483675u)) return std::nullopt;
  return static_cast<Gfx942CachePolicy>(value);
}

} // namespace mlir::ROCDL
namespace mlir::ROCDL {

std::string stringifyMFMANegModifier(MFMANegModifier symbol) {
  auto val = static_cast<uint32_t>(symbol);
  assert(7u == (7u | 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("neg_a");

  if (2u == (2u & val))
    strs.push_back("neg_b");

  if (4u == (4u & val))
    strs.push_back("neg_c");
  return ::llvm::join(strs, "|");
}

::std::optional<MFMANegModifier> symbolizeMFMANegModifier(::llvm::StringRef str) {
  // Special case for all bits unset.
  if (str == "none") return MFMANegModifier::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("neg_a", 1)
      .Case("neg_b", 2)
      .Case("neg_c", 4)
      .Default(::std::nullopt);
    if (bit) { val |= *bit; } else { return ::std::nullopt; }
  }
  return static_cast<MFMANegModifier>(val);
}

::std::optional<MFMANegModifier> symbolizeMFMANegModifier(uint32_t value) {
  // Special case for all bits unset.
  if (value == 0) return MFMANegModifier::none;

  if (value & ~static_cast<uint32_t>(7u)) return std::nullopt;
  return static_cast<MFMANegModifier>(value);
}

} // namespace mlir::ROCDL
namespace mlir::ROCDL {

::llvm::StringRef stringifyMFMAPermB(MFMAPermB val) {
  switch (val) {
    case MFMAPermB::none: return "none";
    case MFMAPermB::bcast_first_32: return "bcast_first_32";
    case MFMAPermB::bcast_second_32: return "bcast_second_32";
    case MFMAPermB::rotate_16_right: return "rotate_16_right";
    case MFMAPermB::bcast_first_16: return "bcast_first_16";
    case MFMAPermB::bcast_second_16: return "bcast_second_16";
    case MFMAPermB::bcast_third_16: return "bcast_third_16";
    case MFMAPermB::bcast_fourth_16: return "bcast_fourth_16";
  }
  return "";
}

::std::optional<MFMAPermB> symbolizeMFMAPermB(::llvm::StringRef str) {
  return ::llvm::StringSwitch<::std::optional<MFMAPermB>>(str)
      .Case("none", MFMAPermB::none)
      .Case("bcast_first_32", MFMAPermB::bcast_first_32)
      .Case("bcast_second_32", MFMAPermB::bcast_second_32)
      .Case("rotate_16_right", MFMAPermB::rotate_16_right)
      .Case("bcast_first_16", MFMAPermB::bcast_first_16)
      .Case("bcast_second_16", MFMAPermB::bcast_second_16)
      .Case("bcast_third_16", MFMAPermB::bcast_third_16)
      .Case("bcast_fourth_16", MFMAPermB::bcast_fourth_16)
      .Default(::std::nullopt);
}
::std::optional<MFMAPermB> symbolizeMFMAPermB(uint32_t value) {
  switch (value) {
  case 0: return MFMAPermB::none;
  case 1: return MFMAPermB::bcast_first_32;
  case 2: return MFMAPermB::bcast_second_32;
  case 3: return MFMAPermB::rotate_16_right;
  case 4: return MFMAPermB::bcast_first_16;
  case 5: return MFMAPermB::bcast_second_16;
  case 6: return MFMAPermB::bcast_third_16;
  case 7: return MFMAPermB::bcast_fourth_16;
  default: return ::std::nullopt;
  }
}


} // namespace mlir::ROCDL
namespace mlir::ROCDL {

::llvm::StringRef stringifyMatrixFormat(MatrixFormat val) {
  switch (val) {
    case MatrixFormat::fp8_e4m3: return "fp8_e4m3";
    case MatrixFormat::fp8_e5m2: return "fp8_e5m2";
    case MatrixFormat::fp6_e2m3: return "fp6_e2m3";
    case MatrixFormat::fp6_e3m2: return "fp6_e3m2";
    case MatrixFormat::fp4_e2m1: return "fp4_e2m1";
  }
  return "";
}

::std::optional<MatrixFormat> symbolizeMatrixFormat(::llvm::StringRef str) {
  return ::llvm::StringSwitch<::std::optional<MatrixFormat>>(str)
      .Case("fp8_e4m3", MatrixFormat::fp8_e4m3)
      .Case("fp8_e5m2", MatrixFormat::fp8_e5m2)
      .Case("fp6_e2m3", MatrixFormat::fp6_e2m3)
      .Case("fp6_e3m2", MatrixFormat::fp6_e3m2)
      .Case("fp4_e2m1", MatrixFormat::fp4_e2m1)
      .Default(::std::nullopt);
}
::std::optional<MatrixFormat> symbolizeMatrixFormat(uint32_t value) {
  switch (value) {
  case 0: return MatrixFormat::fp8_e4m3;
  case 1: return MatrixFormat::fp8_e5m2;
  case 2: return MatrixFormat::fp6_e2m3;
  case 3: return MatrixFormat::fp6_e3m2;
  case 4: return MatrixFormat::fp4_e2m1;
  default: return ::std::nullopt;
  }
}


} // namespace mlir::ROCDL
namespace mlir::ROCDL {

std::string stringifyPreGfx12CachePolicy(PreGfx12CachePolicy symbol) {
  auto val = static_cast<uint32_t>(symbol);
  assert(2147483679u == (2147483679u | 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 (23u == (23u & val)) {
    strs.push_back("all");
    val &= ~static_cast<uint32_t>(23);
  }

  if (1u == (1u & val))
    strs.push_back("glc");

  if (2u == (2u & val))
    strs.push_back("slc");

  if (4u == (4u & val))
    strs.push_back("dlc");

  if (8u == (8u & val))
    strs.push_back("swz");

  if (16u == (16u & val))
    strs.push_back("scc");

  if (2147483648u == (2147483648u & val))
    strs.push_back("volatile");
  return ::llvm::join(strs, "|");
}

::std::optional<PreGfx12CachePolicy> symbolizePreGfx12CachePolicy(::llvm::StringRef str) {
  // Special case for all bits unset.
  if (str == "none") return PreGfx12CachePolicy::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("glc", 1)
      .Case("slc", 2)
      .Case("dlc", 4)
      .Case("swz", 8)
      .Case("scc", 16)
      .Case("all", 23)
      .Case("volatile", 2147483648)
      .Default(::std::nullopt);
    if (bit) { val |= *bit; } else { return ::std::nullopt; }
  }
  return static_cast<PreGfx12CachePolicy>(val);
}

::std::optional<PreGfx12CachePolicy> symbolizePreGfx12CachePolicy(uint32_t value) {
  // Special case for all bits unset.
  if (value == 0) return PreGfx12CachePolicy::none;

  if (value & ~static_cast<uint32_t>(2147483679u)) return std::nullopt;
  return static_cast<PreGfx12CachePolicy>(value);
}

} // namespace mlir::ROCDL
namespace mlir::ROCDL {

std::string stringifySchedGroupMask(SchedGroupMask symbol) {
  auto val = static_cast<uint32_t>(symbol);
  assert(4095u == (4095u | 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 (4095u == (4095u & val)) {
    strs.push_back("all");
    val &= ~static_cast<uint32_t>(4095);
  }

  if (1u == (1u & val))
    strs.push_back("non_mem_non_sideeffect");

  if (2u == (2u & val))
    strs.push_back("valu");

  if (4u == (4u & val))
    strs.push_back("salu");

  if (8u == (8u & val))
    strs.push_back("mfma_wmma");

  if (16u == (16u & val))
    strs.push_back("all_vmem");

  if (32u == (32u & val))
    strs.push_back("vmem_read");

  if (64u == (64u & val))
    strs.push_back("vmem_write");

  if (128u == (128u & val))
    strs.push_back("all_ds");

  if (256u == (256u & val))
    strs.push_back("ds_read");

  if (512u == (512u & val))
    strs.push_back("ds_write");

  if (1024u == (1024u & val))
    strs.push_back("transcendental");

  if (2048u == (2048u & val))
    strs.push_back("ldsdma");
  return ::llvm::join(strs, "|");
}

::std::optional<SchedGroupMask> symbolizeSchedGroupMask(::llvm::StringRef str) {
  // Special case for all bits unset.
  if (str == "none") return SchedGroupMask::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("non_mem_non_sideeffect", 1)
      .Case("valu", 2)
      .Case("salu", 4)
      .Case("mfma_wmma", 8)
      .Case("all_vmem", 16)
      .Case("vmem_read", 32)
      .Case("vmem_write", 64)
      .Case("all_ds", 128)
      .Case("ds_read", 256)
      .Case("ds_write", 512)
      .Case("transcendental", 1024)
      .Case("ldsdma", 2048)
      .Case("all", 4095)
      .Default(::std::nullopt);
    if (bit) { val |= *bit; } else { return ::std::nullopt; }
  }
  return static_cast<SchedGroupMask>(val);
}

::std::optional<SchedGroupMask> symbolizeSchedGroupMask(uint32_t value) {
  // Special case for all bits unset.
  if (value == 0) return SchedGroupMask::none;

  if (value & ~static_cast<uint32_t>(4095u)) return std::nullopt;
  return static_cast<SchedGroupMask>(value);
}

} // namespace mlir::ROCDL
namespace mlir::ROCDL {

std::string stringifyWMMACModifier(WMMACModifier symbol) {
  auto val = static_cast<uint16_t>(symbol);
  assert(3u == (3u | 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 (3u == (3u & val)) {
    strs.push_back("neg_abs");
    val &= ~static_cast<uint16_t>(3);
  }

  if (1u == (1u & val))
    strs.push_back("neg");

  if (2u == (2u & val))
    strs.push_back("abs");
  return ::llvm::join(strs, "|");
}

::std::optional<WMMACModifier> symbolizeWMMACModifier(::llvm::StringRef str) {
  // Special case for all bits unset.
  if (str == "none") return WMMACModifier::none;

  ::llvm::SmallVector<::llvm::StringRef, 2> symbols;
  str.split(symbols, "|");

  uint16_t val = 0;
  for (auto symbol : symbols) {
    auto bit = llvm::StringSwitch<::std::optional<uint16_t>>(symbol.trim())
      .Case("neg", 1)
      .Case("abs", 2)
      .Case("neg_abs", 3)
      .Default(::std::nullopt);
    if (bit) { val |= *bit; } else { return ::std::nullopt; }
  }
  return static_cast<WMMACModifier>(val);
}

::std::optional<WMMACModifier> symbolizeWMMACModifier(uint16_t value) {
  // Special case for all bits unset.
  if (value == 0) return WMMACModifier::none;

  if (value & ~static_cast<uint16_t>(3u)) return std::nullopt;
  return static_cast<WMMACModifier>(value);
}

} // namespace mlir::ROCDL
namespace mlir::ROCDL {

::llvm::StringRef stringifyWMMAMatrixScale(WMMAMatrixScale val) {
  switch (val) {
    case WMMAMatrixScale::row0: return "row0";
    case WMMAMatrixScale::row1: return "row1";
  }
  return "";
}

::std::optional<WMMAMatrixScale> symbolizeWMMAMatrixScale(::llvm::StringRef str) {
  return ::llvm::StringSwitch<::std::optional<WMMAMatrixScale>>(str)
      .Case("row0", WMMAMatrixScale::row0)
      .Case("row1", WMMAMatrixScale::row1)
      .Default(::std::nullopt);
}
::std::optional<WMMAMatrixScale> symbolizeWMMAMatrixScale(uint32_t value) {
  switch (value) {
  case 0: return WMMAMatrixScale::row0;
  case 1: return WMMAMatrixScale::row1;
  default: return ::std::nullopt;
  }
}


} // namespace mlir::ROCDL
namespace mlir::ROCDL {

::llvm::StringRef stringifyWMMAMatrixScaleFormat(WMMAMatrixScaleFormat val) {
  switch (val) {
    case WMMAMatrixScaleFormat::e8: return "e8";
    case WMMAMatrixScaleFormat::e5m3: return "e5m3";
    case WMMAMatrixScaleFormat::e4m3: return "e4m3";
  }
  return "";
}

::std::optional<WMMAMatrixScaleFormat> symbolizeWMMAMatrixScaleFormat(::llvm::StringRef str) {
  return ::llvm::StringSwitch<::std::optional<WMMAMatrixScaleFormat>>(str)
      .Case("e8", WMMAMatrixScaleFormat::e8)
      .Case("e5m3", WMMAMatrixScaleFormat::e5m3)
      .Case("e4m3", WMMAMatrixScaleFormat::e4m3)
      .Default(::std::nullopt);
}
::std::optional<WMMAMatrixScaleFormat> symbolizeWMMAMatrixScaleFormat(uint32_t value) {
  switch (value) {
  case 0: return WMMAMatrixScaleFormat::e8;
  case 1: return WMMAMatrixScaleFormat::e5m3;
  case 2: return WMMAMatrixScaleFormat::e4m3;
  default: return ::std::nullopt;
  }
}


} // namespace mlir::ROCDL