v3.gen.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.

fn FrameTag.from[W](input W) !FrameTag

fn Gen.new(a &flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) &Gen

fn Module.new() &Module

fn WType.from[W](input W) !WType

enum WType {
	void
	i32
	i64
	f32
	f64
}

struct Code {
pub mut:
	bytes []u8
}

fn (mut c Code) raw(b u8)

fn (mut c Code) i32_const(v i64)

---- constants ----

fn (mut c Code) i64_const(v i64)

fn (mut c Code) f32_const(v f32)

fn (mut c Code) f64_const(v f64)

fn (mut c Code) local_get(idx int)

---- locals / globals ----

fn (mut c Code) local_set(idx int)

fn (mut c Code) local_tee(idx int)

fn (mut c Code) global_get(idx int)

fn (mut c Code) global_set(idx int)

fn (mut c Code) load(op u8, align int, offset int)

---- memory ----

fn (mut c Code) store(op u8, align int, offset int)

fn (mut c Code) i32_store(offset int)

i32_store / i32_load with natural alignment for a full i32.

fn (mut c Code) i32_store8(offset int)

fn (mut c Code) i32_load(offset int)

fn (mut c Code) block_void()

---- control flow ----

fn (mut c Code) loop_void()

fn (mut c Code) if_void()

fn (mut c Code) else_()

fn (mut c Code) end()

fn (mut c Code) br(depth int)

fn (mut c Code) br_if(depth int)

fn (mut c Code) ret()

fn (mut c Code) call(idx int)

fn (mut c Code) drop()

struct Gen {
mut:
	a        &flat.FlatAst      = unsafe { nil }
	tc       &types.TypeChecker = unsafe { nil }
	used_fns map[string]bool
	mod      &Module = unsafe { nil }
	// per-function state
	cur           Code
	local_types   []u8
	nparams       int
	var_index     map[string]int
	var_wtype     map[string]WType
	var_unsigned  map[string]bool
	var_widths    map[string]int // sub-32-bit int locals: 8 or 16; else 32
	frames        []Frame
	pending_label string // label of a preceding `label:` marker, for the next loop
	cur_ret       WType
	cur_fn_module string
	cur_fn_file   string
	// module-wide; keyed by qualified function name (see qualified_fn_key)
	fn_index        map[string]int
	fn_ret          map[string]WType
	fn_params       map[string][]WType
	file_aliases    map[string]map[string]string // file -> (import alias -> full import path)
	import_paths    []string                     // every `import a.b.c` path (full)
	module_imports  map[string][]string          // module path -> imported module paths ('' = main)
	global_index    map[string]int               // __global name -> wasm global index
	global_wtype    map[string]WType
	global_unsigned map[string]bool
	global_widths   map[string]int
	data_pool       []u8
	data_off        map[string]int
	uses_print      bool
	write_idx       int
	print_int_idx   int
	has_main        bool
	init_fns        []int // function indices of init() entry points, in call order
	warnings        []string
}

fn (mut g Gen) gen()

gen builds the whole module from the flat AST.

fn (g &Gen) warnings_list() []string

fn (mut g Gen) write(path string) !

write serializes the module to path.

struct Module {
mut:
	types    []FuncType
	imports  []ImportFunc
	funcs    []Func
	exports  []Export
	datas    []DataSeg
	globals  []Global
	mem_min  int = 2
	n_import int
}

fn (mut m Module) add_type(params []u8, results []u8) int

add_type registers a signature, deduplicating identical ones.

fn (mut m Module) add_import_func(module_ string, name string, type_idx int) int

add_import_func registers an imported function and returns its function index. Imports must be added before any defined function so indices stay stable.

fn (mut m Module) add_global(valtype u8, init []u8) int

add_global appends a mutable global and returns its index.

fn (m &Module) reserve_func_index(defined_so_far int) int

reserve_func_index returns the function index a later add_func will occupy.

fn (mut m Module) add_func(type_idx int, locals []u8, code []u8) int

add_func appends a defined function and returns its global function index.

fn (mut m Module) add_export(name string, kind u8, index int)

fn (mut m Module) add_data(offset int, bytes []u8)

fn (mut m Module) set_mem_min(pages int)

fn (m &Module) compile() []u8

compile serializes the whole module into a .wasm byte buffer.