//! Application package fixture.

use support;

/// Return the shared package's state.

@default fn main() -> u64 { return support::read() + support::value; }

//! Verify compiler-emitted binary RIL package boundaries.

use std::sys;

use std::sys::unix;

use std::mem;

use std::lang::alloc;

use std::lang::il;

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

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

/// Maximum fixture image size.

constant IMAGE_SIZE: u32 = 4096;

/// Arena capacity for both decoded fixture packages.

constant ARENA_SIZE: u32 = 32768;

/// Input image storage.

static IMAGE: [u8; IMAGE_SIZE] = [0; IMAGE_SIZE];

/// Decoded package storage.

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

/// Decode one compiler output file.

unsafe fn load(path: *[u8], arena: &mut alloc::Arena) -> binary::Package {

    let length = unix::readFile(path, &mut IMAGE[..]) else panic "load: cannot read fixture";

    return try! program::decode(&IMAGE[..length], arena, binary::Limits { registers: 8192, blocks: 4096 });

}

/// Check identity, ownership, linkage, and source exports for two packages.

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

    assert env.args.len == 3, "main: expected two package paths";

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

    let support = load(env.args[1], &mut arena);

    let app = load(env.args[2], &mut arena);

    assert mem::eq(support.name, "support"), "main: mem::eq(support.name, \"support\")";

    assert mem::eq(app.name, "app"), "main: mem::eq(app.name, \"app\")";

    assert support.dependencies.len == 0, "main: support.dependencies.len == 0";

    assert app.dependencies.len == 1, "main: app.dependencies.len == 1";

    assert mem::eq(app.dependencies[0], "support"), "main: mem::eq(app.dependencies[0], \"support\")";

    assert support.program.fns.len == 1, "main: support.program.fns.len == 1";

    assert support.program.data.len == 1, "main: support.program.data.len == 1";

    assert mem::eq(support.program.fns[0].name, "support::read"), "main: mem::eq(support.program.fns[0].name, \"support::read\")";

    assert mem::eq(support.program.data[0].name, "support::value"), "main: mem::eq(support.program.data[0].name, \"support::value\")";

    assert app.program.fns.len == 1, "main: app.program.fns.len == 1";

    assert app.program.data.len == 0, "main: app.program.data.len == 0";

    assert mem::eq(app.program.fns[0].name, "app::main"), "main: mem::eq(app.program.fns[0].name, \"app::main\")";

    assert support.exports.len == 2, "main: support.exports.len == 2";

    assert app.exports.len == 1, "main: app.exports.len == 1";

    assert app.exports[0].kind == binary::ExportKind::Function, "main: app.exports[0].kind == binary::ExportKind::Function";

    let entry = app.entry else panic "main: missing package entry";

    assert mem::eq(entry, "app::main"), "main: mem::eq(entry, \"app::main\")";

    let mut callFound = false;

    let mut dataFound = false;

    for block in app.program.fns[0].blocks {

        for instr in block.instrs {

            match instr {

                case il::Instr::Call { func, .. } => {

                    if let case il::Val::FnAddr(name) = func {

                        if mem::eq(name, "support::read") {

                            set callFound = true;

                        }

                    }

                },

                case il::Instr::Copy { val, .. } => {

                    if let case il::Val::DataSym(name) = val {

                        if mem::eq(name, "support::value") {

                            set dataFound = true;

                        }

                    }

                },

                else => {

                },

            }

        }

    }

    assert callFound and dataFound, "main: callFound and dataFound";

    return 0;

}

#!/bin/sh

# Check separate RIL package output and reproducible bytes.

set -eu

emulator=${RAD_EMULATOR:-emulator}

work=$(mktemp -d)

trap 'rm -rf "$work"' EXIT HUP INT TERM

mkdir "$work/first" "$work/second"

for output in first second; do

    "$emulator" -memory-size=385024 -data-size=348160 -stack-size=512 \

        -run bin/radiance.rv64.dev \

        -pkg support -mod test/packages/support.rad \

        -pkg app -mod test/packages/app.rad -entry app -ril "$work/$output"

done

cmp "$work/first/support.ril" "$work/second/support.ril"

cmp "$work/first/app.ril" "$work/second/app.ril"

"$emulator" -run bin/packages.check.rv64 -- "$work/first/support.ril" "$work/first/app.ril"

"$emulator" -memory-size=385024 -data-size=348160 -stack-size=512 \

    -run bin/radiance.rv64.dev \

    -pkg support -mod test/packages/support.rad \

    -pkg app -mod test/packages/app.rad -entry app -o "$work/hosted.rv64"

status=0

"$emulator" -run "$work/hosted.rv64" || status=$?

[ "$status" -eq 14 ]

printf 'package output: ownership, linkage, exports, determinism, and hosted execution passed\n'

//! Shared package fixture.

/// Shared mutable data.

export static value: u64 = 7;

/// Read shared mutable data.

export fn read() -> u64 { return value; }