[llvm] [NFC][TableGen] Use StringRef in X86RecognizableInstr (PR #139648)
Rahul Joshi via llvm-commits
llvm-commits at lists.llvm.org
Tue May 13 21:52:46 PDT 2025
https://github.com/jurahul updated https://github.com/llvm/llvm-project/pull/139648
>From 833d83643f8d359270f87f69240314ae58f1d825 Mon Sep 17 00:00:00 2001
From: Rahul Joshi <rjoshi at nvidia.com>
Date: Mon, 12 May 2025 17:14:19 -0700
Subject: [PATCH] [NFC][TableGen] Use StringRef in X86RecognizableInstr
- Use `StringRef` instead of `std::string` in several functions.
- Fix some variable names to conform to LLVM coding standard.
---
llvm/utils/TableGen/X86RecognizableInstr.cpp | 755 +++++++++----------
llvm/utils/TableGen/X86RecognizableInstr.h | 25 +-
2 files changed, 389 insertions(+), 391 deletions(-)
diff --git a/llvm/utils/TableGen/X86RecognizableInstr.cpp b/llvm/utils/TableGen/X86RecognizableInstr.cpp
index 402fc93703228..a26920fd83d10 100644
--- a/llvm/utils/TableGen/X86RecognizableInstr.cpp
+++ b/llvm/utils/TableGen/X86RecognizableInstr.cpp
@@ -437,11 +437,11 @@ void RecognizableInstr::adjustOperandEncoding(OperandEncoding &encoding) {
"Invalid CDisp scaling");
}
-void RecognizableInstr::handleOperand(
- bool optional, unsigned &operandIndex, unsigned &physicalOperandIndex,
- unsigned numPhysicalOperands, const unsigned *operandMapping,
- OperandEncoding (*encodingFromString)(const std::string &,
- uint8_t OpSize)) {
+void RecognizableInstr::handleOperand(bool optional, unsigned &operandIndex,
+ unsigned &physicalOperandIndex,
+ unsigned numPhysicalOperands,
+ const unsigned *operandMapping,
+ EncodingFn encodingFromString) {
if (optional) {
if (physicalOperandIndex >= numPhysicalOperands)
return;
@@ -458,12 +458,12 @@ void RecognizableInstr::handleOperand(
StringRef typeName = (*Operands)[operandIndex].Rec->getName();
- OperandEncoding encoding = encodingFromString(typeName.str(), OpSize);
+ OperandEncoding encoding = encodingFromString(typeName, OpSize);
// Adjust the encoding type for an operand based on the instruction.
adjustOperandEncoding(encoding);
Spec->operands[operandIndex].encoding = encoding;
Spec->operands[operandIndex].type =
- typeFromString(typeName.str(), HasREX_W, OpSize);
+ typeFromString(typeName, HasREX_W, OpSize);
++operandIndex;
++physicalOperandIndex;
@@ -1020,433 +1020,430 @@ void RecognizableInstr::emitDecodePath(DisassemblerTables &tables) const {
#undef MAP
}
-#define TYPE(str, type) \
- if (s == str) \
- return type;
-OperandType RecognizableInstr::typeFromString(const std::string &s,
- bool hasREX_W, uint8_t OpSize) {
+#define TYPE(Str, Expected, Type) \
+ if (Str == Expected) \
+ return Type;
+
+OperandType RecognizableInstr::typeFromString(StringRef Str, bool hasREX_W,
+ uint8_t OpSize) {
if (hasREX_W) {
// For instructions with a REX_W prefix, a declared 32-bit register encoding
// is special.
- TYPE("GR32", TYPE_R32)
+ TYPE(Str, "GR32", TYPE_R32)
}
if (OpSize == X86Local::OpSize16) {
// For OpSize16 instructions, a declared 16-bit register or
// immediate encoding is special.
- TYPE("GR16", TYPE_Rv)
+ TYPE(Str, "GR16", TYPE_Rv)
} else if (OpSize == X86Local::OpSize32) {
// For OpSize32 instructions, a declared 32-bit register or
// immediate encoding is special.
- TYPE("GR32", TYPE_Rv)
+ TYPE(Str, "GR32", TYPE_Rv)
}
- TYPE("i16mem", TYPE_M)
- TYPE("i16imm", TYPE_IMM)
- TYPE("i16i8imm", TYPE_IMM)
- TYPE("GR16", TYPE_R16)
- TYPE("GR16orGR32orGR64", TYPE_R16)
- TYPE("i32mem", TYPE_M)
- TYPE("i32imm", TYPE_IMM)
- TYPE("i32i8imm", TYPE_IMM)
- TYPE("GR32", TYPE_R32)
- TYPE("GR32orGR64", TYPE_R32)
- TYPE("i64mem", TYPE_M)
- TYPE("i64i32imm", TYPE_IMM)
- TYPE("i64i8imm", TYPE_IMM)
- TYPE("GR64", TYPE_R64)
- TYPE("i8mem", TYPE_M)
- TYPE("i8imm", TYPE_IMM)
- TYPE("u4imm", TYPE_UIMM8)
- TYPE("u8imm", TYPE_UIMM8)
- TYPE("i16u8imm", TYPE_UIMM8)
- TYPE("i32u8imm", TYPE_UIMM8)
- TYPE("i64u8imm", TYPE_UIMM8)
- TYPE("GR8", TYPE_R8)
- TYPE("VR128", TYPE_XMM)
- TYPE("VR128X", TYPE_XMM)
- TYPE("f128mem", TYPE_M)
- TYPE("f256mem", TYPE_M)
- TYPE("f512mem", TYPE_M)
- TYPE("FR128", TYPE_XMM)
- TYPE("FR64", TYPE_XMM)
- TYPE("FR64X", TYPE_XMM)
- TYPE("f64mem", TYPE_M)
- TYPE("sdmem", TYPE_M)
- TYPE("FR16X", TYPE_XMM)
- TYPE("FR32", TYPE_XMM)
- TYPE("FR32X", TYPE_XMM)
- TYPE("f32mem", TYPE_M)
- TYPE("f16mem", TYPE_M)
- TYPE("ssmem", TYPE_M)
- TYPE("shmem", TYPE_M)
- TYPE("RST", TYPE_ST)
- TYPE("RSTi", TYPE_ST)
- TYPE("i128mem", TYPE_M)
- TYPE("i256mem", TYPE_M)
- TYPE("i512mem", TYPE_M)
- TYPE("i512mem_GR16", TYPE_M)
- TYPE("i512mem_GR32", TYPE_M)
- TYPE("i512mem_GR64", TYPE_M)
- TYPE("i64i32imm_brtarget", TYPE_REL)
- TYPE("i8imm_brtarget", TYPE_REL)
- TYPE("i16imm_brtarget", TYPE_REL)
- TYPE("i32imm_brtarget", TYPE_REL)
- TYPE("ccode", TYPE_IMM)
- TYPE("cflags", TYPE_IMM)
- TYPE("AVX512RC", TYPE_IMM)
- TYPE("brtarget32", TYPE_REL)
- TYPE("brtarget16", TYPE_REL)
- TYPE("brtarget8", TYPE_REL)
- TYPE("f80mem", TYPE_M)
- TYPE("lea64_8mem", TYPE_M)
- TYPE("lea64_16mem", TYPE_M)
- TYPE("lea64_32mem", TYPE_M)
- TYPE("lea64mem", TYPE_M)
- TYPE("VR64", TYPE_MM64)
- TYPE("i64imm", TYPE_IMM)
- TYPE("anymem", TYPE_M)
- TYPE("opaquemem", TYPE_M)
- TYPE("sibmem", TYPE_MSIB)
- TYPE("SEGMENT_REG", TYPE_SEGMENTREG)
- TYPE("DEBUG_REG", TYPE_DEBUGREG)
- TYPE("CONTROL_REG", TYPE_CONTROLREG)
- TYPE("srcidx8", TYPE_SRCIDX)
- TYPE("srcidx16", TYPE_SRCIDX)
- TYPE("srcidx32", TYPE_SRCIDX)
- TYPE("srcidx64", TYPE_SRCIDX)
- TYPE("dstidx8", TYPE_DSTIDX)
- TYPE("dstidx16", TYPE_DSTIDX)
- TYPE("dstidx32", TYPE_DSTIDX)
- TYPE("dstidx64", TYPE_DSTIDX)
- TYPE("offset16_8", TYPE_MOFFS)
- TYPE("offset16_16", TYPE_MOFFS)
- TYPE("offset16_32", TYPE_MOFFS)
- TYPE("offset32_8", TYPE_MOFFS)
- TYPE("offset32_16", TYPE_MOFFS)
- TYPE("offset32_32", TYPE_MOFFS)
- TYPE("offset32_64", TYPE_MOFFS)
- TYPE("offset64_8", TYPE_MOFFS)
- TYPE("offset64_16", TYPE_MOFFS)
- TYPE("offset64_32", TYPE_MOFFS)
- TYPE("offset64_64", TYPE_MOFFS)
- TYPE("VR256", TYPE_YMM)
- TYPE("VR256X", TYPE_YMM)
- TYPE("VR512", TYPE_ZMM)
- TYPE("VK1", TYPE_VK)
- TYPE("VK1WM", TYPE_VK)
- TYPE("VK2", TYPE_VK)
- TYPE("VK2WM", TYPE_VK)
- TYPE("VK4", TYPE_VK)
- TYPE("VK4WM", TYPE_VK)
- TYPE("VK8", TYPE_VK)
- TYPE("VK8WM", TYPE_VK)
- TYPE("VK16", TYPE_VK)
- TYPE("VK16WM", TYPE_VK)
- TYPE("VK32", TYPE_VK)
- TYPE("VK32WM", TYPE_VK)
- TYPE("VK64", TYPE_VK)
- TYPE("VK64WM", TYPE_VK)
- TYPE("VK1Pair", TYPE_VK_PAIR)
- TYPE("VK2Pair", TYPE_VK_PAIR)
- TYPE("VK4Pair", TYPE_VK_PAIR)
- TYPE("VK8Pair", TYPE_VK_PAIR)
- TYPE("VK16Pair", TYPE_VK_PAIR)
- TYPE("vx32mem", TYPE_MVSIBX)
- TYPE("vx64mem", TYPE_MVSIBX)
- TYPE("vy32mem", TYPE_MVSIBY)
- TYPE("vy64mem", TYPE_MVSIBY)
- TYPE("vx32xmem", TYPE_MVSIBX)
- TYPE("vx64xmem", TYPE_MVSIBX)
- TYPE("vy32xmem", TYPE_MVSIBY)
- TYPE("vy64xmem", TYPE_MVSIBY)
- TYPE("vz32mem", TYPE_MVSIBZ)
- TYPE("vz64mem", TYPE_MVSIBZ)
- TYPE("BNDR", TYPE_BNDR)
- TYPE("TILE", TYPE_TMM)
- TYPE("TILEPair", TYPE_TMM_PAIR)
- errs() << "Unhandled type string " << s << "\n";
+ TYPE(Str, "i16mem", TYPE_M)
+ TYPE(Str, "i16imm", TYPE_IMM)
+ TYPE(Str, "i16i8imm", TYPE_IMM)
+ TYPE(Str, "GR16", TYPE_R16)
+ TYPE(Str, "GR16orGR32orGR64", TYPE_R16)
+ TYPE(Str, "i32mem", TYPE_M)
+ TYPE(Str, "i32imm", TYPE_IMM)
+ TYPE(Str, "i32i8imm", TYPE_IMM)
+ TYPE(Str, "GR32", TYPE_R32)
+ TYPE(Str, "GR32orGR64", TYPE_R32)
+ TYPE(Str, "i64mem", TYPE_M)
+ TYPE(Str, "i64i32imm", TYPE_IMM)
+ TYPE(Str, "i64i8imm", TYPE_IMM)
+ TYPE(Str, "GR64", TYPE_R64)
+ TYPE(Str, "i8mem", TYPE_M)
+ TYPE(Str, "i8imm", TYPE_IMM)
+ TYPE(Str, "u4imm", TYPE_UIMM8)
+ TYPE(Str, "u8imm", TYPE_UIMM8)
+ TYPE(Str, "i16u8imm", TYPE_UIMM8)
+ TYPE(Str, "i32u8imm", TYPE_UIMM8)
+ TYPE(Str, "i64u8imm", TYPE_UIMM8)
+ TYPE(Str, "GR8", TYPE_R8)
+ TYPE(Str, "VR128", TYPE_XMM)
+ TYPE(Str, "VR128X", TYPE_XMM)
+ TYPE(Str, "f128mem", TYPE_M)
+ TYPE(Str, "f256mem", TYPE_M)
+ TYPE(Str, "f512mem", TYPE_M)
+ TYPE(Str, "FR128", TYPE_XMM)
+ TYPE(Str, "FR64", TYPE_XMM)
+ TYPE(Str, "FR64X", TYPE_XMM)
+ TYPE(Str, "f64mem", TYPE_M)
+ TYPE(Str, "sdmem", TYPE_M)
+ TYPE(Str, "FR16X", TYPE_XMM)
+ TYPE(Str, "FR32", TYPE_XMM)
+ TYPE(Str, "FR32X", TYPE_XMM)
+ TYPE(Str, "f32mem", TYPE_M)
+ TYPE(Str, "f16mem", TYPE_M)
+ TYPE(Str, "ssmem", TYPE_M)
+ TYPE(Str, "shmem", TYPE_M)
+ TYPE(Str, "RST", TYPE_ST)
+ TYPE(Str, "RSTi", TYPE_ST)
+ TYPE(Str, "i128mem", TYPE_M)
+ TYPE(Str, "i256mem", TYPE_M)
+ TYPE(Str, "i512mem", TYPE_M)
+ TYPE(Str, "i512mem_GR16", TYPE_M)
+ TYPE(Str, "i512mem_GR32", TYPE_M)
+ TYPE(Str, "i512mem_GR64", TYPE_M)
+ TYPE(Str, "i64i32imm_brtarget", TYPE_REL)
+ TYPE(Str, "i8imm_brtarget", TYPE_REL)
+ TYPE(Str, "i16imm_brtarget", TYPE_REL)
+ TYPE(Str, "i32imm_brtarget", TYPE_REL)
+ TYPE(Str, "ccode", TYPE_IMM)
+ TYPE(Str, "cflags", TYPE_IMM)
+ TYPE(Str, "AVX512RC", TYPE_IMM)
+ TYPE(Str, "brtarget32", TYPE_REL)
+ TYPE(Str, "brtarget16", TYPE_REL)
+ TYPE(Str, "brtarget8", TYPE_REL)
+ TYPE(Str, "f80mem", TYPE_M)
+ TYPE(Str, "lea64_8mem", TYPE_M)
+ TYPE(Str, "lea64_16mem", TYPE_M)
+ TYPE(Str, "lea64_32mem", TYPE_M)
+ TYPE(Str, "lea64mem", TYPE_M)
+ TYPE(Str, "VR64", TYPE_MM64)
+ TYPE(Str, "i64imm", TYPE_IMM)
+ TYPE(Str, "anymem", TYPE_M)
+ TYPE(Str, "opaquemem", TYPE_M)
+ TYPE(Str, "sibmem", TYPE_MSIB)
+ TYPE(Str, "SEGMENT_REG", TYPE_SEGMENTREG)
+ TYPE(Str, "DEBUG_REG", TYPE_DEBUGREG)
+ TYPE(Str, "CONTROL_REG", TYPE_CONTROLREG)
+ TYPE(Str, "srcidx8", TYPE_SRCIDX)
+ TYPE(Str, "srcidx16", TYPE_SRCIDX)
+ TYPE(Str, "srcidx32", TYPE_SRCIDX)
+ TYPE(Str, "srcidx64", TYPE_SRCIDX)
+ TYPE(Str, "dstidx8", TYPE_DSTIDX)
+ TYPE(Str, "dstidx16", TYPE_DSTIDX)
+ TYPE(Str, "dstidx32", TYPE_DSTIDX)
+ TYPE(Str, "dstidx64", TYPE_DSTIDX)
+ TYPE(Str, "offset16_8", TYPE_MOFFS)
+ TYPE(Str, "offset16_16", TYPE_MOFFS)
+ TYPE(Str, "offset16_32", TYPE_MOFFS)
+ TYPE(Str, "offset32_8", TYPE_MOFFS)
+ TYPE(Str, "offset32_16", TYPE_MOFFS)
+ TYPE(Str, "offset32_32", TYPE_MOFFS)
+ TYPE(Str, "offset32_64", TYPE_MOFFS)
+ TYPE(Str, "offset64_8", TYPE_MOFFS)
+ TYPE(Str, "offset64_16", TYPE_MOFFS)
+ TYPE(Str, "offset64_32", TYPE_MOFFS)
+ TYPE(Str, "offset64_64", TYPE_MOFFS)
+ TYPE(Str, "VR256", TYPE_YMM)
+ TYPE(Str, "VR256X", TYPE_YMM)
+ TYPE(Str, "VR512", TYPE_ZMM)
+ TYPE(Str, "VK1", TYPE_VK)
+ TYPE(Str, "VK1WM", TYPE_VK)
+ TYPE(Str, "VK2", TYPE_VK)
+ TYPE(Str, "VK2WM", TYPE_VK)
+ TYPE(Str, "VK4", TYPE_VK)
+ TYPE(Str, "VK4WM", TYPE_VK)
+ TYPE(Str, "VK8", TYPE_VK)
+ TYPE(Str, "VK8WM", TYPE_VK)
+ TYPE(Str, "VK16", TYPE_VK)
+ TYPE(Str, "VK16WM", TYPE_VK)
+ TYPE(Str, "VK32", TYPE_VK)
+ TYPE(Str, "VK32WM", TYPE_VK)
+ TYPE(Str, "VK64", TYPE_VK)
+ TYPE(Str, "VK64WM", TYPE_VK)
+ TYPE(Str, "VK1Pair", TYPE_VK_PAIR)
+ TYPE(Str, "VK2Pair", TYPE_VK_PAIR)
+ TYPE(Str, "VK4Pair", TYPE_VK_PAIR)
+ TYPE(Str, "VK8Pair", TYPE_VK_PAIR)
+ TYPE(Str, "VK16Pair", TYPE_VK_PAIR)
+ TYPE(Str, "vx32mem", TYPE_MVSIBX)
+ TYPE(Str, "vx64mem", TYPE_MVSIBX)
+ TYPE(Str, "vy32mem", TYPE_MVSIBY)
+ TYPE(Str, "vy64mem", TYPE_MVSIBY)
+ TYPE(Str, "vx32xmem", TYPE_MVSIBX)
+ TYPE(Str, "vx64xmem", TYPE_MVSIBX)
+ TYPE(Str, "vy32xmem", TYPE_MVSIBY)
+ TYPE(Str, "vy64xmem", TYPE_MVSIBY)
+ TYPE(Str, "vz32mem", TYPE_MVSIBZ)
+ TYPE(Str, "vz64mem", TYPE_MVSIBZ)
+ TYPE(Str, "BNDR", TYPE_BNDR)
+ TYPE(Str, "TILE", TYPE_TMM)
+ TYPE(Str, "TILEPair", TYPE_TMM_PAIR)
+ errs() << "Unhandled type string " << Str << "\n";
llvm_unreachable("Unhandled type string");
}
#undef TYPE
-#define ENCODING(str, encoding) \
- if (s == str) \
- return encoding;
-OperandEncoding
-RecognizableInstr::immediateEncodingFromString(const std::string &s,
- uint8_t OpSize) {
+#define ENCODING(Str, Expected, Encoding) \
+ if (Str == Expected) \
+ return Encoding;
+
+OperandEncoding RecognizableInstr::immediateEncodingFromString(StringRef Str,
+ uint8_t OpSize) {
if (OpSize != X86Local::OpSize16) {
// For instructions without an OpSize prefix, a declared 16-bit register or
// immediate encoding is special.
- ENCODING("i16imm", ENCODING_IW)
+ ENCODING(Str, "i16imm", ENCODING_IW)
}
- ENCODING("i32i8imm", ENCODING_IB)
- ENCODING("AVX512RC", ENCODING_IRC)
- ENCODING("i16imm", ENCODING_Iv)
- ENCODING("i16i8imm", ENCODING_IB)
- ENCODING("i32imm", ENCODING_Iv)
- ENCODING("i64i32imm", ENCODING_ID)
- ENCODING("i64i8imm", ENCODING_IB)
- ENCODING("i8imm", ENCODING_IB)
- ENCODING("ccode", ENCODING_CC)
- ENCODING("cflags", ENCODING_CF)
- ENCODING("u4imm", ENCODING_IB)
- ENCODING("u8imm", ENCODING_IB)
- ENCODING("i16u8imm", ENCODING_IB)
- ENCODING("i32u8imm", ENCODING_IB)
- ENCODING("i64u8imm", ENCODING_IB)
+ ENCODING(Str, "i32i8imm", ENCODING_IB)
+ ENCODING(Str, "AVX512RC", ENCODING_IRC)
+ ENCODING(Str, "i16imm", ENCODING_Iv)
+ ENCODING(Str, "i16i8imm", ENCODING_IB)
+ ENCODING(Str, "i32imm", ENCODING_Iv)
+ ENCODING(Str, "i64i32imm", ENCODING_ID)
+ ENCODING(Str, "i64i8imm", ENCODING_IB)
+ ENCODING(Str, "i8imm", ENCODING_IB)
+ ENCODING(Str, "ccode", ENCODING_CC)
+ ENCODING(Str, "cflags", ENCODING_CF)
+ ENCODING(Str, "u4imm", ENCODING_IB)
+ ENCODING(Str, "u8imm", ENCODING_IB)
+ ENCODING(Str, "i16u8imm", ENCODING_IB)
+ ENCODING(Str, "i32u8imm", ENCODING_IB)
+ ENCODING(Str, "i64u8imm", ENCODING_IB)
// This is not a typo. Instructions like BLENDVPD put
// register IDs in 8-bit immediates nowadays.
- ENCODING("FR32", ENCODING_IB)
- ENCODING("FR64", ENCODING_IB)
- ENCODING("FR128", ENCODING_IB)
- ENCODING("VR128", ENCODING_IB)
- ENCODING("VR256", ENCODING_IB)
- ENCODING("FR16X", ENCODING_IB)
- ENCODING("FR32X", ENCODING_IB)
- ENCODING("FR64X", ENCODING_IB)
- ENCODING("VR128X", ENCODING_IB)
- ENCODING("VR256X", ENCODING_IB)
- ENCODING("VR512", ENCODING_IB)
- ENCODING("TILE", ENCODING_IB)
- errs() << "Unhandled immediate encoding " << s << "\n";
+ ENCODING(Str, "FR32", ENCODING_IB)
+ ENCODING(Str, "FR64", ENCODING_IB)
+ ENCODING(Str, "FR128", ENCODING_IB)
+ ENCODING(Str, "VR128", ENCODING_IB)
+ ENCODING(Str, "VR256", ENCODING_IB)
+ ENCODING(Str, "FR16X", ENCODING_IB)
+ ENCODING(Str, "FR32X", ENCODING_IB)
+ ENCODING(Str, "FR64X", ENCODING_IB)
+ ENCODING(Str, "VR128X", ENCODING_IB)
+ ENCODING(Str, "VR256X", ENCODING_IB)
+ ENCODING(Str, "VR512", ENCODING_IB)
+ ENCODING(Str, "TILE", ENCODING_IB)
+ errs() << "Unhandled immediate encoding " << Str << "\n";
llvm_unreachable("Unhandled immediate encoding");
}
OperandEncoding
-RecognizableInstr::rmRegisterEncodingFromString(const std::string &s,
- uint8_t OpSize) {
- ENCODING("RST", ENCODING_FP)
- ENCODING("RSTi", ENCODING_FP)
- ENCODING("GR16", ENCODING_RM)
- ENCODING("GR16orGR32orGR64", ENCODING_RM)
- ENCODING("GR32", ENCODING_RM)
- ENCODING("GR32orGR64", ENCODING_RM)
- ENCODING("GR64", ENCODING_RM)
- ENCODING("GR8", ENCODING_RM)
- ENCODING("VR128", ENCODING_RM)
- ENCODING("VR128X", ENCODING_RM)
- ENCODING("FR128", ENCODING_RM)
- ENCODING("FR64", ENCODING_RM)
- ENCODING("FR32", ENCODING_RM)
- ENCODING("FR64X", ENCODING_RM)
- ENCODING("FR32X", ENCODING_RM)
- ENCODING("FR16X", ENCODING_RM)
- ENCODING("VR64", ENCODING_RM)
- ENCODING("VR256", ENCODING_RM)
- ENCODING("VR256X", ENCODING_RM)
- ENCODING("VR512", ENCODING_RM)
- ENCODING("VK1", ENCODING_RM)
- ENCODING("VK2", ENCODING_RM)
- ENCODING("VK4", ENCODING_RM)
- ENCODING("VK8", ENCODING_RM)
- ENCODING("VK16", ENCODING_RM)
- ENCODING("VK32", ENCODING_RM)
- ENCODING("VK64", ENCODING_RM)
- ENCODING("BNDR", ENCODING_RM)
- ENCODING("TILE", ENCODING_RM)
- ENCODING("TILEPair", ENCODING_RM)
- errs() << "Unhandled R/M register encoding " << s << "\n";
+RecognizableInstr::rmRegisterEncodingFromString(StringRef Str, uint8_t OpSize) {
+ ENCODING(Str, "RST", ENCODING_FP)
+ ENCODING(Str, "RSTi", ENCODING_FP)
+ ENCODING(Str, "GR16", ENCODING_RM)
+ ENCODING(Str, "GR16orGR32orGR64", ENCODING_RM)
+ ENCODING(Str, "GR32", ENCODING_RM)
+ ENCODING(Str, "GR32orGR64", ENCODING_RM)
+ ENCODING(Str, "GR64", ENCODING_RM)
+ ENCODING(Str, "GR8", ENCODING_RM)
+ ENCODING(Str, "VR128", ENCODING_RM)
+ ENCODING(Str, "VR128X", ENCODING_RM)
+ ENCODING(Str, "FR128", ENCODING_RM)
+ ENCODING(Str, "FR64", ENCODING_RM)
+ ENCODING(Str, "FR32", ENCODING_RM)
+ ENCODING(Str, "FR64X", ENCODING_RM)
+ ENCODING(Str, "FR32X", ENCODING_RM)
+ ENCODING(Str, "FR16X", ENCODING_RM)
+ ENCODING(Str, "VR64", ENCODING_RM)
+ ENCODING(Str, "VR256", ENCODING_RM)
+ ENCODING(Str, "VR256X", ENCODING_RM)
+ ENCODING(Str, "VR512", ENCODING_RM)
+ ENCODING(Str, "VK1", ENCODING_RM)
+ ENCODING(Str, "VK2", ENCODING_RM)
+ ENCODING(Str, "VK4", ENCODING_RM)
+ ENCODING(Str, "VK8", ENCODING_RM)
+ ENCODING(Str, "VK16", ENCODING_RM)
+ ENCODING(Str, "VK32", ENCODING_RM)
+ ENCODING(Str, "VK64", ENCODING_RM)
+ ENCODING(Str, "BNDR", ENCODING_RM)
+ ENCODING(Str, "TILE", ENCODING_RM)
+ ENCODING(Str, "TILEPair", ENCODING_RM)
+ errs() << "Unhandled R/M register encoding " << Str << "\n";
llvm_unreachable("Unhandled R/M register encoding");
}
OperandEncoding
-RecognizableInstr::roRegisterEncodingFromString(const std::string &s,
- uint8_t OpSize) {
- ENCODING("GR16", ENCODING_REG)
- ENCODING("GR16orGR32orGR64", ENCODING_REG)
- ENCODING("GR32", ENCODING_REG)
- ENCODING("GR32orGR64", ENCODING_REG)
- ENCODING("GR64", ENCODING_REG)
- ENCODING("GR8", ENCODING_REG)
- ENCODING("VR128", ENCODING_REG)
- ENCODING("FR128", ENCODING_REG)
- ENCODING("FR64", ENCODING_REG)
- ENCODING("FR32", ENCODING_REG)
- ENCODING("VR64", ENCODING_REG)
- ENCODING("SEGMENT_REG", ENCODING_REG)
- ENCODING("DEBUG_REG", ENCODING_REG)
- ENCODING("CONTROL_REG", ENCODING_REG)
- ENCODING("VR256", ENCODING_REG)
- ENCODING("VR256X", ENCODING_REG)
- ENCODING("VR128X", ENCODING_REG)
- ENCODING("FR64X", ENCODING_REG)
- ENCODING("FR32X", ENCODING_REG)
- ENCODING("FR16X", ENCODING_REG)
- ENCODING("VR512", ENCODING_REG)
- ENCODING("VK1", ENCODING_REG)
- ENCODING("VK2", ENCODING_REG)
- ENCODING("VK4", ENCODING_REG)
- ENCODING("VK8", ENCODING_REG)
- ENCODING("VK16", ENCODING_REG)
- ENCODING("VK32", ENCODING_REG)
- ENCODING("VK64", ENCODING_REG)
- ENCODING("VK1Pair", ENCODING_REG)
- ENCODING("VK2Pair", ENCODING_REG)
- ENCODING("VK4Pair", ENCODING_REG)
- ENCODING("VK8Pair", ENCODING_REG)
- ENCODING("VK16Pair", ENCODING_REG)
- ENCODING("VK1WM", ENCODING_REG)
- ENCODING("VK2WM", ENCODING_REG)
- ENCODING("VK4WM", ENCODING_REG)
- ENCODING("VK8WM", ENCODING_REG)
- ENCODING("VK16WM", ENCODING_REG)
- ENCODING("VK32WM", ENCODING_REG)
- ENCODING("VK64WM", ENCODING_REG)
- ENCODING("BNDR", ENCODING_REG)
- ENCODING("TILE", ENCODING_REG)
- ENCODING("TILEPair", ENCODING_REG)
- errs() << "Unhandled reg/opcode register encoding " << s << "\n";
+RecognizableInstr::roRegisterEncodingFromString(StringRef Str, uint8_t OpSize) {
+ ENCODING(Str, "GR16", ENCODING_REG)
+ ENCODING(Str, "GR16orGR32orGR64", ENCODING_REG)
+ ENCODING(Str, "GR32", ENCODING_REG)
+ ENCODING(Str, "GR32orGR64", ENCODING_REG)
+ ENCODING(Str, "GR64", ENCODING_REG)
+ ENCODING(Str, "GR8", ENCODING_REG)
+ ENCODING(Str, "VR128", ENCODING_REG)
+ ENCODING(Str, "FR128", ENCODING_REG)
+ ENCODING(Str, "FR64", ENCODING_REG)
+ ENCODING(Str, "FR32", ENCODING_REG)
+ ENCODING(Str, "VR64", ENCODING_REG)
+ ENCODING(Str, "SEGMENT_REG", ENCODING_REG)
+ ENCODING(Str, "DEBUG_REG", ENCODING_REG)
+ ENCODING(Str, "CONTROL_REG", ENCODING_REG)
+ ENCODING(Str, "VR256", ENCODING_REG)
+ ENCODING(Str, "VR256X", ENCODING_REG)
+ ENCODING(Str, "VR128X", ENCODING_REG)
+ ENCODING(Str, "FR64X", ENCODING_REG)
+ ENCODING(Str, "FR32X", ENCODING_REG)
+ ENCODING(Str, "FR16X", ENCODING_REG)
+ ENCODING(Str, "VR512", ENCODING_REG)
+ ENCODING(Str, "VK1", ENCODING_REG)
+ ENCODING(Str, "VK2", ENCODING_REG)
+ ENCODING(Str, "VK4", ENCODING_REG)
+ ENCODING(Str, "VK8", ENCODING_REG)
+ ENCODING(Str, "VK16", ENCODING_REG)
+ ENCODING(Str, "VK32", ENCODING_REG)
+ ENCODING(Str, "VK64", ENCODING_REG)
+ ENCODING(Str, "VK1Pair", ENCODING_REG)
+ ENCODING(Str, "VK2Pair", ENCODING_REG)
+ ENCODING(Str, "VK4Pair", ENCODING_REG)
+ ENCODING(Str, "VK8Pair", ENCODING_REG)
+ ENCODING(Str, "VK16Pair", ENCODING_REG)
+ ENCODING(Str, "VK1WM", ENCODING_REG)
+ ENCODING(Str, "VK2WM", ENCODING_REG)
+ ENCODING(Str, "VK4WM", ENCODING_REG)
+ ENCODING(Str, "VK8WM", ENCODING_REG)
+ ENCODING(Str, "VK16WM", ENCODING_REG)
+ ENCODING(Str, "VK32WM", ENCODING_REG)
+ ENCODING(Str, "VK64WM", ENCODING_REG)
+ ENCODING(Str, "BNDR", ENCODING_REG)
+ ENCODING(Str, "TILE", ENCODING_REG)
+ ENCODING(Str, "TILEPair", ENCODING_REG)
+ errs() << "Unhandled reg/opcode register encoding " << Str << "\n";
llvm_unreachable("Unhandled reg/opcode register encoding");
}
OperandEncoding
-RecognizableInstr::vvvvRegisterEncodingFromString(const std::string &s,
+RecognizableInstr::vvvvRegisterEncodingFromString(StringRef Str,
uint8_t OpSize) {
- ENCODING("GR8", ENCODING_VVVV)
- ENCODING("GR16", ENCODING_VVVV)
- ENCODING("GR32", ENCODING_VVVV)
- ENCODING("GR64", ENCODING_VVVV)
- ENCODING("FR32", ENCODING_VVVV)
- ENCODING("FR128", ENCODING_VVVV)
- ENCODING("FR64", ENCODING_VVVV)
- ENCODING("VR128", ENCODING_VVVV)
- ENCODING("VR256", ENCODING_VVVV)
- ENCODING("FR16X", ENCODING_VVVV)
- ENCODING("FR32X", ENCODING_VVVV)
- ENCODING("FR64X", ENCODING_VVVV)
- ENCODING("VR128X", ENCODING_VVVV)
- ENCODING("VR256X", ENCODING_VVVV)
- ENCODING("VR512", ENCODING_VVVV)
- ENCODING("VK1", ENCODING_VVVV)
- ENCODING("VK2", ENCODING_VVVV)
- ENCODING("VK4", ENCODING_VVVV)
- ENCODING("VK8", ENCODING_VVVV)
- ENCODING("VK16", ENCODING_VVVV)
- ENCODING("VK32", ENCODING_VVVV)
- ENCODING("VK64", ENCODING_VVVV)
- ENCODING("TILE", ENCODING_VVVV)
- ENCODING("TILEPair", ENCODING_VVVV)
- errs() << "Unhandled VEX.vvvv register encoding " << s << "\n";
+ ENCODING(Str, "GR8", ENCODING_VVVV)
+ ENCODING(Str, "GR16", ENCODING_VVVV)
+ ENCODING(Str, "GR32", ENCODING_VVVV)
+ ENCODING(Str, "GR64", ENCODING_VVVV)
+ ENCODING(Str, "FR32", ENCODING_VVVV)
+ ENCODING(Str, "FR128", ENCODING_VVVV)
+ ENCODING(Str, "FR64", ENCODING_VVVV)
+ ENCODING(Str, "VR128", ENCODING_VVVV)
+ ENCODING(Str, "VR256", ENCODING_VVVV)
+ ENCODING(Str, "FR16X", ENCODING_VVVV)
+ ENCODING(Str, "FR32X", ENCODING_VVVV)
+ ENCODING(Str, "FR64X", ENCODING_VVVV)
+ ENCODING(Str, "VR128X", ENCODING_VVVV)
+ ENCODING(Str, "VR256X", ENCODING_VVVV)
+ ENCODING(Str, "VR512", ENCODING_VVVV)
+ ENCODING(Str, "VK1", ENCODING_VVVV)
+ ENCODING(Str, "VK2", ENCODING_VVVV)
+ ENCODING(Str, "VK4", ENCODING_VVVV)
+ ENCODING(Str, "VK8", ENCODING_VVVV)
+ ENCODING(Str, "VK16", ENCODING_VVVV)
+ ENCODING(Str, "VK32", ENCODING_VVVV)
+ ENCODING(Str, "VK64", ENCODING_VVVV)
+ ENCODING(Str, "TILE", ENCODING_VVVV)
+ ENCODING(Str, "TILEPair", ENCODING_VVVV)
+ errs() << "Unhandled VEX.vvvv register encoding " << Str << "\n";
llvm_unreachable("Unhandled VEX.vvvv register encoding");
}
OperandEncoding
-RecognizableInstr::writemaskRegisterEncodingFromString(const std::string &s,
+RecognizableInstr::writemaskRegisterEncodingFromString(StringRef Str,
uint8_t OpSize) {
- ENCODING("VK1WM", ENCODING_WRITEMASK)
- ENCODING("VK2WM", ENCODING_WRITEMASK)
- ENCODING("VK4WM", ENCODING_WRITEMASK)
- ENCODING("VK8WM", ENCODING_WRITEMASK)
- ENCODING("VK16WM", ENCODING_WRITEMASK)
- ENCODING("VK32WM", ENCODING_WRITEMASK)
- ENCODING("VK64WM", ENCODING_WRITEMASK)
- errs() << "Unhandled mask register encoding " << s << "\n";
+ ENCODING(Str, "VK1WM", ENCODING_WRITEMASK)
+ ENCODING(Str, "VK2WM", ENCODING_WRITEMASK)
+ ENCODING(Str, "VK4WM", ENCODING_WRITEMASK)
+ ENCODING(Str, "VK8WM", ENCODING_WRITEMASK)
+ ENCODING(Str, "VK16WM", ENCODING_WRITEMASK)
+ ENCODING(Str, "VK32WM", ENCODING_WRITEMASK)
+ ENCODING(Str, "VK64WM", ENCODING_WRITEMASK)
+ errs() << "Unhandled mask register encoding " << Str << "\n";
llvm_unreachable("Unhandled mask register encoding");
}
-OperandEncoding
-RecognizableInstr::memoryEncodingFromString(const std::string &s,
- uint8_t OpSize) {
- ENCODING("i16mem", ENCODING_RM)
- ENCODING("i32mem", ENCODING_RM)
- ENCODING("i64mem", ENCODING_RM)
- ENCODING("i8mem", ENCODING_RM)
- ENCODING("shmem", ENCODING_RM)
- ENCODING("ssmem", ENCODING_RM)
- ENCODING("sdmem", ENCODING_RM)
- ENCODING("f128mem", ENCODING_RM)
- ENCODING("f256mem", ENCODING_RM)
- ENCODING("f512mem", ENCODING_RM)
- ENCODING("f64mem", ENCODING_RM)
- ENCODING("f32mem", ENCODING_RM)
- ENCODING("f16mem", ENCODING_RM)
- ENCODING("i128mem", ENCODING_RM)
- ENCODING("i256mem", ENCODING_RM)
- ENCODING("i512mem", ENCODING_RM)
- ENCODING("i512mem_GR16", ENCODING_RM)
- ENCODING("i512mem_GR32", ENCODING_RM)
- ENCODING("i512mem_GR64", ENCODING_RM)
- ENCODING("f80mem", ENCODING_RM)
- ENCODING("lea64_8mem", ENCODING_RM)
- ENCODING("lea64_16mem", ENCODING_RM)
- ENCODING("lea64_32mem", ENCODING_RM)
- ENCODING("lea64mem", ENCODING_RM)
- ENCODING("anymem", ENCODING_RM)
- ENCODING("opaquemem", ENCODING_RM)
- ENCODING("sibmem", ENCODING_SIB)
- ENCODING("vx32mem", ENCODING_VSIB)
- ENCODING("vx64mem", ENCODING_VSIB)
- ENCODING("vy32mem", ENCODING_VSIB)
- ENCODING("vy64mem", ENCODING_VSIB)
- ENCODING("vx32xmem", ENCODING_VSIB)
- ENCODING("vx64xmem", ENCODING_VSIB)
- ENCODING("vy32xmem", ENCODING_VSIB)
- ENCODING("vy64xmem", ENCODING_VSIB)
- ENCODING("vz32mem", ENCODING_VSIB)
- ENCODING("vz64mem", ENCODING_VSIB)
- errs() << "Unhandled memory encoding " << s << "\n";
+OperandEncoding RecognizableInstr::memoryEncodingFromString(StringRef Str,
+ uint8_t OpSize) {
+ ENCODING(Str, "i16mem", ENCODING_RM)
+ ENCODING(Str, "i32mem", ENCODING_RM)
+ ENCODING(Str, "i64mem", ENCODING_RM)
+ ENCODING(Str, "i8mem", ENCODING_RM)
+ ENCODING(Str, "shmem", ENCODING_RM)
+ ENCODING(Str, "ssmem", ENCODING_RM)
+ ENCODING(Str, "sdmem", ENCODING_RM)
+ ENCODING(Str, "f128mem", ENCODING_RM)
+ ENCODING(Str, "f256mem", ENCODING_RM)
+ ENCODING(Str, "f512mem", ENCODING_RM)
+ ENCODING(Str, "f64mem", ENCODING_RM)
+ ENCODING(Str, "f32mem", ENCODING_RM)
+ ENCODING(Str, "f16mem", ENCODING_RM)
+ ENCODING(Str, "i128mem", ENCODING_RM)
+ ENCODING(Str, "i256mem", ENCODING_RM)
+ ENCODING(Str, "i512mem", ENCODING_RM)
+ ENCODING(Str, "i512mem_GR16", ENCODING_RM)
+ ENCODING(Str, "i512mem_GR32", ENCODING_RM)
+ ENCODING(Str, "i512mem_GR64", ENCODING_RM)
+ ENCODING(Str, "f80mem", ENCODING_RM)
+ ENCODING(Str, "lea64_8mem", ENCODING_RM)
+ ENCODING(Str, "lea64_16mem", ENCODING_RM)
+ ENCODING(Str, "lea64_32mem", ENCODING_RM)
+ ENCODING(Str, "lea64mem", ENCODING_RM)
+ ENCODING(Str, "anymem", ENCODING_RM)
+ ENCODING(Str, "opaquemem", ENCODING_RM)
+ ENCODING(Str, "sibmem", ENCODING_SIB)
+ ENCODING(Str, "vx32mem", ENCODING_VSIB)
+ ENCODING(Str, "vx64mem", ENCODING_VSIB)
+ ENCODING(Str, "vy32mem", ENCODING_VSIB)
+ ENCODING(Str, "vy64mem", ENCODING_VSIB)
+ ENCODING(Str, "vx32xmem", ENCODING_VSIB)
+ ENCODING(Str, "vx64xmem", ENCODING_VSIB)
+ ENCODING(Str, "vy32xmem", ENCODING_VSIB)
+ ENCODING(Str, "vy64xmem", ENCODING_VSIB)
+ ENCODING(Str, "vz32mem", ENCODING_VSIB)
+ ENCODING(Str, "vz64mem", ENCODING_VSIB)
+ errs() << "Unhandled memory encoding " << Str << "\n";
llvm_unreachable("Unhandled memory encoding");
}
OperandEncoding
-RecognizableInstr::relocationEncodingFromString(const std::string &s,
- uint8_t OpSize) {
+RecognizableInstr::relocationEncodingFromString(StringRef Str, uint8_t OpSize) {
if (OpSize != X86Local::OpSize16) {
// For instructions without an OpSize prefix, a declared 16-bit register or
// immediate encoding is special.
- ENCODING("i16imm", ENCODING_IW)
+ ENCODING(Str, "i16imm", ENCODING_IW)
}
- ENCODING("i16imm", ENCODING_Iv)
- ENCODING("i16i8imm", ENCODING_IB)
- ENCODING("i32imm", ENCODING_Iv)
- ENCODING("i32i8imm", ENCODING_IB)
- ENCODING("i64i32imm", ENCODING_ID)
- ENCODING("i64i8imm", ENCODING_IB)
- ENCODING("i8imm", ENCODING_IB)
- ENCODING("u8imm", ENCODING_IB)
- ENCODING("i16u8imm", ENCODING_IB)
- ENCODING("i32u8imm", ENCODING_IB)
- ENCODING("i64u8imm", ENCODING_IB)
- ENCODING("i64i32imm_brtarget", ENCODING_ID)
- ENCODING("i16imm_brtarget", ENCODING_IW)
- ENCODING("i32imm_brtarget", ENCODING_ID)
- ENCODING("i8imm_brtarget", ENCODING_IB)
- ENCODING("brtarget32", ENCODING_ID)
- ENCODING("brtarget16", ENCODING_IW)
- ENCODING("brtarget8", ENCODING_IB)
- ENCODING("i64imm", ENCODING_IO)
- ENCODING("offset16_8", ENCODING_Ia)
- ENCODING("offset16_16", ENCODING_Ia)
- ENCODING("offset16_32", ENCODING_Ia)
- ENCODING("offset32_8", ENCODING_Ia)
- ENCODING("offset32_16", ENCODING_Ia)
- ENCODING("offset32_32", ENCODING_Ia)
- ENCODING("offset32_64", ENCODING_Ia)
- ENCODING("offset64_8", ENCODING_Ia)
- ENCODING("offset64_16", ENCODING_Ia)
- ENCODING("offset64_32", ENCODING_Ia)
- ENCODING("offset64_64", ENCODING_Ia)
- ENCODING("srcidx8", ENCODING_SI)
- ENCODING("srcidx16", ENCODING_SI)
- ENCODING("srcidx32", ENCODING_SI)
- ENCODING("srcidx64", ENCODING_SI)
- ENCODING("dstidx8", ENCODING_DI)
- ENCODING("dstidx16", ENCODING_DI)
- ENCODING("dstidx32", ENCODING_DI)
- ENCODING("dstidx64", ENCODING_DI)
- errs() << "Unhandled relocation encoding " << s << "\n";
+ ENCODING(Str, "i16imm", ENCODING_Iv)
+ ENCODING(Str, "i16i8imm", ENCODING_IB)
+ ENCODING(Str, "i32imm", ENCODING_Iv)
+ ENCODING(Str, "i32i8imm", ENCODING_IB)
+ ENCODING(Str, "i64i32imm", ENCODING_ID)
+ ENCODING(Str, "i64i8imm", ENCODING_IB)
+ ENCODING(Str, "i8imm", ENCODING_IB)
+ ENCODING(Str, "u8imm", ENCODING_IB)
+ ENCODING(Str, "i16u8imm", ENCODING_IB)
+ ENCODING(Str, "i32u8imm", ENCODING_IB)
+ ENCODING(Str, "i64u8imm", ENCODING_IB)
+ ENCODING(Str, "i64i32imm_brtarget", ENCODING_ID)
+ ENCODING(Str, "i16imm_brtarget", ENCODING_IW)
+ ENCODING(Str, "i32imm_brtarget", ENCODING_ID)
+ ENCODING(Str, "i8imm_brtarget", ENCODING_IB)
+ ENCODING(Str, "brtarget32", ENCODING_ID)
+ ENCODING(Str, "brtarget16", ENCODING_IW)
+ ENCODING(Str, "brtarget8", ENCODING_IB)
+ ENCODING(Str, "i64imm", ENCODING_IO)
+ ENCODING(Str, "offset16_8", ENCODING_Ia)
+ ENCODING(Str, "offset16_16", ENCODING_Ia)
+ ENCODING(Str, "offset16_32", ENCODING_Ia)
+ ENCODING(Str, "offset32_8", ENCODING_Ia)
+ ENCODING(Str, "offset32_16", ENCODING_Ia)
+ ENCODING(Str, "offset32_32", ENCODING_Ia)
+ ENCODING(Str, "offset32_64", ENCODING_Ia)
+ ENCODING(Str, "offset64_8", ENCODING_Ia)
+ ENCODING(Str, "offset64_16", ENCODING_Ia)
+ ENCODING(Str, "offset64_32", ENCODING_Ia)
+ ENCODING(Str, "offset64_64", ENCODING_Ia)
+ ENCODING(Str, "srcidx8", ENCODING_SI)
+ ENCODING(Str, "srcidx16", ENCODING_SI)
+ ENCODING(Str, "srcidx32", ENCODING_SI)
+ ENCODING(Str, "srcidx64", ENCODING_SI)
+ ENCODING(Str, "dstidx8", ENCODING_DI)
+ ENCODING(Str, "dstidx16", ENCODING_DI)
+ ENCODING(Str, "dstidx32", ENCODING_DI)
+ ENCODING(Str, "dstidx64", ENCODING_DI)
+ errs() << "Unhandled relocation encoding " << Str << "\n";
llvm_unreachable("Unhandled relocation encoding");
}
OperandEncoding
-RecognizableInstr::opcodeModifierEncodingFromString(const std::string &s,
+RecognizableInstr::opcodeModifierEncodingFromString(StringRef Str,
uint8_t OpSize) {
- ENCODING("GR32", ENCODING_Rv)
- ENCODING("GR64", ENCODING_RO)
- ENCODING("GR16", ENCODING_Rv)
- ENCODING("GR8", ENCODING_RB)
- ENCODING("ccode", ENCODING_CC)
- errs() << "Unhandled opcode modifier encoding " << s << "\n";
+ ENCODING(Str, "GR32", ENCODING_Rv)
+ ENCODING(Str, "GR64", ENCODING_RO)
+ ENCODING(Str, "GR16", ENCODING_Rv)
+ ENCODING(Str, "GR8", ENCODING_RB)
+ ENCODING(Str, "ccode", ENCODING_CC)
+ errs() << "Unhandled opcode modifier encoding " << Str << "\n";
llvm_unreachable("Unhandled opcode modifier encoding");
}
#undef ENCODING
diff --git a/llvm/utils/TableGen/X86RecognizableInstr.h b/llvm/utils/TableGen/X86RecognizableInstr.h
index eb2cee7bbbf87..2f60b99154796 100644
--- a/llvm/utils/TableGen/X86RecognizableInstr.h
+++ b/llvm/utils/TableGen/X86RecognizableInstr.h
@@ -281,7 +281,7 @@ class RecognizableInstr : public RecognizableInstrBase {
/// If register size does not match OpSize, then
/// register sizes keep their size.
/// @return - The operand's type.
- static OperandType typeFromString(const std::string &s, bool hasREX_W,
+ static OperandType typeFromString(StringRef Str, bool hasREX_W,
uint8_t OpSize);
/// immediateEncodingFromString - Translates an immediate encoding from the
@@ -292,28 +292,28 @@ class RecognizableInstr : public RecognizableInstrBase {
/// @param OpSize - Indicates whether this is an OpSize16 instruction.
/// If it is not, then 16-bit immediate operands stay 16-bit.
/// @return - The operand's encoding.
- static OperandEncoding immediateEncodingFromString(const std::string &s,
+ static OperandEncoding immediateEncodingFromString(StringRef Str,
uint8_t OpSize);
/// rmRegisterEncodingFromString - Like immediateEncodingFromString, but
/// handles operands that are in the REG field of the ModR/M byte.
- static OperandEncoding rmRegisterEncodingFromString(const std::string &s,
+ static OperandEncoding rmRegisterEncodingFromString(StringRef Str,
uint8_t OpSize);
/// rmRegisterEncodingFromString - Like immediateEncodingFromString, but
/// handles operands that are in the REG field of the ModR/M byte.
- static OperandEncoding roRegisterEncodingFromString(const std::string &s,
+ static OperandEncoding roRegisterEncodingFromString(StringRef Str,
uint8_t OpSize);
- static OperandEncoding memoryEncodingFromString(const std::string &s,
+ static OperandEncoding memoryEncodingFromString(StringRef Str,
uint8_t OpSize);
- static OperandEncoding relocationEncodingFromString(const std::string &s,
+ static OperandEncoding relocationEncodingFromString(StringRef Str,
uint8_t OpSize);
- static OperandEncoding opcodeModifierEncodingFromString(const std::string &s,
+ static OperandEncoding opcodeModifierEncodingFromString(StringRef Str,
uint8_t OpSize);
- static OperandEncoding vvvvRegisterEncodingFromString(const std::string &s,
+ static OperandEncoding vvvvRegisterEncodingFromString(StringRef Str,
uint8_t OpSize);
- static OperandEncoding
- writemaskRegisterEncodingFromString(const std::string &s, uint8_t OpSize);
+ static OperandEncoding writemaskRegisterEncodingFromString(StringRef Str,
+ uint8_t OpSize);
/// Adjust the encoding type for an operand based on the instruction.
void adjustOperandEncoding(OperandEncoding &encoding);
@@ -336,12 +336,13 @@ class RecognizableInstr : public RecognizableInstrBase {
/// @param operandMapping - The operand mapping, which has an entry for
/// each operand that indicates whether it is a
/// duplicate, and of what.
+ using EncodingFn =
+ llvm::function_ref<OperandEncoding(StringRef s, uint8_t OpSize)>;
void handleOperand(bool optional, unsigned &operandIndex,
unsigned &physicalOperandIndex,
unsigned numPhysicalOperands,
const unsigned *operandMapping,
- OperandEncoding (*encodingFromString)(const std::string &,
- uint8_t OpSize));
+ EncodingFn encodingFromString);
/// emitInstructionSpecifier - Loads the instruction specifier for the current
/// instruction into a DisassemblerTables.
More information about the llvm-commits
mailing list