v3.ssa #

Parallel-SSA worker support, ported from v2's module.v and adapted to v3's raw-block-id operand model: branch/phi/switch operands that name blocks are remapped by the block offset, while ordinary value operands are remapped by the value offset.

fn build(a_ &flat.FlatAst) &Module

build supports build handling for ssa.

fn build_with_options(a_ &flat.FlatAst, used_fns map[string]bool, tc &types.TypeChecker, opts BuildOptions) &Module

build_with_options builds with options data for ssa.

fn build_with_used(a_ &flat.FlatAst, used_fns map[string]bool, tc &types.TypeChecker) &Module

build_with_used builds with used data for ssa.

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

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

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

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

fn Module.new() &Module

new creates a Module value for ssa.

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

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

fn TypeStore.new() TypeStore

new creates a TypeStore value for ssa.

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

type BlockID = int

BlockID aliases block id values used by ssa.

type TypeID = int

TypeID aliases type id values used by ssa.

type ValueID = int

ValueID aliases value id values used by ssa.

enum AtomicOrdering {
	not_atomic
	unordered
	monotonic
	acquire
	release
	acq_rel
	seq_cst
}

AtomicOrdering lists atomic ordering values used by ssa.

enum CallConv {
	c_decl
	fast_call
	wasm_std
}

CallConv lists call conv values used by ssa.

enum InlineHint {
	none_  // No hint, let optimizer decide
	always // Always inline (e.g. V's [inline] attribute)
	never  // Never inline (e.g. V's [noinline] attribute)
	hint   // Suggest inlining (optimizer may ignore)
}

InlineHint lists inline hint values used by ssa.

enum Linkage {
	external
	private
	internal
}

Linkage lists linkage values used by ssa.

enum OpCode {
	// Terminators
	ret
	br
	jmp
	switch_ // Multi-way branch: switch_ %val, default_block, [case_val, block]...
	unreachable
	// Binary (integer)
	add
	sub
	mul
	sdiv
	srem
	udiv
	urem
	// Binary (float)
	fadd
	fsub
	fmul
	fdiv
	frem
	// Bitwise
	shl
	ashr
	lshr
	and_
	or_
	xor
	// Memory
	alloca
	load
	store
	get_element_ptr
	heap_alloc // Heap allocate memory for a type (malloc+zero): returns ptr
	fence      // Memory ordering barrier
	cmpxchg    // Atomic compare-exchange
	atomicrmw  // Atomic read-modify-write
	// Comparisons
	lt
	gt
	le
	ge
	ult
	ugt
	ule
	uge
	eq
	ne
	// Other
	call
	call_indirect // Indirect call through function pointer
	call_sret     // Call with struct return (x8 indirect return on ARM64)
	neg
	trunc
	sext
	zext
	fptoui
	fptosi
	uitofp
	sitofp
	bitcast
	phi
	select
	assign             // Copy op used during phi elimination
	inline_string_init // Build a string struct by value: (string){str, len}
	// Concurrency
	go_call    // Launch goroutine: go_call fn_ref, args...
	spawn_call // Launch OS thread: spawn_call fn_ref, args...
	// Aggregate (struct/tuple) operations
	extractvalue
	insertvalue
	struct_init
}

OpCode lists op code values used by ssa.

enum TypeKind {
	void_t
	int_t
	float_t
	ptr_t
	array_t
	struct_t
	func_t
	label_t
	metadata_t
}

TypeKind lists type kind values used by ssa.

enum ValueKind {
	unknown
	constant
	argument
	global
	instruction
	phi_result
	basic_block
	string_literal   // V string struct literal (by value)
	c_string_literal // C string literal (raw char pointer)
	func_ref
}

ValueKind lists value kind values used by ssa.

struct BasicBlock {
pub mut:
	id     BlockID
	val_id ValueID // SSA value representing the block (0 in v3's raw-block-id model)
	name   string
	parent int
	instrs []ValueID
	preds  []BlockID
	succs  []BlockID
	// Dominators
	idom     BlockID
	dom_tree []BlockID
}

BasicBlock represents basic block data used by ssa.

struct BuildOptions {
pub:
	hot_fn         string   // build only this function's body (hot reload)
	skip_fn_bodies bool     // register signatures only, mark them prototypes
	skip_modules   []string // skip all functions declared in these modules
}

BuildOptions controls which functions a build materializes. The zero value reproduces the default whole-program build.

struct Builder {
mut:
	m                  &Module            = unsafe { nil }
	a                  &flat.FlatAst      = unsafe { nil }
	tc                 &types.TypeChecker = unsafe { nil }
	used_fns           map[string]bool
	cur_module         string
	cur_func           int
	cur_func_ret_type  string
	cur_block          BlockID
	vars               map[string]ValueID
	var_type_names     map[string]string
	i64_type           TypeID
	i32_type           TypeID
	i8_type            TypeID
	i1_type            TypeID
	u64_type           TypeID
	u32_type           TypeID
	u16_type           TypeID
	u8_type            TypeID
	f32_type           TypeID
	f64_type           TypeID
	void_type          TypeID
	str_type           TypeID
	array_type         TypeID
	map_type           TypeID
	map_state_type     TypeID
	fn_types           map[string]TypeID
	fn_ids             map[string]int
	const_exprs        map[string]flat.NodeId
	struct_types       map[string]TypeID
	struct_field_types map[string]string
	option_types       map[string]TypeID
	sum_type_variants  map[string][]string
	sum_type_canonical map[string]string
	enum_types         map[string]bool
	flag_enum_types    map[string]bool
	enum_values        map[string]int
	enum_member_values map[string]int
	enum_member_dupes  map[string]bool
	c_fn_ids           map[string]int
	c_fn_types         map[string]TypeID
	label_blocks       map[string]BlockID
	defer_body_ids     []flat.NodeId
	break_targets      []BlockID
	continue_targets   []BlockID
	top_level_main     bool
	// --- Build-control machinery (ported from v2 build_all) ---
	// When set, build_functions only materializes this one function body (hot reload).
	hot_fn string
	// When set, build_functions registers signatures only and marks them prototypes.
	skip_fn_bodies bool
	// When non-empty, all functions declared in these modules are skipped (dead
	// code elimination for unused backends/modules).
	skip_modules map[string]bool
	// SSA-level type alias name -> resolved base TypeID. Supplements the checker's
	// alias map (used when building without a checker).
	type_aliases map[string]TypeID
}

Builder stores state for SSA construction.

struct ConstantData {
pub:
	int_val   i64
	float_val f64
	str_val   string
}

ConstantData carries the typed payload of a constant value. It mirrors v2's representation so backends can recover the original int/float/string value instead of re-parsing Value.name.

struct FuncSSAData {
pub:
	func_idx int       // index into the main module's funcs[]
	blocks   []BlockID // worker-local block ids
	params   []ValueID // worker-local param value ids
}

FuncSSAData holds the SSA a worker produced for a single function.

struct Function {
pub mut:
	id           int
	name         string
	typ          TypeID
	blocks       []BlockID
	params       []ValueID
	is_c_extern  bool // C-language extern function (no V body)
	is_prototype bool // Registered declaration/signature whose body is not materialized yet
	linkage      Linkage
	call_conv    CallConv
}

Function represents function data used by ssa.

struct GlobalVar {
pub mut:
	name          string
	typ           TypeID
	linkage       Linkage
	alignment     int
	is_constant   bool
	initial_value i64  // For constants/enums, the initial integer value
	initial_data  []u8 // For constant arrays: serialized element data
}

GlobalVar represents global var data used by ssa.

struct Instruction {
pub mut:
	op         OpCode
	operands   []ValueID
	block      BlockID
	typ        TypeID
	pos        token.Pos
	atomic_ord AtomicOrdering
	inline     InlineHint // Inline hint for call instructions
}

Instruction represents instruction data used by ssa.

fn (i &Instruction) is_block_operand(idx int) bool

is_block_operand reports whether operand idx names a basic block rather than an SSA value. Keep all mixed-layout instruction knowledge here so CFG, optimizer, verifier, and worker code cannot disagree about operand roles.

fn (i &Instruction) is_value_operand(idx int) bool

is_value_operand reports whether operand idx names an SSA value.

fn (i &Instruction) is_definition_operand(idx int) bool

is_definition_operand reports whether operand idx is defined by an instruction rather than read by it. Phi lowering represents copies as assign destination, source, so the destination must never participate in use lists or replacement walks.

fn (i &Instruction) is_successor_operand(idx int) bool

is_successor_operand reports whether operand idx is a CFG successor. Phi block operands are predecessors, so they intentionally do not match here.

struct Module {
pub mut:
	name       string
	target     TargetData
	type_store TypeStore
	values     []Value
	instrs     []Instruction
	blocks     []BasicBlock
	funcs      []Function
	globals    []GlobalVar
	// C struct names: TypeID -> C struct name (e.g. for `struct stat`). Used by
	// codegen to emit `typedef struct <name> ...;` and preserve the C layout.
	c_struct_names map[int]string
	// C structs marked @[typedef] — already a C typedef, not a struct tag.
	c_typedef_structs map[int]bool
	// Constant cache: "type:name" -> ValueID for deduplication.
	const_cache map[string]ValueID
}

Module represents module data used by ssa.

fn (mut m Module) add_block(func_id int, name string) BlockID

add_block updates add block state for Module.

fn (mut m Module) add_external_global(name string, typ TypeID) ValueID

add_external_global registers (or reuses) a global defined outside this module (e.g. C runtime globals such as __stdoutp). Returns the global pointer value.

fn (mut m Module) add_global(name string, typ TypeID) ValueID

add_global updates add global state for Module.

fn (mut m Module) add_global_with_data(name string, elem_type TypeID, is_const bool, data []u8) ValueID

add_global_with_data registers a private global initialized from raw bytes (used for const arrays serialized to element data).

fn (mut m Module) add_instr(op OpCode, block BlockID, typ TypeID, operands []ValueID) ValueID

add_instr updates add instr state for Module.

fn (mut m Module) add_instr_front(op OpCode, block BlockID, typ TypeID, operands []ValueID) ValueID

add_instr_front creates an instruction and prepends it to the block (used for phi insertion by mem2reg, which requires phis at the top of a block).

fn (mut m Module) add_value(kind ValueKind, typ TypeID, name string, index int) ValueID

add_value updates add value state for Module.

fn (mut m Module) add_value_user(value_id ValueID, user_id ValueID)

add_value_user records one instruction in a value's unique user list.

fn (mut m Module) append_phi_operands(phi_val_id ValueID, val ValueID, block_id BlockID)

append_phi_operands appends a (val, block_id) pair to a phi instruction.

fn (mut m Module) block_add_pred(to BlockID, from BlockID)

block_add_pred supports block add pred handling for Module.

fn (mut m Module) block_add_succ(from BlockID, to BlockID)

block_add_succ supports block add succ handling for Module.

fn (mut m Module) detach_instruction_uses(value_id ValueID)

detach_instruction_uses removes every use edge contributed by an instruction that is about to leave its block.

fn (mut m Module) func_add_param(func_id int, param_val ValueID)

func_add_param supports func add param handling for Module.

fn (mut m Module) func_set_c_extern(func_id int, val bool)

func_set_c_extern supports func set c extern handling for Module.

fn (mut m Module) func_set_prototype(func_id int, val bool)

func_set_prototype supports func set prototype handling for Module.

fn (m &Module) get_block_from_val(val_id int) int

get_block_from_val converts a basic-block value operand to its block index.

fn (mut m Module) get_or_add_const(typ TypeID, name string) ValueID

get_or_add_const returns get or add const data for Module.

fn (mut m Module) merge_worker_module(w &Module, func_data []FuncSSAData, seed_values int, seed_instrs int, seed_blocks int, seed_types int, seed_funcs int)

merge_worker_module folds a worker's freshly-built SSA (everything beyond the seed lengths) back into the main module, remapping type/value/instr/block/func ids. func_data carries each built function's worker-local blocks/params.

fn (mut m Module) new_function(name string, ret TypeID) int

new_function supports new function handling for Module.

fn (mut m Module) new_worker_module() &Module

new_worker_module creates a lightweight Module for parallel SSA building. The worker gets a deep copy of the type store and is seeded with the main module's values/instrs/blocks so ids produced in earlier (serial) phases stay valid.

fn (mut m Module) remove_value_user(value_id ValueID, user_id ValueID)

remove_value_user removes one instruction from a value's unique user list.

fn (mut m Module) replace_uses(old_id ValueID, new_id ValueID)

replace_uses supports replace uses handling for Module.

fn (mut m Module) rewrite_instruction(value_id ValueID, op OpCode, operands []ValueID)

rewrite_instruction changes an instruction while maintaining its value-use edges. CFG edges remain the responsibility of callers that change a terminator; they can rebuild or update the CFG once after batching edits.

fn (m &Module) struct_field_offset(typ_id TypeID, field_idx int) int

struct_field_offset returns the byte offset of a field in a struct type.

fn (m &Module) struct_field_size(typ_id TypeID, field_idx int) int

struct_field_size returns the byte size of a field in a struct type.

fn (m &Module) type_align(typ_id TypeID) int

type_align returns the ABI alignment for an SSA type on the current target.

fn (m &Module) type_size(typ_id TypeID) int

type_size returns the byte size for an SSA type on the current target.

struct TargetData {
pub:
	ptr_size      int  = 8
	endian_little bool = true
}

TargetData represents target data data used by ssa.

struct Type {
pub:
	kind        TypeKind
	width       int
	is_unsigned bool
	elem_type   TypeID // For Ptr, Array
	len         int    // For Array
	fields      []TypeID
	field_names []string
	params      []TypeID
	ret_type    TypeID
	is_c_struct bool // True for C interop structs (raw field names, typedef to C struct)
	is_union    bool // True for union types (all fields overlap at offset 0)
}

Type represents type data used by ssa.

struct TypeStore {
pub mut:
	types []Type
	cache map[string]TypeID
}

TypeStore represents type store data used by ssa.

fn (mut ts TypeStore) get_int(width int) TypeID

get_int returns get int data for TypeStore.

fn (mut ts TypeStore) get_uint(width int) TypeID

get_uint returns get uint data for TypeStore.

fn (mut ts TypeStore) get_float(width int) TypeID

get_float returns get float data for TypeStore.

fn (mut ts TypeStore) get_ptr(elem TypeID) TypeID

get_ptr returns get ptr data for TypeStore.

fn (mut ts TypeStore) get_array(elem TypeID, length int) TypeID

get_array returns the cached fixed-array type for (elem, length).

fn (mut ts TypeStore) get_tuple(elem_types []TypeID) TypeID

get_tuple returns a cached anonymous struct type holding the given element types.

fn (mut ts TypeStore) register(t Type) TypeID

register supports register handling for TypeStore.

struct Value {
pub mut:
	id    ValueID
	kind  ValueKind
	typ   TypeID
	name  string
	index int
	uses  []ValueID
}

Value represents value data used by ssa.