export mod binary;

//! Binary RIL wire definitions. Integers use little-endian byte order.

//! Sequences have a u32 element count. Symbols use u32 table indices.

//! Optional fields use a byte: zero for absent, one for present.

export mod writer;

@test export mod tests;

/// Binary RIL signature, encoded as the bytes RIL followed by zero.

export constant MAGIC: u32 = 0x004c4952;

/// Binary RIL format version.

export constant VERSION: u32 = 1;

/// A binary RIL encoding or decoding failure.

export union Error: Copy {

    /// The output buffer has insufficient space.

    Capacity,

    /// A referenced name is absent from the symbol table.

    Symbol,

    /// An integer width, tag, or field is invalid.

    Invalid,

    /// The input ends inside a field.

    Truncated,

    /// The decode arena has insufficient space.

    Storage,

}

/// Wire tag for value Reg.

export constant VALUE_REG: u8 = 0;

/// Wire tag for value Imm.

export constant VALUE_IMM: u8 = 1;

/// Wire tag for value DataSym.

export constant VALUE_DATASYM: u8 = 2;

/// Wire tag for value FnAddr.

export constant VALUE_FNADDR: u8 = 3;

/// Wire tag for value Undef.

export constant VALUE_UNDEF: u8 = 4;

/// Wire tag for instruction Reserve.

export constant INSTR_RESERVE: u8 = 0;

/// Wire tag for instruction Load.

export constant INSTR_LOAD: u8 = 1;

/// Wire tag for instruction Sload.

export constant INSTR_SLOAD: u8 = 2;

/// Wire tag for instruction Store.

export constant INSTR_STORE: u8 = 3;

/// Wire tag for instruction Blit.

export constant INSTR_BLIT: u8 = 4;

/// Wire tag for instruction Copy.

export constant INSTR_COPY: u8 = 5;

/// Wire tag for instruction BinOp.

export constant INSTR_BINOP: u8 = 6;

/// Wire tag for instruction UnOp.

export constant INSTR_UNOP: u8 = 7;

/// Wire tag for instruction Zext.

export constant INSTR_ZEXT: u8 = 8;

/// Wire tag for instruction Sext.

export constant INSTR_SEXT: u8 = 9;

/// Wire tag for instruction Call.

export constant INSTR_CALL: u8 = 10;

/// Wire tag for instruction Ret.

export constant INSTR_RET: u8 = 11;

/// Wire tag for instruction Jmp.

export constant INSTR_JMP: u8 = 12;

/// Wire tag for instruction Br.

export constant INSTR_BR: u8 = 13;

/// Wire tag for instruction Switch.

export constant INSTR_SWITCH: u8 = 14;

/// Wire tag for instruction Unreachable.

export constant INSTR_UNREACHABLE: u8 = 15;

/// Wire tag for instruction Ecall.

export constant INSTR_ECALL: u8 = 16;

/// Wire tag for instruction Ebreak.

export constant INSTR_EBREAK: u8 = 17;

/// Wire tag for instruction MemoryFence.

export constant INSTR_MEMORYFENCE: u8 = 18;

/// Wire tag for data Val.

export constant DATA_VAL: u8 = 0;

/// Wire tag for data Sym.

export constant DATA_SYM: u8 = 1;

/// Wire tag for data Fn.

export constant DATA_FN: u8 = 2;

/// Wire tag for data Str.

export constant DATA_STR: u8 = 3;

/// Wire tag for data Undef.

export constant DATA_UNDEF: u8 = 4;

/// Wire tag for binary operation Add.

export constant BIN_ADD: u8 = 0;

/// Wire tag for binary operation Sub.

export constant BIN_SUB: u8 = 1;

/// Wire tag for binary operation Mul.

export constant BIN_MUL: u8 = 2;

/// Wire tag for binary operation Sdiv.

export constant BIN_SDIV: u8 = 3;

/// Wire tag for binary operation Udiv.

export constant BIN_UDIV: u8 = 4;

/// Wire tag for binary operation Srem.

export constant BIN_SREM: u8 = 5;

/// Wire tag for binary operation Urem.

export constant BIN_UREM: u8 = 6;

/// Wire tag for binary operation Eq.

export constant BIN_EQ: u8 = 7;

/// Wire tag for binary operation Ne.

export constant BIN_NE: u8 = 8;

/// Wire tag for binary operation Slt.

export constant BIN_SLT: u8 = 9;

/// Wire tag for binary operation Sge.

export constant BIN_SGE: u8 = 10;

/// Wire tag for binary operation Ult.

export constant BIN_ULT: u8 = 11;

/// Wire tag for binary operation Uge.

export constant BIN_UGE: u8 = 12;

/// Wire tag for binary operation And.

export constant BIN_AND: u8 = 13;

/// Wire tag for binary operation Or.

export constant BIN_OR: u8 = 14;

/// Wire tag for binary operation Xor.

export constant BIN_XOR: u8 = 15;

/// Wire tag for binary operation Shl.

export constant BIN_SHL: u8 = 16;

/// Wire tag for binary operation Sshr.

export constant BIN_SSHR: u8 = 17;

/// Wire tag for binary operation Ushr.

export constant BIN_USHR: u8 = 18;

/// Wire tag for unary operation Neg.

export constant UN_NEG: u8 = 0;

/// Wire tag for unary operation Not.

export constant UN_NOT: u8 = 1;

/// Wire tag for comparison Eq.

export constant CMP_EQ: u8 = 0;

/// Wire tag for comparison Ne.

export constant CMP_NE: u8 = 1;

/// Wire tag for comparison Slt.

export constant CMP_SLT: u8 = 2;

/// Wire tag for comparison Ult.

export constant CMP_ULT: u8 = 3;

//! Binary RIL encoding fixtures.

use std::testing;

use std::lang::il;

use std::lang::il::binary::writer;

use std::lang::il::binary;

/// Decode arena backing storage. Tests reset it before each use.

static MEMORY: [u8; 512] = [0; 512];

/// Check little-endian encoding for every integer width.

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

    let mut buffer: [u8; 15] = [0; 15];

    let mut out = writer::new(&mut buffer[..], &[]);

    try writer::integer(&mut out, 0x12, 1) catch { throw testing::TestError::Failed; };

    try writer::integer(&mut out, 0x3456, 2) catch { throw testing::TestError::Failed; };

    try writer::integer(&mut out, 0x789abcde, 4) catch { throw testing::TestError::Failed; };

    try writer::integer(&mut out, 0x0123456789abcdef, 8) catch { throw testing::TestError::Failed; };

    try testing::expectBytesEq(&buffer[..], &[0x12, 0x56, 0x34, 0xde, 0xbc, 0x9a, 0x78, 0xef, 0xcd,

        0xab, 0x89, 0x67, 0x45, 0x23, 0x01]);

}

/// Compare one instruction with its fixed wire representation.

unsafe fn instruction(item: il::Instr, expected: &[u8]) throws (testing::TestError) {

    let mut buffer: [u8; 256] = [0; 256];

    let mut out = writer::new(&mut buffer[..], &["data", "fn"]);

    try writer::instr(&mut out, item) catch { throw testing::TestError::Failed; };

    try testing::expectBytesEq(&buffer[..out.offset], expected);

    for capacity in 0..expected.len {

        let mut short = writer::new(&mut buffer[..capacity], &["data", "fn"]);

        let mut failed = false;

        try writer::instr(&mut short, item) catch err {

            try testing::expect(err == binary::Error::Capacity);

            set failed = true;

        };

        try testing::expect(failed);

        try testing::expect(short.offset <= capacity);

    }

}

/// Check all instruction tags and their field order.

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

    let mut args: [il::Val; 1] = [il::Val::Undef];

    let mut cases: [il::SwitchCase; 1] = [il::SwitchCase {

        value: -1, target: 2, args: &mut args[..],

    }];

    try instruction(il::Instr::Reserve {

        dst: il::Reg { n: 1 }, size: il::Val::Undef, alignment: 16,

    }, &[0, 1, 0, 0, 0, 4, 16, 0, 0, 0]);

    try instruction(il::Instr::Load {

        typ: il::Type::W8, dst: il::Reg { n: 1 }, src: il::Reg { n: 2 }, offset: -1,

    }, &[1, 1, 1, 0, 0, 0, 2, 0, 0, 0, 255, 255, 255, 255]);

    try instruction(il::Instr::Sload {

        typ: il::Type::W16, dst: il::Reg { n: 1 }, src: il::Reg { n: 2 }, offset: 3,

    }, &[2, 2, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0]);

    try instruction(il::Instr::Store {

        typ: il::Type::W32, src: il::Val::Undef, dst: il::Reg { n: 2 }, offset: 3,

    }, &[3, 4, 4, 2, 0, 0, 0, 3, 0, 0, 0]);

    try instruction(il::Instr::Blit {

        dst: il::Reg { n: 1 }, src: il::Reg { n: 2 }, size: il::Val::Undef,

    }, &[4, 1, 0, 0, 0, 2, 0, 0, 0, 4]);

    try instruction(il::Instr::Copy {

        dst: il::Reg { n: 1 }, val: il::Val::Undef,

    }, &[5, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::BinOp {

        op: il::BinOp::Add, typ: il::Type::W64, dst: il::Reg { n: 1 }, a: il::Val::Undef,

        b: il::Val::Undef,

    }, &[6, 0, 8, 1, 0, 0, 0, 4, 4]);

    try instruction(il::Instr::UnOp {

        op: il::UnOp::Neg, typ: il::Type::W64, dst: il::Reg { n: 1 }, a: il::Val::Undef,

    }, &[7, 0, 8, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Zext {

        typ: il::Type::W8, dst: il::Reg { n: 1 }, val: il::Val::Undef,

    }, &[8, 1, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Sext {

        typ: il::Type::W16, dst: il::Reg { n: 1 }, val: il::Val::Undef,

    }, &[9, 2, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Call {

        retTy: il::Type::W64, dst: nil, func: il::Val::FnAddr("fn"), args: &[],

    }, &[10, 8, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0]);

    try instruction(il::Instr::Call {

        retTy: il::Type::W64, dst: il::Reg { n: 2 }, func: il::Val::FnAddr("fn"), args: &args[..],

    }, &[10, 8, 1, 2, 0, 0, 0, 3, 1, 0, 0, 0, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Ret {

        val: nil,

    }, &[11, 0]);

    try instruction(il::Instr::Ret {

        val: il::Val::Undef,

    }, &[11, 1, 4]);

    try instruction(il::Instr::Jmp {

        target: 2, args: &mut args[..],

    }, &[12, 2, 0, 0, 0, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Br {

        op: il::CmpOp::Eq, typ: il::Type::W32, a: il::Val::Undef, b: il::Val::Undef, thenTarget: 1,

        thenArgs: &mut args[..], elseTarget: 2, elseArgs: &mut args[..],

    }, &[13, 0, 4, 4, 4, 1, 0, 0, 0, 1, 0, 0, 0, 4, 2, 0, 0, 0, 1, 0, 0, 0, 4]);

    try instruction(il::Instr::Switch {

        val: il::Val::Undef, defaultTarget: 1, defaultArgs: &mut args[..], cases: &mut cases[..],

    }, &[

        14, 4, 1, 0, 0, 0, 1, 0, 0, 0, 4, 1,

        0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 2,

        0, 0, 0, 1, 0, 0, 0, 4,

    ]);

    try instruction(il::Instr::Unreachable, &[15]);

    try instruction(il::Instr::Ecall {

        dst: il::Reg { n: 1 }, num: il::Val::Undef, a0: il::Val::Undef, a1: il::Val::Undef,

        a2: il::Val::Undef, a3: il::Val::Undef,

    }, &[16, 1, 0, 0, 0, 4, 4, 4, 4, 4]);

    try instruction(il::Instr::Ebreak, &[17]);

    try instruction(il::Instr::MemoryFence, &[18]);

}

/// Check every value tag and empty and nonempty sequences.

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

    let mut buffer: [u8; 64] = [0; 64];

    let mut out = writer::new(&mut buffer[..], &["data", "fn"]);

    try writer::values(&mut out, &[]) catch { throw testing::TestError::Failed; };

    try writer::values(&mut out, &[

        il::Val::Reg(il::Reg { n: 0x12345678 }),

        il::Val::Imm(-2), il::Val::DataSym("data"),

        il::Val::FnAddr("fn"), il::Val::Undef,

    ]) catch { throw testing::TestError::Failed; };

    try testing::expectBytesEq(&buffer[..out.offset], &[

        0, 0, 0, 0, 5, 0, 0, 0,

        0, 0x78, 0x56, 0x34, 0x12,

        1, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

        2, 0, 0, 0, 0, 3, 1, 0, 0, 0, 4,

    ]);

}

/// Check initializer bytes and repetition counts.

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

    let mut buffer: [u8; 128] = [0; 128];

    let mut out = writer::new(&mut buffer[..], &["data", "fn"]);

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W8,

        val: -1 }, count: 0 }) catch { throw testing::TestError::Failed; };

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W16,

        val: -2 }, count: 1 }) catch { throw testing::TestError::Failed; };

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W32,

        val: -3 }, count: 2 }) catch { throw testing::TestError::Failed; };

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Val { typ: il::Type::W64,

        val: -4 }, count: 3 }) catch { throw testing::TestError::Failed; };

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Sym("data"), count: 4 })

        catch { throw testing::TestError::Failed; };

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Fn("fn"), count: 5 }) catch

        { throw testing::TestError::Failed; };

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Str("ab"), count: 6 }) catch

        { throw testing::TestError::Failed; };

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Str(""), count: 7 }) catch {

        throw testing::TestError::Failed; };

    try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Undef, count: 8 }) catch {

        throw testing::TestError::Failed; };

    try testing::expectBytesEq(&buffer[..out.offset], &[0, 1, 255, 0, 0, 0, 0, 0, 2, 254, 255, 1, 0,

        0, 0, 0, 4, 253, 255, 255, 255, 2, 0, 0, 0, 0, 8, 252, 255, 255, 255, 255, 255, 255, 255, 3,

        0, 0, 0, 1, 0, 0, 0, 0, 4, 0, 0, 0, 2, 1, 0, 0, 0, 5, 0, 0, 0, 3, 2, 0, 0, 0, 97, 98, 6, 0,

        0, 0, 3, 0, 0, 0, 0, 7, 0, 0, 0, 4, 8, 0, 0, 0]);

}

/// Reject invalid widths, insufficient storage, and absent symbols.

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

    let mut buffer: [u8; 8] = [0; 8];

    let mut out = writer::new(&mut buffer[..], &[]);

    let mut failures: u32 = 0;

    try writer::integer(&mut out, 1, 3) catch err {

        try testing::expect(err == binary::Error::Invalid);

        set failures += 1;

    };

    try writer::symbol(&mut out, "absent") catch err {

        try testing::expect(err == binary::Error::Symbol);

        set failures += 1;

    };

    try testing::expect(out.offset == 0);

    try writer::integer(&mut out, 0, 8) catch { throw testing::TestError::Failed; };

    try writer::integer(&mut out, 1, 1) catch err {

        try testing::expect(err == binary::Error::Capacity);

        set failures += 1;

    };

    try testing::expect(failures == 3);

    try testing::expect(out.offset == 8);

}

/// Check operation tags independently of the native union representation.

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

    let binaryOps = &[

        il::BinOp::Add, il::BinOp::Sub, il::BinOp::Mul,

        il::BinOp::Sdiv, il::BinOp::Udiv, il::BinOp::Srem,

        il::BinOp::Urem, il::BinOp::Eq, il::BinOp::Ne,

        il::BinOp::Slt, il::BinOp::Sge, il::BinOp::Ult,

        il::BinOp::Uge, il::BinOp::And, il::BinOp::Or,

        il::BinOp::Xor, il::BinOp::Shl, il::BinOp::Sshr,

        il::BinOp::Ushr,

    ];

    for op, tag in binaryOps {

        try instruction(il::Instr::BinOp {

            op, typ: il::Type::W64, dst: il::Reg { n: 1 },

            a: il::Val::Undef, b: il::Val::Undef,

        }, &[6, tag as u8, 8, 1, 0, 0, 0, 4, 4]);

    }

    for op, tag in &[il::UnOp::Neg, il::UnOp::Not] {

        try instruction(il::Instr::UnOp {

            op, typ: il::Type::W64, dst: il::Reg { n: 1 },

            a: il::Val::Undef,

        }, &[7, tag as u8, 8, 1, 0, 0, 0, 4]);

    }

    let mut empty: [il::Val; 0] = [];

    for op, tag in &[il::CmpOp::Eq, il::CmpOp::Ne, il::CmpOp::Slt, il::CmpOp::Ult] {

        try instruction(il::Instr::Br {

            op, typ: il::Type::W8, a: il::Val::Undef, b: il::Val::Undef,

            thenTarget: 1, thenArgs: &mut empty[..],

            elseTarget: 2, elseArgs: &mut empty[..],

        }, &[13, tag as u8, 1, 4, 4, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0]);

    }

}

/// Check byte-sequence bounds at every output size.

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

    let mut buffer: [u8; 7] = [0; 7];

    for capacity in 0..7 {

        let mut out = writer::new(&mut buffer[..capacity], &[]);

        let mut failed = false;

        try writer::bytes(&mut out, "abc") catch err {

            try testing::expect(err == binary::Error::Capacity);

            set failed = true;

        };

        try testing::expect(failed);

        try testing::expect(out.offset <= capacity);

    }

    let mut out = writer::new(&mut buffer[..], &[]);

    try writer::bytes(&mut out, "abc") catch { throw testing::TestError::Failed; };

    try testing::expectBytesEq(&buffer[..], &[3, 0, 0, 0, 97, 98, 99]);

}

//! Bounded binary RIL encoding into caller-owned storage.

//! After an error, discard bytes written by the failed operation.

use std::lang::il;

use std::mem;

use std::lang::il::binary;

/// Output cursor and the symbol table used by this package.

/// The output buffer and symbol table must remain valid until the last write.

export record Writer: Copy {

    /// Destination bytes.

    bytes: *unsafe mut [u8],

    /// Number of bytes written.

    offset: u32,

    /// Names in wire-index order. The caller supplies unique names.

    symbols: *unsafe [*[u8]],

}

/// Create an output cursor without allocation.

/// The caller must retain exclusive access to the output buffer.

export unsafe fn new(bytes: &mut [u8], symbols: *unsafe [*[u8]]) -> Writer {

    return Writer { bytes: bytes as *unsafe mut [u8], offset: 0, symbols };

}

/// Write the low bytes of an integer with width 1, 2, 4, or 8.

export unsafe fn integer(out: &mut Writer, value: u64, width: u32) throws (binary::Error) {

    if width <> 1 and width <> 2 and width <> 4 and width <> 8 {

        throw binary::Error::Invalid;

    }

    if out.offset > out.bytes.len or width > out.bytes.len - out.offset {

        throw binary::Error::Capacity;

    }

    for i in 0..width {

        set out.bytes[out.offset + i] = (value >> (i * 8) as u64) as u8;

    }

    set out.offset += width;

}

/// Write a byte sequence with its u32 length.

export unsafe fn bytes(out: &mut Writer, value: &[u8]) throws (binary::Error) {

    try integer(out, value.len as u64, 4);

    if value.len > out.bytes.len - out.offset {

        throw binary::Error::Capacity;

    }

    for b, i in value {

        set out.bytes[out.offset + i] = b;

    }

    set out.offset += value.len;

}

/// Write the index of a name in the package symbol table.

export unsafe fn symbol(out: &mut Writer, name: &[u8]) throws (binary::Error) {

    for candidate, i in out.symbols {

        if mem::eq(candidate, name) {

            try integer(out, i as u64, 4);

            return;

        }

    }

    throw binary::Error::Symbol;

}

/// Write an IL type as its byte width.

export unsafe fn typ(out: &mut Writer, value: il::Type) throws (binary::Error) {

    try integer(out, il::typeSize(value) as u64, 1);

}

/// Write a tagged value. Symbol addresses use table indices.

export unsafe fn val(out: &mut Writer, value: il::Val) throws (binary::Error) {

    match value {

        case il::Val::Reg(reg) => {

            try integer(out, super::VALUE_REG as u64, 1);

            try integer(out, reg.n as u64, 4);

        },

        case il::Val::Imm(n) => {

            try integer(out, super::VALUE_IMM as u64, 1);

            try integer(out, n as u64, 8);

        },

        case il::Val::DataSym(name) => {

            try integer(out, super::VALUE_DATASYM as u64, 1);

            try symbol(out, name);

        },

        case il::Val::FnAddr(name) => {

            try integer(out, super::VALUE_FNADDR as u64, 1);

            try symbol(out, name);

        },

        case il::Val::Undef => try integer(out, super::VALUE_UNDEF as u64, 1),

    }

}

/// Write a sequence of values.

export unsafe fn values(out: &mut Writer, items: &[il::Val]) throws (binary::Error) {

    try integer(out, items.len as u64, 4);

    for item in items {

        try val(out, item);

    }

}

/// Write an explicit bin operation tag.

unsafe fn binOp(out: &mut Writer, value: il::BinOp) throws (binary::Error) {

    match value {

        case il::BinOp::Add => try integer(out, super::BIN_ADD as u64, 1),

        case il::BinOp::Sub => try integer(out, super::BIN_SUB as u64, 1),

        case il::BinOp::Mul => try integer(out, super::BIN_MUL as u64, 1),

        case il::BinOp::Sdiv => try integer(out, super::BIN_SDIV as u64, 1),

        case il::BinOp::Udiv => try integer(out, super::BIN_UDIV as u64, 1),

        case il::BinOp::Srem => try integer(out, super::BIN_SREM as u64, 1),

        case il::BinOp::Urem => try integer(out, super::BIN_UREM as u64, 1),

        case il::BinOp::Eq => try integer(out, super::BIN_EQ as u64, 1),

        case il::BinOp::Ne => try integer(out, super::BIN_NE as u64, 1),

        case il::BinOp::Slt => try integer(out, super::BIN_SLT as u64, 1),

        case il::BinOp::Sge => try integer(out, super::BIN_SGE as u64, 1),

        case il::BinOp::Ult => try integer(out, super::BIN_ULT as u64, 1),

        case il::BinOp::Uge => try integer(out, super::BIN_UGE as u64, 1),

        case il::BinOp::And => try integer(out, super::BIN_AND as u64, 1),

        case il::BinOp::Or => try integer(out, super::BIN_OR as u64, 1),

        case il::BinOp::Xor => try integer(out, super::BIN_XOR as u64, 1),

        case il::BinOp::Shl => try integer(out, super::BIN_SHL as u64, 1),

        case il::BinOp::Sshr => try integer(out, super::BIN_SSHR as u64, 1),

        case il::BinOp::Ushr => try integer(out, super::BIN_USHR as u64, 1),

    }

}

/// Write an explicit un operation tag.

unsafe fn unOp(out: &mut Writer, value: il::UnOp) throws (binary::Error) {

    match value {

        case il::UnOp::Neg => try integer(out, super::UN_NEG as u64, 1),

        case il::UnOp::Not => try integer(out, super::UN_NOT as u64, 1),

    }

}

/// Write an explicit cmp operation tag.

unsafe fn cmpOp(out: &mut Writer, value: il::CmpOp) throws (binary::Error) {

    match value {

        case il::CmpOp::Eq => try integer(out, super::CMP_EQ as u64, 1),

        case il::CmpOp::Ne => try integer(out, super::CMP_NE as u64, 1),

        case il::CmpOp::Slt => try integer(out, super::CMP_SLT as u64, 1),

        case il::CmpOp::Ult => try integer(out, super::CMP_ULT as u64, 1),

    }

}

/// Write one instruction. Fields follow the IL record declaration order.

export unsafe fn instr(out: &mut Writer, item: il::Instr) throws (binary::Error) {

    match item {

        case il::Instr::Reserve { dst: vdst, size: vsize, alignment: valignment } => {

            try integer(out, super::INSTR_RESERVE as u64, 1);

            try integer(out, vdst.n as u64, 4);

            try val(out, vsize);

            try integer(out, valignment as u64, 4);

        },

        case il::Instr::Load { typ: vtyp, dst: vdst, src: vsrc, offset: voffset } => {

            try integer(out, super::INSTR_LOAD as u64, 1);

            try typ(out, vtyp);

            try integer(out, vdst.n as u64, 4);

            try integer(out, vsrc.n as u64, 4);

            try integer(out, voffset as u64, 4);

        },

        case il::Instr::Sload { typ: vtyp, dst: vdst, src: vsrc, offset: voffset } => {

            try integer(out, super::INSTR_SLOAD as u64, 1);

            try typ(out, vtyp);

            try integer(out, vdst.n as u64, 4);

            try integer(out, vsrc.n as u64, 4);

            try integer(out, voffset as u64, 4);

        },

        case il::Instr::Store { typ: vtyp, src: vsrc, dst: vdst, offset: voffset } => {

            try integer(out, super::INSTR_STORE as u64, 1);

            try typ(out, vtyp);

            try val(out, vsrc);

            try integer(out, vdst.n as u64, 4);

            try integer(out, voffset as u64, 4);

        },

        case il::Instr::Blit { dst: vdst, src: vsrc, size: vsize } => {

            try integer(out, super::INSTR_BLIT as u64, 1);

            try integer(out, vdst.n as u64, 4);

            try integer(out, vsrc.n as u64, 4);

            try val(out, vsize);

        },

        case il::Instr::Copy { dst: vdst, val: vval } => {

            try integer(out, super::INSTR_COPY as u64, 1);

            try integer(out, vdst.n as u64, 4);

            try val(out, vval);

        },

        case il::Instr::BinOp { op: vop, typ: vtyp, dst: vdst, a: va, b: vb } => {

            try integer(out, super::INSTR_BINOP as u64, 1);

            try binOp(out, vop);

            try typ(out, vtyp);

            try integer(out, vdst.n as u64, 4);

            try val(out, va);

            try val(out, vb);

        },

        case il::Instr::UnOp { op: vop, typ: vtyp, dst: vdst, a: va } => {

            try integer(out, super::INSTR_UNOP as u64, 1);

            try unOp(out, vop);

            try typ(out, vtyp);

            try integer(out, vdst.n as u64, 4);

            try val(out, va);

        },

        case il::Instr::Zext { typ: vtyp, dst: vdst, val: vval } => {

            try integer(out, super::INSTR_ZEXT as u64, 1);

            try typ(out, vtyp);

            try integer(out, vdst.n as u64, 4);

            try val(out, vval);

        },

        case il::Instr::Sext { typ: vtyp, dst: vdst, val: vval } => {

            try integer(out, super::INSTR_SEXT as u64, 1);

            try typ(out, vtyp);

            try integer(out, vdst.n as u64, 4);

            try val(out, vval);

        },

        case il::Instr::Call { retTy: vretTy, dst: vdst, func: vfunc, args: vargs } => {

            try integer(out, super::INSTR_CALL as u64, 1);

            try typ(out, vretTy);

            if let present = vdst {

                try integer(out, 1, 1);

                try integer(out, present.n as u64, 4);

            } else {

                try integer(out, 0, 1);

            }

            try val(out, vfunc);

            try values(out, vargs);

        },

        case il::Instr::Ret { val: vval } => {

            try integer(out, super::INSTR_RET as u64, 1);

            if let present = vval {

                try integer(out, 1, 1);

                try val(out, present);

            } else {

                try integer(out, 0, 1);

            }

        },

        case il::Instr::Jmp { target: vtarget, args: vargs } => {

            try integer(out, super::INSTR_JMP as u64, 1);

            try integer(out, vtarget as u64, 4);

            try values(out, vargs);

        },

        case il::Instr::Br { op: vop, typ: vtyp, a: va, b: vb, thenTarget: vthenTarget, thenArgs: vthenArgs, elseTarget: velseTarget, elseArgs: velseArgs } => {

            try integer(out, super::INSTR_BR as u64, 1);

            try cmpOp(out, vop);

            try typ(out, vtyp);

            try val(out, va);

            try val(out, vb);

            try integer(out, vthenTarget as u64, 4);

            try values(out, vthenArgs);

            try integer(out, velseTarget as u64, 4);

            try values(out, velseArgs);

        },

        case il::Instr::Switch { val: vval, defaultTarget: vdefaultTarget, defaultArgs: vdefaultArgs, cases: vcases } => {

            try integer(out, super::INSTR_SWITCH as u64, 1);

            try val(out, vval);

            try integer(out, vdefaultTarget as u64, 4);

            try values(out, vdefaultArgs);

            try integer(out, vcases.len as u64, 4);

            for branch in vcases {

                try integer(out, branch.value as u64, 8);

                try integer(out, branch.target as u64, 4);

                try values(out, branch.args);

            }

        },

        case il::Instr::Unreachable => {

            try integer(out, super::INSTR_UNREACHABLE as u64, 1);

        },

        case il::Instr::Ecall { dst: vdst, num: vnum, a0: va0, a1: va1, a2: va2, a3: va3 } => {

            try integer(out, super::INSTR_ECALL as u64, 1);

            try integer(out, vdst.n as u64, 4);

            try val(out, vnum);

            try val(out, va0);

            try val(out, va1);

            try val(out, va2);

            try val(out, va3);

        },

        case il::Instr::Ebreak => {

            try integer(out, super::INSTR_EBREAK as u64, 1);

        },

        case il::Instr::MemoryFence => {

            try integer(out, super::INSTR_MEMORYFENCE as u64, 1);

        },

    }

}

/// Write one data initializer and its repetition count.

export unsafe fn dataValue(out: &mut Writer, value: il::DataValue) throws (binary::Error) {

    match value.item {

        case il::DataItem::Val { typ: t, val: n } => {

            try integer(out, super::DATA_VAL as u64, 1);

            try typ(out, t);

            try integer(out, n as u64, il::typeSize(t));

        },

        case il::DataItem::Sym(name) => {

            try integer(out, super::DATA_SYM as u64, 1);

            try symbol(out, name);

        },

        case il::DataItem::Fn(name) => {

            try integer(out, super::DATA_FN as u64, 1);

            try symbol(out, name);

        },

        case il::DataItem::Str(text) => {

            try integer(out, super::DATA_STR as u64, 1);

            try bytes(out, text);

        },

        case il::DataItem::Undef => try integer(out, super::DATA_UNDEF as u64, 1),

    }

    try integer(out, value.count as u64, 4);

}

lib/std/lang/il/binary.rad

lib/std/lang/il/binary/writer.rad

lib/std/lang/il/binary/tests.rad