match inst {

        // Call.

        case super::Instr::Call { dst, retTy, func, args } => {

            write(out, "call ");

            writeType(out, retTy);

            write(out, " ");

            if let d = dst {

                writeReg(out, d);

                write(out, " ");

            }

            writeVal(out, func);

            writeArgs(out, args);

        }

        case super::Instr::Jmp { target, args } => {

            write(out, "jmp @");

            write(out, blocks[target].label);

            if args.len > 0 {

                writeArgs(out, 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, va);

            write(out, " ");

            writeVal(out, vb);

            write(out, " @");

            write(out, blocks[thenTarget].label);

            if thenArgs.len > 0 {

                writeArgs(out, thenArgs);

            }

            write(out, " @");

            write(out, blocks[elseTarget].label);

            if elseArgs.len > 0 {

                writeArgs(out, elseArgs);

            }

        }

        case super::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {

            write(out, "switch ");

            writeVal(out, val);

            for c in cases {

                write(out, " (");

                writeI64(out, c.value);

                write(out, " @");

                write(out, blocks[c.target].label);

                if c.args.len > 0 {

                    writeArgs(out, c.args);

                }

                write(out, ")");

            }

            write(out, " @");

            write(out, blocks[defaultTarget].label);

            if defaultArgs.len > 0 {

                writeArgs(out, defaultArgs);

            }

        }

        else => writeFixedInstr(out, inst),

    }

}

/// Write an instruction whose operands need no graph traversal.

fn writeFixedInstr(out: &mut opaque sexpr::Output, inst: super::Instr) {

        case super::Instr::Call { .. }, super::Instr::Jmp { .. },

             super::Instr::Br { .. }, super::Instr::Switch { .. } =>

            panic "writeFixedInstr: expected fixed operands",

use std::lang::il::printer;

/// Check one instruction between the function header and closing delimiter.

unsafe fn checkPrintedInstruction(instr: super::Instr, expected: &[u8]) throws (testing::TestError) {

    let mut instructions = [instr];

    let blocks = [super::Block {

        label: "entry", params: &[], instrs: &mut instructions[..],

        locs: &[], preds: &[], loopDepth: 0,

    }];

    let function = super::Fn {

        name: "sample", params: &[], returnType: super::Type::W64,

        isExtern: false, isLeaf: true, blocks: &blocks[..],

    };

    let functions: [*unsafe super::Fn; 1] = [&function];

    let program = super::Program { data: &[], fns: &functions[..] };

    let mut storage: [u8; 512] = [0; 512];

    let bytes: 'output = &mut storage[..] in {

        let mut out = sexpr::Buffer 'output { buf: bytes, pos: 0 };

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

        let prefix = "fn w64 $sample() {\n  @entry\n    ";

        let suffix = ";\n}\n";

        try testing::expect(out.pos == prefix.len + expected.len + suffix.len);

        try testing::expectBytesEq(&out.buf[..prefix.len], prefix);

        try testing::expectBytesEq(&out.buf[prefix.len..prefix.len + expected.len], expected);

        try testing::expectBytesEq(&out.buf[prefix.len + expected.len..out.pos], suffix);

    }

}

/// Fixed instruction formatting preserves operands, widths, and optional returns.

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

    let dst = super::Reg { n: 4294967295 };

    let reg = super::Reg { n: 2 };

    let value = super::Val::Imm(-9223372036854775808);

    let source = super::Val::Reg(reg);

    try checkPrintedInstruction(super::Instr::Reserve { dst, size: value, alignment: 8 }, "reserve %4294967295 -9223372036854775808 8");

    try checkPrintedInstruction(super::Instr::Load { typ: super::Type::W8, dst, src: reg, offset: -2147483648 }, "load w8 %4294967295 %2 -2147483648");

    try checkPrintedInstruction(super::Instr::Sload { typ: super::Type::W16, dst, src: reg, offset: 2147483647 }, "sload w16 %4294967295 %2 2147483647");

    try checkPrintedInstruction(super::Instr::Store { typ: super::Type::W32, src: source, dst: reg, offset: 0 }, "store w32 %2 %2 0");

    try checkPrintedInstruction(super::Instr::Blit { dst, src: reg, size: value }, "blit %4294967295 %2 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::Copy { dst, val: super::Val::Undef }, "copy %4294967295 undefined");

    try checkPrintedInstruction(super::Instr::BinOp { op: super::BinOp::Add, typ: super::Type::W64, dst, a: source, b: value }, "add w64 %4294967295 %2 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::UnOp { op: super::UnOp::Not, typ: super::Type::W64, dst, a: source }, "not w64 %4294967295 %2");

    try checkPrintedInstruction(super::Instr::Zext { typ: super::Type::W8, dst, val: source }, "zext w8 %4294967295 %2");

    try checkPrintedInstruction(super::Instr::Sext { typ: super::Type::W32, dst, val: value }, "sext w32 %4294967295 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::Ret { val: nil }, "ret");

    try checkPrintedInstruction(super::Instr::Ret { val: value }, "ret -9223372036854775808");

    try checkPrintedInstruction(super::Instr::Unreachable, "unreachable");

    try checkPrintedInstruction(super::Instr::Ecall { dst, num: value, a0: source, a1: value, a2: source, a3: value }, "ecall %4294967295 -9223372036854775808 %2 -9223372036854775808 %2 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::DeviceRead { typ: super::Type::W8, dst, handle: source, offset: value }, "device-read w8 %4294967295 %2 -9223372036854775808");

    try checkPrintedInstruction(super::Instr::DeviceWrite { typ: super::Type::W64, handle: source, offset: value, value: source }, "device-write w64 %2 -9223372036854775808 %2");

    try checkPrintedInstruction(super::Instr::Ebreak, "ebreak");

    try checkPrintedInstruction(super::Instr::MemoryFence, "memory-fence");

}