let entryPkg = try getEntryPackage(ctx);

    if let directory = ctx.rilDirectory {

        try emitPackages(ctx, res, directory);

        return;

    }

    if ctx.dump == Dump::Il {

        // Lower all packages into a single unified IL program for dumping.

        let program = try lowerAllPackages(ctx, res);

        il::printer::printProgram(&mut out, &program);

}

unsafe fn printInstrText(instr: u32) -> *[u8] {

    let mut arena = alloc::new(&mut PRINT_ARENA_STORAGE[..]);

    let mut pos: u32 = 0;

    return &PRINT_BUFFER[..pos];

}

@test unsafe fn testAssemblePercentPrefixedRegisters() throws (testing::TestError) {

    let program = try assembleSource(

///////////////////////

// Output Helpers    //

///////////////////////

/// Write a string to output.

    sexpr::write(out, s);

}

/// Format `i32` into arena.

unsafe fn formatI32(a: &mut alloc::Arena, val: i32) -> *[u8] {

/// Mnemonic column width for alignment.

constant MNEMONIC_WIDTH: u32 = 8;

/// Write text wrapped in parentheses.

    write(out, "(");

    write(out, s);

    write(out, ")");

}

/// Write strings separated by ", ".

    for part, i in parts {

        if i > 0 {

            write(out, ", ");

        }

        write(out, part);

    }

}

/// Write mnemonic with padding for alignment.

    write(out, m);

    let mut i = m.len;

    while i < MNEMONIC_WIDTH {

        write(out, " ");

        set i += 1;

////////////////////////////////

// Instruction Format Helpers //

////////////////////////////////

/// R-type: `op rd, rs1, rs2`.

    writeMnem(out, m);

    writeDelim(out, &[regNameR(rd), regNameR(rs1), regNameR(rs2)]);

}

/// I-type: `op rd, rs1, imm`.

    writeMnem(out, m);

    writeDelim(out, &[regNameR(rd), regNameR(rs1), formatI32(a, imm)]);

}

/// 2-reg: `op rd, rs`.

    writeMnem(out, m);

    writeDelim(out, &[regNameR(rd), regNameR(rs)]);

}

/// reg + imm: `op rd, imm`.

    writeMnem(out, m);

    writeDelim(out, &[regNameR(rd), formatI32(a, imm)]);

}

/// imm only: `op imm`.

    writeMnem(out, m);

    write(out, formatI32(a, imm));

}

/// 1-reg: `op rs`.

    writeMnem(out, m);

    write(out, regNameR(rs));

}

/// Load: `op rd, imm(rs1)`.

    writeMnem(out, m);

    writeDelim(out, &[regNameR(rd), formatI32(a, imm)]);

    writeParens(out, regNameR(rs1));

}

/// Store: `op rs2, imm(rs1)`.

    writeMnem(out, m);

    writeDelim(out, &[regNameR(rs2), formatI32(a, imm)]);

    writeParens(out, regNameR(rs1));

}

/// Branch: `op rs1, rs2, imm`.

    writeMnem(out, m);

    writeDelim(out, &[regNameR(rs1), regNameR(rs2), formatI32(a, imm)]);

}

/// Branch zero: `op rs1, imm`.

    writeMnem(out, m);

    writeDelim(out, &[regNameR(rs1), formatI32(a, imm)]);

}

/// Print a single instruction to output buffer.

    let decoded = decode::decode(instr);

    match decoded {

        case decode::Instr::Lui { rd, imm } => fmtRI(out, a, "lui", rd, imm),

        case decode::Instr::Auipc { rd, imm } => fmtRI(out, a, "auipc", rd, imm),

        },

    }

}

/// Print code with labels to the given output.

    // Package header.

    write(out, "# package `");

    write(out, pkgName);

    write(out, "`\n\n");

    }

    return nil;

}

/// Print a memory-ordering mask in canonical order.

    if mask == 0 {

        write(out, "0");

        return;

    }

    if (mask & 8) <> 0 {

///////////////////////

// String formatting //

///////////////////////

/// Write a `u32` before its stack buffer leaves scope.

    let start = fmt::formatU32(val, &mut digits[..]);

    write(out, &digits[start..]);

}

/// Write an `i32` before its stack buffer leaves scope.

    let start = fmt::formatI32(val, &mut digits[..]);

    write(out, &digits[start..]);

}

/// Write an `i64` before its stack buffer leaves scope.

    let start = fmt::formatI64(val, &mut digits[..]);

    write(out, &digits[start..]);

}

/////////////////////

// Output helpers  //

/////////////////////

/// Write a string to the output.

    sexpr::write(out, s);

}

/// Emit indentation.

    for _ in 0..depth {

        write(out, "    ");

    }

}

    }

    return false;

}

/// Write a symbol name. Simple names use `$name`, qualified names use `$"name"`.

    write(out, "$");

    if needsQuoting(name) {

        write(out, "\"");

        write(out, name);

        write(out, "\"");

        case super::Type::W64 => return "w64",

    }

}

/// Write a type.

    write(out, typeStr(typ));

}

////////////////////////

// Operation printing //

////////////////////

// Value printing //

////////////////////

/// Write a value (register, immediate, symbol, or undefined).

    match val {

        case super::Val::Reg(reg) => writeReg(out, reg),

        case super::Val::Imm(v) => writeI64(out, 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 in one operation before its stack buffer leaves scope.

    let start = fmt::formatU32(reg.n, &mut buffer[1..]);

    set buffer[start] = '%';

    write(out, &buffer[start..]);

}

/// Write a comma-separated argument list in parentheses.

    write(out, "(");

    for arg, i in args {

        if i > 0 {

            write(out, ", ");

        }

    }

    write(out, ")");

}

/// Write a typed parameter (e.g., `w32 %0`).

    writeType(out, param.type);

    write(out, " ");

    writeReg(out, param.value);

}

/// Write a comma-separated parameter list.

    for param, i in params {

        if i > 0 {

            write(out, ", ");

        }

        writeParam(out, param);

//////////////////////////

// Instruction printing //

//////////////////////////

/// Write an instruction.

    match inst {

        // Memory operations.

        case super::Instr::Reserve { dst, size, alignment } => {

            write(out, "reserve ");

            writeReg(out, dst);

        }

    }

}

/// Write a typed binary operation: `op type %dst %a %b`.

    name: *[u8],

    typ: super::Type,

    dst: super::Reg,

    va: super::Val,

    vb: super::Val

    write(out, " ");

    writeVal(out, vb);

}

/// Write a typed unary operation: `op type %dst %val`.

    name: *[u8],

    typ: super::Type,

    dst: super::Reg,

    val: super::Val

) {

////////////////////

// Block printing //

////////////////////

/// Write a basic block.

    // Block label.

    write(out, "  @");

    write(out, block.label);

    // Block parameters.

///////////////////////

// Function printing //

///////////////////////

/// Write a function.

    // Function signature.

    if f.isExtern {

        write(out, "extern ");

    }

    write(out, "fn ");

///////////////////

// Data printing //

///////////////////

/// Write a data item.

    match item {

        case super::DataItem::Val { typ, val } => {

            writeType(out, typ);

            write(out, " ");

            writeI64(out, val);

        }

    }

}

/// Write a data value (item with optional repeat count).

    writeDataItem(out, value.item);

    if value.count > 1 {

        write(out, " * ");

        writeU32(out, value.count);

    }

}

/// Write global data.

    write(out, "data ");

    if not d.readOnly {

        write(out, "mut ");

    }

    writeSymbol(out, d.name);

//////////////////////

// Program printing //

//////////////////////

/// Print a program.

    // Data declarations.

    for data, i in program.data {

        writeData(out, data);

        if i < program.data.len - 1 or program.fns.len > 0 {

            write(out, "\n");

export unsafe fn printProgramToBuffer(

    program: &super::Program,

    buf: *mut [u8]

) -> *[u8] {

    let mut pos: u32 = 0;

    return &buf[..pos];

}

//! Tests for RIL source register iteration.

use std::testing;

/// Fixed register cursors can be initialized in safe code.

@test fn testSafeRegisterCursor() throws (testing::TestError) {

    let instr = super::Instr::Ecall {

        dst: super::Reg { n: 0 },

use std::io;

use std::lang::alloc;

/// Output target for S-expression printing.

}

/// An S-expression element.

export union Expr: Copy {

    /// An empty expression.

export unsafe fn block(a: &mut alloc::Arena, name: *[u8], items: &[Expr], children: &[Expr]) -> Expr {

    return Expr::Block { name, items: allocItems(a, items), children: allocItems(a, children) };

}

/// Write a string to the output target.

}

/// Emit indentation to the output target.

    for _ in 0..depth {

        write(out, "  ");

    }

}

/// Print a single character with escaping to the output target.

    match c {

        case '\n' => write(out, "\\n"),

        case '\r' => write(out, "\\r"),

        case '\t' => write(out, "\\t"),

        case '\\' => write(out, "\\\\"),

        else => write(out, &[c]),

    }

}

/// Print a quoted string with escape sequences to the output target.

    write(out, "\"");

    for i in 0..s.len {

        printEscapedTo(out, s[i]);

    }

    write(out, "\"");

}

/// Print a character literal with escape sequences to the output target.

    write(out, "'");

    printEscapedTo(out, c);

    write(out, "'");

}

/// Print an S-expression to the given output target at the given depth.

    match expr {

        case Expr::Null => {},

        case Expr::Sym(s) => write(out, s),

        case Expr::Str(s) => printStringTo(out, s),

        case Expr::Char(c) => printCharTo(out, c),

        }

    }

}

/// Print an S-expression to stdout at the given indentation depth.

    printTo(expr, depth, &mut out);

}

/// Emit indentation for `depth` levels to stdout.

    indentTo(&mut out, depth);

}