package core:rexcode/ir

Source

Block :: struct {
	ops:    []Operation,
	params: []Result,
	id:     Id,
}

Dataflow :: enum u8 {
	STACK, // WASM
	SSA,   // SPIR-V / LLVM / AIR / DXIL
}

Error :: struct #packed {
	location: u32,
	code:     Error_Code,
	_:        [3]u8 `fmt:"-"`,
}

Error_Code :: enum u8 {
	NONE                   = 0, 
	// Shared with the ISA side (encode/decode of the byte/word stream).
	INVALID_OPCODE, 
	NO_MATCHING_ENCODING, 
	OPERAND_MISMATCH, 
	IMMEDIATE_OUT_OF_RANGE, 
	BUFFER_OVERFLOW, 
	BUFFER_TOO_SHORT, 
	// IR-specific (no ISA analog -- these need a type system / SSA / a module).
	INVALID_TYPE,               // malformed or out-of-range Type_Ref
	TYPE_MISMATCH,              // an operand/result type disagrees with the op signature
	UNDEFINED_REF,              // a Ref to an id/symbol that is never defined
	DUPLICATE_DEFINITION,       // an id/symbol defined twice
	MALFORMED_MODULE,           // structural violation (block without terminator, ...)
	UNSUPPORTED_FEATURE,        // a capability/extension the codec does not implement
}

Function :: struct {
	blocks:    []Block,
	name:      string,
	signature: Type_Ref,
	// a FUNCTION type in Module.types
	id:        Id,
}

Global :: struct {
	name:    string,
	init:    Id,
	// a CONSTANT ref, or ID_NONE
	type:    Type_Ref,
	mutable: bool,
}

Id :: distinct u32

Module :: struct {
	target:    string,
	// triple / capability profile / version tag
	types:     []Type,
	// the type table; Type_Ref indexes here
	globals:   []Global,
	functions: []Function,
	symbols:   Symbol_Table,
	// externally-visible names
	dataflow:  Dataflow,
}

Operand :: struct #packed {
	imm:   i64,
	kind:  Operand_Kind,
	space: Ref_Space,
	// REF: which id space
	aux:   u16,
	// LIT_FLOAT width / ATTRIBUTE tag / dialect bits
	flags: u32,
}

Operand_Kind :: enum u8 {
	NONE, 
	LIT_INT,   // integer literal (value in `imm`)
	LIT_FLOAT, // float literal (IEEE bits in `imm`, width in `aux`)
	REF,       // reference to an entity: `imm` is the Id, `space` the Ref_Space
	TYPE,      // a Type_Ref (in the low 32 bits of `imm`)
	ATTRIBUTE, // a dialect enum / decoration / mask (value in `imm`, tag in `aux`)
}

Operation :: struct {
	operands: []Operand,
	result:   Result,
	// SSA def; `.id == ID_NONE` for stack/void ops
	opcode:   u16,
	flags:    Operation_Flags,
	_:        u8,
}

Operation_Flags :: distinct bit_field u8 {
	terminator: bool | 1,
	control:    bool | 1,
	memory:     bool | 1,
	_:          u8 | 5,
}

Print_Options :: struct {
	uppercase:     bool,
	hex_prefix:    string,
	// default "0x"
	hex_lowercase: bool,
	value_prefix:  string,
	// SSA value sigil, default "%"
	block_prefix:  string,
	// block-label sigil, default "^"
	show_offsets:  bool,
	indent:        string,
	// default "  "
	separator:     string,
}

Print_Result :: struct {
	text:   string,
	tokens: []Token,
}

Ref :: struct #packed {
	id:    Id,
	space: Ref_Space,
	_:     [3]u8,
}

Ref_Space :: enum u8 {
	NONE, 
	VALUE,    // an SSA result (or a local/stack slot)
	BLOCK,    // a basic block / structured-control label (branch target)
	FUNCTION, 
	GLOBAL, 
	TYPE, 
	CONSTANT, // a constant-pool entry
	MEMORY,   // a linear memory / address space
	METADATA, // a metadata/debug node
	EXTERNAL, // an imported/exported symbol -- relocatable across object files
}

Result :: struct #packed {
	id:   Id,
	// ID_NONE if the op defines no value
	type: Type_Ref,
}

Symbol_Table :: struct {
	names: map[string]Id,
	space: Ref_Space,
}

Token :: struct {
	offset:          u32,
	// byte offset in the output string
	length:          u16,
	kind:            Token_Kind,
	operation_index: u16,
}

Token_Kind :: enum u8 {
	WHITESPACE, 
	NEWLINE, 
	OFFSET,      // byte/word offset prefix
	KEYWORD,     // `func` / `block` / `define` / `OpLabel` style keywords
	OPCODE,      // the operation mnemonic
	TYPE,        // a type reference / spelling           (IR-only)
	VALUE_REF,   // a use of an SSA value / local         (IR-only)
	RESULT,      // a value definition (`%3 =`)           (IR-only)
	BLOCK_LABEL, // a basic-block / branch-target label   (IR-only)
	GLOBAL_REF,  // function / global / symbol reference  (IR-only)
	IMMEDIATE,   // literal constant
	ATTRIBUTE,   // dialect attribute / decoration / flag (IR-only)
	PUNCTUATION, // `(`, `)`, `,`, `=`, `:`
	COMMENT, 
}

Type :: struct {
	fields:  []Type_Ref,
	// STRUCT members, or FUNCTION params ++ result
	name:    string,
	// OPAQUE / named struct
	elem:    Type_Ref,
	// VECTOR / ARRAY / POINTER / typed REF element
	count:   u32,
	// VECTOR length, literal ARRAY length, or FUNCTION param count
	len_ref: Id,
	// ARRAY length as a constant <id> (id-typed lengths, e.g. SPIR-V)
	bits:    u16,
	// INT / FLOAT width
	aux:     u16,
	// POINTER address space, packed kind flags, ...
	kind:    Type_Kind,
	_:       [3]u8,
}

Type_Kind :: enum u8 {
	VOID, 
	BOOL,     // a distinct boolean (SPIR-V OpTypeBool, LLVM i1)
	INT,      // `bits` = width (1/8/16/32/64/...); signedness is op-level in most IRs
	FLOAT,    // `bits` = width (16/32/64/128)
	VECTOR,   // `elem` x `count`   (fixed-width SIMD)
	ARRAY,    // `elem` x `count` (literal length) or `elem` x `len_ref` (<id> length)
	POINTER,  // `elem`, address space in `aux`
	STRUCT,   // members in `fields`
	FUNCTION, // `fields` = params ++ [result]; `count` = param count
	OPAQUE,   // named / forward-declared / abstract handle (images, tokens, ...)
	REF,      // funcref / externref / typed GC reference (`elem` for typed refs)
}

Type_Ref :: distinct u32

DEFAULT_PRINT_OPTIONS :: Print_Options{uppercase = false, hex_prefix = "0x", hex_lowercase = true, value_prefix = "%", block_prefix = "^", show_offsets = false, indent = "  ", separator = "\n"}

ID_NONE :: Id(0xFFFFFFFF)

TYPE_NONE :: Type_Ref(0xFFFFFFFF)

op_block :: proc "contextless" (id: Id) -> Operand {…}

op_float :: proc "contextless" (bits: u64, w: u16) -> Operand {…}

op_int :: proc "contextless" (v: i64) -> Operand {…}

op_ref :: proc "contextless" (space: Ref_Space, id: Id) -> Operand {…}

op_type :: proc "contextless" (t: Type_Ref) -> Operand {…}

op_value :: proc "contextless" (id: Id) -> Operand {…}

operand_id :: proc "contextless" (o: Operand) -> Id {…}

operand_type :: proc "contextless" (o: Operand) -> Type_Ref {…}

print_decimal :: proc(sb: ^strings.Builder, value: u32) {…}

print_hex :: proc(sb: ^strings.Builder, value: u64, options: ^Print_Options) {…}

print_hex_digits :: proc(sb: ^strings.Builder, value: u64, options: ^Print_Options) {…}

ref :: proc "contextless" (space: Ref_Space, id: Id) -> Ref {…}

symbol_define :: proc(st: ^Symbol_Table, name: string, id: Id) {…}

symbol_lookup :: proc(st: ^Symbol_Table, name: string) -> (id: Id, ok: bool) {…}

symbol_reserve :: proc(st: ^Symbol_Table, name: string) -> Id {…}

symbol_table_destroy :: proc(st: ^Symbol_Table) {…}

symbol_table_init :: proc(st: ^Symbol_Table, space: Ref_Space = Ref_Space.EXTERNAL, allocator := context.allocator) {…}

token_kind_to_string :: proc(k: Token_Kind) -> string {…}

type_array :: proc "contextless" (elem: Type_Ref, len_ref: Id) -> Type {…}

type_bool :: proc "contextless" () -> Type {…}

type_float :: proc "contextless" (bits: u16) -> Type {…}

type_int :: proc "contextless" (bits: u16) -> Type {…}

type_pointer :: proc "contextless" (elem: Type_Ref, address_space: u16 = 0) -> Type {…}

type_vector :: proc "contextless" (elem: Type_Ref, count: u32) -> Type {…}

type_void :: proc "contextless" () -> Type {…}