radiance · Radiance self-hosting compiler

.ai/ compiler/ lib/ examples/ std/ arch/ collections/ lang/ alloc/ ast/ gen/ il/ printer.rad 16.3 KiB verify.rad 11.9 KiB module/ parser/ resolver/ scanner/ alloc.rad 4.2 KiB ast.rad 22.6 KiB gen.rad 489 B il.rad 18.0 KiB lower.rad 261.8 KiB module.rad 13.4 KiB package.rad 1.2 KiB parser.rad 79.7 KiB resolver.rad 246.8 KiB scanner.rad 18.1 KiB sexpr.rad 6.3 KiB strings.rad 2.2 KiB sys/ arch.rad 65 B collections.rad 36 B fmt.rad 3.8 KiB intrinsics.rad 399 B io.rad 1.2 KiB lang.rad 222 B mem.rad 2.1 KiB sys.rad 167 B testing.rad 2.3 KiB tests.rad 11.6 KiB vec.rad 3.1 KiB std.rad 231 B scripts/ seed/ test/ vim/ .gitignore 353 B .gitsigners 112 B LICENSE 1.1 KiB Makefile 3.0 KiB README 2.5 KiB std.lib 1.0 KiB std.lib.test 252 B

lib/std/lang/il/printer.rad 16.3 KiB raw

//! IL pretty printer.

use std::fmt;
use std::mem;
use std::lang::sexpr;
use std::lang::alloc;

///////////////////////
// String formatting //
///////////////////////

/// Copy a byte slice into arena-allocated storage.
fn copyToArena(a: *mut alloc::Arena, text: *[u8]) -> *[u8] {
    let slice = try! alloc::allocSlice(a, 1, 1, text.len) as *mut [u8];
    try! mem::copy(slice, text);
    return slice;
}

/// Format a `u32` into a string in the arena.
fn formatU32(a: *mut alloc::Arena, val: u32) -> *[u8] {
    let mut digits: [u8; 10] = undefined;
    return copyToArena(a, fmt::formatU32(val, &mut digits[..]));
}

/// Format an `i32` into a string in the arena.
fn formatI32(a: *mut alloc::Arena, val: i32) -> *[u8] {
    let mut digits: [u8; 12] = undefined;
    return copyToArena(a, fmt::formatI32(val, &mut digits[..]));
}

/// Format an `i64` into a string in the arena.
fn formatI64(a: *mut alloc::Arena, val: i64) -> *[u8] {
    let mut digits: [u8; 20] = undefined;
    return copyToArena(a, fmt::formatI64(val, &mut digits[..]));
}

/// Concatenate prefix and string in the arena.
fn prefixStr(a: *mut alloc::Arena, prefix: u8, str: *[u8]) -> *[u8] {
    let len = str.len + 1;
    let ptr = try! alloc::allocSlice(a, 1, 1, len);
    let slice = ptr as *mut [u8];
    slice[0] = prefix;
    try! mem::copy(&mut slice[1..], str);

    return slice;
}

/// Format a register reference (`%n`).
fn regStr(a: *mut alloc::Arena, reg: super::Reg) -> *[u8] {
    return prefixStr(a, '%', formatU32(a, reg.n));
}

/////////////////////
// Output helpers  //
/////////////////////

/// Write a string to the output.
fn write(out: *mut sexpr::Output, s: *[u8]) {
    sexpr::write(out, s);
}

/// Emit indentation.
fn indent(out: *mut sexpr::Output, depth: u32) {
    for _ in 0..depth {
        write(out, "    ");
    }
}

/// Check if name contains the path separator.
fn needsQuoting(name: *[u8]) -> bool {
    for ch in name {
        if ch == ':' {
            return true;
        }
    }
    return false;
}

/// Write a symbol name. Simple names use `$name`, qualified names use `$"name"`.
fn writeSymbol(out: *mut sexpr::Output, name: *[u8]) {
    write(out, "$");
    if needsQuoting(name) {
        write(out, "\"");
        write(out, name);
        write(out, "\"");
    } else {
        write(out, name);
    }
}

////////////////////
// Type printing  //
////////////////////

/// Get the string representation of a type.
fn typeStr(typ: super::Type) -> *[u8] {
    match typ {
        case super::Type::W8 => return "w8",
        case super::Type::W16 => return "w16",
        case super::Type::W32 => return "w32",
        case super::Type::W64 => return "w64",
        case super::Type::Ptr => return "ptr",
    }
}

/// Write a type.
fn writeType(out: *mut sexpr::Output, typ: super::Type) {
    write(out, typeStr(typ));
}

////////////////////////
// Operation printing //
////////////////////////

/// Get the string representation of a binary ALU operation.
fn binOpStr(op: super::BinOp) -> *[u8] {
    match op {
        case super::BinOp::Add => return "add",
        case super::BinOp::Sub => return "sub",
        case super::BinOp::Mul => return "mul",
        case super::BinOp::Sdiv => return "sdiv",
        case super::BinOp::Udiv => return "udiv",
        case super::BinOp::Srem => return "srem",
        case super::BinOp::Urem => return "urem",
        case super::BinOp::Eq => return "eq",
        case super::BinOp::Ne => return "ne",
        case super::BinOp::Slt => return "slt",
        case super::BinOp::Sge => return "sge",
        case super::BinOp::Ult => return "ult",
        case super::BinOp::Uge => return "uge",
        case super::BinOp::And => return "and",
        case super::BinOp::Or => return "or",
        case super::BinOp::Xor => return "xor",
        case super::BinOp::Shl => return "shl",
        case super::BinOp::Sshr => return "sshr",
        case super::BinOp::Ushr => return "ushr",
    }
}

/// Get the string representation of a unary ALU operation.
fn unOpStr(op: super::UnOp) -> *[u8] {
    match op {
        case super::UnOp::Neg => return "neg",
        case super::UnOp::Not => return "not",
    }
}

////////////////////
// Value printing //
////////////////////

/// Write a value (register, immediate, symbol, or undefined).
fn writeVal(out: *mut sexpr::Output, a: *mut alloc::Arena, val: super::Val) {
    match val {
        case super::Val::Reg(reg) => write(out, regStr(a, reg)),
        case super::Val::Imm(v) => write(out, formatI64(a, v)),
        case super::Val::DataSym(name) => writeSymbol(out, name),
        case super::Val::FnAddr(name) => writeSymbol(out, name),
        case super::Val::Undef => write(out, "undefined"),
    }
}

/// Write a register.
fn writeReg(out: *mut sexpr::Output, a: *mut alloc::Arena, reg: super::Reg) {
    write(out, regStr(a, reg));
}

/// Write a comma-separated argument list in parentheses.
fn writeArgs(out: *mut sexpr::Output, a: *mut alloc::Arena, args: *[super::Val]) {
    write(out, "(");
    for arg, i in args {
        if i > 0 {
            write(out, ", ");
        }
        writeVal(out, a, arg);
    }
    write(out, ")");
}

/// Write a typed parameter (e.g., `w32 %0`).
fn writeParam(out: *mut sexpr::Output, a: *mut alloc::Arena, param: super::Param) {
    writeType(out, param.type);
    write(out, " ");
    writeReg(out, a, param.value);
}

/// Write a comma-separated parameter list.
fn writeParams(out: *mut sexpr::Output, a: *mut alloc::Arena, params: *[super::Param]) {
    for param, i in params {
        if i > 0 {
            write(out, ", ");
        }
        writeParam(out, a, param);
    }
}

//////////////////////////
// Instruction printing //
//////////////////////////

/// Write an instruction.
fn writeInstr(out: *mut sexpr::Output, a: *mut alloc::Arena, blocks: *[super::Block], inst: super::Instr) {
    match inst {
        // Memory operations.
        case super::Instr::Reserve { dst, size, alignment } => {
            write(out, "reserve ");
            writeReg(out, a, dst);
            write(out, " ");
            writeVal(out, a, size);
            write(out, " ");
            write(out, formatU32(a, alignment));
        }
        case super::Instr::Load { dst, typ, src, offset } => {
            write(out, "load ");
            writeType(out, typ);
            write(out, " ");
            writeReg(out, a, dst);
            write(out, " ");
            writeReg(out, a, src);
            write(out, " ");
            write(out, formatI32(a, offset));
        }
        case super::Instr::Sload { dst, typ, src, offset } => {
            write(out, "sload ");
            writeType(out, typ);
            write(out, " ");
            writeReg(out, a, dst);
            write(out, " ");
            writeReg(out, a, src);
            write(out, " ");
            write(out, formatI32(a, offset));
        }
        case super::Instr::Store { typ, src, dst, offset } => {
            write(out, "store ");
            writeType(out, typ);
            write(out, " ");
            writeVal(out, a, src);
            write(out, " ");
            writeReg(out, a, dst);
            write(out, " ");
            write(out, formatI32(a, offset));
        }
        case super::Instr::Blit { dst, src, size } => {
            write(out, "blit ");
            writeReg(out, a, dst);
            write(out, " ");
            writeReg(out, a, src);
            write(out, " ");
            writeVal(out, a, size);
        }
        case super::Instr::Copy { dst, val } => {
            write(out, "copy ");
            writeReg(out, a, dst);
            write(out, " ");
            writeVal(out, a, val);
        }

        // ALU operations.
        case super::Instr::BinOp { op, dst, typ, a: va, b } =>
            writeTypedBinOp(out, a, binOpStr(op), typ, dst, va, b),
        case super::Instr::UnOp { op, dst, typ, a: va } =>
            writeTypedUnaryOp(out, a, unOpStr(op), typ, dst, va),

        // Conversion operations.
        case super::Instr::Zext { dst, typ, val } =>
            writeTypedUnaryOp(out, a, "zext", typ, dst, val),
        case super::Instr::Sext { dst, typ, val } =>
            writeTypedUnaryOp(out, a, "sext", typ, dst, val),
        case super::Instr::MakePtr { dst, val } => {
            write(out, "ptr ");
            writeReg(out, a, dst);
            write(out, " ");
            writeVal(out, a, val);
        }

        // Call.
        case super::Instr::Call { dst, retTy, func, args } => {
            write(out, "call ");
            writeType(out, retTy);
            write(out, " ");
            if let d = dst {
                writeReg(out, a, d);
                write(out, " ");
            }
            writeVal(out, a, func);
            writeArgs(out, a, args);
        }

        // Terminators.
        case super::Instr::Ret { val } => {
            write(out, "ret");
            if let v = val {
                write(out, " ");
                writeVal(out, a, v);
            }
        }
        case super::Instr::Jmp { target, args } => {
            write(out, "jmp @");
            write(out, blocks[target].label);
            if args.len > 0 {
                writeArgs(out, a, args);
            }
        }
        case super::Instr::Br { op, typ, a: va, b: vb, thenTarget, thenArgs, elseTarget, elseArgs } => {
            write(out, "br.");
            match op {
                case super::CmpOp::Eq  => write(out, "eq"),
                case super::CmpOp::Ne  => write(out, "ne"),
                case super::CmpOp::Slt => write(out, "slt"),
                case super::CmpOp::Ult => write(out, "ult"),
            }
            write(out, " ");
            writeType(out, typ);
            write(out, " ");
            writeVal(out, a, va);
            write(out, " ");
            writeVal(out, a, vb);
            write(out, " @");
            write(out, blocks[thenTarget].label);
            if thenArgs.len > 0 {
                writeArgs(out, a, thenArgs);
            }
            write(out, " @");
            write(out, blocks[elseTarget].label);
            if elseArgs.len > 0 {
                writeArgs(out, a, elseArgs);
            }
        }
        case super::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {
            write(out, "switch ");
            writeVal(out, a, val);
            for c in cases {
                write(out, " (");
                write(out, formatI64(a, c.value));
                write(out, " @");
                write(out, blocks[c.target].label);
                if c.args.len > 0 {
                    writeArgs(out, a, c.args);
                }
                write(out, ")");
            }
            write(out, " @");
            write(out, blocks[defaultTarget].label);
            if defaultArgs.len > 0 {
                writeArgs(out, a, defaultArgs);
            }
        }
        case super::Instr::Unreachable => {
            write(out, "unreachable");
        }

        // Intrinsics.
        case super::Instr::Ecall { dst, num, a0, a1, a2, a3 } => {
            write(out, "ecall ");
            writeReg(out, a, dst);
            write(out, " ");
            writeVal(out, a, num);
            write(out, " ");
            writeVal(out, a, a0);
            write(out, " ");
            writeVal(out, a, a1);
            write(out, " ");
            writeVal(out, a, a2);
            write(out, " ");
            writeVal(out, a, a3);
        }
        case super::Instr::Ebreak => {
            write(out, "ebreak");
        }
        case super::Instr::Elem { dst, base, idx, len, stride } => {
            write(out, "elem ");
            writeReg(out, a, dst);
            write(out, " ");
            writeReg(out, a, base);
            write(out, " ");
            writeVal(out, a, idx);
            write(out, " ");
            writeVal(out, a, len);
            write(out, " ");
            write(out, formatU32(a, stride));
        }
    }
}

/// Write a typed binary operation: `op type %dst %a %b`.
fn writeTypedBinOp(
    out: *mut sexpr::Output,
    a: *mut alloc::Arena,
    name: *[u8],
    typ: super::Type,
    dst: super::Reg,
    va: super::Val,
    vb: super::Val
) {
    write(out, name);
    write(out, " ");
    writeType(out, typ);
    write(out, " ");
    writeReg(out, a, dst);
    write(out, " ");
    writeVal(out, a, va);
    write(out, " ");
    writeVal(out, a, vb);
}

/// Write a typed unary operation: `op type %dst %val`.
fn writeTypedUnaryOp(
    out: *mut sexpr::Output,
    a: *mut alloc::Arena,
    name: *[u8],
    typ: super::Type,
    dst: super::Reg,
    val: super::Val
) {
    write(out, name);
    write(out, " ");
    writeType(out, typ);
    write(out, " ");
    writeReg(out, a, dst);
    write(out, " ");
    writeVal(out, a, val);
}

////////////////////
// Block printing //
////////////////////

/// Write a basic block.
fn writeBlock(out: *mut sexpr::Output, a: *mut alloc::Arena, blocks: *[super::Block], block: *super::Block) {
    // Block label.
    write(out, "  @");
    write(out, block.label);

    // Block parameters.
    if block.params.len > 0 {
        write(out, "(");
        writeParams(out, a, block.params);
        write(out, ")");
    }
    write(out, "\n");

    // Instructions.
    for instr in block.instrs {
        indent(out, 1);
        writeInstr(out, a, blocks, instr);
        write(out, ";\n");
    }
}

///////////////////////
// Function printing //
///////////////////////

/// Write a function.
fn writeFn(out: *mut sexpr::Output, a: *mut alloc::Arena, f: *super::Fn) {
    // Function signature.
    if f.isExtern {
        write(out, "extern ");
    }
    write(out, "fn ");
    writeType(out, f.returnType);
    write(out, " ");
    writeSymbol(out, f.name);
    write(out, "(");
    writeParams(out, a, f.params);
    write(out, ")");

    // Extern functions have no body.
    if f.isExtern {
        write(out, ";\n");
        return;
    }
    write(out, " {\n");

    // Blocks.
    for i in 0..f.blocks.len {
        if f.blocks[i].instrs.len > 0 {
            writeBlock(out, a, f.blocks, &f.blocks[i]);
        }
    }
    write(out, "}\n");
}

///////////////////
// Data printing //
///////////////////

/// Write a data item.
fn writeDataItem(out: *mut sexpr::Output, a: *mut alloc::Arena, item: super::DataItem) {
    match item {
        case super::DataItem::Val { typ, val } => {
            writeType(out, typ);
            write(out, " ");
            write(out, formatI64(a, val));
        }
        case super::DataItem::Sym(name) => {
            write(out, "sym ");
            writeSymbol(out, name);
        }
        case super::DataItem::Fn(name) => {
            write(out, "fn ");
            writeSymbol(out, name);
        }
        case super::DataItem::Str(s) => {
            write(out, "str ");
            sexpr::printStringTo(out, s);
        }
        case super::DataItem::Undef => {
            write(out, "undef");
        }
    }
}

/// Write a data value (item with optional repeat count).
fn writeDataValue(out: *mut sexpr::Output, a: *mut alloc::Arena, value: super::DataValue) {
    writeDataItem(out, a, value.item);
    if value.count > 1 {
        write(out, " * ");
        write(out, formatU32(a, value.count));
    }
}

/// Write global data.
fn writeData(out: *mut sexpr::Output, a: *mut alloc::Arena, d: super::Data) {
    write(out, "data ");
    if not d.readOnly {
        write(out, "mut ");
    }
    writeSymbol(out, d.name);
    write(out, " align ");
    write(out, formatU32(a, d.alignment));
    write(out, " {\n");

    for v in d.values {
        indent(out, 1);
        writeDataValue(out, a, v);
        write(out, ";\n");
    }
    write(out, "}\n");
}

//////////////////////
// Program printing //
//////////////////////

/// Print a program.
pub fn printProgram(out: *mut sexpr::Output, a: *mut alloc::Arena, program: *super::Program) {
    // Data declarations.
    for data, i in program.data {
        writeData(out, a, data);
        if i < program.data.len - 1 or program.fns.len > 0 {
            write(out, "\n");
        }
    }
    // Functions.
    for func, i in program.fns {
        writeFn(out, a, func);
        if i < program.fns.len - 1 {
            write(out, "\n");
        }
    }
}

/// Print a program to a buffer, returning the written slice.
pub fn printProgramToBuffer(
    program: *super::Program,
    arena: *mut alloc::Arena,
    buf: *mut [u8]
) -> *[u8] {
    let mut pos: u32 = 0;
    let mut out = sexpr::Output::Buffer { buf, pos: &mut pos };
    printProgram(&mut out, arena, program);

    return &buf[..pos];
}

1	//! IL pretty printer.
2
3	use std::fmt;
4	use std::mem;
5	use std::lang::sexpr;
6	use std::lang::alloc;
7
8	///////////////////////
9	// String formatting //
10	///////////////////////
11
12	/// Copy a byte slice into arena-allocated storage.
13	fn copyToArena(a: mut alloc::Arena, text: [u8]) -> *[u8] {
14	let slice = try! alloc::allocSlice(a, 1, 1, text.len) as *mut [u8];
15	try! mem::copy(slice, text);
16	return slice;
17	}
18
19	/// Format a `u32` into a string in the arena.
20	fn formatU32(a: mut alloc::Arena, val: u32) -> [u8] {
21	let mut digits: [u8; 10] = undefined;
22	return copyToArena(a, fmt::formatU32(val, &mut digits[..]));
23	}
24
25	/// Format an `i32` into a string in the arena.
26	fn formatI32(a: mut alloc::Arena, val: i32) -> [u8] {
27	let mut digits: [u8; 12] = undefined;
28	return copyToArena(a, fmt::formatI32(val, &mut digits[..]));
29	}
30
31	/// Format an `i64` into a string in the arena.
32	fn formatI64(a: mut alloc::Arena, val: i64) -> [u8] {
33	let mut digits: [u8; 20] = undefined;
34	return copyToArena(a, fmt::formatI64(val, &mut digits[..]));
35	}
36
37	/// Concatenate prefix and string in the arena.
38	fn prefixStr(a: mut alloc::Arena, prefix: u8, str: [u8]) -> *[u8] {
39	let len = str.len + 1;
40	let ptr = try! alloc::allocSlice(a, 1, 1, len);
41	let slice = ptr as *mut [u8];
42	slice[0] = prefix;
43	try! mem::copy(&mut slice[1..], str);
44
45	return slice;
46	}
47
48	/// Format a register reference (`%n`).
49	fn regStr(a: mut alloc::Arena, reg: super::Reg) -> [u8] {
50	return prefixStr(a, '%', formatU32(a, reg.n));
51	}
52
53	/////////////////////
54	// Output helpers //
55	/////////////////////
56
57	/// Write a string to the output.
58	fn write(out: mut sexpr::Output, s: [u8]) {
59	sexpr::write(out, s);
60	}
61
62	/// Emit indentation.
63	fn indent(out: *mut sexpr::Output, depth: u32) {
64	for _ in 0..depth {
65	write(out, " ");
66	}
67	}
68
69	/// Check if name contains the path separator.
70	fn needsQuoting(name: *[u8]) -> bool {
71	for ch in name {
72	if ch == ':' {
73	return true;
74	}
75	}
76	return false;
77	}
78
79	/// Write a symbol name. Simple names use `$name`, qualified names use `$"name"`.
80	fn writeSymbol(out: mut sexpr::Output, name: [u8]) {
81	write(out, "$");
82	if needsQuoting(name) {
83	write(out, "\"");
84	write(out, name);
85	write(out, "\"");
86	} else {
87	write(out, name);
88	}
89	}
90
91	////////////////////
92	// Type printing //
93	////////////////////
94
95	/// Get the string representation of a type.
96	fn typeStr(typ: super::Type) -> *[u8] {
97	match typ {
98	case super::Type::W8 => return "w8",
99	case super::Type::W16 => return "w16",
100	case super::Type::W32 => return "w32",
101	case super::Type::W64 => return "w64",
102	case super::Type::Ptr => return "ptr",
103	}
104	}
105
106	/// Write a type.
107	fn writeType(out: *mut sexpr::Output, typ: super::Type) {
108	write(out, typeStr(typ));
109	}
110
111	////////////////////////
112	// Operation printing //
113	////////////////////////
114
115	/// Get the string representation of a binary ALU operation.
116	fn binOpStr(op: super::BinOp) -> *[u8] {
117	match op {
118	case super::BinOp::Add => return "add",
119	case super::BinOp::Sub => return "sub",
120	case super::BinOp::Mul => return "mul",
121	case super::BinOp::Sdiv => return "sdiv",
122	case super::BinOp::Udiv => return "udiv",
123	case super::BinOp::Srem => return "srem",
124	case super::BinOp::Urem => return "urem",
125	case super::BinOp::Eq => return "eq",
126	case super::BinOp::Ne => return "ne",
127	case super::BinOp::Slt => return "slt",
128	case super::BinOp::Sge => return "sge",
129	case super::BinOp::Ult => return "ult",
130	case super::BinOp::Uge => return "uge",
131	case super::BinOp::And => return "and",
132	case super::BinOp::Or => return "or",
133	case super::BinOp::Xor => return "xor",
134	case super::BinOp::Shl => return "shl",
135	case super::BinOp::Sshr => return "sshr",
136	case super::BinOp::Ushr => return "ushr",
137	}
138	}
139
140	/// Get the string representation of a unary ALU operation.
141	fn unOpStr(op: super::UnOp) -> *[u8] {
142	match op {
143	case super::UnOp::Neg => return "neg",
144	case super::UnOp::Not => return "not",
145	}
146	}
147
148	////////////////////
149	// Value printing //
150	////////////////////
151
152	/// Write a value (register, immediate, symbol, or undefined).
153	fn writeVal(out: mut sexpr::Output, a: mut alloc::Arena, val: super::Val) {
154	match val {
155	case super::Val::Reg(reg) => write(out, regStr(a, reg)),
156	case super::Val::Imm(v) => write(out, formatI64(a, v)),
157	case super::Val::DataSym(name) => writeSymbol(out, name),
158	case super::Val::FnAddr(name) => writeSymbol(out, name),
159	case super::Val::Undef => write(out, "undefined"),
160	}
161	}
162
163	/// Write a register.
164	fn writeReg(out: mut sexpr::Output, a: mut alloc::Arena, reg: super::Reg) {
165	write(out, regStr(a, reg));
166	}
167
168	/// Write a comma-separated argument list in parentheses.
169	fn writeArgs(out: mut sexpr::Output, a: mut alloc::Arena, args: *[super::Val]) {
170	write(out, "(");
171	for arg, i in args {
172	if i > 0 {
173	write(out, ", ");
174	}
175	writeVal(out, a, arg);
176	}
177	write(out, ")");
178	}
179
180	/// Write a typed parameter (e.g., `w32 %0`).
181	fn writeParam(out: mut sexpr::Output, a: mut alloc::Arena, param: super::Param) {
182	writeType(out, param.type);
183	write(out, " ");
184	writeReg(out, a, param.value);
185	}
186
187	/// Write a comma-separated parameter list.
188	fn writeParams(out: mut sexpr::Output, a: mut alloc::Arena, params: *[super::Param]) {
189	for param, i in params {
190	if i > 0 {
191	write(out, ", ");
192	}
193	writeParam(out, a, param);
194	}
195	}
196
197	//////////////////////////
198	// Instruction printing //
199	//////////////////////////
200
201	/// Write an instruction.
202	fn writeInstr(out: mut sexpr::Output, a: mut alloc::Arena, blocks: *[super::Block], inst: super::Instr) {
203	match inst {
204	// Memory operations.
205	case super::Instr::Reserve { dst, size, alignment } => {
206	write(out, "reserve ");
207	writeReg(out, a, dst);
208	write(out, " ");
209	writeVal(out, a, size);
210	write(out, " ");
211	write(out, formatU32(a, alignment));
212	}
213	case super::Instr::Load { dst, typ, src, offset } => {
214	write(out, "load ");
215	writeType(out, typ);
216	write(out, " ");
217	writeReg(out, a, dst);
218	write(out, " ");
219	writeReg(out, a, src);
220	write(out, " ");
221	write(out, formatI32(a, offset));
222	}
223	case super::Instr::Sload { dst, typ, src, offset } => {
224	write(out, "sload ");
225	writeType(out, typ);
226	write(out, " ");
227	writeReg(out, a, dst);
228	write(out, " ");
229	writeReg(out, a, src);
230	write(out, " ");
231	write(out, formatI32(a, offset));
232	}
233	case super::Instr::Store { typ, src, dst, offset } => {
234	write(out, "store ");
235	writeType(out, typ);
236	write(out, " ");
237	writeVal(out, a, src);
238	write(out, " ");
239	writeReg(out, a, dst);
240	write(out, " ");
241	write(out, formatI32(a, offset));
242	}
243	case super::Instr::Blit { dst, src, size } => {
244	write(out, "blit ");
245	writeReg(out, a, dst);
246	write(out, " ");
247	writeReg(out, a, src);
248	write(out, " ");
249	writeVal(out, a, size);
250	}
251	case super::Instr::Copy { dst, val } => {
252	write(out, "copy ");
253	writeReg(out, a, dst);
254	write(out, " ");
255	writeVal(out, a, val);
256	}
257
258	// ALU operations.
259	case super::Instr::BinOp { op, dst, typ, a: va, b } =>
260	writeTypedBinOp(out, a, binOpStr(op), typ, dst, va, b),
261	case super::Instr::UnOp { op, dst, typ, a: va } =>
262	writeTypedUnaryOp(out, a, unOpStr(op), typ, dst, va),
263
264	// Conversion operations.
265	case super::Instr::Zext { dst, typ, val } =>
266	writeTypedUnaryOp(out, a, "zext", typ, dst, val),
267	case super::Instr::Sext { dst, typ, val } =>
268	writeTypedUnaryOp(out, a, "sext", typ, dst, val),
269	case super::Instr::MakePtr { dst, val } => {
270	write(out, "ptr ");
271	writeReg(out, a, dst);
272	write(out, " ");
273	writeVal(out, a, val);
274	}
275
276	// Call.
277	case super::Instr::Call { dst, retTy, func, args } => {
278	write(out, "call ");
279	writeType(out, retTy);
280	write(out, " ");
281	if let d = dst {
282	writeReg(out, a, d);
283	write(out, " ");
284	}
285	writeVal(out, a, func);
286	writeArgs(out, a, args);
287	}
288
289	// Terminators.
290	case super::Instr::Ret { val } => {
291	write(out, "ret");
292	if let v = val {
293	write(out, " ");
294	writeVal(out, a, v);
295	}
296	}
297	case super::Instr::Jmp { target, args } => {
298	write(out, "jmp @");
299	write(out, blocks[target].label);
300	if args.len > 0 {
301	writeArgs(out, a, args);
302	}
303	}
304	case super::Instr::Br { op, typ, a: va, b: vb, thenTarget, thenArgs, elseTarget, elseArgs } => {
305	write(out, "br.");
306	match op {
307	case super::CmpOp::Eq => write(out, "eq"),
308	case super::CmpOp::Ne => write(out, "ne"),
309	case super::CmpOp::Slt => write(out, "slt"),
310	case super::CmpOp::Ult => write(out, "ult"),
311	}
312	write(out, " ");
313	writeType(out, typ);
314	write(out, " ");
315	writeVal(out, a, va);
316	write(out, " ");
317	writeVal(out, a, vb);
318	write(out, " @");
319	write(out, blocks[thenTarget].label);
320	if thenArgs.len > 0 {
321	writeArgs(out, a, thenArgs);
322	}
323	write(out, " @");
324	write(out, blocks[elseTarget].label);
325	if elseArgs.len > 0 {
326	writeArgs(out, a, elseArgs);
327	}
328	}
329	case super::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {
330	write(out, "switch ");
331	writeVal(out, a, val);
332	for c in cases {
333	write(out, " (");
334	write(out, formatI64(a, c.value));
335	write(out, " @");
336	write(out, blocks[c.target].label);
337	if c.args.len > 0 {
338	writeArgs(out, a, c.args);
339	}
340	write(out, ")");
341	}
342	write(out, " @");
343	write(out, blocks[defaultTarget].label);
344	if defaultArgs.len > 0 {
345	writeArgs(out, a, defaultArgs);
346	}
347	}
348	case super::Instr::Unreachable => {
349	write(out, "unreachable");
350	}
351
352	// Intrinsics.
353	case super::Instr::Ecall { dst, num, a0, a1, a2, a3 } => {
354	write(out, "ecall ");
355	writeReg(out, a, dst);
356	write(out, " ");
357	writeVal(out, a, num);
358	write(out, " ");
359	writeVal(out, a, a0);
360	write(out, " ");
361	writeVal(out, a, a1);
362	write(out, " ");
363	writeVal(out, a, a2);
364	write(out, " ");
365	writeVal(out, a, a3);
366	}
367	case super::Instr::Ebreak => {
368	write(out, "ebreak");
369	}
370	case super::Instr::Elem { dst, base, idx, len, stride } => {
371	write(out, "elem ");
372	writeReg(out, a, dst);
373	write(out, " ");
374	writeReg(out, a, base);
375	write(out, " ");
376	writeVal(out, a, idx);
377	write(out, " ");
378	writeVal(out, a, len);
379	write(out, " ");
380	write(out, formatU32(a, stride));
381	}
382	}
383	}
384
385	/// Write a typed binary operation: `op type %dst %a %b`.
386	fn writeTypedBinOp(
387	out: *mut sexpr::Output,
388	a: *mut alloc::Arena,
389	name: *[u8],
390	typ: super::Type,
391	dst: super::Reg,
392	va: super::Val,
393	vb: super::Val
394	) {
395	write(out, name);
396	write(out, " ");
397	writeType(out, typ);
398	write(out, " ");
399	writeReg(out, a, dst);
400	write(out, " ");
401	writeVal(out, a, va);
402	write(out, " ");
403	writeVal(out, a, vb);
404	}
405
406	/// Write a typed unary operation: `op type %dst %val`.
407	fn writeTypedUnaryOp(
408	out: *mut sexpr::Output,
409	a: *mut alloc::Arena,
410	name: *[u8],
411	typ: super::Type,
412	dst: super::Reg,
413	val: super::Val
414	) {
415	write(out, name);
416	write(out, " ");
417	writeType(out, typ);
418	write(out, " ");
419	writeReg(out, a, dst);
420	write(out, " ");
421	writeVal(out, a, val);
422	}
423
424	////////////////////
425	// Block printing //
426	////////////////////
427
428	/// Write a basic block.
429	fn writeBlock(out: mut sexpr::Output, a: mut alloc::Arena, blocks: [super::Block], block: super::Block) {
430	// Block label.
431	write(out, " @");
432	write(out, block.label);
433
434	// Block parameters.
435	if block.params.len > 0 {
436	write(out, "(");
437	writeParams(out, a, block.params);
438	write(out, ")");
439	}
440	write(out, "\n");
441
442	// Instructions.
443	for instr in block.instrs {
444	indent(out, 1);
445	writeInstr(out, a, blocks, instr);
446	write(out, ";\n");
447	}
448	}
449
450	///////////////////////
451	// Function printing //
452	///////////////////////
453
454	/// Write a function.
455	fn writeFn(out: mut sexpr::Output, a: mut alloc::Arena, f: *super::Fn) {
456	// Function signature.
457	if f.isExtern {
458	write(out, "extern ");
459	}
460	write(out, "fn ");
461	writeType(out, f.returnType);
462	write(out, " ");
463	writeSymbol(out, f.name);
464	write(out, "(");
465	writeParams(out, a, f.params);
466	write(out, ")");
467
468	// Extern functions have no body.
469	if f.isExtern {
470	write(out, ";\n");
471	return;
472	}
473	write(out, " {\n");
474
475	// Blocks.
476	for i in 0..f.blocks.len {
477	if f.blocks[i].instrs.len > 0 {
478	writeBlock(out, a, f.blocks, &f.blocks[i]);
479	}
480	}
481	write(out, "}\n");
482	}
483
484	///////////////////
485	// Data printing //
486	///////////////////
487
488	/// Write a data item.
489	fn writeDataItem(out: mut sexpr::Output, a: mut alloc::Arena, item: super::DataItem) {
490	match item {
491	case super::DataItem::Val { typ, val } => {
492	writeType(out, typ);
493	write(out, " ");
494	write(out, formatI64(a, val));
495	}
496	case super::DataItem::Sym(name) => {
497	write(out, "sym ");
498	writeSymbol(out, name);
499	}
500	case super::DataItem::Fn(name) => {
501	write(out, "fn ");
502	writeSymbol(out, name);
503	}
504	case super::DataItem::Str(s) => {
505	write(out, "str ");
506	sexpr::printStringTo(out, s);
507	}
508	case super::DataItem::Undef => {
509	write(out, "undef");
510	}
511	}
512	}
513
514	/// Write a data value (item with optional repeat count).
515	fn writeDataValue(out: mut sexpr::Output, a: mut alloc::Arena, value: super::DataValue) {
516	writeDataItem(out, a, value.item);
517	if value.count > 1 {
518	write(out, " * ");
519	write(out, formatU32(a, value.count));
520	}
521	}
522
523	/// Write global data.
524	fn writeData(out: mut sexpr::Output, a: mut alloc::Arena, d: super::Data) {
525	write(out, "data ");
526	if not d.readOnly {
527	write(out, "mut ");
528	}
529	writeSymbol(out, d.name);
530	write(out, " align ");
531	write(out, formatU32(a, d.alignment));
532	write(out, " {\n");
533
534	for v in d.values {
535	indent(out, 1);
536	writeDataValue(out, a, v);
537	write(out, ";\n");
538	}
539	write(out, "}\n");
540	}
541
542	//////////////////////
543	// Program printing //
544	//////////////////////
545
546	/// Print a program.
547	pub fn printProgram(out: mut sexpr::Output, a: mut alloc::Arena, program: *super::Program) {
548	// Data declarations.
549	for data, i in program.data {
550	writeData(out, a, data);
551	if i < program.data.len - 1 or program.fns.len > 0 {
552	write(out, "\n");
553	}
554	}
555	// Functions.
556	for func, i in program.fns {
557	writeFn(out, a, func);
558	if i < program.fns.len - 1 {
559	write(out, "\n");
560	}
561	}
562	}
563
564	/// Print a program to a buffer, returning the written slice.
565	pub fn printProgramToBuffer(
566	program: *super::Program,
567	arena: *mut alloc::Arena,
568	buf: *mut [u8]
569	) -> *[u8] {
570	let mut pos: u32 = 0;
571	let mut out = sexpr::Output::Buffer { buf, pos: &mut pos };
572	printProgram(&mut out, arena, program);
573
574	return &buf[..pos];
575	}