radiance · Radiance self-hosting compiler

compiler/ lib/ examples/ std/ arch/ char/ collections/ lang/ alloc/ ast/ gen/ il/ printer.rad 15.7 KiB tests.rad 648 B module/ parser/ resolver/ scanner/ alloc.rad 5.4 KiB ast.rad 23.1 KiB gen.rad 507 B il.rad 15.3 KiB lower.rad 271.6 KiB module.rad 13.5 KiB package.rad 1.2 KiB parser.rad 78.7 KiB resolver.rad 314.0 KiB scanner.rad 17.4 KiB sexpr.rad 6.3 KiB strings.rad 2.2 KiB types.rad 280 B sys/ arch.rad 68 B char.rad 855 B collections.rad 39 B fmt.rad 8.1 KiB intrinsics.rad 683 B io.rad 1.4 KiB lang.rad 360 B mem.rad 2.2 KiB sys.rad 173 B testing.rad 2.4 KiB tests.rad 15.4 KiB vec.rad 4.8 KiB std.rad 358 B scripts/ seed/ sublime/ test/ vim/ .gitignore 336 B .gitsigners 112 B LICENSE 1.1 KiB Makefile 3.7 KiB README 2.5 KiB STYLE 2.5 KiB std.lib 1.2 KiB std.lib.test 373 B

lib/std/lang/il/printer.rad 15.7 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];
    set 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",
    }
}

/// 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),

        // 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::MemoryFence => {
            write(out, "memory-fence");
        }
    }
}

/// 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.
export 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.
export 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	set 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	}
103	}
104
105	/// Write a type.
106	fn writeType(out: *mut sexpr::Output, typ: super::Type) {
107	write(out, typeStr(typ));
108	}
109
110	////////////////////////
111	// Operation printing //
112	////////////////////////
113
114	/// Get the string representation of a binary ALU operation.
115	fn binOpStr(op: super::BinOp) -> *[u8] {
116	match op {
117	case super::BinOp::Add => return "add",
118	case super::BinOp::Sub => return "sub",
119	case super::BinOp::Mul => return "mul",
120	case super::BinOp::Sdiv => return "sdiv",
121	case super::BinOp::Udiv => return "udiv",
122	case super::BinOp::Srem => return "srem",
123	case super::BinOp::Urem => return "urem",
124	case super::BinOp::Eq => return "eq",
125	case super::BinOp::Ne => return "ne",
126	case super::BinOp::Slt => return "slt",
127	case super::BinOp::Sge => return "sge",
128	case super::BinOp::Ult => return "ult",
129	case super::BinOp::Uge => return "uge",
130	case super::BinOp::And => return "and",
131	case super::BinOp::Or => return "or",
132	case super::BinOp::Xor => return "xor",
133	case super::BinOp::Shl => return "shl",
134	case super::BinOp::Sshr => return "sshr",
135	case super::BinOp::Ushr => return "ushr",
136	}
137	}
138
139	/// Get the string representation of a unary ALU operation.
140	fn unOpStr(op: super::UnOp) -> *[u8] {
141	match op {
142	case super::UnOp::Neg => return "neg",
143	case super::UnOp::Not => return "not",
144	}
145	}
146
147	////////////////////
148	// Value printing //
149	////////////////////
150
151	/// Write a value (register, immediate, symbol, or undefined).
152	fn writeVal(out: mut sexpr::Output, a: mut alloc::Arena, val: super::Val) {
153	match val {
154	case super::Val::Reg(reg) => write(out, regStr(a, reg)),
155	case super::Val::Imm(v) => write(out, formatI64(a, v)),
156	case super::Val::DataSym(name) => writeSymbol(out, name),
157	case super::Val::FnAddr(name) => writeSymbol(out, name),
158	case super::Val::Undef => write(out, "undefined"),
159	}
160	}
161
162	/// Write a register.
163	fn writeReg(out: mut sexpr::Output, a: mut alloc::Arena, reg: super::Reg) {
164	write(out, regStr(a, reg));
165	}
166
167	/// Write a comma-separated argument list in parentheses.
168	fn writeArgs(out: mut sexpr::Output, a: mut alloc::Arena, args: *[super::Val]) {
169	write(out, "(");
170	for arg, i in args {
171	if i > 0 {
172	write(out, ", ");
173	}
174	writeVal(out, a, arg);
175	}
176	write(out, ")");
177	}
178
179	/// Write a typed parameter (e.g., `w32 %0`).
180	fn writeParam(out: mut sexpr::Output, a: mut alloc::Arena, param: super::Param) {
181	writeType(out, param.type);
182	write(out, " ");
183	writeReg(out, a, param.value);
184	}
185
186	/// Write a comma-separated parameter list.
187	fn writeParams(out: mut sexpr::Output, a: mut alloc::Arena, params: *[super::Param]) {
188	for param, i in params {
189	if i > 0 {
190	write(out, ", ");
191	}
192	writeParam(out, a, param);
193	}
194	}
195
196	//////////////////////////
197	// Instruction printing //
198	//////////////////////////
199
200	/// Write an instruction.
201	fn writeInstr(out: mut sexpr::Output, a: mut alloc::Arena, blocks: *[super::Block], inst: super::Instr) {
202	match inst {
203	// Memory operations.
204	case super::Instr::Reserve { dst, size, alignment } => {
205	write(out, "reserve ");
206	writeReg(out, a, dst);
207	write(out, " ");
208	writeVal(out, a, size);
209	write(out, " ");
210	write(out, formatU32(a, alignment));
211	}
212	case super::Instr::Load { dst, typ, src, offset } => {
213	write(out, "load ");
214	writeType(out, typ);
215	write(out, " ");
216	writeReg(out, a, dst);
217	write(out, " ");
218	writeReg(out, a, src);
219	write(out, " ");
220	write(out, formatI32(a, offset));
221	}
222	case super::Instr::Sload { dst, typ, src, offset } => {
223	write(out, "sload ");
224	writeType(out, typ);
225	write(out, " ");
226	writeReg(out, a, dst);
227	write(out, " ");
228	writeReg(out, a, src);
229	write(out, " ");
230	write(out, formatI32(a, offset));
231	}
232	case super::Instr::Store { typ, src, dst, offset } => {
233	write(out, "store ");
234	writeType(out, typ);
235	write(out, " ");
236	writeVal(out, a, src);
237	write(out, " ");
238	writeReg(out, a, dst);
239	write(out, " ");
240	write(out, formatI32(a, offset));
241	}
242	case super::Instr::Blit { dst, src, size } => {
243	write(out, "blit ");
244	writeReg(out, a, dst);
245	write(out, " ");
246	writeReg(out, a, src);
247	write(out, " ");
248	writeVal(out, a, size);
249	}
250	case super::Instr::Copy { dst, val } => {
251	write(out, "copy ");
252	writeReg(out, a, dst);
253	write(out, " ");
254	writeVal(out, a, val);
255	}
256
257	// ALU operations.
258	case super::Instr::BinOp { op, dst, typ, a: va, b } =>
259	writeTypedBinOp(out, a, binOpStr(op), typ, dst, va, b),
260	case super::Instr::UnOp { op, dst, typ, a: va } =>
261	writeTypedUnaryOp(out, a, unOpStr(op), typ, dst, va),
262
263	// Conversion operations.
264	case super::Instr::Zext { dst, typ, val } =>
265	writeTypedUnaryOp(out, a, "zext", typ, dst, val),
266	case super::Instr::Sext { dst, typ, val } =>
267	writeTypedUnaryOp(out, a, "sext", typ, dst, val),
268
269	// Call.
270	case super::Instr::Call { dst, retTy, func, args } => {
271	write(out, "call ");
272	writeType(out, retTy);
273	write(out, " ");
274	if let d = dst {
275	writeReg(out, a, d);
276	write(out, " ");
277	}
278	writeVal(out, a, func);
279	writeArgs(out, a, args);
280	}
281
282	// Terminators.
283	case super::Instr::Ret { val } => {
284	write(out, "ret");
285	if let v = val {
286	write(out, " ");
287	writeVal(out, a, v);
288	}
289	}
290	case super::Instr::Jmp { target, args } => {
291	write(out, "jmp @");
292	write(out, blocks[target].label);
293	if args.len > 0 {
294	writeArgs(out, a, args);
295	}
296	}
297	case super::Instr::Br { op, typ, a: va, b: vb, thenTarget, thenArgs, elseTarget, elseArgs } => {
298	write(out, "br.");
299	match op {
300	case super::CmpOp::Eq => write(out, "eq"),
301	case super::CmpOp::Ne => write(out, "ne"),
302	case super::CmpOp::Slt => write(out, "slt"),
303	case super::CmpOp::Ult => write(out, "ult"),
304	}
305	write(out, " ");
306	writeType(out, typ);
307	write(out, " ");
308	writeVal(out, a, va);
309	write(out, " ");
310	writeVal(out, a, vb);
311	write(out, " @");
312	write(out, blocks[thenTarget].label);
313	if thenArgs.len > 0 {
314	writeArgs(out, a, thenArgs);
315	}
316	write(out, " @");
317	write(out, blocks[elseTarget].label);
318	if elseArgs.len > 0 {
319	writeArgs(out, a, elseArgs);
320	}
321	}
322	case super::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {
323	write(out, "switch ");
324	writeVal(out, a, val);
325	for c in cases {
326	write(out, " (");
327	write(out, formatI64(a, c.value));
328	write(out, " @");
329	write(out, blocks[c.target].label);
330	if c.args.len > 0 {
331	writeArgs(out, a, c.args);
332	}
333	write(out, ")");
334	}
335	write(out, " @");
336	write(out, blocks[defaultTarget].label);
337	if defaultArgs.len > 0 {
338	writeArgs(out, a, defaultArgs);
339	}
340	}
341	case super::Instr::Unreachable => {
342	write(out, "unreachable");
343	}
344
345	// Intrinsics.
346	case super::Instr::Ecall { dst, num, a0, a1, a2, a3 } => {
347	write(out, "ecall ");
348	writeReg(out, a, dst);
349	write(out, " ");
350	writeVal(out, a, num);
351	write(out, " ");
352	writeVal(out, a, a0);
353	write(out, " ");
354	writeVal(out, a, a1);
355	write(out, " ");
356	writeVal(out, a, a2);
357	write(out, " ");
358	writeVal(out, a, a3);
359	}
360	case super::Instr::Ebreak => {
361	write(out, "ebreak");
362	}
363	case super::Instr::MemoryFence => {
364	write(out, "memory-fence");
365	}
366	}
367	}
368
369	/// Write a typed binary operation: `op type %dst %a %b`.
370	fn writeTypedBinOp(
371	out: *mut sexpr::Output,
372	a: *mut alloc::Arena,
373	name: *[u8],
374	typ: super::Type,
375	dst: super::Reg,
376	va: super::Val,
377	vb: super::Val
378	) {
379	write(out, name);
380	write(out, " ");
381	writeType(out, typ);
382	write(out, " ");
383	writeReg(out, a, dst);
384	write(out, " ");
385	writeVal(out, a, va);
386	write(out, " ");
387	writeVal(out, a, vb);
388	}
389
390	/// Write a typed unary operation: `op type %dst %val`.
391	fn writeTypedUnaryOp(
392	out: *mut sexpr::Output,
393	a: *mut alloc::Arena,
394	name: *[u8],
395	typ: super::Type,
396	dst: super::Reg,
397	val: super::Val
398	) {
399	write(out, name);
400	write(out, " ");
401	writeType(out, typ);
402	write(out, " ");
403	writeReg(out, a, dst);
404	write(out, " ");
405	writeVal(out, a, val);
406	}
407
408	////////////////////
409	// Block printing //
410	////////////////////
411
412	/// Write a basic block.
413	fn writeBlock(out: mut sexpr::Output, a: mut alloc::Arena, blocks: [super::Block], block: super::Block) {
414	// Block label.
415	write(out, " @");
416	write(out, block.label);
417
418	// Block parameters.
419	if block.params.len > 0 {
420	write(out, "(");
421	writeParams(out, a, block.params);
422	write(out, ")");
423	}
424	write(out, "\n");
425
426	// Instructions.
427	for instr in block.instrs {
428	indent(out, 1);
429	writeInstr(out, a, blocks, instr);
430	write(out, ";\n");
431	}
432	}
433
434	///////////////////////
435	// Function printing //
436	///////////////////////
437
438	/// Write a function.
439	fn writeFn(out: mut sexpr::Output, a: mut alloc::Arena, f: *super::Fn) {
440	// Function signature.
441	if f.isExtern {
442	write(out, "extern ");
443	}
444	write(out, "fn ");
445	writeType(out, f.returnType);
446	write(out, " ");
447	writeSymbol(out, f.name);
448	write(out, "(");
449	writeParams(out, a, f.params);
450	write(out, ")");
451
452	// Extern functions have no body.
453	if f.isExtern {
454	write(out, ";\n");
455	return;
456	}
457	write(out, " {\n");
458
459	// Blocks.
460	for i in 0..f.blocks.len {
461	if f.blocks[i].instrs.len > 0 {
462	writeBlock(out, a, f.blocks, &f.blocks[i]);
463	}
464	}
465	write(out, "}\n");
466	}
467
468	///////////////////
469	// Data printing //
470	///////////////////
471
472	/// Write a data item.
473	fn writeDataItem(out: mut sexpr::Output, a: mut alloc::Arena, item: super::DataItem) {
474	match item {
475	case super::DataItem::Val { typ, val } => {
476	writeType(out, typ);
477	write(out, " ");
478	write(out, formatI64(a, val));
479	}
480	case super::DataItem::Sym(name) => {
481	write(out, "sym ");
482	writeSymbol(out, name);
483	}
484	case super::DataItem::Fn(name) => {
485	write(out, "fn ");
486	writeSymbol(out, name);
487	}
488	case super::DataItem::Str(s) => {
489	write(out, "str ");
490	sexpr::printStringTo(out, s);
491	}
492	case super::DataItem::Undef => {
493	write(out, "undef");
494	}
495	}
496	}
497
498	/// Write a data value (item with optional repeat count).
499	fn writeDataValue(out: mut sexpr::Output, a: mut alloc::Arena, value: super::DataValue) {
500	writeDataItem(out, a, value.item);
501	if value.count > 1 {
502	write(out, " * ");
503	write(out, formatU32(a, value.count));
504	}
505	}
506
507	/// Write global data.
508	fn writeData(out: mut sexpr::Output, a: mut alloc::Arena, d: super::Data) {
509	write(out, "data ");
510	if not d.readOnly {
511	write(out, "mut ");
512	}
513	writeSymbol(out, d.name);
514	write(out, " align ");
515	write(out, formatU32(a, d.alignment));
516	write(out, " {\n");
517
518	for v in d.values {
519	indent(out, 1);
520	writeDataValue(out, a, v);
521	write(out, ";\n");
522	}
523	write(out, "}\n");
524	}
525
526	//////////////////////
527	// Program printing //
528	//////////////////////
529
530	/// Print a program.
531	export fn printProgram(out: mut sexpr::Output, a: mut alloc::Arena, program: *super::Program) {
532	// Data declarations.
533	for data, i in program.data {
534	writeData(out, a, data);
535	if i < program.data.len - 1 or program.fns.len > 0 {
536	write(out, "\n");
537	}
538	}
539	// Functions.
540	for func, i in program.fns {
541	writeFn(out, a, func);
542	if i < program.fns.len - 1 {
543	write(out, "\n");
544	}
545	}
546	}
547
548	/// Print a program to a buffer, returning the written slice.
549	export fn printProgramToBuffer(
550	program: *super::Program,
551	arena: *mut alloc::Arena,
552	buf: *mut [u8]
553	) -> *[u8] {
554	let mut pos: u32 = 0;
555	let mut out = sexpr::Output::Buffer { buf, pos: &mut pos };
556	printProgram(&mut out, arena, program);
557
558	return &buf[..pos];
559	}