mirror of
https://github.com/roc-lang/roc.git
synced 2025-08-04 12:18:19 +00:00
Delete pushes and pops for each instruction
This commit is contained in:
Brian Carroll
parent
b5d3af0522
commit
4b0c5fd0c6
1 changed files with 189 additions and 201 deletions
|
|
@ -5,7 +5,6 @@ use core::panic;
|
|||
use roc_wasm_module::linking::IndexRelocType;
|
||||
|
||||
use roc_error_macros::internal_error;
|
||||
use roc_module::symbol::Symbol;
|
||||
use roc_wasm_module::opcodes::{OpCode, OpCode::*};
|
||||
use roc_wasm_module::serialize::SerialBuffer;
|
||||
use roc_wasm_module::{
|
||||
|
|
@ -31,17 +30,17 @@ struct Insertion {
|
|||
}
|
||||
|
||||
macro_rules! instruction_no_args {
|
||||
($method_name: ident, $opcode: expr, $pops: expr, $push: expr) => {
|
||||
($method_name: ident, $opcode: expr) => {
|
||||
pub fn $method_name(&mut self) {
|
||||
self.inst($opcode, $pops, $push);
|
||||
self.inst($opcode);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! instruction_memargs {
|
||||
($method_name: ident, $opcode: expr, $pops: expr, $push: expr) => {
|
||||
($method_name: ident, $opcode: expr) => {
|
||||
pub fn $method_name(&mut self, align: Align, offset: u32) {
|
||||
self.inst_mem($opcode, $pops, $push, align, offset);
|
||||
self.inst_mem($opcode, align, offset);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
@ -268,19 +267,19 @@ impl<'a> CodeBuilder<'a> {
|
|||
|
||||
/// Base method for generating instructions
|
||||
/// Emits the opcode and simulates VM stack push/pop
|
||||
fn inst_base(&mut self, opcode: OpCode, pops: usize, push: bool) {
|
||||
fn inst_base(&mut self, opcode: OpCode) {
|
||||
self.code.push(opcode as u8);
|
||||
}
|
||||
|
||||
/// Plain instruction without any immediates
|
||||
fn inst(&mut self, opcode: OpCode, pops: usize, push: bool) {
|
||||
self.inst_base(opcode, pops, push);
|
||||
fn inst(&mut self, opcode: OpCode) {
|
||||
self.inst_base(opcode);
|
||||
log_instruction!("{opcode:?}");
|
||||
}
|
||||
|
||||
/// Block instruction
|
||||
fn inst_block(&mut self, opcode: OpCode, pops: usize) {
|
||||
self.inst_base(opcode, pops, false);
|
||||
fn inst_block(&mut self, opcode: OpCode) {
|
||||
self.inst_base(opcode);
|
||||
|
||||
// We don't support block result types. Too hard to track types through arbitrary control flow.
|
||||
// This results in slightly more instructions but not much. (Rust does the same thing!)
|
||||
|
|
@ -289,14 +288,14 @@ impl<'a> CodeBuilder<'a> {
|
|||
log_instruction!("{opcode:?}");
|
||||
}
|
||||
|
||||
fn inst_imm32(&mut self, opcode: OpCode, pops: usize, push: bool, immediate: u32) {
|
||||
self.inst_base(opcode, pops, push);
|
||||
fn inst_imm32(&mut self, opcode: OpCode, immediate: u32) {
|
||||
self.inst_base(opcode);
|
||||
self.code.encode_u32(immediate);
|
||||
log_instruction!("{:10}\t{}", format!("{opcode:?}"), immediate);
|
||||
}
|
||||
|
||||
fn inst_mem(&mut self, opcode: OpCode, pops: usize, push: bool, align: Align, offset: u32) {
|
||||
self.inst_base(opcode, pops, push);
|
||||
fn inst_mem(&mut self, opcode: OpCode, align: Align, offset: u32) {
|
||||
self.inst_base(opcode);
|
||||
self.code.push(align as u8);
|
||||
self.code.encode_u32(offset);
|
||||
log_instruction!("{:10} {:?} {}", format!("{opcode:?}"), align, offset);
|
||||
|
|
@ -312,59 +311,48 @@ impl<'a> CodeBuilder<'a> {
|
|||
|
||||
***********************************************************/
|
||||
|
||||
instruction_no_args!(unreachable_, UNREACHABLE, 0, false);
|
||||
instruction_no_args!(nop, NOP, 0, false);
|
||||
instruction_no_args!(unreachable_, UNREACHABLE);
|
||||
instruction_no_args!(nop, NOP);
|
||||
|
||||
pub fn block(&mut self) {
|
||||
self.inst_block(BLOCK, 0);
|
||||
self.inst_block(BLOCK);
|
||||
}
|
||||
pub fn loop_(&mut self) {
|
||||
self.inst_block(LOOP, 0);
|
||||
self.inst_block(LOOP);
|
||||
}
|
||||
pub fn if_(&mut self) {
|
||||
self.inst_block(IF, 1);
|
||||
self.inst_block(IF);
|
||||
}
|
||||
pub fn else_(&mut self) {
|
||||
self.inst(ELSE, 0, false);
|
||||
self.inst(ELSE);
|
||||
}
|
||||
|
||||
pub fn end(&mut self) {
|
||||
self.inst_base(END, 0, false);
|
||||
log_instruction!("END");
|
||||
self.inst(END);
|
||||
}
|
||||
pub fn br(&mut self, levels: u32) {
|
||||
self.inst_imm32(BR, 0, false, levels);
|
||||
self.inst_imm32(BR, levels);
|
||||
}
|
||||
pub fn br_if(&mut self, levels: u32) {
|
||||
// In dynamic execution, br_if can pop 2 values if condition is true and the target block has a result.
|
||||
// But our stack model is for *static* analysis and we need it to be correct at the next instruction,
|
||||
// where the branch was not taken. So we only pop 1 value, the condition.
|
||||
self.inst_imm32(BRIF, 1, false, levels);
|
||||
self.inst_imm32(BRIF, levels);
|
||||
}
|
||||
#[allow(dead_code)]
|
||||
fn br_table() {
|
||||
todo!("br instruction");
|
||||
unimplemented!("br_table instruction is not currently used");
|
||||
}
|
||||
|
||||
instruction_no_args!(return_, RETURN, 0, false);
|
||||
instruction_no_args!(return_, RETURN);
|
||||
|
||||
pub fn call(&mut self, function_index: u32, n_args: usize, has_return_val: bool) {
|
||||
self.call_impl(function_index, n_args, has_return_val, false)
|
||||
pub fn call(&mut self, function_index: u32, _n_args: usize, _has_return_val: bool) {
|
||||
self.call_impl(function_index, false)
|
||||
}
|
||||
|
||||
pub fn call_import(&mut self, function_index: u32, n_args: usize, has_return_val: bool) {
|
||||
self.call_impl(function_index, n_args, has_return_val, true)
|
||||
pub fn call_import(&mut self, function_index: u32, _n_args: usize, _has_return_val: bool) {
|
||||
self.call_impl(function_index, true)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn call_impl(
|
||||
&mut self,
|
||||
function_index: u32,
|
||||
n_args: usize,
|
||||
has_return_val: bool,
|
||||
is_import: bool,
|
||||
) {
|
||||
self.inst_base(CALL, n_args, has_return_val);
|
||||
fn call_impl(&mut self, function_index: u32, is_import: bool) {
|
||||
self.inst_base(CALL);
|
||||
|
||||
if is_import {
|
||||
self.import_relocations
|
||||
|
|
@ -382,14 +370,14 @@ impl<'a> CodeBuilder<'a> {
|
|||
);
|
||||
}
|
||||
|
||||
instruction_no_args!(drop_, DROP, 1, false);
|
||||
instruction_no_args!(select, SELECT, 3, true);
|
||||
instruction_no_args!(drop_, DROP);
|
||||
instruction_no_args!(select, SELECT);
|
||||
|
||||
pub fn get_local(&mut self, id: LocalId) {
|
||||
self.inst_imm32(GETLOCAL, 0, true, id.0);
|
||||
self.inst_imm32(GETLOCAL, id.0);
|
||||
}
|
||||
pub fn set_local(&mut self, id: LocalId) {
|
||||
self.inst_imm32(SETLOCAL, 1, false, id.0);
|
||||
self.inst_imm32(SETLOCAL, id.0);
|
||||
let index = id.0 as usize;
|
||||
let len = self.set_locals.len();
|
||||
if index >= len {
|
||||
|
|
@ -404,45 +392,45 @@ impl<'a> CodeBuilder<'a> {
|
|||
(index < self.set_locals.len()) && self.set_locals[index]
|
||||
}
|
||||
pub fn tee_local(&mut self, id: LocalId) {
|
||||
self.inst_imm32(TEELOCAL, 0, false, id.0);
|
||||
self.inst_imm32(TEELOCAL, id.0);
|
||||
}
|
||||
pub fn get_global(&mut self, id: u32) {
|
||||
self.inst_imm32(GETGLOBAL, 0, true, id);
|
||||
self.inst_imm32(GETGLOBAL, id);
|
||||
}
|
||||
pub fn set_global(&mut self, id: u32) {
|
||||
self.inst_imm32(SETGLOBAL, 1, false, id);
|
||||
self.inst_imm32(SETGLOBAL, id);
|
||||
}
|
||||
|
||||
instruction_memargs!(i32_load, I32LOAD, 1, true);
|
||||
instruction_memargs!(i64_load, I64LOAD, 1, true);
|
||||
instruction_memargs!(f32_load, F32LOAD, 1, true);
|
||||
instruction_memargs!(f64_load, F64LOAD, 1, true);
|
||||
instruction_memargs!(i32_load8_s, I32LOAD8S, 1, true);
|
||||
instruction_memargs!(i32_load8_u, I32LOAD8U, 1, true);
|
||||
instruction_memargs!(i32_load16_s, I32LOAD16S, 1, true);
|
||||
instruction_memargs!(i32_load16_u, I32LOAD16U, 1, true);
|
||||
instruction_memargs!(i64_load8_s, I64LOAD8S, 1, true);
|
||||
instruction_memargs!(i64_load8_u, I64LOAD8U, 1, true);
|
||||
instruction_memargs!(i64_load16_s, I64LOAD16S, 1, true);
|
||||
instruction_memargs!(i64_load16_u, I64LOAD16U, 1, true);
|
||||
instruction_memargs!(i64_load32_s, I64LOAD32S, 1, true);
|
||||
instruction_memargs!(i64_load32_u, I64LOAD32U, 1, true);
|
||||
instruction_memargs!(i32_store, I32STORE, 2, false);
|
||||
instruction_memargs!(i64_store, I64STORE, 2, false);
|
||||
instruction_memargs!(f32_store, F32STORE, 2, false);
|
||||
instruction_memargs!(f64_store, F64STORE, 2, false);
|
||||
instruction_memargs!(i32_store8, I32STORE8, 2, false);
|
||||
instruction_memargs!(i32_store16, I32STORE16, 2, false);
|
||||
instruction_memargs!(i64_store8, I64STORE8, 2, false);
|
||||
instruction_memargs!(i64_store16, I64STORE16, 2, false);
|
||||
instruction_memargs!(i64_store32, I64STORE32, 2, false);
|
||||
instruction_memargs!(i32_load, I32LOAD);
|
||||
instruction_memargs!(i64_load, I64LOAD);
|
||||
instruction_memargs!(f32_load, F32LOAD);
|
||||
instruction_memargs!(f64_load, F64LOAD);
|
||||
instruction_memargs!(i32_load8_s, I32LOAD8S);
|
||||
instruction_memargs!(i32_load8_u, I32LOAD8U);
|
||||
instruction_memargs!(i32_load16_s, I32LOAD16S);
|
||||
instruction_memargs!(i32_load16_u, I32LOAD16U);
|
||||
instruction_memargs!(i64_load8_s, I64LOAD8S);
|
||||
instruction_memargs!(i64_load8_u, I64LOAD8U);
|
||||
instruction_memargs!(i64_load16_s, I64LOAD16S);
|
||||
instruction_memargs!(i64_load16_u, I64LOAD16U);
|
||||
instruction_memargs!(i64_load32_s, I64LOAD32S);
|
||||
instruction_memargs!(i64_load32_u, I64LOAD32U);
|
||||
instruction_memargs!(i32_store, I32STORE);
|
||||
instruction_memargs!(i64_store, I64STORE);
|
||||
instruction_memargs!(f32_store, F32STORE);
|
||||
instruction_memargs!(f64_store, F64STORE);
|
||||
instruction_memargs!(i32_store8, I32STORE8);
|
||||
instruction_memargs!(i32_store16, I32STORE16);
|
||||
instruction_memargs!(i64_store8, I64STORE8);
|
||||
instruction_memargs!(i64_store16, I64STORE16);
|
||||
instruction_memargs!(i64_store32, I64STORE32);
|
||||
|
||||
pub fn memory_size(&mut self) {
|
||||
self.inst(CURRENTMEMORY, 0, true);
|
||||
self.inst(CURRENTMEMORY);
|
||||
self.code.push(0);
|
||||
}
|
||||
pub fn memory_grow(&mut self) {
|
||||
self.inst(GROWMEMORY, 1, true);
|
||||
self.inst(GROWMEMORY);
|
||||
self.code.push(0);
|
||||
}
|
||||
|
||||
|
|
@ -453,149 +441,149 @@ impl<'a> CodeBuilder<'a> {
|
|||
log_instruction!("{:10}\t{}", format!("{opcode:?}"), x);
|
||||
}
|
||||
pub fn i32_const(&mut self, x: i32) {
|
||||
self.inst_base(I32CONST, 0, true);
|
||||
self.inst_base(I32CONST);
|
||||
self.code.encode_i32(x);
|
||||
self.log_const(I32CONST, x);
|
||||
}
|
||||
pub fn i64_const(&mut self, x: i64) {
|
||||
self.inst_base(I64CONST, 0, true);
|
||||
self.inst_base(I64CONST);
|
||||
self.code.encode_i64(x);
|
||||
self.log_const(I64CONST, x);
|
||||
}
|
||||
pub fn f32_const(&mut self, x: f32) {
|
||||
self.inst_base(F32CONST, 0, true);
|
||||
self.inst_base(F32CONST);
|
||||
self.code.encode_f32(x);
|
||||
self.log_const(F32CONST, x);
|
||||
}
|
||||
pub fn f64_const(&mut self, x: f64) {
|
||||
self.inst_base(F64CONST, 0, true);
|
||||
self.inst_base(F64CONST);
|
||||
self.code.encode_f64(x);
|
||||
self.log_const(F64CONST, x);
|
||||
}
|
||||
|
||||
// TODO: Consider creating unified methods for numerical ops like 'eq' and 'add',
|
||||
// passing the ValueType as an argument. Could simplify lowlevel code gen.
|
||||
instruction_no_args!(i32_eqz, I32EQZ, 1, true);
|
||||
instruction_no_args!(i32_eq, I32EQ, 2, true);
|
||||
instruction_no_args!(i32_ne, I32NE, 2, true);
|
||||
instruction_no_args!(i32_lt_s, I32LTS, 2, true);
|
||||
instruction_no_args!(i32_lt_u, I32LTU, 2, true);
|
||||
instruction_no_args!(i32_gt_s, I32GTS, 2, true);
|
||||
instruction_no_args!(i32_gt_u, I32GTU, 2, true);
|
||||
instruction_no_args!(i32_le_s, I32LES, 2, true);
|
||||
instruction_no_args!(i32_le_u, I32LEU, 2, true);
|
||||
instruction_no_args!(i32_ge_s, I32GES, 2, true);
|
||||
instruction_no_args!(i32_ge_u, I32GEU, 2, true);
|
||||
instruction_no_args!(i64_eqz, I64EQZ, 1, true);
|
||||
instruction_no_args!(i64_eq, I64EQ, 2, true);
|
||||
instruction_no_args!(i64_ne, I64NE, 2, true);
|
||||
instruction_no_args!(i64_lt_s, I64LTS, 2, true);
|
||||
instruction_no_args!(i64_lt_u, I64LTU, 2, true);
|
||||
instruction_no_args!(i64_gt_s, I64GTS, 2, true);
|
||||
instruction_no_args!(i64_gt_u, I64GTU, 2, true);
|
||||
instruction_no_args!(i64_le_s, I64LES, 2, true);
|
||||
instruction_no_args!(i64_le_u, I64LEU, 2, true);
|
||||
instruction_no_args!(i64_ge_s, I64GES, 2, true);
|
||||
instruction_no_args!(i64_ge_u, I64GEU, 2, true);
|
||||
instruction_no_args!(f32_eq, F32EQ, 2, true);
|
||||
instruction_no_args!(f32_ne, F32NE, 2, true);
|
||||
instruction_no_args!(f32_lt, F32LT, 2, true);
|
||||
instruction_no_args!(f32_gt, F32GT, 2, true);
|
||||
instruction_no_args!(f32_le, F32LE, 2, true);
|
||||
instruction_no_args!(f32_ge, F32GE, 2, true);
|
||||
instruction_no_args!(f64_eq, F64EQ, 2, true);
|
||||
instruction_no_args!(f64_ne, F64NE, 2, true);
|
||||
instruction_no_args!(f64_lt, F64LT, 2, true);
|
||||
instruction_no_args!(f64_gt, F64GT, 2, true);
|
||||
instruction_no_args!(f64_le, F64LE, 2, true);
|
||||
instruction_no_args!(f64_ge, F64GE, 2, true);
|
||||
instruction_no_args!(i32_clz, I32CLZ, 1, true);
|
||||
instruction_no_args!(i32_ctz, I32CTZ, 1, true);
|
||||
instruction_no_args!(i32_popcnt, I32POPCNT, 1, true);
|
||||
instruction_no_args!(i32_add, I32ADD, 2, true);
|
||||
instruction_no_args!(i32_sub, I32SUB, 2, true);
|
||||
instruction_no_args!(i32_mul, I32MUL, 2, true);
|
||||
instruction_no_args!(i32_div_s, I32DIVS, 2, true);
|
||||
instruction_no_args!(i32_div_u, I32DIVU, 2, true);
|
||||
instruction_no_args!(i32_rem_s, I32REMS, 2, true);
|
||||
instruction_no_args!(i32_rem_u, I32REMU, 2, true);
|
||||
instruction_no_args!(i32_and, I32AND, 2, true);
|
||||
instruction_no_args!(i32_or, I32OR, 2, true);
|
||||
instruction_no_args!(i32_xor, I32XOR, 2, true);
|
||||
instruction_no_args!(i32_shl, I32SHL, 2, true);
|
||||
instruction_no_args!(i32_shr_s, I32SHRS, 2, true);
|
||||
instruction_no_args!(i32_shr_u, I32SHRU, 2, true);
|
||||
instruction_no_args!(i32_rotl, I32ROTL, 2, true);
|
||||
instruction_no_args!(i32_rotr, I32ROTR, 2, true);
|
||||
instruction_no_args!(i64_clz, I64CLZ, 1, true);
|
||||
instruction_no_args!(i64_ctz, I64CTZ, 1, true);
|
||||
instruction_no_args!(i64_popcnt, I64POPCNT, 1, true);
|
||||
instruction_no_args!(i64_add, I64ADD, 2, true);
|
||||
instruction_no_args!(i64_sub, I64SUB, 2, true);
|
||||
instruction_no_args!(i64_mul, I64MUL, 2, true);
|
||||
instruction_no_args!(i64_div_s, I64DIVS, 2, true);
|
||||
instruction_no_args!(i64_div_u, I64DIVU, 2, true);
|
||||
instruction_no_args!(i64_rem_s, I64REMS, 2, true);
|
||||
instruction_no_args!(i64_rem_u, I64REMU, 2, true);
|
||||
instruction_no_args!(i64_and, I64AND, 2, true);
|
||||
instruction_no_args!(i64_or, I64OR, 2, true);
|
||||
instruction_no_args!(i64_xor, I64XOR, 2, true);
|
||||
instruction_no_args!(i64_shl, I64SHL, 2, true);
|
||||
instruction_no_args!(i64_shr_s, I64SHRS, 2, true);
|
||||
instruction_no_args!(i64_shr_u, I64SHRU, 2, true);
|
||||
instruction_no_args!(i64_rotl, I64ROTL, 2, true);
|
||||
instruction_no_args!(i64_rotr, I64ROTR, 2, true);
|
||||
instruction_no_args!(f32_abs, F32ABS, 1, true);
|
||||
instruction_no_args!(f32_neg, F32NEG, 1, true);
|
||||
instruction_no_args!(f32_ceil, F32CEIL, 1, true);
|
||||
instruction_no_args!(f32_floor, F32FLOOR, 1, true);
|
||||
instruction_no_args!(f32_trunc, F32TRUNC, 1, true);
|
||||
instruction_no_args!(f32_nearest, F32NEAREST, 1, true);
|
||||
instruction_no_args!(f32_sqrt, F32SQRT, 1, true);
|
||||
instruction_no_args!(f32_add, F32ADD, 2, true);
|
||||
instruction_no_args!(f32_sub, F32SUB, 2, true);
|
||||
instruction_no_args!(f32_mul, F32MUL, 2, true);
|
||||
instruction_no_args!(f32_div, F32DIV, 2, true);
|
||||
instruction_no_args!(f32_min, F32MIN, 2, true);
|
||||
instruction_no_args!(f32_max, F32MAX, 2, true);
|
||||
instruction_no_args!(f32_copysign, F32COPYSIGN, 2, true);
|
||||
instruction_no_args!(f64_abs, F64ABS, 1, true);
|
||||
instruction_no_args!(f64_neg, F64NEG, 1, true);
|
||||
instruction_no_args!(f64_ceil, F64CEIL, 1, true);
|
||||
instruction_no_args!(f64_floor, F64FLOOR, 1, true);
|
||||
instruction_no_args!(f64_trunc, F64TRUNC, 1, true);
|
||||
instruction_no_args!(f64_nearest, F64NEAREST, 1, true);
|
||||
instruction_no_args!(f64_sqrt, F64SQRT, 1, true);
|
||||
instruction_no_args!(f64_add, F64ADD, 2, true);
|
||||
instruction_no_args!(f64_sub, F64SUB, 2, true);
|
||||
instruction_no_args!(f64_mul, F64MUL, 2, true);
|
||||
instruction_no_args!(f64_div, F64DIV, 2, true);
|
||||
instruction_no_args!(f64_min, F64MIN, 2, true);
|
||||
instruction_no_args!(f64_max, F64MAX, 2, true);
|
||||
instruction_no_args!(f64_copysign, F64COPYSIGN, 2, true);
|
||||
instruction_no_args!(i32_wrap_i64, I32WRAPI64, 1, true);
|
||||
instruction_no_args!(i32_trunc_s_f32, I32TRUNCSF32, 1, true);
|
||||
instruction_no_args!(i32_trunc_u_f32, I32TRUNCUF32, 1, true);
|
||||
instruction_no_args!(i32_trunc_s_f64, I32TRUNCSF64, 1, true);
|
||||
instruction_no_args!(i32_trunc_u_f64, I32TRUNCUF64, 1, true);
|
||||
instruction_no_args!(i64_extend_s_i32, I64EXTENDSI32, 1, true);
|
||||
instruction_no_args!(i64_extend_u_i32, I64EXTENDUI32, 1, true);
|
||||
instruction_no_args!(i64_trunc_s_f32, I64TRUNCSF32, 1, true);
|
||||
instruction_no_args!(i64_trunc_u_f32, I64TRUNCUF32, 1, true);
|
||||
instruction_no_args!(i64_trunc_s_f64, I64TRUNCSF64, 1, true);
|
||||
instruction_no_args!(i64_trunc_u_f64, I64TRUNCUF64, 1, true);
|
||||
instruction_no_args!(f32_convert_s_i32, F32CONVERTSI32, 1, true);
|
||||
instruction_no_args!(f32_convert_u_i32, F32CONVERTUI32, 1, true);
|
||||
instruction_no_args!(f32_convert_s_i64, F32CONVERTSI64, 1, true);
|
||||
instruction_no_args!(f32_convert_u_i64, F32CONVERTUI64, 1, true);
|
||||
instruction_no_args!(f32_demote_f64, F32DEMOTEF64, 1, true);
|
||||
instruction_no_args!(f64_convert_s_i32, F64CONVERTSI32, 1, true);
|
||||
instruction_no_args!(f64_convert_u_i32, F64CONVERTUI32, 1, true);
|
||||
instruction_no_args!(f64_convert_s_i64, F64CONVERTSI64, 1, true);
|
||||
instruction_no_args!(f64_convert_u_i64, F64CONVERTUI64, 1, true);
|
||||
instruction_no_args!(f64_promote_f32, F64PROMOTEF32, 1, true);
|
||||
instruction_no_args!(i32_reinterpret_f32, I32REINTERPRETF32, 1, true);
|
||||
instruction_no_args!(i64_reinterpret_f64, I64REINTERPRETF64, 1, true);
|
||||
instruction_no_args!(f32_reinterpret_i32, F32REINTERPRETI32, 1, true);
|
||||
instruction_no_args!(f64_reinterpret_i64, F64REINTERPRETI64, 1, true);
|
||||
instruction_no_args!(i32_eqz, I32EQZ);
|
||||
instruction_no_args!(i32_eq, I32EQ);
|
||||
instruction_no_args!(i32_ne, I32NE);
|
||||
instruction_no_args!(i32_lt_s, I32LTS);
|
||||
instruction_no_args!(i32_lt_u, I32LTU);
|
||||
instruction_no_args!(i32_gt_s, I32GTS);
|
||||
instruction_no_args!(i32_gt_u, I32GTU);
|
||||
instruction_no_args!(i32_le_s, I32LES);
|
||||
instruction_no_args!(i32_le_u, I32LEU);
|
||||
instruction_no_args!(i32_ge_s, I32GES);
|
||||
instruction_no_args!(i32_ge_u, I32GEU);
|
||||
instruction_no_args!(i64_eqz, I64EQZ);
|
||||
instruction_no_args!(i64_eq, I64EQ);
|
||||
instruction_no_args!(i64_ne, I64NE);
|
||||
instruction_no_args!(i64_lt_s, I64LTS);
|
||||
instruction_no_args!(i64_lt_u, I64LTU);
|
||||
instruction_no_args!(i64_gt_s, I64GTS);
|
||||
instruction_no_args!(i64_gt_u, I64GTU);
|
||||
instruction_no_args!(i64_le_s, I64LES);
|
||||
instruction_no_args!(i64_le_u, I64LEU);
|
||||
instruction_no_args!(i64_ge_s, I64GES);
|
||||
instruction_no_args!(i64_ge_u, I64GEU);
|
||||
instruction_no_args!(f32_eq, F32EQ);
|
||||
instruction_no_args!(f32_ne, F32NE);
|
||||
instruction_no_args!(f32_lt, F32LT);
|
||||
instruction_no_args!(f32_gt, F32GT);
|
||||
instruction_no_args!(f32_le, F32LE);
|
||||
instruction_no_args!(f32_ge, F32GE);
|
||||
instruction_no_args!(f64_eq, F64EQ);
|
||||
instruction_no_args!(f64_ne, F64NE);
|
||||
instruction_no_args!(f64_lt, F64LT);
|
||||
instruction_no_args!(f64_gt, F64GT);
|
||||
instruction_no_args!(f64_le, F64LE);
|
||||
instruction_no_args!(f64_ge, F64GE);
|
||||
instruction_no_args!(i32_clz, I32CLZ);
|
||||
instruction_no_args!(i32_ctz, I32CTZ);
|
||||
instruction_no_args!(i32_popcnt, I32POPCNT);
|
||||
instruction_no_args!(i32_add, I32ADD);
|
||||
instruction_no_args!(i32_sub, I32SUB);
|
||||
instruction_no_args!(i32_mul, I32MUL);
|
||||
instruction_no_args!(i32_div_s, I32DIVS);
|
||||
instruction_no_args!(i32_div_u, I32DIVU);
|
||||
instruction_no_args!(i32_rem_s, I32REMS);
|
||||
instruction_no_args!(i32_rem_u, I32REMU);
|
||||
instruction_no_args!(i32_and, I32AND);
|
||||
instruction_no_args!(i32_or, I32OR);
|
||||
instruction_no_args!(i32_xor, I32XOR);
|
||||
instruction_no_args!(i32_shl, I32SHL);
|
||||
instruction_no_args!(i32_shr_s, I32SHRS);
|
||||
instruction_no_args!(i32_shr_u, I32SHRU);
|
||||
instruction_no_args!(i32_rotl, I32ROTL);
|
||||
instruction_no_args!(i32_rotr, I32ROTR);
|
||||
instruction_no_args!(i64_clz, I64CLZ);
|
||||
instruction_no_args!(i64_ctz, I64CTZ);
|
||||
instruction_no_args!(i64_popcnt, I64POPCNT);
|
||||
instruction_no_args!(i64_add, I64ADD);
|
||||
instruction_no_args!(i64_sub, I64SUB);
|
||||
instruction_no_args!(i64_mul, I64MUL);
|
||||
instruction_no_args!(i64_div_s, I64DIVS);
|
||||
instruction_no_args!(i64_div_u, I64DIVU);
|
||||
instruction_no_args!(i64_rem_s, I64REMS);
|
||||
instruction_no_args!(i64_rem_u, I64REMU);
|
||||
instruction_no_args!(i64_and, I64AND);
|
||||
instruction_no_args!(i64_or, I64OR);
|
||||
instruction_no_args!(i64_xor, I64XOR);
|
||||
instruction_no_args!(i64_shl, I64SHL);
|
||||
instruction_no_args!(i64_shr_s, I64SHRS);
|
||||
instruction_no_args!(i64_shr_u, I64SHRU);
|
||||
instruction_no_args!(i64_rotl, I64ROTL);
|
||||
instruction_no_args!(i64_rotr, I64ROTR);
|
||||
instruction_no_args!(f32_abs, F32ABS);
|
||||
instruction_no_args!(f32_neg, F32NEG);
|
||||
instruction_no_args!(f32_ceil, F32CEIL);
|
||||
instruction_no_args!(f32_floor, F32FLOOR);
|
||||
instruction_no_args!(f32_trunc, F32TRUNC);
|
||||
instruction_no_args!(f32_nearest, F32NEAREST);
|
||||
instruction_no_args!(f32_sqrt, F32SQRT);
|
||||
instruction_no_args!(f32_add, F32ADD);
|
||||
instruction_no_args!(f32_sub, F32SUB);
|
||||
instruction_no_args!(f32_mul, F32MUL);
|
||||
instruction_no_args!(f32_div, F32DIV);
|
||||
instruction_no_args!(f32_min, F32MIN);
|
||||
instruction_no_args!(f32_max, F32MAX);
|
||||
instruction_no_args!(f32_copysign, F32COPYSIGN);
|
||||
instruction_no_args!(f64_abs, F64ABS);
|
||||
instruction_no_args!(f64_neg, F64NEG);
|
||||
instruction_no_args!(f64_ceil, F64CEIL);
|
||||
instruction_no_args!(f64_floor, F64FLOOR);
|
||||
instruction_no_args!(f64_trunc, F64TRUNC);
|
||||
instruction_no_args!(f64_nearest, F64NEAREST);
|
||||
instruction_no_args!(f64_sqrt, F64SQRT);
|
||||
instruction_no_args!(f64_add, F64ADD);
|
||||
instruction_no_args!(f64_sub, F64SUB);
|
||||
instruction_no_args!(f64_mul, F64MUL);
|
||||
instruction_no_args!(f64_div, F64DIV);
|
||||
instruction_no_args!(f64_min, F64MIN);
|
||||
instruction_no_args!(f64_max, F64MAX);
|
||||
instruction_no_args!(f64_copysign, F64COPYSIGN);
|
||||
instruction_no_args!(i32_wrap_i64, I32WRAPI64);
|
||||
instruction_no_args!(i32_trunc_s_f32, I32TRUNCSF32);
|
||||
instruction_no_args!(i32_trunc_u_f32, I32TRUNCUF32);
|
||||
instruction_no_args!(i32_trunc_s_f64, I32TRUNCSF64);
|
||||
instruction_no_args!(i32_trunc_u_f64, I32TRUNCUF64);
|
||||
instruction_no_args!(i64_extend_s_i32, I64EXTENDSI32);
|
||||
instruction_no_args!(i64_extend_u_i32, I64EXTENDUI32);
|
||||
instruction_no_args!(i64_trunc_s_f32, I64TRUNCSF32);
|
||||
instruction_no_args!(i64_trunc_u_f32, I64TRUNCUF32);
|
||||
instruction_no_args!(i64_trunc_s_f64, I64TRUNCSF64);
|
||||
instruction_no_args!(i64_trunc_u_f64, I64TRUNCUF64);
|
||||
instruction_no_args!(f32_convert_s_i32, F32CONVERTSI32);
|
||||
instruction_no_args!(f32_convert_u_i32, F32CONVERTUI32);
|
||||
instruction_no_args!(f32_convert_s_i64, F32CONVERTSI64);
|
||||
instruction_no_args!(f32_convert_u_i64, F32CONVERTUI64);
|
||||
instruction_no_args!(f32_demote_f64, F32DEMOTEF64);
|
||||
instruction_no_args!(f64_convert_s_i32, F64CONVERTSI32);
|
||||
instruction_no_args!(f64_convert_u_i32, F64CONVERTUI32);
|
||||
instruction_no_args!(f64_convert_s_i64, F64CONVERTSI64);
|
||||
instruction_no_args!(f64_convert_u_i64, F64CONVERTUI64);
|
||||
instruction_no_args!(f64_promote_f32, F64PROMOTEF32);
|
||||
instruction_no_args!(i32_reinterpret_f32, I32REINTERPRETF32);
|
||||
instruction_no_args!(i64_reinterpret_f64, I64REINTERPRETF64);
|
||||
instruction_no_args!(f32_reinterpret_i32, F32REINTERPRETI32);
|
||||
instruction_no_args!(f64_reinterpret_i64, F64REINTERPRETI64);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue