//! 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;

export mod reader;

export mod program;

export mod collect;

use std::lang::il;

@test export mod tests;

@test export mod decodeTests;

/// 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 a checked device read.

export constant INSTR_DEVICE_READ: u8 = 19;

/// Wire tag for a checked device write.

export constant INSTR_DEVICE_WRITE: u8 = 20;

/// 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;

/// The kind of an exported package symbol.

export union ExportKind: Copy {

    /// A callable function entry.

    Function,

    /// A global data definition.

    Data,

}

/// A public symbol supplied by a package.

export record Export: Copy {

    /// Qualified symbol name.

    name: *[u8],

    /// Definition kind.

    kind: ExportKind,

}

/// A binary package and its IL definitions.

/// Referenced storage must remain valid and immutable while the package is read.

export record Package: Copy {

    /// Unique symbol names in wire-index order.

    symbols: *unsafe [*[u8]],

    /// Immutable package name.

    name: *[u8],

    /// Names of required packages.

    dependencies: *unsafe [*[u8]],

    /// Public definitions.

    exports: *unsafe [Export],

    /// Default exported entry, if the package has one.

    entry: ?*[u8],

    /// Package-local functions and global data.

    program: il::Program,

}

/// Structural limits supplied by the consumer of decoded IL.

export record Limits: Copy {

    /// Exclusive upper bound for SSA register numbers.

    registers: u32,

    /// Maximum number of blocks in one function.

    blocks: u32,

}