Skip to content
This repository was archived by the owner on Mar 28, 2020. It is now read-only.

Commit 6a6f29c

Browse files
author
Dan Gohman
committed
[WebAssembly] Add binary-encoding opcode values to instruction descriptions.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@283389 91177308-0d34-0410-b5e6-96231b3b80d8
1 parent ba129eb commit 6a6f29c

8 files changed

+147
-133
lines changed

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -44,6 +44,10 @@ namespace WebAssembly {
4444
enum OperandType {
4545
/// Basic block label in a branch construct.
4646
OPERAND_BASIC_BLOCK = MCOI::OPERAND_FIRST_TARGET,
47+
/// 32-bit integer immediates.
48+
OPERAND_I32IMM,
49+
/// 64-bit integer immediates.
50+
OPERAND_I64IMM,
4751
/// 32-bit floating-point immediates.
4852
OPERAND_F32IMM,
4953
/// 64-bit floating-point immediates.

lib/Target/WebAssembly/WebAssemblyInstrControl.td

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -18,14 +18,13 @@ let isBranch = 1, isTerminator = 1, hasCtrlDep = 1 in {
1818
// The condition operand is a boolean value which WebAssembly represents as i32.
1919
def BR_IF : I<(outs), (ins bb_op:$dst, I32:$cond),
2020
[(brcond I32:$cond, bb:$dst)],
21-
"br_if \t$dst, $cond">;
21+
"br_if \t$dst, $cond", 0x07>;
2222
let isCodeGenOnly = 1 in
23-
def BR_UNLESS : I<(outs), (ins bb_op:$dst, I32:$cond), [],
24-
"br_unless\t$dst, $cond">;
23+
def BR_UNLESS : I<(outs), (ins bb_op:$dst, I32:$cond), []>;
2524
let isBarrier = 1 in {
2625
def BR : I<(outs), (ins bb_op:$dst),
2726
[(br bb:$dst)],
28-
"br \t$dst">;
27+
"br \t$dst", 0x06>;
2928
} // isBarrier = 1
3029
} // isBranch = 1, isTerminator = 1, hasCtrlDep = 1
3130

@@ -46,7 +45,7 @@ let Defs = [ARGUMENTS] in {
4645
let isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
4746
def BR_TABLE_I32 : I<(outs), (ins I32:$index, variable_ops),
4847
[(WebAssemblybr_table I32:$index)],
49-
"br_table \t$index"> {
48+
"br_table \t$index", 0x08> {
5049
let TSFlags{0} = 1;
5150
let TSFlags{1} = 1;
5251
}
@@ -62,8 +61,8 @@ def BR_TABLE_I64 : I<(outs), (ins I64:$index, variable_ops),
6261
// use/clobber VALUE_STACK to prevent them from being moved into the middle of
6362
// an expression tree.
6463
let Uses = [VALUE_STACK], Defs = [VALUE_STACK] in {
65-
def BLOCK : I<(outs), (ins), [], "block">;
66-
def LOOP : I<(outs), (ins), [], "loop">;
64+
def BLOCK : I<(outs), (ins), [], "block", 0x01>;
65+
def LOOP : I<(outs), (ins), [], "loop", 0x02>;
6766
def END_BLOCK : I<(outs), (ins), [], "end_block">;
6867
def END_LOOP : I<(outs), (ins), [], "end_loop">;
6968
} // Uses = [VALUE_STACK], Defs = [VALUE_STACK]

lib/Target/WebAssembly/WebAssemblyInstrConv.td

Lines changed: 25 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -17,14 +17,14 @@ let Defs = [ARGUMENTS] in {
1717

1818
def I32_WRAP_I64 : I<(outs I32:$dst), (ins I64:$src),
1919
[(set I32:$dst, (trunc I64:$src))],
20-
"i32.wrap/i64\t$dst, $src">;
20+
"i32.wrap/i64\t$dst, $src", 0xa1>;
2121

2222
def I64_EXTEND_S_I32 : I<(outs I64:$dst), (ins I32:$src),
2323
[(set I64:$dst, (sext I32:$src))],
24-
"i64.extend_s/i32\t$dst, $src">;
24+
"i64.extend_s/i32\t$dst, $src", 0xa6>;
2525
def I64_EXTEND_U_I32 : I<(outs I64:$dst), (ins I32:$src),
2626
[(set I64:$dst, (zext I32:$src))],
27-
"i64.extend_u/i32\t$dst, $src">;
27+
"i64.extend_u/i32\t$dst, $src", 0xa7>;
2828

2929
} // defs = [ARGUMENTS]
3030

@@ -39,73 +39,73 @@ let Defs = [ARGUMENTS] in {
3939
let hasSideEffects = 1 in {
4040
def I32_TRUNC_S_F32 : I<(outs I32:$dst), (ins F32:$src),
4141
[(set I32:$dst, (fp_to_sint F32:$src))],
42-
"i32.trunc_s/f32\t$dst, $src">;
42+
"i32.trunc_s/f32\t$dst, $src", 0x9d>;
4343
def I32_TRUNC_U_F32 : I<(outs I32:$dst), (ins F32:$src),
4444
[(set I32:$dst, (fp_to_uint F32:$src))],
45-
"i32.trunc_u/f32\t$dst, $src">;
45+
"i32.trunc_u/f32\t$dst, $src", 0x9f>;
4646
def I64_TRUNC_S_F32 : I<(outs I64:$dst), (ins F32:$src),
4747
[(set I64:$dst, (fp_to_sint F32:$src))],
48-
"i64.trunc_s/f32\t$dst, $src">;
48+
"i64.trunc_s/f32\t$dst, $src", 0xa2>;
4949
def I64_TRUNC_U_F32 : I<(outs I64:$dst), (ins F32:$src),
5050
[(set I64:$dst, (fp_to_uint F32:$src))],
51-
"i64.trunc_u/f32\t$dst, $src">;
51+
"i64.trunc_u/f32\t$dst, $src", 0xa4>;
5252
def I32_TRUNC_S_F64 : I<(outs I32:$dst), (ins F64:$src),
5353
[(set I32:$dst, (fp_to_sint F64:$src))],
54-
"i32.trunc_s/f64\t$dst, $src">;
54+
"i32.trunc_s/f64\t$dst, $src", 0x9e>;
5555
def I32_TRUNC_U_F64 : I<(outs I32:$dst), (ins F64:$src),
5656
[(set I32:$dst, (fp_to_uint F64:$src))],
57-
"i32.trunc_u/f64\t$dst, $src">;
57+
"i32.trunc_u/f64\t$dst, $src", 0xa0>;
5858
def I64_TRUNC_S_F64 : I<(outs I64:$dst), (ins F64:$src),
5959
[(set I64:$dst, (fp_to_sint F64:$src))],
60-
"i64.trunc_s/f64\t$dst, $src">;
60+
"i64.trunc_s/f64\t$dst, $src", 0xa3>;
6161
def I64_TRUNC_U_F64 : I<(outs I64:$dst), (ins F64:$src),
6262
[(set I64:$dst, (fp_to_uint F64:$src))],
63-
"i64.trunc_u/f64\t$dst, $src">;
63+
"i64.trunc_u/f64\t$dst, $src", 0xa5>;
6464
} // hasSideEffects = 1
6565

6666
def F32_CONVERT_S_I32 : I<(outs F32:$dst), (ins I32:$src),
6767
[(set F32:$dst, (sint_to_fp I32:$src))],
68-
"f32.convert_s/i32\t$dst, $src">;
68+
"f32.convert_s/i32\t$dst, $src", 0xa8>;
6969
def F32_CONVERT_U_I32 : I<(outs F32:$dst), (ins I32:$src),
7070
[(set F32:$dst, (uint_to_fp I32:$src))],
71-
"f32.convert_u/i32\t$dst, $src">;
71+
"f32.convert_u/i32\t$dst, $src", 0xa9>;
7272
def F64_CONVERT_S_I32 : I<(outs F64:$dst), (ins I32:$src),
7373
[(set F64:$dst, (sint_to_fp I32:$src))],
74-
"f64.convert_s/i32\t$dst, $src">;
74+
"f64.convert_s/i32\t$dst, $src", 0xae>;
7575
def F64_CONVERT_U_I32 : I<(outs F64:$dst), (ins I32:$src),
7676
[(set F64:$dst, (uint_to_fp I32:$src))],
77-
"f64.convert_u/i32\t$dst, $src">;
77+
"f64.convert_u/i32\t$dst, $src", 0xaf>;
7878
def F32_CONVERT_S_I64 : I<(outs F32:$dst), (ins I64:$src),
7979
[(set F32:$dst, (sint_to_fp I64:$src))],
80-
"f32.convert_s/i64\t$dst, $src">;
80+
"f32.convert_s/i64\t$dst, $src", 0xaa>;
8181
def F32_CONVERT_U_I64 : I<(outs F32:$dst), (ins I64:$src),
8282
[(set F32:$dst, (uint_to_fp I64:$src))],
83-
"f32.convert_u/i64\t$dst, $src">;
83+
"f32.convert_u/i64\t$dst, $src", 0xab>;
8484
def F64_CONVERT_S_I64 : I<(outs F64:$dst), (ins I64:$src),
8585
[(set F64:$dst, (sint_to_fp I64:$src))],
86-
"f64.convert_s/i64\t$dst, $src">;
86+
"f64.convert_s/i64\t$dst, $src", 0xb0>;
8787
def F64_CONVERT_U_I64 : I<(outs F64:$dst), (ins I64:$src),
8888
[(set F64:$dst, (uint_to_fp I64:$src))],
89-
"f64.convert_u/i64\t$dst, $src">;
89+
"f64.convert_u/i64\t$dst, $src", 0xb1>;
9090

9191
def F64_PROMOTE_F32 : I<(outs F64:$dst), (ins F32:$src),
9292
[(set F64:$dst, (fpextend F32:$src))],
93-
"f64.promote/f32\t$dst, $src">;
93+
"f64.promote/f32\t$dst, $src", 0xb2>;
9494
def F32_DEMOTE_F64 : I<(outs F32:$dst), (ins F64:$src),
9595
[(set F32:$dst, (fpround F64:$src))],
96-
"f32.demote/f64\t$dst, $src">;
96+
"f32.demote/f64\t$dst, $src", 0xac>;
9797

9898
def I32_REINTERPRET_F32 : I<(outs I32:$dst), (ins F32:$src),
9999
[(set I32:$dst, (bitconvert F32:$src))],
100-
"i32.reinterpret/f32\t$dst, $src">;
100+
"i32.reinterpret/f32\t$dst, $src", 0xb4>;
101101
def F32_REINTERPRET_I32 : I<(outs F32:$dst), (ins I32:$src),
102102
[(set F32:$dst, (bitconvert I32:$src))],
103-
"f32.reinterpret/i32\t$dst, $src">;
103+
"f32.reinterpret/i32\t$dst, $src", 0xad>;
104104
def I64_REINTERPRET_F64 : I<(outs I64:$dst), (ins F64:$src),
105105
[(set I64:$dst, (bitconvert F64:$src))],
106-
"i64.reinterpret/f64\t$dst, $src">;
106+
"i64.reinterpret/f64\t$dst, $src", 0xb5>;
107107
def F64_REINTERPRET_I64 : I<(outs F64:$dst), (ins I64:$src),
108108
[(set F64:$dst, (bitconvert I64:$src))],
109-
"f64.reinterpret/i64\t$dst, $src">;
109+
"f64.reinterpret/i64\t$dst, $src", 0xb3>;
110110

111111
} // Defs = [ARGUMENTS]

lib/Target/WebAssembly/WebAssemblyInstrFloat.td

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -15,26 +15,26 @@
1515
let Defs = [ARGUMENTS] in {
1616

1717
let isCommutable = 1 in
18-
defm ADD : BinaryFP<fadd, "add ">;
19-
defm SUB : BinaryFP<fsub, "sub ">;
18+
defm ADD : BinaryFP<fadd, "add ", 0x75, 0x89>;
19+
defm SUB : BinaryFP<fsub, "sub ", 0x76, 0x8a>;
2020
let isCommutable = 1 in
21-
defm MUL : BinaryFP<fmul, "mul ">;
22-
defm DIV : BinaryFP<fdiv, "div ">;
23-
defm SQRT : UnaryFP<fsqrt, "sqrt">;
21+
defm MUL : BinaryFP<fmul, "mul ", 0x77, 0x8b>;
22+
defm DIV : BinaryFP<fdiv, "div ", 0x78, 0x8c>;
23+
defm SQRT : UnaryFP<fsqrt, "sqrt", 0x82, 0x96>;
2424

25-
defm ABS : UnaryFP<fabs, "abs ">;
26-
defm NEG : UnaryFP<fneg, "neg ">;
27-
defm COPYSIGN : BinaryFP<fcopysign, "copysign">;
25+
defm ABS : UnaryFP<fabs, "abs ", 0x7b, 0x8f>;
26+
defm NEG : UnaryFP<fneg, "neg ", 0x7c, 0x90>;
27+
defm COPYSIGN : BinaryFP<fcopysign, "copysign", 0x7d, 0x91>;
2828

2929
let isCommutable = 1 in {
30-
defm MIN : BinaryFP<fminnan, "min ">;
31-
defm MAX : BinaryFP<fmaxnan, "max ">;
30+
defm MIN : BinaryFP<fminnan, "min ", 0x79, 0x8d>;
31+
defm MAX : BinaryFP<fmaxnan, "max ", 0x7a, 0x8e>;
3232
} // isCommutable = 1
3333

34-
defm CEIL : UnaryFP<fceil, "ceil">;
35-
defm FLOOR : UnaryFP<ffloor, "floor">;
36-
defm TRUNC : UnaryFP<ftrunc, "trunc">;
37-
defm NEAREST : UnaryFP<fnearbyint, "nearest">;
34+
defm CEIL : UnaryFP<fceil, "ceil", 0x7e, 0x92>;
35+
defm FLOOR : UnaryFP<ffloor, "floor", 0x7f, 0x93>;
36+
defm TRUNC : UnaryFP<ftrunc, "trunc", 0x80, 0x94>;
37+
defm NEAREST : UnaryFP<fnearbyint, "nearest", 0x81, 0x95>;
3838

3939
} // Defs = [ARGUMENTS]
4040

@@ -51,13 +51,13 @@ def : Pat<(frint f64:$src), (NEAREST_F64 f64:$src)>;
5151
let Defs = [ARGUMENTS] in {
5252

5353
let isCommutable = 1 in {
54-
defm EQ : ComparisonFP<SETOEQ, "eq ">;
55-
defm NE : ComparisonFP<SETUNE, "ne ">;
54+
defm EQ : ComparisonFP<SETOEQ, "eq ", 0x83, 0x97>;
55+
defm NE : ComparisonFP<SETUNE, "ne ", 0x84, 0x98>;
5656
} // isCommutable = 1
57-
defm LT : ComparisonFP<SETOLT, "lt ">;
58-
defm LE : ComparisonFP<SETOLE, "le ">;
59-
defm GT : ComparisonFP<SETOGT, "gt ">;
60-
defm GE : ComparisonFP<SETOGE, "ge ">;
57+
defm LT : ComparisonFP<SETOLT, "lt ", 0x85, 0x99>;
58+
defm LE : ComparisonFP<SETOLE, "le ", 0x86, 0x9a>;
59+
defm GT : ComparisonFP<SETOGT, "gt ", 0x87, 0x9b>;
60+
defm GE : ComparisonFP<SETOGE, "ge ", 0x88, 0x9c>;
6161

6262
} // Defs = [ARGUMENTS]
6363

lib/Target/WebAssembly/WebAssemblyInstrFormats.td

Lines changed: 29 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -13,56 +13,57 @@
1313
//===----------------------------------------------------------------------===//
1414

1515
// WebAssembly Instruction Format.
16-
class WebAssemblyInst<string asmstr> : Instruction {
17-
field bits<0> Inst; // Instruction encoding.
16+
class WebAssemblyInst<bits<32> inst, string asmstr> : Instruction {
17+
field bits<32> Inst = inst; // Instruction encoding.
1818
let Namespace = "WebAssembly";
1919
let Pattern = [];
2020
let AsmString = asmstr;
2121
}
2222

2323
// Normal instructions.
24-
class I<dag oops, dag iops, list<dag> pattern, string asmstr = "">
25-
: WebAssemblyInst<asmstr> {
24+
class I<dag oops, dag iops, list<dag> pattern, string asmstr = "", bits<32> inst = -1>
25+
: WebAssemblyInst<inst, asmstr> {
2626
dag OutOperandList = oops;
2727
dag InOperandList = iops;
2828
let Pattern = pattern;
2929
}
3030

31-
class SIMD_I<dag oops, dag iops, list<dag> pattern, string asmstr = "">
32-
: I<oops, iops, pattern, asmstr>, Requires<[HasSIMD128]>;
31+
class SIMD_I<dag oops, dag iops, list<dag> pattern,
32+
string asmstr = "", bits<32> inst = -1>
33+
: I<oops, iops, pattern, asmstr, inst>, Requires<[HasSIMD128]>;
3334

3435
// Unary and binary instructions, for the local types that WebAssembly supports.
35-
multiclass UnaryInt<SDNode node, string name> {
36+
multiclass UnaryInt<SDNode node, string name, bits<32> i32Inst, bits<32> i64Inst> {
3637
def _I32 : I<(outs I32:$dst), (ins I32:$src),
3738
[(set I32:$dst, (node I32:$src))],
38-
!strconcat("i32.", !strconcat(name, "\t$dst, $src"))>;
39+
!strconcat("i32.", !strconcat(name, "\t$dst, $src")), i32Inst>;
3940
def _I64 : I<(outs I64:$dst), (ins I64:$src),
4041
[(set I64:$dst, (node I64:$src))],
41-
!strconcat("i64.", !strconcat(name, "\t$dst, $src"))>;
42+
!strconcat("i64.", !strconcat(name, "\t$dst, $src")), i64Inst>;
4243
}
43-
multiclass BinaryInt<SDNode node, string name> {
44+
multiclass BinaryInt<SDNode node, string name, bits<32> i32Inst, bits<32> i64Inst> {
4445
def _I32 : I<(outs I32:$dst), (ins I32:$lhs, I32:$rhs),
4546
[(set I32:$dst, (node I32:$lhs, I32:$rhs))],
46-
!strconcat("i32.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
47+
!strconcat("i32.", !strconcat(name, "\t$dst, $lhs, $rhs")), i32Inst>;
4748
def _I64 : I<(outs I64:$dst), (ins I64:$lhs, I64:$rhs),
4849
[(set I64:$dst, (node I64:$lhs, I64:$rhs))],
49-
!strconcat("i64.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
50+
!strconcat("i64.", !strconcat(name, "\t$dst, $lhs, $rhs")), i64Inst>;
5051
}
51-
multiclass UnaryFP<SDNode node, string name> {
52+
multiclass UnaryFP<SDNode node, string name, bits<32> f32Inst, bits<32> f64Inst> {
5253
def _F32 : I<(outs F32:$dst), (ins F32:$src),
5354
[(set F32:$dst, (node F32:$src))],
54-
!strconcat("f32.", !strconcat(name, "\t$dst, $src"))>;
55+
!strconcat("f32.", !strconcat(name, "\t$dst, $src")), f32Inst>;
5556
def _F64 : I<(outs F64:$dst), (ins F64:$src),
5657
[(set F64:$dst, (node F64:$src))],
57-
!strconcat("f64.", !strconcat(name, "\t$dst, $src"))>;
58+
!strconcat("f64.", !strconcat(name, "\t$dst, $src")), f64Inst>;
5859
}
59-
multiclass BinaryFP<SDNode node, string name> {
60+
multiclass BinaryFP<SDNode node, string name, bits<32> f32Inst, bits<32> f64Inst> {
6061
def _F32 : I<(outs F32:$dst), (ins F32:$lhs, F32:$rhs),
6162
[(set F32:$dst, (node F32:$lhs, F32:$rhs))],
62-
!strconcat("f32.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
63+
!strconcat("f32.", !strconcat(name, "\t$dst, $lhs, $rhs")), f32Inst>;
6364
def _F64 : I<(outs F64:$dst), (ins F64:$lhs, F64:$rhs),
6465
[(set F64:$dst, (node F64:$lhs, F64:$rhs))],
65-
!strconcat("f64.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
66+
!strconcat("f64.", !strconcat(name, "\t$dst, $lhs, $rhs")), f64Inst>;
6667
}
6768
multiclass SIMDBinary<SDNode node, SDNode fnode, string name> {
6869
def _I8x16 : SIMD_I<(outs V128:$dst), (ins V128:$lhs, V128:$rhs),
@@ -79,19 +80,23 @@ multiclass SIMDBinary<SDNode node, SDNode fnode, string name> {
7980
!strconcat("f32x4.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
8081

8182
}
82-
multiclass ComparisonInt<CondCode cond, string name> {
83+
multiclass ComparisonInt<CondCode cond, string name, bits<32> i32Inst, bits<32> i64Inst> {
8384
def _I32 : I<(outs I32:$dst), (ins I32:$lhs, I32:$rhs),
8485
[(set I32:$dst, (setcc I32:$lhs, I32:$rhs, cond))],
85-
!strconcat("i32.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
86+
!strconcat("i32.", !strconcat(name, "\t$dst, $lhs, $rhs")),
87+
i32Inst>;
8688
def _I64 : I<(outs I32:$dst), (ins I64:$lhs, I64:$rhs),
8789
[(set I32:$dst, (setcc I64:$lhs, I64:$rhs, cond))],
88-
!strconcat("i64.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
90+
!strconcat("i64.", !strconcat(name, "\t$dst, $lhs, $rhs")),
91+
i64Inst>;
8992
}
90-
multiclass ComparisonFP<CondCode cond, string name> {
93+
multiclass ComparisonFP<CondCode cond, string name, bits<32> f32Inst, bits<32> f64Inst> {
9194
def _F32 : I<(outs I32:$dst), (ins F32:$lhs, F32:$rhs),
9295
[(set I32:$dst, (setcc F32:$lhs, F32:$rhs, cond))],
93-
!strconcat("f32.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
96+
!strconcat("f32.", !strconcat(name, "\t$dst, $lhs, $rhs")),
97+
f32Inst>;
9498
def _F64 : I<(outs I32:$dst), (ins F64:$lhs, F64:$rhs),
9599
[(set I32:$dst, (setcc F64:$lhs, F64:$rhs, cond))],
96-
!strconcat("f64.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
100+
!strconcat("f64.", !strconcat(name, "\t$dst, $lhs, $rhs")),
101+
f64Inst>;
97102
}

lib/Target/WebAssembly/WebAssemblyInstrInfo.td

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -71,6 +71,12 @@ let OperandNamespace = "WebAssembly" in {
7171
let OperandType = "OPERAND_BASIC_BLOCK" in
7272
def bb_op : Operand<OtherVT>;
7373

74+
let OperandType = "OPERAND_I32IMM" in
75+
def i32imm_op : Operand<i32>;
76+
77+
let OperandType = "OPERAND_I64IMM" in
78+
def i64imm_op : Operand<i64>;
79+
7480
let OperandType = "OPERAND_F32IMM" in
7581
def f32imm_op : Operand<f32>;
7682

@@ -144,10 +150,10 @@ defm : LOCAL<F64>;
144150
defm : LOCAL<V128>, Requires<[HasSIMD128]>;
145151

146152
let isMoveImm = 1, isAsCheapAsAMove = 1, isReMaterializable = 1 in {
147-
def CONST_I32 : I<(outs I32:$res), (ins i32imm:$imm),
153+
def CONST_I32 : I<(outs I32:$res), (ins i32imm_op:$imm),
148154
[(set I32:$res, imm:$imm)],
149155
"i32.const\t$res, $imm">;
150-
def CONST_I64 : I<(outs I64:$res), (ins i64imm:$imm),
156+
def CONST_I64 : I<(outs I64:$res), (ins i64imm_op:$imm),
151157
[(set I64:$res, imm:$imm)],
152158
"i64.const\t$res, $imm">;
153159
def CONST_F32 : I<(outs F32:$res), (ins f32imm_op:$imm),

0 commit comments

Comments
 (0)