module wasm

// code.v emits the WASM instruction stream for a single function body. It is a
// thin layer over a []u8 buffer with one method per opcode used by the backend,
// analogous to the arm64 backend's asm.v instruction encoders.

pub struct Code {
pub mut:
	bytes []u8
}

@[inline]
pub fn (mut c Code) raw(b u8) {
	c.bytes << b
}

// ---- constants ----

pub fn (mut c Code) i32_const(v i64) {
	c.bytes << 0x41
	// Wrap to a signed 32-bit value so the LEB128 stays in i32 range; e.g.
	// u32(4000000000) must encode as the 32-bit pattern, not a 5-byte i64.
	leb_i(mut c.bytes, i64(i32(v)))
}

pub fn (mut c Code) i64_const(v i64) {
	c.bytes << 0x42
	leb_i(mut c.bytes, v)
}

pub fn (mut c Code) f32_const(v f32) {
	c.bytes << 0x43
	bits := u32(f32_bits(v))
	for i in 0 .. 4 {
		c.bytes << u8((bits >> (8 * i)) & 0xff)
	}
}

pub fn (mut c Code) f64_const(v f64) {
	c.bytes << 0x44
	bits := f64_bits(v)
	for i in 0 .. 8 {
		c.bytes << u8((bits >> (8 * i)) & 0xff)
	}
}

fn f32_bits(v f32) u32 {
	return unsafe { *(&u32(&v)) }
}

fn f64_bits(v f64) u64 {
	return unsafe { *(&u64(&v)) }
}

// ---- locals / globals ----

pub fn (mut c Code) local_get(idx int) {
	c.bytes << 0x20
	leb_u(mut c.bytes, u64(idx))
}

pub fn (mut c Code) local_set(idx int) {
	c.bytes << 0x21
	leb_u(mut c.bytes, u64(idx))
}

pub fn (mut c Code) local_tee(idx int) {
	c.bytes << 0x22
	leb_u(mut c.bytes, u64(idx))
}

pub fn (mut c Code) global_get(idx int) {
	c.bytes << 0x23
	leb_u(mut c.bytes, u64(idx))
}

pub fn (mut c Code) global_set(idx int) {
	c.bytes << 0x24
	leb_u(mut c.bytes, u64(idx))
}

// ---- memory ----

pub fn (mut c Code) load(op u8, align int, offset int) {
	c.bytes << op
	leb_u(mut c.bytes, u64(align))
	leb_u(mut c.bytes, u64(offset))
}

pub fn (mut c Code) store(op u8, align int, offset int) {
	c.bytes << op
	leb_u(mut c.bytes, u64(align))
	leb_u(mut c.bytes, u64(offset))
}

// i32_store / i32_load with natural alignment for a full i32.
pub fn (mut c Code) i32_store(offset int) {
	c.store(0x36, 2, offset)
}

pub fn (mut c Code) i32_store8(offset int) {
	c.store(0x3a, 0, offset)
}

pub fn (mut c Code) i32_load(offset int) {
	c.load(0x28, 2, offset)
}

// ---- control flow ----

pub fn (mut c Code) block_void() {
	c.bytes << 0x02
	c.bytes << 0x40
}

pub fn (mut c Code) loop_void() {
	c.bytes << 0x03
	c.bytes << 0x40
}

pub fn (mut c Code) if_void() {
	c.bytes << 0x04
	c.bytes << 0x40
}

pub fn (mut c Code) else_() {
	c.bytes << 0x05
}

pub fn (mut c Code) end() {
	c.bytes << 0x0b
}

pub fn (mut c Code) br(depth int) {
	c.bytes << 0x0c
	leb_u(mut c.bytes, u64(depth))
}

pub fn (mut c Code) br_if(depth int) {
	c.bytes << 0x0d
	leb_u(mut c.bytes, u64(depth))
}

pub fn (mut c Code) ret() {
	c.bytes << 0x0f
}

pub fn (mut c Code) call(idx int) {
	c.bytes << 0x10
	leb_u(mut c.bytes, u64(idx))
}

pub fn (mut c Code) drop() {
	c.bytes << 0x1a
}