//! Build a native machine fixture with the reusable RV64 backend.

use std::sys;

use std::sys::unix;

use std::lang::il;

use std::lang::alloc;

use std::lang::gen::data;

use std::collections::dict;

use std::arch::rv64;

use std::arch::rv64::image;

/// Persistent code generation arena.

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

/// Function lowering and allocation workspace.

static SCRATCH: [u8; 16777216] = [0; 16777216];

/// Data symbol lookup workspace.

unsafe static ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;

/// Compile data accesses and conditional finish writes into a native image.

@default unsafe fn main(env: *sys::Env) -> i32 {

    assert env.args.len == 2;

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

    let mut scratch = alloc::new(&mut SCRATCH[..]);

    let mut generator = try! rv64::beginProgram(rv64::ProgramOptions {

        entryPatch: rv64::EntryPatch::None, debug: false,

        placement: image::Placement::Physical {

            code: 0x80010000, roData: 0x80018000, rwData: 0x80020000, entry: 0x80010000,

        },

    }, &mut arena);

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

    let mut entry = [

        il::Instr::Copy { dst: il::Reg { n: 0 }, val: il::Val::DataSym("fixture::value") },

        il::Instr::Load { typ: il::Type::W64, dst: il::Reg { n: 1 }, src: il::Reg { n: 0 }, offset: 0 },

        il::Instr::Br {

            op: il::CmpOp::Eq, typ: il::Type::W64, a: il::Val::Reg(il::Reg { n: 1 }), b: il::Val::Imm(42),

            thenTarget: 1, thenArgs: &mut args[..], elseTarget: 3, elseArgs: &mut args[..],

        },

    ];

    let mut zero = [

        il::Instr::Copy { dst: il::Reg { n: 2 }, val: il::Val::DataSym("fixture::zero") },

        il::Instr::Load { typ: il::Type::W64, dst: il::Reg { n: 3 }, src: il::Reg { n: 2 }, offset: 0 },

        il::Instr::Br {

            op: il::CmpOp::Eq, typ: il::Type::W64, a: il::Val::Reg(il::Reg { n: 3 }), b: il::Val::Imm(0),

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

        },

    ];

    let mut success = [

        il::Instr::Copy { dst: il::Reg { n: 4 }, val: il::Val::Imm(0x10001000) },

        il::Instr::Store { typ: il::Type::W32, src: il::Val::Imm(0x5555), dst: il::Reg { n: 4 }, offset: 0 },

        il::Instr::Unreachable,

    ];

    let mut failure = [

        il::Instr::Copy { dst: il::Reg { n: 5 }, val: il::Val::Imm(0x10001000) },

        il::Instr::Store { typ: il::Type::W32, src: il::Val::Imm(0x13333), dst: il::Reg { n: 5 }, offset: 0 },

        il::Instr::Unreachable,

    ];

    let func = il::Fn {

        name: "fixture::entry", params: &[], returnType: il::Type::W64, isExtern: false, isLeaf: true,

        blocks: &[

            il::Block { label: "entry", params: &[], instrs: &mut entry[..], locs: &[], preds: &[], loopDepth: 0 },

            il::Block { label: "zero", params: &[], instrs: &mut zero[..], locs: &[], preds: &[0], loopDepth: 0 },

            il::Block { label: "success", params: &[], instrs: &mut success[..], locs: &[], preds: &[1], loopDepth: 0 },

            il::Block { label: "failure", params: &[], instrs: &mut failure[..], locs: &[], preds: &[0, 1], loopDepth: 0 },

        ],

    };

    rv64::generateFunction(&mut generator, &func, &mut scratch);

    let globals = &[

        il::Data {

            name: "fixture::value", size: 8, alignment: 8, readOnly: false, isZeroInit: false,

            values: &[il::DataValue { item: il::DataItem::Val { typ: il::Type::W64, val: 42 }, count: 1 }],

        },

        il::Data {

            name: "fixture::zero", size: 4096, alignment: 8, readOnly: false, isZeroInit: true, values: &[],

        },

    ];

    unsafe static symbols: [data::DataSym; 2] = undefined;

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

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

    let result = try! rv64::finishProgram(&mut generator, globals,

        rv64::Storage { dataSyms: &mut symbols[..], dataSymEntries: &mut ENTRIES[..] },

        &[], &mut ro[..], &mut rw[..]);

    let header = try! image::header(result.layout);

    let code = @sliceOf(result.code.ptr as *u8, result.code.len * 4);

    let fd = unix::openOpts(env.args[1], unix::OpenFlags(*unix::O_WRONLY | *unix::O_CREAT | *unix::O_TRUNC), 420);

    assert fd >= 0;

    let written = unix::writeAll(fd, &header[..]) and unix::writeAll(fd, code) and unix::writeAll(fd, &ro[..result.roDataSize]) and unix::writeAll(fd, &rw[..result.rwDataSize]);

    let closed = unix::close(fd) == 0;

    assert written and closed;

    return 0;

}