test: emulator seed-test std-test bin-test kernel-test package-test

# Separate binary package emission and decode checks.

package-test: emulator $(BIN_DIR)/packages.check.rv64

	@sh test/packages/run

$(BIN_DIR)/packages.check.rv64: test/packages/check.rad $(STD_LIB) $(RAD_BIN)

	@$(RADIANCE) $(STD) -pkg check -mod $< -entry check -o $@

.PHONY: test clean default seed-test std-test bin-test kernel-test package-test seed \

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

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

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

/// Maximum number of exported definitions in one binary package.

constant MAX_PACKAGE_EXPORTS: u32 = 8192;

/// Maximum number of indexed names in one binary package.

constant MAX_PACKAGE_SYMBOLS: u32 = 16384;

/// Export workspace reused for each binary package.

unsafe static PACKAGE_EXPORTS: [binary::Export; MAX_PACKAGE_EXPORTS] = undefined;

/// Symbol workspace reused for each binary package.

unsafe static PACKAGE_SYMBOLS: [*[u8]; MAX_PACKAGE_SYMBOLS] = undefined;

    "usage: radiance -pkg <name> [-start <input.ras>] -mod <input>.. [-pkg <name> -mod <input>..] -entry <pkg> [-o <output> | -ril <directory>]\n";

    /// Output directory for separate binary RIL packages.

    rilDirectory: ?*[u8],

    let mut rilDirectory: ?*[u8] = nil;

        } else if mem::eq(arg, "-ril") {

            try nextArg(args, &mut idx, &["`-ril` requires an output directory"]);

            set rilDirectory = args[idx];

    if rilDirectory <> nil and (outputPath <> nil or dump <> Dump::None) {

        throw error(&["`-ril` requires a separate invocation from `-o` or `-dump`"]);

    }

        rilDirectory,

/// Source exports selected for one binary RIL package.

record PackageExports: Copy {

    /// Number of initialized entries in the caller's export table.

    count: u32,

    /// Default function entry.

    entry: ?*[u8],

}

/// Collect exported definitions and the default entry from a package's source modules.

unsafe fn packageExports(

    ctx: &CompileContext,

    pkg: &package::Package,

    ilProgram: &il::Program,

    exports: &mut [binary::Export],

    arena: &mut alloc::Arena

) -> PackageExports throws (Error) {

    let mut count: u32 = 0;

    let mut entryName: ?*[u8] = nil;

    for i in 0..ctx.graph.entriesLen {

        let modEntry = module::get(&ctx.graph, i as u16) else continue;

        if modEntry.packageId <> pkg.id { continue; }

        let root = modEntry.ast else continue;

        let case ast::NodeValue::Block(block) = root.value else continue;

        for node in block.statements {

            let mut ident: ?*ast::Node = nil;

            let mut attrs: ?ast::Attributes = nil;

            let mut kind = binary::ExportKind::Function;

            match node.value {

                case ast::NodeValue::FnDecl(decl) => { set ident = decl.name; set attrs = decl.attrs; },

                case ast::NodeValue::ConstDecl(decl) => {

                    set ident = decl.ident; set attrs = decl.attrs; set kind = binary::ExportKind::Data;

                },

                case ast::NodeValue::StaticDecl(decl) => {

                    set ident = decl.ident; set attrs = decl.attrs; set kind = binary::ExportKind::Data;

                },

                else => continue,

            }

            let attributes = attrs else continue;

            let isDefault = ast::attributesContains(&attributes, ast::Attribute::Default)

                and pkg.rootModuleId == modEntry.id;

            if not isDefault and not ast::attributesContains(&attributes, ast::Attribute::Export) {

                continue;

            }

            let nameNode = ident else continue;

            let case ast::NodeValue::Ident(name) = nameNode.value else continue;

            let qualified = il::formatQualifiedName(arena, module::moduleQualifiedPath(modEntry), name);

            let mut present = false;

            match kind {

                case binary::ExportKind::Function => {

                    for func in ilProgram.fns {

                        if mem::eq(func.name, qualified) { set present = true; }

                    }

                },

                case binary::ExportKind::Data => {

                    for item in ilProgram.data {

                        if mem::eq(item.name, qualified) { set present = true; }

                    }

                },

            }

            if not present { continue; }

            if count == exports.len { throw error(&["too many package exports"]); }

            set exports[count] = binary::Export { name: qualified, kind };

            set count += 1;

            if isDefault { set entryName = qualified; }

        }

    }

    return PackageExports { count, entry: entryName };

}

/// Emit one binary RIL file per package into an existing directory.

unsafe fn emitPackages(ctx: *unsafe mut CompileContext, res: *unsafe mut resolver::Resolver, directory: *[u8]) throws (Error) {

    for i in 0..ctx.packageCount {

        if ctx.inputs[i].asmPathCount > 0 or ctx.inputs[i].startupPath <> nil {

            throw error(&["binary RIL output requires Radiance source modules"]);

        }

    }

    let unified = try lowerAllPackages(ctx, res);

    let allocator = alloc::arenaAllocator(&mut res.arena);

    for i in 0..ctx.packageCount {

        let pkg = &ctx.packages[i];

        let mut dataItems: *mut [il::Data] = &mut [];

        let mut functions: *unsafe mut [*unsafe il::Fn] = &mut [];

        for item in unified.data {

            if ownsSymbol(pkg.name, item.name) { dataItems.append(item, allocator); }

        }

        for func in unified.fns {

            if ownsSymbol(pkg.name, func.name) { functions.append(func, allocator); }

        }

        let local = il::Program { data: &dataItems[..], fns: functions };

        let selected = try packageExports(ctx, pkg, &local, &mut PACKAGE_EXPORTS[..], &mut res.arena);

        let mut dependencies: [*[u8]; MAX_PACKAGES] = undefined;

        let mut names = collect::new(&mut PACKAGE_SYMBOLS[..], &mut dependencies[..]);

        let image = try collect::package(&mut names, pkg.name, local, &PACKAGE_EXPORTS[..selected.count], selected.entry) catch {

            throw error(&["cannot collect binary RIL package", pkg.name]);

        };

        let length = try program::encode(&mut FN_ARENA[..], &image) catch {

            throw error(&["binary RIL output capacity exceeded", pkg.name]);

        };

        let mut path: [u8; MAX_PATH_LEN] = undefined;

        let mut pos: u32 = 0;

        for part in &[directory, "/", pkg.name, ".ril"] {

            set pos += try mem::copy(&mut path[pos..MAX_PATH_LEN - 1], part) catch {

                throw error(&["binary RIL output path is too long"]);

            };

        }

        set path[pos] = 0;

        if not unix::writeFile(&path[..pos], &FN_ARENA[..length]) {

            throw error(&["cannot write binary RIL package", pkg.name]);

        }

    }

}

/// Match a qualified definition to its package name.

fn ownsSymbol(owner: *[u8], name: *[u8]) -> bool {

    let suffix = mem::stripPrefix(owner, name) else return false;

    return suffix.len > 2 and suffix[0] == ':' and suffix[1] == ':';

}

    if let directory = ctx.rilDirectory {

        try emitPackages(ctx, res, directory);

        return;

    }

export mod collect;

//! Deterministic symbol and dependency collection for package-local IL.

use std::mem;

use std::lang::il;

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

/// Caller-owned storage for a package's indexed names.

/// Both tables must outlive the collector and all packages that use them.

export record Names: Copy {

    /// Unique names in first-use order.

    symbols: *unsafe mut [*[u8]],

    /// Number of initialized symbol entries.

    symbolCount: u32,

    /// Unique dependency names in first-use order.

    dependencies: *unsafe mut [*[u8]],

    /// Number of initialized dependency entries.

    dependencyCount: u32,

}

/// Start collection with empty caller-provided tables.

/// The caller must retain exclusive access to both tables during collection.

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

    return Names { symbols: symbols as *unsafe mut [*[u8]], symbolCount: 0, dependencies: dependencies as *unsafe mut [*[u8]], dependencyCount: 0 };

}

/// Add a unique name and check the symbol table's capacity.

unsafe fn add(names: &mut Names, name: *[u8]) throws (binary::Error) {

    if name.len == 0 {

        throw binary::Error::Invalid;

    }

    for i in 0..names.symbolCount {

        if mem::eq(names.symbols[i], name) {

            return;

        }

    }

    if names.symbolCount == names.symbols.len {

        throw binary::Error::Capacity;

    }

    set names.symbols[names.symbolCount] = name;

    set names.symbolCount += 1;

}

/// Add a qualified reference and its owning package dependency.

unsafe fn reference(names: &mut Names, owner: *[u8], name: *[u8]) throws (binary::Error) {

    try add(names, name);

    for i in 0..name.len {

        if name[i] == ':' and i + 1 < name.len and name[i + 1] == ':' {

            if i == 0 or i + 2 == name.len {

                throw binary::Error::Invalid;

            }

            let dependency = &name[..i];

            if mem::eq(dependency, owner) {

                return;

            }

            try add(names, dependency);

            for j in 0..names.dependencyCount {

                if mem::eq(names.dependencies[j], dependency) {

                    return;

                }

            }

            if names.dependencyCount == names.dependencies.len {

                throw binary::Error::Capacity;

            }

            set names.dependencies[names.dependencyCount] = dependency;

            set names.dependencyCount += 1;

            return;

        }

    }

    throw binary::Error::Invalid;

}

/// Collect names referenced by one IL value.

unsafe fn value(names: &mut Names, owner: *[u8], item: il::Val) throws (binary::Error) {

    match item {

        case il::Val::DataSym(name) => try reference(names, owner, name),

        case il::Val::FnAddr(name) => try reference(names, owner, name),

        else => {},

    }

}

/// Collect names from an instruction's variable-length operand sequence.

unsafe fn values(names: &mut Names, owner: *[u8], items: &[il::Val]) throws (binary::Error) {

    for item in items {

        try value(names, owner, item);

    }

}

/// Collect all symbolic instruction operands.

unsafe fn instruction(names: &mut Names, owner: *[u8], instr: il::Instr) throws (binary::Error) {

    match instr {

        case il::Instr::Reserve { size, .. } => try value(names, owner, size),

        case il::Instr::Blit { size, .. } => try value(names, owner, size),

        case il::Instr::Store { src, .. } => try value(names, owner, src),

        case il::Instr::Copy { val, .. } => try value(names, owner, val),

        case il::Instr::Zext { val, .. } => try value(names, owner, val),

        case il::Instr::Sext { val, .. } => try value(names, owner, val),

        case il::Instr::BinOp { a, b, .. } => {

            try value(names, owner, a);

            try value(names, owner, b);

        },

        case il::Instr::UnOp { a, .. } => try value(names, owner, a),

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

            try value(names, owner, func);

            try values(names, owner, args);

        },

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

            if let item = val {

                try value(names, owner, item);

            }

        },

        case il::Instr::Jmp { args, .. } => try values(names, owner, args),

        case il::Instr::Br { a, b, thenArgs, elseArgs, .. } => {

            try value(names, owner, a);

            try value(names, owner, b);

            try values(names, owner, thenArgs);

            try values(names, owner, elseArgs);

        },

        case il::Instr::Switch { val, defaultArgs, cases, .. } => {

            try value(names, owner, val);

            try values(names, owner, defaultArgs);

            for branch in cases {

                try values(names, owner, branch.args);

            }

        },

        case il::Instr::Ecall { num, a0, a1, a2, a3, .. } => {

            try value(names, owner, num);

            try value(names, owner, a0);

            try value(names, owner, a1);

            try value(names, owner, a2);

            try value(names, owner, a3);

        },

        case il::Instr::Load { .. }, il::Instr::Sload { .. }, il::Instr::Unreachable,

             il::Instr::Ebreak, il::Instr::MemoryFence => {},

    }

}

/// Check that a definition belongs to the selected package.

unsafe fn definition(names: &mut Names, owner: *[u8], name: *[u8]) throws (binary::Error) {

    let rest = mem::stripPrefix(owner, name) else {

        throw binary::Error::Invalid;

    };

    if rest.len < 3 or rest[0] <> ':' or rest[1] <> ':' {

        throw binary::Error::Invalid;

    }

    try add(names, name);

}

/// Build package tables from local definitions and their qualified references.

/// Returned tables borrow `names`. Reset the collector before building another package.

export unsafe fn package(

    names: &mut Names,

    owner: *[u8],

    program: il::Program,

    exports: &[binary::Export],

    entry: ?*[u8]

) -> binary::Package throws (binary::Error) {

    try add(names, owner);

    for item in exports {

        try definition(names, owner, item.name);

    }

    if let name = entry {

        try definition(names, owner, name);

    }

    for item in program.data {

        try definition(names, owner, item.name);

        for data in item.values {

            match data.item {

                case il::DataItem::Sym(name) => try reference(names, owner, name),

                case il::DataItem::Fn(name) => try reference(names, owner, name),

                else => {},

            }

        }

    }

    for func in program.fns {

        try definition(names, owner, func.name);

        for block in func.blocks {

            for instr in block.instrs {

                try instruction(names, owner, instr);

            }

        }

    }

    return binary::Package {

        symbols: &names.symbols[..names.symbolCount], name: owner,

        dependencies: &names.dependencies[..names.dependencyCount], exports: exports as *unsafe [binary::Export], entry, program,

    };

}

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

/// Check symbol collection capacity and package ownership failures.

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

    let mut symbols: [*[u8]; 8] = undefined;

    let mut dependencies: [*[u8]; 1] = undefined;

    let empty = il::Program { data: &[], fns: &[] };

    let mut names = collect::new(&mut symbols[..0], &mut dependencies[..]);

    let mut failed = false;

    try collect::package(&mut names, "p", empty, &[], nil) catch err {

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

        set failed = true;

    };

    try testing::expect(failed);

    let item = il::Data {

        name: "p::data", size: 8, alignment: 8, readOnly: false, isZeroInit: false,

        values: &[il::DataValue { item: il::DataItem::Fn("dep::fn"), count: 1 }],

    };

    let local = il::Program { data: retainData(&[item]), fns: &[] };

    set names = collect::new(&mut symbols[..], &mut dependencies[..0]);

    set failed = false;

    try collect::package(&mut names, "p", local, &[], nil) catch err {

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

        set failed = true;

    };

    try testing::expect(failed);

    set names = collect::new(&mut symbols[..], &mut dependencies[..]);

    set failed = false;

    try collect::package(&mut names, "other", local, &[], nil) catch err {

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

        set failed = true;

    };

    try testing::expect(failed);

    set names = collect::new(&mut symbols[..], &mut dependencies[..]);

    let package = try collect::package(&mut names, "p", local, &[], nil) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(package.dependencies.len == 1);

    try testing::expectBytesEq(package.dependencies[0], "dep");

    try testing::expect(package.symbols.len == 4);

}

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

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