multiclass CALL<WebAssemblyRegClass vt> {
def CALL_#vt : I<(outs vt:$dst), (ins global:$callee, variable_ops),
[(set vt:$dst, (WebAssemblycall1 (WebAssemblywrapper tglobaladdr:$callee)))],
- "call $callee, $dst">;
+ "call\t$callee, $dst">;
def CALL_INDIRECT_#vt : I<(outs vt:$dst), (ins I32:$callee, variable_ops),
[(set vt:$dst, (WebAssemblycall1 I32:$callee))],
- "call_indirect $callee, $dst">;
+ "call_indirect\t$callee, $dst">;
}
let Uses = [SP32, SP64], isCall = 1 in {
defm : CALL<I32>;
def CALL_VOID : I<(outs), (ins global:$callee, variable_ops),
[(WebAssemblycall0 (WebAssemblywrapper tglobaladdr:$callee))],
- "call $callee">;
+ "call\t$callee">;
def CALL_INDIRECT_VOID : I<(outs), (ins I32:$callee, variable_ops),
[(WebAssemblycall0 I32:$callee)],
- "call_indirect $callee">;
+ "call_indirect\t$callee">;
} // Uses = [SP32,SP64], isCall = 1
let isBranch = 1, isTerminator = 1, hasCtrlDep = 1 in {
def BR_IF : I<(outs), (ins bb_op:$dst, I32:$a),
[(brcond I32:$a, bb:$dst)],
- "br_if $dst, $a">;
+ "br_if\t$dst, $a">;
let isBarrier = 1 in {
def BR : I<(outs), (ins bb_op:$dst),
[(br bb:$dst)],
- "br $dst">;
+ "br\t$dst">;
} // isBarrier = 1
} // isBranch = 1, isTerminator = 1, hasCtrlDep = 1
let isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
def SWITCH_I32 : I<(outs), (ins I32:$index, variable_ops),
[(WebAssemblyswitch I32:$index)],
- "switch $index">;
+ "switch\t$index">;
def SWITCH_I64 : I<(outs), (ins I64:$index, variable_ops),
[(WebAssemblyswitch I64:$index)],
- "switch $index">;
+ "switch\t$index">;
} // isTerminator = 1, hasCtrlDep = 1, isBarrier = 1
// Placemarkers to indicate the start of a block or loop scope.
-def BLOCK : I<(outs), (ins bb_op:$dst), [], "block $dst">;
-def LOOP : I<(outs), (ins bb_op:$dst), [], "loop $dst">;
+def BLOCK : I<(outs), (ins bb_op:$dst), [], "block\t$dst">;
+def LOOP : I<(outs), (ins bb_op:$dst), [], "loop\t$dst">;
multiclass RETURN<WebAssemblyRegClass vt> {
def RETURN_#vt : I<(outs), (ins vt:$val), [(WebAssemblyreturn vt:$val)],
- "return $val">;
+ "return\t$val">;
}
let isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
def I32_WRAP_I64 : I<(outs I32:$dst), (ins I64:$src),
[(set I32:$dst, (trunc I64:$src))],
- "i32.wrap/i64 $dst, $src">;
+ "i32.wrap/i64\t$dst, $src">;
def I64_EXTEND_S_I32 : I<(outs I64:$dst), (ins I32:$src),
[(set I64:$dst, (sext I32:$src))],
- "i64.extend_s/i32 $dst, $src">;
+ "i64.extend_s/i32\t$dst, $src">;
def I64_EXTEND_U_I32 : I<(outs I64:$dst), (ins I32:$src),
[(set I64:$dst, (zext I32:$src))],
- "i64.extend_u/i32 $dst, $src">;
+ "i64.extend_u/i32\t$dst, $src">;
def I32_TRUNC_S_F32 : I<(outs I32:$dst), (ins F32:$src),
[(set I32:$dst, (fp_to_sint F32:$src))],
- "i32.trunc_s/f32 $dst, $src">;
+ "i32.trunc_s/f32\t$dst, $src">;
def I32_TRUNC_U_F32 : I<(outs I32:$dst), (ins F32:$src),
[(set I32:$dst, (fp_to_uint F32:$src))],
- "i32.trunc_u/f32 $dst, $src">;
+ "i32.trunc_u/f32\t$dst, $src">;
def I64_TRUNC_S_F32 : I<(outs I64:$dst), (ins F32:$src),
[(set I64:$dst, (fp_to_sint F32:$src))],
- "i64.trunc_s/f32 $dst, $src">;
+ "i64.trunc_s/f32\t$dst, $src">;
def I64_TRUNC_U_F32 : I<(outs I64:$dst), (ins F32:$src),
[(set I64:$dst, (fp_to_uint F32:$src))],
- "i64.trunc_u/f32 $dst, $src">;
+ "i64.trunc_u/f32\t$dst, $src">;
def I32_TRUNC_S_F64 : I<(outs I32:$dst), (ins F64:$src),
[(set I32:$dst, (fp_to_sint F64:$src))],
- "i32.trunc_s/f64 $dst, $src">;
+ "i32.trunc_s/f64\t$dst, $src">;
def I32_TRUNC_U_F64 : I<(outs I32:$dst), (ins F64:$src),
[(set I32:$dst, (fp_to_uint F64:$src))],
- "i32.trunc_u/f64 $dst, $src">;
+ "i32.trunc_u/f64\t$dst, $src">;
def I64_TRUNC_S_F64 : I<(outs I64:$dst), (ins F64:$src),
[(set I64:$dst, (fp_to_sint F64:$src))],
- "i64.trunc_s/f64 $dst, $src">;
+ "i64.trunc_s/f64\t$dst, $src">;
def I64_TRUNC_U_F64 : I<(outs I64:$dst), (ins F64:$src),
[(set I64:$dst, (fp_to_uint F64:$src))],
- "i64.trunc_u/f64 $dst, $src">;
+ "i64.trunc_u/f64\t$dst, $src">;
def F32_CONVERT_S_I32 : I<(outs F32:$dst), (ins I32:$src),
[(set F32:$dst, (sint_to_fp I32:$src))],
- "f32.convert_s/i32 $dst, $src">;
+ "f32.convert_s/i32\t$dst, $src">;
def F32_CONVERT_U_I32 : I<(outs F32:$dst), (ins I32:$src),
[(set F32:$dst, (uint_to_fp I32:$src))],
- "f32.convert_u/i32 $dst, $src">;
+ "f32.convert_u/i32\t$dst, $src">;
def F64_CONVERT_S_I32 : I<(outs F64:$dst), (ins I32:$src),
[(set F64:$dst, (sint_to_fp I32:$src))],
- "f64.convert_s/i32 $dst, $src">;
+ "f64.convert_s/i32\t$dst, $src">;
def F64_CONVERT_U_I32 : I<(outs F64:$dst), (ins I32:$src),
[(set F64:$dst, (uint_to_fp I32:$src))],
- "f64.convert_u/i32 $dst, $src">;
+ "f64.convert_u/i32\t$dst, $src">;
def F32_CONVERT_S_I64 : I<(outs F32:$dst), (ins I64:$src),
[(set F32:$dst, (sint_to_fp I64:$src))],
- "f32.convert_s/i64 $dst, $src">;
+ "f32.convert_s/i64\t$dst, $src">;
def F32_CONVERT_U_I64 : I<(outs F32:$dst), (ins I64:$src),
[(set F32:$dst, (uint_to_fp I64:$src))],
- "f32.convert_u/i64 $dst, $src">;
+ "f32.convert_u/i64\t$dst, $src">;
def F64_CONVERT_S_I64 : I<(outs F64:$dst), (ins I64:$src),
[(set F64:$dst, (sint_to_fp I64:$src))],
- "f64.convert_s/i64 $dst, $src">;
+ "f64.convert_s/i64\t$dst, $src">;
def F64_CONVERT_U_I64 : I<(outs F64:$dst), (ins I64:$src),
[(set F64:$dst, (uint_to_fp I64:$src))],
- "f64.convert_u/i64 $dst, $src">;
+ "f64.convert_u/i64\t$dst, $src">;
def F64_PROMOTE_F32 : I<(outs F64:$dst), (ins F32:$src),
[(set F64:$dst, (fextend F32:$src))],
- "f64.promote/f32 $dst, $src">;
+ "f64.promote/f32\t$dst, $src">;
def F32_DEMOTE_F64 : I<(outs F32:$dst), (ins F64:$src),
[(set F32:$dst, (fround F64:$src))],
- "f32.demote/f64 $dst, $src">;
+ "f32.demote/f64\t$dst, $src">;
def I32_REINTERPRET_F32 : I<(outs I32:$dst), (ins F32:$src),
[(set I32:$dst, (bitconvert F32:$src))],
- "i32.reinterpret/f32 $dst, $src">;
+ "i32.reinterpret/f32\t$dst, $src">;
def F32_REINTERPRET_I32 : I<(outs F32:$dst), (ins I32:$src),
[(set F32:$dst, (bitconvert I32:$src))],
- "f32.reinterpret/i32 $dst, $src">;
+ "f32.reinterpret/i32\t$dst, $src">;
def I64_REINTERPRET_F64 : I<(outs I64:$dst), (ins F64:$src),
[(set I64:$dst, (bitconvert F64:$src))],
- "i64.reinterpret/f64 $dst, $src">;
+ "i64.reinterpret/f64\t$dst, $src">;
def F64_REINTERPRET_I64 : I<(outs F64:$dst), (ins I64:$src),
[(set F64:$dst, (bitconvert I64:$src))],
- "f64.reinterpret/i64 $dst, $src">;
+ "f64.reinterpret/i64\t$dst, $src">;
def SELECT_F32 : I<(outs F32:$dst), (ins I32:$cond, F32:$lhs, F32:$rhs),
[(set F32:$dst, (select I32:$cond, F32:$lhs, F32:$rhs))],
- "f32.select $dst, $cond, $lhs, $rhs">;
+ "f32.select\t$dst, $cond, $lhs, $rhs">;
def SELECT_F64 : I<(outs F64:$dst), (ins I32:$cond, F64:$lhs, F64:$rhs),
[(set F64:$dst, (select I32:$cond, F64:$lhs, F64:$rhs))],
- "f64.select $dst, $cond, $lhs, $rhs">;
+ "f64.select\t$dst, $cond, $lhs, $rhs">;
multiclass UnaryInt<SDNode node, string name> {
def _I32 : I<(outs I32:$dst), (ins I32:$src),
[(set I32:$dst, (node I32:$src))],
- !strconcat("i32.", !strconcat(name, " $dst, $src"))>;
+ !strconcat("i32.", !strconcat(name, "\t$dst, $src"))>;
def _I64 : I<(outs I64:$dst), (ins I64:$src),
[(set I64:$dst, (node I64:$src))],
- !strconcat("i64.", !strconcat(name, " $dst, $src"))>;
+ !strconcat("i64.", !strconcat(name, "\t$dst, $src"))>;
}
multiclass BinaryInt<SDNode node, string name> {
def _I32 : I<(outs I32:$dst), (ins I32:$lhs, I32:$rhs),
[(set I32:$dst, (node I32:$lhs, I32:$rhs))],
- !strconcat("i32.", !strconcat(name, " $dst, $lhs, $rhs"))>;
+ !strconcat("i32.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
def _I64 : I<(outs I64:$dst), (ins I64:$lhs, I64:$rhs),
[(set I64:$dst, (node I64:$lhs, I64:$rhs))],
- !strconcat("i64.", !strconcat(name, " $dst, $lhs, $rhs"))>;
+ !strconcat("i64.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
}
multiclass UnaryFP<SDNode node, string name> {
def _F32 : I<(outs F32:$dst), (ins F32:$src),
[(set F32:$dst, (node F32:$src))],
- !strconcat("f32.", !strconcat(name, " $dst, $src"))>;
+ !strconcat("f32.", !strconcat(name, "\t$dst, $src"))>;
def _F64 : I<(outs F64:$dst), (ins F64:$src),
[(set F64:$dst, (node F64:$src))],
- !strconcat("f64.", !strconcat(name, " $dst, $src"))>;
+ !strconcat("f64.", !strconcat(name, "\t$dst, $src"))>;
}
multiclass BinaryFP<SDNode node, string name> {
def _F32 : I<(outs F32:$dst), (ins F32:$lhs, F32:$rhs),
[(set F32:$dst, (node F32:$lhs, F32:$rhs))],
- !strconcat("f32.", !strconcat(name, " $dst, $lhs, $rhs"))>;
+ !strconcat("f32.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
def _F64 : I<(outs F64:$dst), (ins F64:$lhs, F64:$rhs),
[(set F64:$dst, (node F64:$lhs, F64:$rhs))],
- !strconcat("f64.", !strconcat(name, " $dst, $lhs, $rhs"))>;
+ !strconcat("f64.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
}
multiclass ComparisonInt<CondCode cond, string name> {
def _I32 : I<(outs I32:$dst), (ins I32:$lhs, I32:$rhs),
[(set I32:$dst, (setcc I32:$lhs, I32:$rhs, cond))],
- !strconcat("i32.", !strconcat(name, " $dst, $lhs, $rhs"))>;
+ !strconcat("i32.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
def _I64 : I<(outs I32:$dst), (ins I64:$lhs, I64:$rhs),
[(set I32:$dst, (setcc I64:$lhs, I64:$rhs, cond))],
- !strconcat("i64.", !strconcat(name, " $dst, $lhs, $rhs"))>;
+ !strconcat("i64.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
}
multiclass ComparisonFP<CondCode cond, string name> {
def _F32 : I<(outs I32:$dst), (ins F32:$lhs, F32:$rhs),
[(set I32:$dst, (setcc F32:$lhs, F32:$rhs, cond))],
- !strconcat("f32.", !strconcat(name, " $dst, $lhs, $rhs"))>;
+ !strconcat("f32.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
def _F64 : I<(outs I32:$dst), (ins F64:$lhs, F64:$rhs),
[(set I32:$dst, (setcc F64:$lhs, F64:$rhs, cond))],
- !strconcat("f64.", !strconcat(name, " $dst, $lhs, $rhs"))>;
+ !strconcat("f64.", !strconcat(name, "\t$dst, $lhs, $rhs"))>;
}
def CONST_I32 : I<(outs I32:$res), (ins i32imm:$imm),
[(set I32:$res, imm:$imm)],
- "i32.const $res, $imm">;
+ "i32.const\t$res, $imm">;
def CONST_I64 : I<(outs I64:$res), (ins i64imm:$imm),
[(set I64:$res, imm:$imm)],
- "i64.const $res, $imm">;
+ "i64.const\t$res, $imm">;
def CONST_F32 : I<(outs F32:$res), (ins f32imm:$imm),
[(set F32:$res, fpimm:$imm)],
- "f32.const $res, $imm">;
+ "f32.const\t$res, $imm">;
def CONST_F64 : I<(outs F64:$res), (ins f64imm:$imm),
[(set F64:$res, fpimm:$imm)],
- "f64.const $res, $imm">;
+ "f64.const\t$res, $imm">;
// Special types of immediates. FIXME: Hard-coded as 32-bit for now.
def GLOBAL : I<(outs I32:$dst), (ins global:$addr),
[(set I32:$dst, (WebAssemblywrapper tglobaladdr:$addr))],
- "global $dst, $addr">;
+ "global\t$dst, $addr">;
def JUMP_TABLE : I<(outs I32:$dst), (ins tjumptable_op:$addr),
[(set I32:$dst, (WebAssemblywrapper tjumptable:$addr))],
- "jump_table $dst, $addr">;
+ "jump_table\t$dst, $addr">;
//===----------------------------------------------------------------------===//
// Additional sets of instructions.
def SELECT_I32 : I<(outs I32:$dst), (ins I32:$cond, I32:$lhs, I32:$rhs),
[(set I32:$dst, (select I32:$cond, I32:$lhs, I32:$rhs))],
- "i32.select $dst, $cond, $lhs, $rhs">;
+ "i32.select\t$dst, $cond, $lhs, $rhs">;
def SELECT_I64 : I<(outs I64:$dst), (ins I32:$cond, I64:$lhs, I64:$rhs),
[(set I64:$dst, (select I32:$cond, I64:$lhs, I64:$rhs))],
- "i64.select $dst, $cond, $lhs, $rhs">;
+ "i64.select\t$dst, $cond, $lhs, $rhs">;
// Basic load.
def LOAD_I32 : I<(outs I32:$dst), (ins I32:$addr),
[(set I32:$dst, (load I32:$addr))],
- "i32.load $dst, $addr">;
+ "i32.load\t$dst, $addr">;
def LOAD_I64 : I<(outs I64:$dst), (ins I32:$addr),
[(set I64:$dst, (load I32:$addr))],
- "i64.load $dst, $addr">;
+ "i64.load\t$dst, $addr">;
def LOAD_F32 : I<(outs F32:$dst), (ins I32:$addr),
[(set F32:$dst, (load I32:$addr))],
- "f32.load $dst, $addr">;
+ "f32.load\t$dst, $addr">;
def LOAD_F64 : I<(outs F64:$dst), (ins I32:$addr),
[(set F64:$dst, (load I32:$addr))],
- "f64.load $dst, $addr">;
+ "f64.load\t$dst, $addr">;
// Extending load.
def LOAD8_S_I32 : I<(outs I32:$dst), (ins I32:$addr),
[(set I32:$dst, (sextloadi8 I32:$addr))],
- "i32.load8_s $dst, $addr">;
+ "i32.load8_s\t$dst, $addr">;
def LOAD8_U_I32 : I<(outs I32:$dst), (ins I32:$addr),
[(set I32:$dst, (zextloadi8 I32:$addr))],
- "i32.load8_u $dst, $addr">;
+ "i32.load8_u\t$dst, $addr">;
def LOAD16_S_I32 : I<(outs I32:$dst), (ins I32:$addr),
[(set I32:$dst, (sextloadi16 I32:$addr))],
- "i32.load16_s $dst, $addr">;
+ "i32.load16_s\t$dst, $addr">;
def LOAD16_U_I32 : I<(outs I32:$dst), (ins I32:$addr),
[(set I32:$dst, (zextloadi16 I32:$addr))],
- "i32.load16_u $dst, $addr">;
+ "i32.load16_u\t$dst, $addr">;
def LOAD8_S_I64 : I<(outs I64:$dst), (ins I32:$addr),
[(set I64:$dst, (sextloadi8 I32:$addr))],
- "i64.load8_s $dst, $addr">;
+ "i64.load8_s\t$dst, $addr">;
def LOAD8_U_I64 : I<(outs I64:$dst), (ins I32:$addr),
[(set I64:$dst, (zextloadi8 I32:$addr))],
- "i64.load8_u $dst, $addr">;
+ "i64.load8_u\t$dst, $addr">;
def LOAD16_S_I64 : I<(outs I64:$dst), (ins I32:$addr),
[(set I64:$dst, (sextloadi16 I32:$addr))],
- "i64.load16_s $dst, $addr">;
+ "i64.load16_s\t$dst, $addr">;
def LOAD16_U_I64 : I<(outs I64:$dst), (ins I32:$addr),
[(set I64:$dst, (zextloadi16 I32:$addr))],
- "i64.load16_u $dst, $addr">;
+ "i64.load16_u\t$dst, $addr">;
def LOAD32_S_I64 : I<(outs I64:$dst), (ins I32:$addr),
[(set I64:$dst, (sextloadi32 I32:$addr))],
- "i64.load32_s $dst, $addr">;
+ "i64.load32_s\t$dst, $addr">;
def LOAD32_U_I64 : I<(outs I64:$dst), (ins I32:$addr),
[(set I64:$dst, (zextloadi32 I32:$addr))],
- "i64.load32_u $dst, $addr">;
+ "i64.load32_u\t$dst, $addr">;
// "Don't care" extending load become zero-extending load.
def : Pat<(i32 (extloadi8 I32:$addr)), (LOAD8_U_I32 $addr)>;
// Note: WebAssembly inverts SelectionDAG's usual operand order.
def STORE_I32 : I<(outs), (ins I32:$addr, I32:$val),
[(store i32:$val, I32:$addr)],
- "i32.store $addr, $val">;
+ "i32.store\t$addr, $val">;
def STORE_I64 : I<(outs), (ins I32:$addr, I64:$val),
[(store i64:$val, I32:$addr)],
- "i64.store $addr, $val">;
+ "i64.store\t$addr, $val">;
def STORE_F32 : I<(outs), (ins I32:$addr, F32:$val),
[(store f32:$val, I32:$addr)],
- "f32.store $addr, $val">;
+ "f32.store\t$addr, $val">;
def STORE_F64 : I<(outs), (ins I32:$addr, F64:$val),
[(store f64:$val, I32:$addr)],
- "f64.store $addr, $val">;
+ "f64.store\t$addr, $val">;
// Truncating store.
def STORE8_I32 : I<(outs), (ins I32:$addr, I32:$val),
[(truncstorei8 I32:$val, I32:$addr)],
- "i32.store8 $addr, $val">;
+ "i32.store8\t$addr, $val">;
def STORE16_I32 : I<(outs), (ins I32:$addr, I32:$val),
[(truncstorei16 I32:$val, I32:$addr)],
- "i32.store16 $addr, $val">;
+ "i32.store16\t$addr, $val">;
def STORE8_I64 : I<(outs), (ins I32:$addr, I64:$val),
[(truncstorei8 I64:$val, I32:$addr)],
- "i64.store8 $addr, $val">;
+ "i64.store8\t$addr, $val">;
def STORE16_I64 : I<(outs), (ins I32:$addr, I64:$val),
[(truncstorei16 I64:$val, I32:$addr)],
- "i64.store16 $addr, $val">;
+ "i64.store16\t$addr, $val">;
def STORE32_I64 : I<(outs), (ins I32:$addr, I64:$val),
[(truncstorei32 I64:$val, I32:$addr)],
- "i64.store32 $addr, $val">;
+ "i64.store32\t$addr, $val">;
// Memory size.
def MEMORY_SIZE_I32 : I<(outs I32:$dst), (ins),
[(set I32:$dst, (int_wasm_memory_size))],
- "i32.memory_size $dst">,
+ "i32.memory_size\t$dst">,
Requires<[HasAddr32]>;
def MEMORY_SIZE_I64 : I<(outs I64:$dst), (ins),
[(set I64:$dst, (int_wasm_memory_size))],
- "i64.memory_size $dst">,
+ "i64.memory_size\t$dst">,
Requires<[HasAddr64]>;
// Grow memory.
def GROW_MEMORY_I32 : I<(outs), (ins I32:$delta),
[(int_wasm_grow_memory I32:$delta)],
- "i32.grow_memory $delta">,
+ "i32.grow_memory\t$delta">,
Requires<[HasAddr32]>;
def GROW_MEMORY_I64 : I<(outs), (ins I64:$delta),
[(int_wasm_grow_memory I64:$delta)],
- "i64.grow_memory $delta">,
+ "i64.grow_memory\t$delta">,
Requires<[HasAddr64]>;
projects / oota-llvm.git / commitdiff