diff --git a/llvm/lib/Target/BPF/Disassembler/BPFDisassembler.cpp b/llvm/lib/Target/BPF/Disassembler/BPFDisassembler.cpp index 230cf3b0ddbe4..813dddad7d75f 100644 --- a/llvm/lib/Target/BPF/Disassembler/BPFDisassembler.cpp +++ b/llvm/lib/Target/BPF/Disassembler/BPFDisassembler.cpp @@ -26,6 +26,7 @@ #include using namespace llvm; +using namespace llvm::MCD; #define DEBUG_TYPE "bpf-disassembler" diff --git a/llvm/lib/Target/CSKY/Disassembler/CSKYDisassembler.cpp b/llvm/lib/Target/CSKY/Disassembler/CSKYDisassembler.cpp index 887e281279535..39e651d52e4d3 100644 --- a/llvm/lib/Target/CSKY/Disassembler/CSKYDisassembler.cpp +++ b/llvm/lib/Target/CSKY/Disassembler/CSKYDisassembler.cpp @@ -26,6 +26,7 @@ #include "llvm/Support/Endian.h" using namespace llvm; +using namespace llvm::MCD; #define DEBUG_TYPE "csky-disassembler" diff --git a/llvm/lib/Target/Hexagon/Disassembler/HexagonDisassembler.cpp b/llvm/lib/Target/Hexagon/Disassembler/HexagonDisassembler.cpp index 0639878c1256f..974f6533411e0 100644 --- a/llvm/lib/Target/Hexagon/Disassembler/HexagonDisassembler.cpp +++ b/llvm/lib/Target/Hexagon/Disassembler/HexagonDisassembler.cpp @@ -34,6 +34,7 @@ #define DEBUG_TYPE "hexagon-disassembler" using namespace llvm; +using namespace llvm::MCD; using namespace Hexagon; using DecodeStatus = MCDisassembler::DecodeStatus; diff --git a/llvm/lib/Target/Lanai/Disassembler/LanaiDisassembler.cpp b/llvm/lib/Target/Lanai/Disassembler/LanaiDisassembler.cpp index 9cd0636306b16..96feaf28d0a0f 100644 --- a/llvm/lib/Target/Lanai/Disassembler/LanaiDisassembler.cpp +++ b/llvm/lib/Target/Lanai/Disassembler/LanaiDisassembler.cpp @@ -28,6 +28,7 @@ #define DEBUG_TYPE "lanai-disassembler" using namespace llvm; +using namespace llvm::MCD; typedef MCDisassembler::DecodeStatus DecodeStatus; diff --git a/llvm/lib/Target/LoongArch/Disassembler/LoongArchDisassembler.cpp b/llvm/lib/Target/LoongArch/Disassembler/LoongArchDisassembler.cpp index 735f798afde24..d4058fac4304a 100644 --- a/llvm/lib/Target/LoongArch/Disassembler/LoongArchDisassembler.cpp +++ b/llvm/lib/Target/LoongArch/Disassembler/LoongArchDisassembler.cpp @@ -24,6 +24,7 @@ #include "llvm/Support/Endian.h" using namespace llvm; +using namespace llvm::MCD; #define DEBUG_TYPE "loongarch-disassembler" diff --git a/llvm/lib/Target/PowerPC/Disassembler/PPCDisassembler.cpp b/llvm/lib/Target/PowerPC/Disassembler/PPCDisassembler.cpp index 5e27f06c94f06..47586c417cfe3 100644 --- a/llvm/lib/Target/PowerPC/Disassembler/PPCDisassembler.cpp +++ b/llvm/lib/Target/PowerPC/Disassembler/PPCDisassembler.cpp @@ -18,6 +18,7 @@ #include "llvm/Support/Endian.h" using namespace llvm; +using namespace llvm::MCD; DEFINE_PPC_REGCLASSES diff --git a/llvm/lib/Target/SystemZ/Disassembler/SystemZDisassembler.cpp b/llvm/lib/Target/SystemZ/Disassembler/SystemZDisassembler.cpp index 0b91aba67694f..a724c5a7f97c8 100644 --- a/llvm/lib/Target/SystemZ/Disassembler/SystemZDisassembler.cpp +++ b/llvm/lib/Target/SystemZ/Disassembler/SystemZDisassembler.cpp @@ -20,6 +20,7 @@ #include using namespace llvm; +using namespace llvm::MCD; #define DEBUG_TYPE "systemz-disassembler" diff --git a/llvm/lib/Target/Xtensa/Disassembler/XtensaDisassembler.cpp b/llvm/lib/Target/Xtensa/Disassembler/XtensaDisassembler.cpp index 396b00f7b8628..7d22a0489a951 100644 --- a/llvm/lib/Target/Xtensa/Disassembler/XtensaDisassembler.cpp +++ b/llvm/lib/Target/Xtensa/Disassembler/XtensaDisassembler.cpp @@ -25,6 +25,7 @@ #include "llvm/Support/Endian.h" using namespace llvm; +using namespace llvm::MCD; #define DEBUG_TYPE "Xtensa-disassembler" diff --git a/llvm/test/TableGen/FixedLenDecoderEmitter/additional-encoding.td b/llvm/test/TableGen/FixedLenDecoderEmitter/additional-encoding.td index 47c9335f6cdf2..0d4d3c096f83d 100644 --- a/llvm/test/TableGen/FixedLenDecoderEmitter/additional-encoding.td +++ b/llvm/test/TableGen/FixedLenDecoderEmitter/additional-encoding.td @@ -30,27 +30,27 @@ class I : Instruction { let OutOperandList = out_ops; } -// CHECK: /* 0 */ MCD::OPC_ExtractField, 12, 4, // Inst{15-12} ... -// CHECK-NEXT: /* 3 */ MCD::OPC_FilterValueOrSkip, 0, 15, 0, // Skip to: 22 -// CHECK-NEXT: /* 7 */ MCD::OPC_Scope, 8, 0, // Skip to: 18 -// CHECK-NEXT: /* 10 */ MCD::OPC_CheckField, 6, 6, 0, -// CHECK-NEXT: /* 14 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: {{.*}}:NOP, DecodeIdx: 0 -// CHECK-NEXT: /* 18 */ MCD::OPC_TryDecode, {{[0-9]+}}, 2, 1, -// CHECK-NEXT: /* 22 */ MCD::OPC_FilterValueOrSkip, 1, 15, 0, // Skip to: 41 -// CHECK-NEXT: /* 26 */ MCD::OPC_Scope, 8, 0, // Skip to: 37 -// CHECK-NEXT: /* 29 */ MCD::OPC_CheckField, 6, 6, 0, -// CHECK-NEXT: /* 33 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: {{.*}}:NOP, DecodeIdx: 0 -// CHECK-NEXT: /* 37 */ MCD::OPC_TryDecode, {{[0-9]+}}, 2, 1, -// CHECK-NEXT: /* 41 */ MCD::OPC_FilterValueOrSkip, 2, 15, 0, // Skip to: 60 -// CHECK-NEXT: /* 45 */ MCD::OPC_Scope, 8, 0, // Skip to: 56 -// CHECK-NEXT: /* 48 */ MCD::OPC_CheckField, 6, 6, 0, -// CHECK-NEXT: /* 52 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: {{.*}}:NOP, DecodeIdx: 0 -// CHECK-NEXT: /* 56 */ MCD::OPC_TryDecode, {{[0-9]+}}, 2, 1, -// CHECK-NEXT: /* 60 */ MCD::OPC_FilterValue, 3, -// CHECK-NEXT: /* 62 */ MCD::OPC_Scope, 8, 0, // Skip to: 73 -// CHECK-NEXT: /* 65 */ MCD::OPC_CheckField, 6, 6, 0, -// CHECK-NEXT: /* 69 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: {{.*}}:NOP, DecodeIdx: 0 -// CHECK-NEXT: /* 73 */ MCD::OPC_TryDecode, {{[0-9]+}}, 2, 1, +// CHECK: /* 0 */ OPC_ExtractField, 12, 4, // Field = Inst{15-12} +// CHECK-NEXT: /* 3 */ OPC_FilterValueOrSkip, 0, 15, 0, // if Field != 0x0 skip to 22 +// CHECK-NEXT: /* 7 */ OPC_Scope, 8, 0, // end scope at 18 +// CHECK-NEXT: /* 10 */ OPC_CheckField, 6, 6, 0, // if Inst{11-6} != 0x0 +// CHECK-NEXT: /* 14 */ OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: {{.*}}:NOP, DecodeIdx: 0 +// CHECK-NEXT: /* 18 */ OPC_TryDecode, {{[0-9]+}}, 2, 1, // Opcode: SHIFT0, DecodeIdx: 1 +// CHECK-NEXT: /* 22 */ OPC_FilterValueOrSkip, 1, 15, 0, // if Field != 0x1 skip to 41 +// CHECK-NEXT: /* 26 */ OPC_Scope, 8, 0, // end scope at 37 +// CHECK-NEXT: /* 29 */ OPC_CheckField, 6, 6, 0, // if Inst{11-6} != 0x0 +// CHECK-NEXT: /* 33 */ OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: {{.*}}:NOP, DecodeIdx: 0 +// CHECK-NEXT: /* 37 */ OPC_TryDecode, {{[0-9]+}}, 2, 1, // Opcode: SHIFT1, DecodeIdx: 1 +// CHECK-NEXT: /* 41 */ OPC_FilterValueOrSkip, 2, 15, 0, // if Field != 0x2 skip to 60 +// CHECK-NEXT: /* 45 */ OPC_Scope, 8, 0, // end scope at 56 +// CHECK-NEXT: /* 48 */ OPC_CheckField, 6, 6, 0, // if Inst{11-6} != 0x0 +// CHECK-NEXT: /* 52 */ OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: {{.*}}:NOP, DecodeIdx: 0 +// CHECK-NEXT: /* 56 */ OPC_TryDecode, {{[0-9]+}}, 2, 1, // Opcode: SHIFT2, DecodeIdx: 1 +// CHECK-NEXT: /* 60 */ OPC_FilterValue, 3, // if Field != 0x3 +// CHECK-NEXT: /* 62 */ OPC_Scope, 8, 0, // end scope at 73 +// CHECK-NEXT: /* 65 */ OPC_CheckField, 6, 6, 0, // if Inst{11-6} != 0x0 +// CHECK-NEXT: /* 69 */ OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: {{.*}}:NOP, DecodeIdx: 0 +// CHECK-NEXT: /* 73 */ OPC_TryDecode, {{[0-9]+}}, 2, 1, // Opcode: SHIFT3, DecodeIdx: 1 class SHIFT opc> : I<(outs), (ins ShAmtOp:$shamt)>, EncSHIFT; diff --git a/llvm/test/TableGen/FixedLenDecoderEmitter/big-filter.td b/llvm/test/TableGen/FixedLenDecoderEmitter/big-filter.td index 28762bfa1ec24..87aa7f814c3f3 100644 --- a/llvm/test/TableGen/FixedLenDecoderEmitter/big-filter.td +++ b/llvm/test/TableGen/FixedLenDecoderEmitter/big-filter.td @@ -12,13 +12,13 @@ class I : Instruction { // Check that a 64-bit filter with all bits set does not confuse DecoderEmitter. // // CHECK-LABEL: static const uint8_t DecoderTable128[34] = { -// CHECK-NEXT: /* 0 */ MCD::OPC_ExtractField, 0, 64, // Inst{63-0} ... -// CHECK-NEXT: /* 3 */ MCD::OPC_FilterValueOrSkip, 1, 8, 0, // Skip to: 15 -// CHECK-NEXT: /* 7 */ MCD::OPC_CheckField, 127, 1, 1, -// CHECK-NEXT: /* 11 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: I2, DecodeIdx: 0 -// CHECK-NEXT: /* 15 */ MCD::OPC_FilterValue, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, -// CHECK-NEXT: /* 26 */ MCD::OPC_CheckField, 127, 1, 0, -// CHECK-NEXT: /* 30 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: I1, DecodeIdx: 0 +// CHECK-NEXT: /* 0 */ OPC_ExtractField, 0, 64, // Field = Inst{63-0} +// CHECK-NEXT: /* 3 */ OPC_FilterValueOrSkip, 1, 8, 0, // if Field != 0x1 skip to 15 +// CHECK-NEXT: /* 7 */ OPC_CheckField, 127, 1, 1, // if Inst{127} != 0x1 +// CHECK-NEXT: /* 11 */ OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: I2, DecodeIdx: 0 +// CHECK-NEXT: /* 15 */ OPC_FilterValue, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, // if Field != 0xffffffffffffffff +// CHECK-NEXT: /* 26 */ OPC_CheckField, 127, 1, 0, // if Inst{127} != 0x0 +// CHECK-NEXT: /* 30 */ OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: I1, DecodeIdx: 0 // CHECK-NEXT: }; def I1 : I { diff --git a/llvm/test/TableGen/FixedLenDecoderEmitter/var-len-conflict-1.td b/llvm/test/TableGen/FixedLenDecoderEmitter/var-len-conflict-1.td index 8afcf786f9c73..b18d28a9f5136 100644 --- a/llvm/test/TableGen/FixedLenDecoderEmitter/var-len-conflict-1.td +++ b/llvm/test/TableGen/FixedLenDecoderEmitter/var-len-conflict-1.td @@ -18,19 +18,19 @@ class I : Instruction { // 00000001 ________ I16_1 // 00000010 ________ I16_2 -// CHECK: /* 0 */ MCD::OPC_Scope, 17, 0, // Skip to: 20 -// CHECK-NEXT: /* 3 */ MCD::OPC_ExtractField, 0, 1, // Inst{0} ... -// CHECK-NEXT: /* 6 */ MCD::OPC_FilterValueOrSkip, 0, 4, 0, // Skip to: 14 -// CHECK-NEXT: /* 10 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: I8_0, DecodeIdx: 0 -// CHECK-NEXT: /* 14 */ MCD::OPC_FilterValue, 1, -// CHECK-NEXT: /* 16 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: I8_1, DecodeIdx: 0 -// CHECK-NEXT: /* 20 */ MCD::OPC_ExtractField, 8, 8, // Inst{15-8} ... -// CHECK-NEXT: /* 23 */ MCD::OPC_FilterValueOrSkip, 0, 4, 0, // Skip to: 31 -// CHECK-NEXT: /* 27 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 1, // Opcode: I16_0, DecodeIdx: 1 -// CHECK-NEXT: /* 31 */ MCD::OPC_FilterValueOrSkip, 1, 4, 0, // Skip to: 39 -// CHECK-NEXT: /* 35 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 1, // Opcode: I16_1, DecodeIdx: 1 -// CHECK-NEXT: /* 39 */ MCD::OPC_FilterValue, 2, -// CHECK-NEXT: /* 41 */ MCD::OPC_Decode, {{[0-9]+}}, 2, 1, // Opcode: I16_2, DecodeIdx: 1 +// CHECK: /* 0 */ OPC_Scope, 17, 0, // end scope at 20 +// CHECK-NEXT: /* 3 */ OPC_ExtractField, 0, 1, // Field = Inst{0} +// CHECK-NEXT: /* 6 */ OPC_FilterValueOrSkip, 0, 4, 0, // if Field != 0x0 skip to 14 +// CHECK-NEXT: /* 10 */ OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: I8_0, DecodeIdx: 0 +// CHECK-NEXT: /* 14 */ OPC_FilterValue, 1, // if Field != 0x1 +// CHECK-NEXT: /* 16 */ OPC_Decode, {{[0-9]+}}, 2, 0, // Opcode: I8_1, DecodeIdx: 0 +// CHECK-NEXT: /* 20 */ OPC_ExtractField, 8, 8, // Field = Inst{15-8} +// CHECK-NEXT: /* 23 */ OPC_FilterValueOrSkip, 0, 4, 0, // if Field != 0x0 skip to 31 +// CHECK-NEXT: /* 27 */ OPC_Decode, {{[0-9]+}}, 2, 1, // Opcode: I16_0, DecodeIdx: 1 +// CHECK-NEXT: /* 31 */ OPC_FilterValueOrSkip, 1, 4, 0, // if Field != 0x1 skip to 39 +// CHECK-NEXT: /* 35 */ OPC_Decode, {{[0-9]+}}, 2, 1, // Opcode: I16_1, DecodeIdx: 1 +// CHECK-NEXT: /* 39 */ OPC_FilterValue, 2, // if Field != 0x2 +// CHECK-NEXT: /* 41 */ OPC_Decode, {{[0-9]+}}, 2, 1, // Opcode: I16_2, DecodeIdx: 1 def I8_0 : I { dag Inst = (descend (operand "$op", 7), 0b0); } def I8_1 : I { dag Inst = (descend (operand "$op", 7), 0b1); } diff --git a/llvm/test/TableGen/VarLenDecoder.td b/llvm/test/TableGen/VarLenDecoder.td index 7eda1e6e47431..c02433ffba3cd 100644 --- a/llvm/test/TableGen/VarLenDecoder.td +++ b/llvm/test/TableGen/VarLenDecoder.td @@ -53,18 +53,18 @@ def FOO32 : MyVarInst { // CHECK-NEXT: 43, // CHECK-NEXT: }; -// CHECK-SMALL: /* 0 */ MCD::OPC_ExtractField, 3, 5, // Inst{7-3} ... -// CHECK-SMALL-NEXT: /* 3 */ MCD::OPC_FilterValueOrSkip, 8, 4, 0, // Skip to: 11 -// CHECK-SMALL-NEXT: /* 7 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 0, // Opcode: FOO16 -// CHECK-SMALL-NEXT: /* 11 */ MCD::OPC_FilterValue, 9, -// CHECK-SMALL-NEXT: /* 13 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: FOO32 +// CHECK-SMALL: /* 0 */ OPC_ExtractField, 3, 5, // Field = Inst{7-3} +// CHECK-SMALL-NEXT: /* 3 */ OPC_FilterValueOrSkip, 8, 4, 0, // if Field != 0x8 skip to 11 +// CHECK-SMALL-NEXT: /* 7 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 0, // Opcode: FOO16 +// CHECK-SMALL-NEXT: /* 11 */ OPC_FilterValue, 9, // if Field != 0x9 pop scope +// CHECK-SMALL-NEXT: /* 13 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: FOO32 // CHECK-SMALL-NEXT: }; -// CHECK-LARGE: /* 0 */ MCD::OPC_ExtractField, 3, 5, // Inst{7-3} ... -// CHECK-LARGE-NEXT: /* 3 */ MCD::OPC_FilterValueOrSkip, 8, 4, 0, 0, // Skip to: 12 -// CHECK-LARGE-NEXT: /* 8 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 0, // Opcode: FOO16 -// CHECK-LARGE-NEXT: /* 12 */ MCD::OPC_FilterValue, 9, -// CHECK-LARGE-NEXT: /* 14 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: FOO32 +// CHECK-LARGE: /* 0 */ OPC_ExtractField, 3, 5, // Field = Inst{7-3} +// CHECK-LARGE-NEXT: /* 3 */ OPC_FilterValueOrSkip, 8, 4, 0, 0, // if Field != 0x8 skip to 12 +// CHECK-LARGE-NEXT: /* 8 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 0, // Opcode: FOO16 +// CHECK-LARGE-NEXT: /* 12 */ OPC_FilterValue, 9, // if Field != 0x9 pop scope +// CHECK-LARGE-NEXT: /* 14 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: FOO32 // CHECK-LARGE-NEXT: }; // CHECK: case 0: @@ -86,12 +86,12 @@ def FOO32 : MyVarInst { // CHECK-NEXT: MI.addOperand(MCOperand::createImm(tmp)); // CHECK-NEXT: return S; -// CHECK-LABEL: case MCD::OPC_ExtractField: { +// CHECK-LABEL: case OPC_ExtractField: { // CHECK: makeUp(insn, Start + Len); -// CHECK-LABEL: case MCD::OPC_CheckField: { +// CHECK-LABEL: case OPC_CheckField: { // CHECK: makeUp(insn, Start + Len); -// CHECK-LABEL: case MCD::OPC_Decode: { +// CHECK-LABEL: case OPC_Decode: { // CHECK: Len = InstrLenTable[Opc]; // CHECK-NEXT: makeUp(insn, Len); diff --git a/llvm/test/TableGen/trydecode-emission.td b/llvm/test/TableGen/trydecode-emission.td index d1cf4bf541835..c4e288e36676a 100644 --- a/llvm/test/TableGen/trydecode-emission.td +++ b/llvm/test/TableGen/trydecode-emission.td @@ -34,11 +34,11 @@ def InstB : TestInstruction { let hasCompleteDecoder = 0; } -// CHECK: /* 0 */ MCD::OPC_CheckField, 4, 4, 0, -// CHECK-NEXT: /* 4 */ MCD::OPC_Scope, 8, 0, // Skip to: 15 -// CHECK-NEXT: /* 7 */ MCD::OPC_CheckField, 2, 2, 0, -// CHECK-NEXT: /* 11 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, -// CHECK-NEXT: /* 15 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 +// CHECK: /* 0 */ OPC_CheckField, 4, 4, 0, // if Inst{7-4} != 0x0 +// CHECK-NEXT: /* 4 */ OPC_Scope, 8, 0, // end scope at 15 +// CHECK-NEXT: /* 7 */ OPC_CheckField, 2, 2, 0, // if Inst{3-2} != 0x0 +// CHECK-NEXT: /* 11 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, // Opcode: InstB, DecodeIdx: 0 +// CHECK-NEXT: /* 15 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 // CHECK-NEXT: }; // CHECK: if (!Check(S, DecodeInstB(MI, insn, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } @@ -47,11 +47,11 @@ def InstB : TestInstruction { // CHECK-NEXT: NumToSkip |= (*Ptr++) << 8; // CHECK-NEXT: return NumToSkip; -// CHECK-LARGE: /* 0 */ MCD::OPC_CheckField, 4, 4, 0, -// CHECK-LARGE-NEXT: /* 4 */ MCD::OPC_Scope, 8, 0, 0, // Skip to: 16 -// CHECK-LARGE-NEXT: /* 8 */ MCD::OPC_CheckField, 2, 2, 0, -// CHECK-LARGE-NEXT: /* 12 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, -// CHECK-LARGE-NEXT: /* 16 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 +// CHECK-LARGE: /* 0 */ OPC_CheckField, 4, 4, 0, // if Inst{7-4} != 0x0 +// CHECK-LARGE-NEXT: /* 4 */ OPC_Scope, 8, 0, 0, // end scope at 16 +// CHECK-LARGE-NEXT: /* 8 */ OPC_CheckField, 2, 2, 0, // if Inst{3-2} != 0x0 +// CHECK-LARGE-NEXT: /* 12 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, // Opcode: InstB, DecodeIdx: 0 +// CHECK-LARGE-NEXT: /* 16 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 // CHECK-LARGE-NEXT: }; // CHECK-LARGE: if (!Check(S, DecodeInstB(MI, insn, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } diff --git a/llvm/test/TableGen/trydecode-emission2.td b/llvm/test/TableGen/trydecode-emission2.td index d7a87eb4b8691..c628a860e100e 100644 --- a/llvm/test/TableGen/trydecode-emission2.td +++ b/llvm/test/TableGen/trydecode-emission2.td @@ -31,24 +31,24 @@ def InstB : TestInstruction { let hasCompleteDecoder = 0; } -// CHECK: /* 0 */ MCD::OPC_CheckField, 2, 1, 0, -// CHECK-NEXT: /* 4 */ MCD::OPC_CheckField, 5, 3, 0, -// CHECK-NEXT: /* 8 */ MCD::OPC_Scope, 8, 0, // Skip to: 19 -// CHECK-NEXT: /* 11 */ MCD::OPC_CheckField, 0, 2, 3, -// CHECK-NEXT: /* 15 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, -// CHECK-NEXT: /* 19 */ MCD::OPC_CheckField, 3, 2, 0, -// CHECK-NEXT: /* 23 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 1, +// CHECK: /* 0 */ OPC_CheckField, 2, 1, 0, +// CHECK-NEXT: /* 4 */ OPC_CheckField, 5, 3, 0, +// CHECK-NEXT: /* 8 */ OPC_Scope, 8, 0, // end scope at 19 +// CHECK-NEXT: /* 11 */ OPC_CheckField, 0, 2, 3, +// CHECK-NEXT: /* 15 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, +// CHECK-NEXT: /* 19 */ OPC_CheckField, 3, 2, 0, +// CHECK-NEXT: /* 23 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 1, // CHECK: if (!Check(S, DecodeInstB(MI, insn, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } // CHECK: if (!Check(S, DecodeInstA(MI, insn, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } -// CHECK-LARGE: /* 0 */ MCD::OPC_CheckField, 2, 1, 0, -// CHECK-LARGE-NEXT: /* 4 */ MCD::OPC_CheckField, 5, 3, 0, -// CHECK-LARGE-NEXT: /* 8 */ MCD::OPC_Scope, 8, 0, 0, // Skip to: 20 -// CHECK-LARGE-NEXT: /* 12 */ MCD::OPC_CheckField, 0, 2, 3, -// CHECK-LARGE-NEXT: /* 16 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, -// CHECK-LARGE-NEXT: /* 20 */ MCD::OPC_CheckField, 3, 2, 0, -// CHECK-LARGE-NEXT: /* 24 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 1, +// CHECK-LARGE: /* 0 */ OPC_CheckField, 2, 1, 0, +// CHECK-LARGE-NEXT: /* 4 */ OPC_CheckField, 5, 3, 0, +// CHECK-LARGE-NEXT: /* 8 */ OPC_Scope, 8, 0, 0, // end scope at 20 +// CHECK-LARGE-NEXT: /* 12 */ OPC_CheckField, 0, 2, 3, +// CHECK-LARGE-NEXT: /* 16 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, +// CHECK-LARGE-NEXT: /* 20 */ OPC_CheckField, 3, 2, 0, +// CHECK-LARGE-NEXT: /* 24 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 1, // CHECK-LARGE-NEXT: }; // CHECK-LARGE: if (!Check(S, DecodeInstB(MI, insn, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } diff --git a/llvm/test/TableGen/trydecode-emission3.td b/llvm/test/TableGen/trydecode-emission3.td index b7d1b8ddc1b6c..66fe7050e3ea7 100644 --- a/llvm/test/TableGen/trydecode-emission3.td +++ b/llvm/test/TableGen/trydecode-emission3.td @@ -35,20 +35,20 @@ def InstB : TestInstruction { let AsmString = "InstB"; } -// CHECK: /* 0 */ MCD::OPC_CheckField, 4, 4, 0, -// CHECK-NEXT: /* 4 */ MCD::OPC_Scope, 8, 0, // Skip to: 15 -// CHECK-NEXT: /* 7 */ MCD::OPC_CheckField, 2, 2, 0, -// CHECK-NEXT: /* 11 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, -// CHECK-NEXT: /* 15 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 +// CHECK: /* 0 */ OPC_CheckField, 4, 4, 0, +// CHECK-NEXT: /* 4 */ OPC_Scope, 8, 0, // end scope at 15 +// CHECK-NEXT: /* 7 */ OPC_CheckField, 2, 2, 0, +// CHECK-NEXT: /* 11 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, +// CHECK-NEXT: /* 15 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 // CHECK-NEXT: }; // CHECK: if (!Check(S, DecodeInstBOp(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } -// CHECK-LARGE: /* 0 */ MCD::OPC_CheckField, 4, 4, 0, -// CHECK-LARGE-NEXT: /* 4 */ MCD::OPC_Scope, 8, 0, 0, // Skip to: 16 -// CHECK-LARGE-NEXT: /* 8 */ MCD::OPC_CheckField, 2, 2, 0, -// CHECK-LARGE-NEXT: /* 12 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, -// CHECK-LARGE-NEXT: /* 16 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 +// CHECK-LARGE: /* 0 */ OPC_CheckField, 4, 4, 0, +// CHECK-LARGE-NEXT: /* 4 */ OPC_Scope, 8, 0, 0, // end scope at 16 +// CHECK-LARGE-NEXT: /* 8 */ OPC_CheckField, 2, 2, 0, +// CHECK-LARGE-NEXT: /* 12 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, +// CHECK-LARGE-NEXT: /* 16 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 // CHECK-LARGE-NEXT: }; // CHECK-LARGE: if (!Check(S, DecodeInstBOp(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } diff --git a/llvm/test/TableGen/trydecode-emission4.td b/llvm/test/TableGen/trydecode-emission4.td index 439bd9d4ff369..2432655e13129 100644 --- a/llvm/test/TableGen/trydecode-emission4.td +++ b/llvm/test/TableGen/trydecode-emission4.td @@ -33,21 +33,21 @@ def InstB : TestInstruction { let hasCompleteDecoder = 0; } -// CHECK: /* 0 */ MCD::OPC_CheckField, 250, 3, 4, 0, -// CHECK-NEXT: /* 5 */ MCD::OPC_Scope, 9, 0, // Skip to: 17 -// CHECK-NEXT: /* 8 */ MCD::OPC_CheckField, 248, 3, 2, 0, -// CHECK-NEXT: /* 13 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, -// CHECK-NEXT: /* 17 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 +// CHECK: /* 0 */ OPC_CheckField, 250, 3, 4, 0, +// CHECK-NEXT: /* 5 */ OPC_Scope, 9, 0, // end scope at 17 +// CHECK-NEXT: /* 8 */ OPC_CheckField, 248, 3, 2, 0, +// CHECK-NEXT: /* 13 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, +// CHECK-NEXT: /* 17 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 // CHECK-NEXT: }; // CHECK: if (!Check(S, DecodeInstB(MI, insn, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } -// CHECK-LARGE: /* 0 */ MCD::OPC_CheckField, 250, 3, 4, 0, -// CHECK-LARGE-NEXT: /* 5 */ MCD::OPC_Scope, 9, 0, 0, // Skip to: 18 -// CHECK-LARGE-NEXT: /* 9 */ MCD::OPC_CheckField, 248, 3, 2, 0, -// CHECK-LARGE-NEXT: /* 14 */ MCD::OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, -// CHECK-LARGE-NEXT: /* 18 */ MCD::OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 +// CHECK-LARGE: /* 0 */ OPC_CheckField, 250, 3, 4, 0, +// CHECK-LARGE-NEXT: /* 5 */ OPC_Scope, 9, 0, 0, // end scope at 18 +// CHECK-LARGE-NEXT: /* 9 */ OPC_CheckField, 248, 3, 2, 0, +// CHECK-LARGE-NEXT: /* 14 */ OPC_TryDecode, {{[0-9]+}}, {{[0-9]+}}, 0, +// CHECK-LARGE-NEXT: /* 18 */ OPC_Decode, {{[0-9]+}}, {{[0-9]+}}, 1, // Opcode: InstA, DecodeIdx: 1 // CHECK-LARGE-NEXT: }; // CHECK-LARGE: if (!Check(S, DecodeInstB(MI, insn, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; } diff --git a/llvm/utils/TableGen/DecoderEmitter.cpp b/llvm/utils/TableGen/DecoderEmitter.cpp index a8a9036a1a7f4..29d90d921aff0 100644 --- a/llvm/utils/TableGen/DecoderEmitter.cpp +++ b/llvm/utils/TableGen/DecoderEmitter.cpp @@ -54,6 +54,7 @@ #include using namespace llvm; +using namespace llvm::MCD; #define DEBUG_TYPE "decoder-emitter" @@ -291,7 +292,7 @@ class DecoderTable { const_iterator end() const { return Data.end(); } /// Inserts a state machine opcode into the table. - void insertOpcode(MCD::DecoderOps Opcode) { Data.push_back(Opcode); } + void insertOpcode(DecoderOps Opcode) { Data.push_back(Opcode); } /// Inserts a uint8 encoded value into the table. void insertUInt8(unsigned Value) { @@ -721,6 +722,25 @@ unsigned Filter::usefulness() const { // // ////////////////////////////////// +static StringRef getDecoderOpName(DecoderOps Op) { +#define CASE(OP) \ + case OP: \ + return #OP + switch (Op) { + CASE(OPC_Scope); + CASE(OPC_ExtractField); + CASE(OPC_FilterValueOrSkip); + CASE(OPC_FilterValue); + CASE(OPC_CheckField); + CASE(OPC_CheckPredicate); + CASE(OPC_Decode); + CASE(OPC_TryDecode); + CASE(OPC_SoftFail); + } +#undef CASE + llvm_unreachable("Unknown decoder op"); +} + // Emit the decoder state machine table. Returns a mask of MCD decoder ops // that were emitted. unsigned DecoderEmitter::emitTable(formatted_raw_ostream &OS, @@ -743,7 +763,7 @@ unsigned DecoderEmitter::emitTable(formatted_raw_ostream &OS, OS << BitWidth << "[" << Table.size() << "] = {\n"; // Emit ULEB128 encoded value to OS, returning the number of bytes emitted. - auto emitULEB128 = [](DecoderTable::const_iterator &I, + auto EmitULEB128 = [](DecoderTable::const_iterator &I, formatted_raw_ostream &OS) { while (*I >= 128) OS << (unsigned)*I++ << ", "; @@ -752,7 +772,7 @@ unsigned DecoderEmitter::emitTable(formatted_raw_ostream &OS, // Emit `getNumToSkipInBytes()`-byte numtoskip value to OS, returning the // NumToSkip value. - auto emitNumToSkip = [](DecoderTable::const_iterator &I, + auto EmitNumToSkip = [](DecoderTable::const_iterator &I, formatted_raw_ostream &OS) { uint8_t Byte = *I++; uint32_t NumToSkip = Byte; @@ -774,141 +794,148 @@ unsigned DecoderEmitter::emitTable(formatted_raw_ostream &OS, DecoderTable::const_iterator E = Table.end(); const uint8_t *const EndPtr = Table.data() + Table.size(); - auto emitNumToSkipComment = [&](uint32_t NumToSkip, bool InComment = false) { - uint32_t Index = ((I - Table.begin()) + NumToSkip); - OS << (InComment ? ", " : "// "); - OS << "Skip to: " << Index; + auto EmitPos = [&OS](uint32_t Pos) { + constexpr uint32_t StartColumn = 12; + OS << "/* " << Pos << " */"; + OS.PadToColumn(StartColumn); + }; + + auto StartComment = [&OS]() { + constexpr uint32_t CommentColumn = 52; + OS.PadToColumn(CommentColumn); + OS << "// "; + }; + + auto EmitNumToSkipComment = [&](uint32_t NumToSkip) { + uint32_t Index = (I - Table.begin()) + NumToSkip; + OS << "skip to " << Index; }; // The first entry when specializing decoders per bitwidth is the bitwidth. // This will be used for additional checks in `decodeInstruction`. if (SpecializeDecodersPerBitwidth) { - OS << "/* 0 */"; - OS.PadToColumn(14); - emitULEB128(I, OS); - OS << " // Bitwidth " << BitWidth << '\n'; + EmitPos(0); + EmitULEB128(I, OS); + StartComment(); + OS << "Bitwidth " << BitWidth << '\n'; } + auto DecodeAndEmitULEB128 = [EndPtr, + &EmitULEB128](DecoderTable::const_iterator &I, + formatted_raw_ostream &OS) { + const char *ErrMsg = nullptr; + uint64_t Value = decodeULEB128(&*I, nullptr, EndPtr, &ErrMsg); + assert(ErrMsg == nullptr && "ULEB128 value too large!"); + + EmitULEB128(I, OS); + return Value; + }; + unsigned OpcodeMask = 0; while (I != E) { assert(I < E && "incomplete decode table entry!"); - uint64_t Pos = I - Table.begin(); - OS << "/* " << Pos << " */"; - OS.PadToColumn(12); - + uint32_t Pos = I - Table.begin(); + EmitPos(Pos); const uint8_t DecoderOp = *I++; OpcodeMask |= (1 << DecoderOp); + OS << getDecoderOpName(static_cast(DecoderOp)) << ", "; switch (DecoderOp) { default: PrintFatalError("Invalid decode table opcode: " + Twine((int)DecoderOp) + " at index " + Twine(Pos)); - case MCD::OPC_Scope: { - OS << " MCD::OPC_Scope, "; - uint32_t NumToSkip = emitNumToSkip(I, OS); - emitNumToSkipComment(NumToSkip); - OS << '\n'; + case OPC_Scope: { + uint32_t NumToSkip = EmitNumToSkip(I, OS); + StartComment(); + uint32_t Index = (I - Table.begin()) + NumToSkip; + OS << "end scope at " << Index; break; } - case MCD::OPC_ExtractField: { - OS << " MCD::OPC_ExtractField, "; - + case OPC_ExtractField: { // ULEB128 encoded start value. - const char *ErrMsg = nullptr; - unsigned Start = decodeULEB128(&*I, nullptr, EndPtr, &ErrMsg); - assert(ErrMsg == nullptr && "ULEB128 value too large!"); - emitULEB128(I, OS); - + unsigned Start = DecodeAndEmitULEB128(I, OS); unsigned Len = *I++; - OS << Len << ", // Inst{"; + OS << Len << ','; + StartComment(); + OS << "Field = Inst{"; if (Len > 1) - OS << (Start + Len - 1) << "-"; - OS << Start << "} ...\n"; + OS << (Start + Len - 1) << '-'; + OS << Start << '}'; break; } - case MCD::OPC_FilterValueOrSkip: { - OS << " MCD::OPC_FilterValueOrSkip, "; + case OPC_FilterValueOrSkip: { // The filter value is ULEB128 encoded. - emitULEB128(I, OS); - uint32_t NumToSkip = emitNumToSkip(I, OS); - emitNumToSkipComment(NumToSkip); - OS << '\n'; + uint64_t FilterVal = DecodeAndEmitULEB128(I, OS); + uint32_t NumToSkip = EmitNumToSkip(I, OS); + StartComment(); + OS << "if Field != " << format_hex(FilterVal, 0) << ' '; + EmitNumToSkipComment(NumToSkip); break; } - case MCD::OPC_FilterValue: { - OS << " MCD::OPC_FilterValue, "; + case OPC_FilterValue: { // The filter value is ULEB128 encoded. - emitULEB128(I, OS); - OS << '\n'; + uint64_t FilterVal = DecodeAndEmitULEB128(I, OS); + + StartComment(); + OS << "if Field != " << format_hex(FilterVal, 0) << " pop scope"; break; } - case MCD::OPC_CheckField: { - OS << " MCD::OPC_CheckField, "; + case OPC_CheckField: { // ULEB128 encoded start value. - emitULEB128(I, OS); + unsigned Start = DecodeAndEmitULEB128(I, OS); + // 8-bit length. unsigned Len = *I++; OS << Len << ", "; + // ULEB128 encoded field value. - emitULEB128(I, OS); - OS << '\n'; + uint64_t FieldVal = DecodeAndEmitULEB128(I, OS); + + StartComment(); + OS << "if Inst{"; + if (Len > 1) + OS << (Start + Len - 1) << '-'; + OS << Start << "} != " << format_hex(FieldVal, 0) << " pop scope"; break; } - case MCD::OPC_CheckPredicate: { - OS << " MCD::OPC_CheckPredicate, "; - emitULEB128(I, OS); - OS << '\n'; + case OPC_CheckPredicate: { + unsigned PIdx = DecodeAndEmitULEB128(I, OS); + StartComment(); + OS << "if !checkPredicate(" << PIdx << ") pop scope"; break; } - case MCD::OPC_Decode: - case MCD::OPC_TryDecode: { - bool IsTry = DecoderOp == MCD::OPC_TryDecode; + case OPC_Decode: + case OPC_TryDecode: { // Decode the Opcode value. - const char *ErrMsg = nullptr; - unsigned Opc = decodeULEB128(&*I, nullptr, EndPtr, &ErrMsg); - assert(ErrMsg == nullptr && "ULEB128 value too large!"); - - OS << " MCD::OPC_" << (IsTry ? "Try" : "") << "Decode, "; - emitULEB128(I, OS); + unsigned Opc = DecodeAndEmitULEB128(I, OS); // Decoder index. - unsigned DecodeIdx = decodeULEB128(&*I, nullptr, EndPtr, &ErrMsg); - assert(ErrMsg == nullptr && "ULEB128 value too large!"); - emitULEB128(I, OS); + unsigned DecodeIdx = DecodeAndEmitULEB128(I, OS); auto EncI = OpcodeToEncodingID.find(Opc); assert(EncI != OpcodeToEncodingID.end() && "no encoding entry"); auto EncodingID = EncI->second; - if (!IsTry) { - OS << "// Opcode: " << Encodings[EncodingID].getName() - << ", DecodeIdx: " << DecodeIdx << '\n'; - break; - } - OS << '\n'; + StartComment(); + OS << "Opcode: " << Encodings[EncodingID].getName() + << ", DecodeIdx: " << DecodeIdx; break; } - case MCD::OPC_SoftFail: { - OS << " MCD::OPC_SoftFail, "; + case OPC_SoftFail: { // Decode the positive mask. - const char *ErrMsg = nullptr; - uint64_t PositiveMask = decodeULEB128(&*I, nullptr, EndPtr, &ErrMsg); - assert(ErrMsg == nullptr && "ULEB128 value too large!"); - emitULEB128(I, OS); + uint64_t PositiveMask = DecodeAndEmitULEB128(I, OS); // Decode the negative mask. - uint64_t NegativeMask = decodeULEB128(&*I, nullptr, EndPtr, &ErrMsg); - assert(ErrMsg == nullptr && "ULEB128 value too large!"); - emitULEB128(I, OS); - OS << "// +ve mask: 0x"; - OS.write_hex(PositiveMask); - OS << ", -ve mask: 0x"; - OS.write_hex(NegativeMask); - OS << '\n'; + uint64_t NegativeMask = DecodeAndEmitULEB128(I, OS); + + StartComment(); + OS << "positive mask: " << format_hex(PositiveMask, 0) + << "negative mask: " << format_hex(NegativeMask, 0); break; } } + OS << '\n'; } OS << "};\n\n"; @@ -981,7 +1008,6 @@ void DecoderEmitter::emitDecoderFunction(formatted_raw_ostream &OS, PrintTemplate(); PrintDecodeFnName(Index); OS << "(" << DecodeParams << ") {\n"; - OS << " using namespace llvm::MCD;\n"; OS << " " << TmpTypeDecl; OS << " [[maybe_unused]] TmpType tmp;\n"; OS << Decoder; @@ -993,7 +1019,6 @@ void DecoderEmitter::emitDecoderFunction(formatted_raw_ostream &OS, OS << "// Handling " << Decoders.size() << " cases.\n"; PrintTemplate(); OS << "decodeToMCInst(unsigned Idx, " << DecodeParams << ") {\n"; - OS << " using namespace llvm::MCD;\n"; OS << " DecodeComplete = true;\n"; if (UseFnTableInDecodeToMCInst) { @@ -1280,7 +1305,7 @@ void DecoderTableBuilder::emitPredicateTableEntry(unsigned EncodingID) const { // computed. unsigned PIdx = getPredicateIndex(PS.str()); - TableInfo.Table.insertOpcode(MCD::OPC_CheckPredicate); + TableInfo.Table.insertOpcode(OPC_CheckPredicate); TableInfo.Table.insertULEB128(PIdx); } @@ -1295,7 +1320,7 @@ void DecoderTableBuilder::emitSoftFailTableEntry(unsigned EncodingID) const { APInt PositiveMask = InstBits.Zero & SoftFailMask; APInt NegativeMask = InstBits.One & SoftFailMask; - TableInfo.Table.insertOpcode(MCD::OPC_SoftFail); + TableInfo.Table.insertOpcode(OPC_SoftFail); TableInfo.Table.insertULEB128(PositiveMask.getZExtValue()); TableInfo.Table.insertULEB128(NegativeMask.getZExtValue()); } @@ -1315,7 +1340,7 @@ void DecoderTableBuilder::emitSingletonTableEntry( // Check any additional encoding fields needed. for (const FilterChooser::Island &Ilnd : reverse(Islands)) { - TableInfo.Table.insertOpcode(MCD::OPC_CheckField); + TableInfo.Table.insertOpcode(OPC_CheckField); TableInfo.Table.insertULEB128(Ilnd.StartBit); TableInfo.Table.insertUInt8(Ilnd.NumBits); TableInfo.Table.insertULEB128(Ilnd.FieldVal); @@ -1335,8 +1360,8 @@ void DecoderTableBuilder::emitSingletonTableEntry( // decoder method indicates that additional processing should be done to see // if there is any other instruction that also matches the bitpattern and // can decode it. - const MCD::DecoderOps DecoderOp = - Encoding.hasCompleteDecoder() ? MCD::OPC_Decode : MCD::OPC_TryDecode; + const DecoderOps DecoderOp = + Encoding.hasCompleteDecoder() ? OPC_Decode : OPC_TryDecode; TableInfo.Table.insertOpcode(DecoderOp); const Record *InstDef = Encodings[EncodingID].getInstruction()->TheDef; TableInfo.Table.insertULEB128(Target.getInstrIntValue(InstDef)); @@ -1625,7 +1650,7 @@ void DecoderTableBuilder::emitTableEntries(const FilterChooser &FC) const { // known don't, enter a scope so that they have a chance. size_t FixupLoc = 0; if (FC.VariableFC) { - Table.insertOpcode(MCD::OPC_Scope); + Table.insertOpcode(OPC_Scope); FixupLoc = Table.insertNumToSkip(); } @@ -1639,7 +1664,7 @@ void DecoderTableBuilder::emitTableEntries(const FilterChooser &FC) const { // If there is only one possible field value, emit a combined OPC_CheckField // instead of OPC_ExtractField + OPC_FilterValue. const auto &[FilterVal, Delegate] = *FC.FilterChooserMap.begin(); - Table.insertOpcode(MCD::OPC_CheckField); + Table.insertOpcode(OPC_CheckField); Table.insertULEB128(FC.StartBit); Table.insertUInt8(FC.NumBits); Table.insertULEB128(FilterVal); @@ -1648,13 +1673,13 @@ void DecoderTableBuilder::emitTableEntries(const FilterChooser &FC) const { emitTableEntries(*Delegate); } else { // The general case: emit a switch over the field value. - Table.insertOpcode(MCD::OPC_ExtractField); + Table.insertOpcode(OPC_ExtractField); Table.insertULEB128(FC.StartBit); Table.insertUInt8(FC.NumBits); // Emit switch cases for all but the last element. for (const auto &[FilterVal, Delegate] : drop_end(FC.FilterChooserMap)) { - Table.insertOpcode(MCD::OPC_FilterValueOrSkip); + Table.insertOpcode(OPC_FilterValueOrSkip); Table.insertULEB128(FilterVal); size_t FixupPos = Table.insertNumToSkip(); @@ -1668,7 +1693,7 @@ void DecoderTableBuilder::emitTableEntries(const FilterChooser &FC) const { // Emit a switch case for the last element. It never falls through; // if it doesn't match, we leave the current scope. const auto &[FilterVal, Delegate] = *FC.FilterChooserMap.rbegin(); - Table.insertOpcode(MCD::OPC_FilterValue); + Table.insertOpcode(OPC_FilterValue); Table.insertULEB128(FilterVal); // Emit table entries for the last case. @@ -2101,9 +2126,9 @@ InstructionEncoding::InstructionEncoding(const Record *EncodingDef, // decodeInstruction(). static void emitDecodeInstruction(formatted_raw_ostream &OS, bool IsVarLenInst, unsigned OpcodeMask) { - const bool HasTryDecode = OpcodeMask & (1 << MCD::OPC_TryDecode); - const bool HasCheckPredicate = OpcodeMask & (1 << MCD::OPC_CheckPredicate); - const bool HasSoftFail = OpcodeMask & (1 << MCD::OPC_SoftFail); + const bool HasTryDecode = OpcodeMask & (1 << OPC_TryDecode); + const bool HasCheckPredicate = OpcodeMask & (1 << OPC_CheckPredicate); + const bool HasSoftFail = OpcodeMask & (1 << OPC_SoftFail); OS << R"( static unsigned decodeNumToSkip(const uint8_t *&Ptr) { @@ -2127,7 +2152,6 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, OS << ") {\n"; if (HasCheckPredicate) OS << " const FeatureBitset &Bits = STI.getFeatureBits();\n"; - OS << " using namespace llvm::MCD;\n"; OS << " const uint8_t *Ptr = DecodeTable;\n"; if (SpecializeDecodersPerBitwidth) { @@ -2152,7 +2176,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, errs() << Loc << ": Unexpected decode table opcode: " << (int)DecoderOp << '\n'; return MCDisassembler::Fail; - case MCD::OPC_Scope: { + case OPC_Scope: { unsigned NumToSkip = decodeNumToSkip(Ptr); const uint8_t *SkipTo = Ptr + NumToSkip; ScopeStack.push_back(SkipTo); @@ -2160,7 +2184,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, << ")\n"); break; } - case MCD::OPC_ExtractField: { + case OPC_ExtractField: { // Decode the start value. unsigned Start = decodeULEB128AndIncUnsafe(Ptr); unsigned Len = *Ptr++;)"; @@ -2172,7 +2196,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, << Len << "): " << CurFieldValue << "\n"); break; } - case MCD::OPC_FilterValueOrSkip: { + case OPC_FilterValueOrSkip: { // Decode the field value. uint64_t Val = decodeULEB128AndIncUnsafe(Ptr); bool Failed = Val != CurFieldValue; @@ -2189,7 +2213,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, } break; } - case MCD::OPC_FilterValue: { + case OPC_FilterValue: { // Decode the field value. uint64_t Val = decodeULEB128AndIncUnsafe(Ptr); bool Failed = Val != CurFieldValue; @@ -2207,7 +2231,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, } break; } - case MCD::OPC_CheckField: { + case OPC_CheckField: { // Decode the start value. unsigned Start = decodeULEB128AndIncUnsafe(Ptr); unsigned Len = *Ptr;)"; @@ -2237,7 +2261,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, })"; if (HasCheckPredicate) { OS << R"( - case MCD::OPC_CheckPredicate: { + case OPC_CheckPredicate: { // Decode the Predicate Index value. unsigned PIdx = decodeULEB128AndIncUnsafe(Ptr); // Check the predicate. @@ -2258,7 +2282,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, })"; } OS << R"( - case MCD::OPC_Decode: { + case OPC_Decode: { // Decode the Opcode value. unsigned Opc = decodeULEB128AndIncUnsafe(Ptr); unsigned DecodeIdx = decodeULEB128AndIncUnsafe(Ptr); @@ -2281,7 +2305,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, })"; if (HasTryDecode) { OS << R"( - case MCD::OPC_TryDecode: { + case OPC_TryDecode: { // Decode the Opcode value. unsigned Opc = decodeULEB128AndIncUnsafe(Ptr); unsigned DecodeIdx = decodeULEB128AndIncUnsafe(Ptr); @@ -2315,7 +2339,7 @@ static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, } if (HasSoftFail) { OS << R"( - case MCD::OPC_SoftFail: { + case OPC_SoftFail: { // Decode the mask values. uint64_t PositiveMask = decodeULEB128AndIncUnsafe(Ptr); uint64_t NegativeMask = decodeULEB128AndIncUnsafe(Ptr); @@ -2619,7 +2643,7 @@ template constexpr uint32_t InsnBitWidth = 0; if (!SpecializeDecodersPerBitwidth) emitDecoderFunction(OS, TableInfo.Decoders, 0); - const bool HasCheckPredicate = OpcodeMask & (1 << MCD::OPC_CheckPredicate); + const bool HasCheckPredicate = OpcodeMask & (1 << OPC_CheckPredicate); // Emit the predicate function. if (HasCheckPredicate)