Skip to content

Commit

Permalink
[X86][NFC] Refine code in X86InstrArithmetic.td
Browse files Browse the repository at this point in the history 
1. Simplify the variable name
2. Change HasOddOpcode to HasEvenOpcode b/c
  a. opcode of any 8-bit arithmetic instruction is even
  b. opcode of a 16/32/64-bit arithmetic instruction is usually
     odd, but it can be even sometimes, e.g. INC/DEC, ADCX/ADOX
  c. so that we can remove `let Opcode = o` for the mentioned corner
     cases.
  • Loading branch information
@KanRobert
KanRobert committed Dec 21, 2023
1 parent e414ba3 commit 2fe94ce
Show file tree
Hide file tree
Showing 2 changed files with 78 additions and 82 deletions.
138 changes: 67 additions & 71 deletions llvm/lib/Target/X86/X86InstrArithmetic.td
View file
Original file line number Diff line number Diff line change
Expand Up @@ -232,7 +232,7 @@ class BinOpMIF_MF<bits<8> o, string m, X86TypeInfo t, SDNode node, Format f>

// BinOpMI8 - Instructions that read "[mem], imm8".
class BinOpMI8<string m, X86TypeInfo t, Format f>
: ITy<0x82, f, t, (outs), (ins t.MemOperand:$dst, t.Imm8Operand:$src), m,
: ITy<0x83, f, t, (outs), (ins t.MemOperand:$dst, t.Imm8Operand:$src), m,
"{$src, $dst|$dst, $src}", []> {
let ImmT = Imm8;
let mayLoad = 1;
Expand Down Expand Up @@ -292,15 +292,15 @@ class UnaryOpM<bits<8> o, Format f, string m, X86TypeInfo t, list<dag> p>

// INCDECR - Instructions like "inc reg".
class INCDECR<Format f, string m, X86TypeInfo t, SDPatternOperator node>
: UnaryOpR<0xFE, f, m, t,
: UnaryOpR<0xFF, f, m, t,
[(set t.RegClass:$dst, EFLAGS, (node t.RegClass:$src1, 1))]>,
DefEFLAGS {
let isConvertibleToThreeAddress = 1; // Can xform into LEA.
}

// INCDECM - Instructions like "inc [mem]".
class INCDECM<Format f, string m, X86TypeInfo t, int num>
: UnaryOpM<0xFE, f, m, t,
: UnaryOpM<0xFF, f, m, t,
[(store (add (t.LoadNode addr:$dst), num), addr:$dst),
(implicit EFLAGS)]>, DefEFLAGS;

Expand All @@ -309,7 +309,6 @@ class INCDECR_ALT<bits<8> o, string m, X86TypeInfo t>
: UnaryOpR<o, AddRegFrm, m, t, []>, DefEFLAGS {
// Short forms only valid in 32-bit mode. Selected during MCInst lowering.
let Predicates = [Not64BitMode];
let Opcode = o;
}

// MulOpR - Instructions like "mul reg".
Expand Down Expand Up @@ -664,13 +663,13 @@ multiclass ArithBinOp_RF<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
def NAME#8ri : BinOpRI_RF<0x80, mnemonic, Xi8 , opnodeflag, RegMRM>;
// NOTE: These are order specific, we want the ri8 forms to be listed
// first so that they are slightly preferred to the ri forms.
def NAME#16ri8 : BinOpRI8_RF<0x82, mnemonic, Xi16, RegMRM>;
def NAME#32ri8 : BinOpRI8_RF<0x82, mnemonic, Xi32, RegMRM>;
def NAME#64ri8 : BinOpRI8_RF<0x82, mnemonic, Xi64, RegMRM>;
def NAME#16ri8 : BinOpRI8_RF<0x83, mnemonic, Xi16, RegMRM>;
def NAME#32ri8 : BinOpRI8_RF<0x83, mnemonic, Xi32, RegMRM>;
def NAME#64ri8 : BinOpRI8_RF<0x83, mnemonic, Xi64, RegMRM>;

def NAME#16ri : BinOpRI_RF<0x80, mnemonic, Xi16, opnodeflag, RegMRM>;
def NAME#32ri : BinOpRI_RF<0x80, mnemonic, Xi32, opnodeflag, RegMRM>;
def NAME#64ri32: BinOpRI_RF<0x80, mnemonic, Xi64, opnodeflag, RegMRM>;
def NAME#16ri : BinOpRI_RF<0x81, mnemonic, Xi16, opnodeflag, RegMRM>;
def NAME#32ri : BinOpRI_RF<0x81, mnemonic, Xi32, opnodeflag, RegMRM>;
def NAME#64ri32: BinOpRI_RF<0x81, mnemonic, Xi64, opnodeflag, RegMRM>;
}
} // Constraints = "$src1 = $dst"

Expand All @@ -687,10 +686,10 @@ multiclass ArithBinOp_RF<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
def NAME#64mi8 : BinOpMI8_MF<mnemonic, Xi64, MemMRM>;

def NAME#8mi : BinOpMI_MF<0x80, mnemonic, Xi8 , opnode, MemMRM>;
def NAME#16mi : BinOpMI_MF<0x80, mnemonic, Xi16, opnode, MemMRM>;
def NAME#32mi : BinOpMI_MF<0x80, mnemonic, Xi32, opnode, MemMRM>;
def NAME#16mi : BinOpMI_MF<0x81, mnemonic, Xi16, opnode, MemMRM>;
def NAME#32mi : BinOpMI_MF<0x81, mnemonic, Xi32, opnode, MemMRM>;
let Predicates = [In64BitMode] in
def NAME#64mi32 : BinOpMI_MF<0x80, mnemonic, Xi64, opnode, MemMRM>;
def NAME#64mi32 : BinOpMI_MF<0x81, mnemonic, Xi64, opnode, MemMRM>;

// These are for the disassembler since 0x82 opcode behaves like 0x80, but
// not in 64-bit mode.
Expand Down Expand Up @@ -744,13 +743,13 @@ multiclass ArithBinOp_RFF<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
// NOTE: These are order specific, we want the ri8 forms to be listed
// first so that they are slightly preferred to the ri forms.
def NAME#16ri8 : BinOpRI8F_RF<0x82, mnemonic, Xi16, RegMRM>;
def NAME#32ri8 : BinOpRI8F_RF<0x82, mnemonic, Xi32, RegMRM>;
def NAME#64ri8 : BinOpRI8F_RF<0x82, mnemonic, Xi64, RegMRM>;
def NAME#16ri8 : BinOpRI8F_RF<0x83, mnemonic, Xi16, RegMRM>;
def NAME#32ri8 : BinOpRI8F_RF<0x83, mnemonic, Xi32, RegMRM>;
def NAME#64ri8 : BinOpRI8F_RF<0x83, mnemonic, Xi64, RegMRM>;

def NAME#16ri : BinOpRIF_RF<0x80, mnemonic, Xi16, opnode, RegMRM>;
def NAME#32ri : BinOpRIF_RF<0x80, mnemonic, Xi32, opnode, RegMRM>;
def NAME#64ri32: BinOpRIF_RF<0x80, mnemonic, Xi64, opnode, RegMRM>;
def NAME#16ri : BinOpRIF_RF<0x81, mnemonic, Xi16, opnode, RegMRM>;
def NAME#32ri : BinOpRIF_RF<0x81, mnemonic, Xi32, opnode, RegMRM>;
def NAME#64ri32: BinOpRIF_RF<0x81, mnemonic, Xi64, opnode, RegMRM>;
}
} // Constraints = "$src1 = $dst"

Expand All @@ -767,10 +766,10 @@ multiclass ArithBinOp_RFF<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
def NAME#64mi8 : BinOpMI8F_MF<mnemonic, Xi64, MemMRM>;

def NAME#8mi : BinOpMIF_MF<0x80, mnemonic, Xi8 , opnode, MemMRM>;
def NAME#16mi : BinOpMIF_MF<0x80, mnemonic, Xi16, opnode, MemMRM>;
def NAME#32mi : BinOpMIF_MF<0x80, mnemonic, Xi32, opnode, MemMRM>;
def NAME#16mi : BinOpMIF_MF<0x81, mnemonic, Xi16, opnode, MemMRM>;
def NAME#32mi : BinOpMIF_MF<0x81, mnemonic, Xi32, opnode, MemMRM>;
let Predicates = [In64BitMode] in
def NAME#64mi32 : BinOpMIF_MF<0x80, mnemonic, Xi64, opnode, MemMRM>;
def NAME#64mi32 : BinOpMIF_MF<0x81, mnemonic, Xi64, opnode, MemMRM>;

// These are for the disassembler since 0x82 opcode behaves like 0x80, but
// not in 64-bit mode.
Expand Down Expand Up @@ -822,13 +821,13 @@ multiclass ArithBinOp_F<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
// NOTE: These are order specific, we want the ri8 forms to be listed
// first so that they are slightly preferred to the ri forms.
def NAME#16ri8 : BinOpRI8_F<0x82, mnemonic, Xi16, RegMRM>;
def NAME#32ri8 : BinOpRI8_F<0x82, mnemonic, Xi32, RegMRM>;
def NAME#64ri8 : BinOpRI8_F<0x82, mnemonic, Xi64, RegMRM>;
def NAME#16ri8 : BinOpRI8_F<0x83, mnemonic, Xi16, RegMRM>;
def NAME#32ri8 : BinOpRI8_F<0x83, mnemonic, Xi32, RegMRM>;
def NAME#64ri8 : BinOpRI8_F<0x83, mnemonic, Xi64, RegMRM>;

def NAME#16ri : BinOpRI_F<0x80, mnemonic, Xi16, opnode, RegMRM>;
def NAME#32ri : BinOpRI_F<0x80, mnemonic, Xi32, opnode, RegMRM>;
def NAME#64ri32: BinOpRI_F<0x80, mnemonic, Xi64, opnode, RegMRM>;
def NAME#16ri : BinOpRI_F<0x81, mnemonic, Xi16, opnode, RegMRM>;
def NAME#32ri : BinOpRI_F<0x81, mnemonic, Xi32, opnode, RegMRM>;
def NAME#64ri32: BinOpRI_F<0x81, mnemonic, Xi64, opnode, RegMRM>;
}

def NAME#8mr : BinOpMR_F<BaseOpc, mnemonic, Xi8 , opnode>;
Expand All @@ -844,10 +843,10 @@ multiclass ArithBinOp_F<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
def NAME#64mi8 : BinOpMI8_F<mnemonic, Xi64, MemMRM>;

def NAME#8mi : BinOpMI_F<0x80, mnemonic, Xi8 , opnode, MemMRM>;
def NAME#16mi : BinOpMI_F<0x80, mnemonic, Xi16, opnode, MemMRM>;
def NAME#32mi : BinOpMI_F<0x80, mnemonic, Xi32, opnode, MemMRM>;
def NAME#16mi : BinOpMI_F<0x81, mnemonic, Xi16, opnode, MemMRM>;
def NAME#32mi : BinOpMI_F<0x81, mnemonic, Xi32, opnode, MemMRM>;
let Predicates = [In64BitMode] in
def NAME#64mi32 : BinOpMI_F<0x80, mnemonic, Xi64, opnode, MemMRM>;
def NAME#64mi32 : BinOpMI_F<0x81, mnemonic, Xi64, opnode, MemMRM>;

// These are for the disassembler since 0x82 opcode behaves like 0x80, but
// not in 64-bit mode.
Expand All @@ -868,16 +867,16 @@ multiclass ArithBinOp_F<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
}


defm AND : ArithBinOp_RF<0x20, 0x22, 0x24, "and", MRM4r, MRM4m,
defm AND : ArithBinOp_RF<0x21, 0x23, 0x25, "and", MRM4r, MRM4m,
X86and_flag, and, 1, 0, 0>;
defm OR : ArithBinOp_RF<0x08, 0x0A, 0x0C, "or", MRM1r, MRM1m,
defm OR : ArithBinOp_RF<0x09, 0x0B, 0x0D, "or", MRM1r, MRM1m,
X86or_flag, or, 1, 0, 0>;
defm XOR : ArithBinOp_RF<0x30, 0x32, 0x34, "xor", MRM6r, MRM6m,
defm XOR : ArithBinOp_RF<0x31, 0x33, 0x35, "xor", MRM6r, MRM6m,
X86xor_flag, xor, 1, 0, 0>;
defm ADD : ArithBinOp_RF<0x00, 0x02, 0x04, "add", MRM0r, MRM0m,
defm ADD : ArithBinOp_RF<0x01, 0x03, 0x05, "add", MRM0r, MRM0m,
X86add_flag, add, 1, 1, 1>;
let isCompare = 1 in {
defm SUB : ArithBinOp_RF<0x28, 0x2A, 0x2C, "sub", MRM5r, MRM5m,
defm SUB : ArithBinOp_RF<0x29, 0x2B, 0x2D, "sub", MRM5r, MRM5m,
X86sub_flag, sub, 0, 1, 0>;
}

Expand All @@ -891,13 +890,13 @@ def XOR8rr_NOREX : I<0x30, MRMDestReg, (outs GR8_NOREX:$dst),
Sched<[WriteALU]>;

// Arithmetic.
defm ADC : ArithBinOp_RFF<0x10, 0x12, 0x14, "adc", MRM2r, MRM2m, X86adc_flag,
defm ADC : ArithBinOp_RFF<0x11, 0x13, 0x15, "adc", MRM2r, MRM2m, X86adc_flag,
1, 0>;
defm SBB : ArithBinOp_RFF<0x18, 0x1A, 0x1C, "sbb", MRM3r, MRM3m, X86sbb_flag,
defm SBB : ArithBinOp_RFF<0x19, 0x1B, 0x1D, "sbb", MRM3r, MRM3m, X86sbb_flag,
0, 0>;

let isCompare = 1 in {
defm CMP : ArithBinOp_F<0x38, 0x3A, 0x3C, "cmp", MRM7r, MRM7m, X86cmp, 0, 0>;
defm CMP : ArithBinOp_F<0x39, 0x3B, 0x3D, "cmp", MRM7r, MRM7m, X86cmp, 0, 0>;
}

// Patterns to recognize loads on the LHS of an ADC. We can't make X86adc_flag
Expand Down Expand Up @@ -1040,32 +1039,32 @@ let isCompare = 1 in {
// combine them. This gives bunch of other patterns that start with
// and a chance to match.
def TEST8rr : BinOpRR_F<0x84, "test", Xi8 , null_frag>;
def TEST16rr : BinOpRR_F<0x84, "test", Xi16, null_frag>;
def TEST32rr : BinOpRR_F<0x84, "test", Xi32, null_frag>;
def TEST64rr : BinOpRR_F<0x84, "test", Xi64, null_frag>;
def TEST16rr : BinOpRR_F<0x85, "test", Xi16, null_frag>;
def TEST32rr : BinOpRR_F<0x85, "test", Xi32, null_frag>;
def TEST64rr : BinOpRR_F<0x85, "test", Xi64, null_frag>;
} // isCommutable

def TEST8mr : BinOpMR_F<0x84, "test", Xi8 , null_frag>;
def TEST16mr : BinOpMR_F<0x84, "test", Xi16, null_frag>;
def TEST32mr : BinOpMR_F<0x84, "test", Xi32, null_frag>;
def TEST64mr : BinOpMR_F<0x84, "test", Xi64, null_frag>;
def TEST16mr : BinOpMR_F<0x85, "test", Xi16, null_frag>;
def TEST32mr : BinOpMR_F<0x85, "test", Xi32, null_frag>;
def TEST64mr : BinOpMR_F<0x85, "test", Xi64, null_frag>;

def TEST8ri : BinOpRI_F<0xF6, "test", Xi8 , X86testpat, MRM0r>;
def TEST16ri : BinOpRI_F<0xF6, "test", Xi16, X86testpat, MRM0r>;
def TEST32ri : BinOpRI_F<0xF6, "test", Xi32, X86testpat, MRM0r>;
def TEST64ri32 : BinOpRI_F<0xF6, "test", Xi64, X86testpat, MRM0r>;
def TEST16ri : BinOpRI_F<0xF7, "test", Xi16, X86testpat, MRM0r>;
def TEST32ri : BinOpRI_F<0xF7, "test", Xi32, X86testpat, MRM0r>;
def TEST64ri32 : BinOpRI_F<0xF7, "test", Xi64, X86testpat, MRM0r>;

def TEST8mi : BinOpMI_F<0xF6, "test", Xi8 , X86testpat, MRM0m>;
def TEST16mi : BinOpMI_F<0xF6, "test", Xi16, X86testpat, MRM0m>;
def TEST32mi : BinOpMI_F<0xF6, "test", Xi32, X86testpat, MRM0m>;
def TEST16mi : BinOpMI_F<0xF7, "test", Xi16, X86testpat, MRM0m>;
def TEST32mi : BinOpMI_F<0xF7, "test", Xi32, X86testpat, MRM0m>;

let Predicates = [In64BitMode] in
def TEST64mi32 : BinOpMI_F<0xF6, "test", Xi64, X86testpat, MRM0m>;
def TEST64mi32 : BinOpMI_F<0xF7, "test", Xi64, X86testpat, MRM0m>;

def TEST8i8 : BinOpAI_F<0xA8, "test", Xi8 , AL, "{$src, %al|al, $src}">;
def TEST16i16 : BinOpAI_F<0xA8, "test", Xi16, AX, "{$src, %ax|ax, $src}">;
def TEST32i32 : BinOpAI_F<0xA8, "test", Xi32, EAX, "{$src, %eax|eax, $src}">;
def TEST64i32 : BinOpAI_F<0xA8, "test", Xi64, RAX, "{$src, %rax|rax, $src}">;
def TEST16i16 : BinOpAI_F<0xA9, "test", Xi16, AX, "{$src, %ax|ax, $src}">;
def TEST32i32 : BinOpAI_F<0xA9, "test", Xi32, EAX, "{$src, %eax|eax, $src}">;
def TEST64i32 : BinOpAI_F<0xA9, "test", Xi64, RAX, "{$src, %rax|rax, $src}">;
} // isCompare

// Patterns to match a relocImm into the immediate field.
Expand Down Expand Up @@ -1189,38 +1188,35 @@ let Uses = [RDX] in
//
// We don't have patterns for these as there is no advantage over ADC for
// most code.
class ADCOXOpRR <bits<8> opcode, string mnemonic, X86TypeInfo info>
: BinOpRR_RF<opcode, mnemonic, info, null_frag> {
let Opcode = opcode;
class ADCOXOpRR <string m, X86TypeInfo t>
: BinOpRR_RF<0xF6, m, t, null_frag> {
let OpSize = OpSizeFixed;
let Form = MRMSrcReg;
let isCommutable = 1;
}

class ADCOXOpRM <bits<8> opcode, string mnemonic, X86TypeInfo info>
: BinOpRM_RF<opcode, mnemonic, info, null_frag> {
let Opcode = opcode;
class ADCOXOpRM <string m, X86TypeInfo t>
: BinOpRM_RF<0xF6, m, t, null_frag> {
let OpSize = OpSizeFixed;
let Form = MRMSrcMem;
}

let Predicates = [HasADX], Constraints = "$src1 = $dst" in {
let SchedRW = [WriteADC], isCommutable = 1 in {
def ADCX32rr : ADCOXOpRR<0xF6, "adcx", Xi32>, T8PD;
def ADCX64rr : ADCOXOpRR<0xF6, "adcx", Xi64>, T8PD;

def ADOX32rr : ADCOXOpRR<0xF6, "adox", Xi32>, T8XS;
def ADOX64rr : ADCOXOpRR<0xF6, "adox", Xi64>, T8XS;
let SchedRW = [WriteADC] in {
def ADCX32rr : ADCOXOpRR<"adcx", Xi32>, T8PD;
def ADCX64rr : ADCOXOpRR<"adcx", Xi64>, T8PD;
def ADOX32rr : ADCOXOpRR<"adox", Xi32>, T8XS;
def ADOX64rr : ADCOXOpRR<"adox", Xi64>, T8XS;
}

let SchedRW = [WriteADC.Folded, WriteADC.ReadAfterFold,
// Memory operand.
ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault,
// Implicit read of EFLAGS
WriteADC.ReadAfterFold] in {
def ADCX32rm : ADCOXOpRM<0xF6, "adcx", Xi32>, T8PD;
def ADCX64rm : ADCOXOpRM<0xF6, "adcx", Xi64>, T8PD;

def ADOX32rm : ADCOXOpRM<0xF6, "adox", Xi32>, T8XS;
def ADOX64rm : ADCOXOpRM<0xF6, "adox", Xi64>, T8XS;
def ADCX32rm : ADCOXOpRM<"adcx", Xi32>, T8PD;
def ADCX64rm : ADCOXOpRM<"adcx", Xi64>, T8PD;
def ADOX32rm : ADCOXOpRM<"adox", Xi32>, T8XS;
def ADOX64rm : ADCOXOpRM<"adox", Xi64>, T8XS;
}
}
22 changes: 11 additions & 11 deletions llvm/lib/Target/X86/X86InstrUtils.td
View file
Original file line number Diff line number Diff line change
Expand Up @@ -147,7 +147,7 @@ class X86TypeInfo<ValueType vt, string instrsuffix, RegisterClass regclass,
Operand immoperand, SDPatternOperator immoperator,
SDPatternOperator immnosuoperator, Operand imm8operand,
SDPatternOperator imm8operator, SDPatternOperator imm8nosuoperator,
bit hasOddOpcode, OperandSize opSize,
bit hasEvenOpcode, OperandSize opSize,
bit hasREX_W> {
/// VT - This is the value type itself.
ValueType VT = vt;
Expand Down Expand Up @@ -197,10 +197,10 @@ class X86TypeInfo<ValueType vt, string instrsuffix, RegisterClass regclass,

SDPatternOperator Imm8NoSuOperator = imm8nosuoperator;

/// HasOddOpcode - This bit is true if the instruction should have an odd (as
/// opposed to even) opcode. Operations on i8 are usually even, operations on
/// other datatypes are odd.
bit HasOddOpcode = hasOddOpcode;
/// HasEvenOpcode - This bit is true if the instruction should have an even (as
/// opposed to odd) opcode. Operations on i8 are even, operations on
/// other datatypes are usually odd.
bit HasEvenOpcode = hasEvenOpcode;

/// OpSize - Selects whether the instruction needs a 0x66 prefix based on
/// 16-bit vs 32-bit mode. i8/i64 set this to OpSizeFixed. i16 sets this
Expand All @@ -216,16 +216,16 @@ def invalid_node : SDNode<"<<invalid_node>>", SDTIntLeaf,[],"<<invalid_node>>">;

def Xi8 : X86TypeInfo<i8, "b", GR8, loadi8, i8mem, Imm8, i8imm,
imm_su, imm, i8imm, invalid_node, invalid_node,
0, OpSizeFixed, 0>;
1, OpSizeFixed, 0>;
def Xi16 : X86TypeInfo<i16, "w", GR16, loadi16, i16mem, Imm16, i16imm,
imm_su, imm, i16i8imm, i16immSExt8_su, i16immSExt8,
1, OpSize16, 0>;
0, OpSize16, 0>;
def Xi32 : X86TypeInfo<i32, "l", GR32, loadi32, i32mem, Imm32, i32imm,
imm_su, imm, i32i8imm, i32immSExt8_su, i32immSExt8,
1, OpSize32, 0>;
0, OpSize32, 0>;
def Xi64 : X86TypeInfo<i64, "q", GR64, loadi64, i64mem, Imm32S, i64i32imm,
i64immSExt32_su, i64immSExt32, i64i8imm, i64immSExt8_su,
i64immSExt8, 1, OpSizeFixed, 1>;
i64immSExt8, 0, OpSizeFixed, 1>;

// Group template arguments that can be derived from the vector type (EltNum x
// EltVT). These are things like the register class for the writemask, etc.
Expand Down Expand Up @@ -992,8 +992,8 @@ class MMXIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
class ITy<bits<8> opcode, Format f, X86TypeInfo typeinfo, dag outs, dag ins,
string mnemonic, string args, list<dag> pattern>
: I<{opcode{7}, opcode{6}, opcode{5}, opcode{4},
opcode{3}, opcode{2}, opcode{1}, typeinfo.HasOddOpcode },
f, outs, ins,
opcode{3}, opcode{2}, opcode{1},
!if(!eq(typeinfo.HasEvenOpcode, 1), 0, opcode{0})}, f, outs, ins,
!strconcat(mnemonic, "{", typeinfo.InstrSuffix, "}\t", args), pattern> {

let hasSideEffects = 0;
Expand Down

0 comments on commit 2fe94ce

Please sign in to comment.