) -> Program throws (Error) {

    return try linkProgram(input, globalData, storage, roDataPrefix, roDataBuf, rwDataBuf);

}

/// Lay out data, resolve relocations, and publish the completed program.

fn linkProgram(

    input: Generator,

    globalData: &[il::Data],

    storage: Storage,

    roDataPrefix: *[u8],

    roDataBuf: &mut [u8],

    rwDataBuf: &mut [u8]

/// Finalization preserves hosted placement and propagates bounded failures.

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

    for scenario in 0..6 {

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

        let placement = image::Placement::Physical {

            code: 0x80000000, roData: 0x80000000, rwData: 0x80002000, entry: 0x80000000,

        } if scenario == 5 else image::Placement::Hosted;

        let entryPatch = rv64::EntryPatch::Reserved(nil) if scenario == 2 else rv64::EntryPatch::None;

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

            entryPatch, debug: false, placement,

        }, &mut arena);

        emit::emit(&mut generator.e, encode::nop());

        if scenario == 3 { set generator.e.error = rv64::Error::Capacity; }

        if scenario == 4 { emit::recordCall(&mut generator.e, "missing"); }

        let mut ro: [u8; 5] = [42; 5];

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

        let capacity: u32 = 2 if scenario == 1 else 3;

        let result = try rv64::finishProgram(generator, &[],

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

            &[7, 8, 9], &mut ro[1..capacity + 1], &mut rw[..]

        ) catch err {

            // Record the failure before the next independent generator is built.

            let expected = rv64::Error::Image(image::Error::Overlap) if scenario == 5

                else rv64::Error::Symbol if scenario == 2 or scenario == 4

                else rv64::Error::Capacity;

            assert err == expected;

            assert scenario <> 0;

            assert ro[0] == 42 and ro[capacity + 1] == 42;

            continue;

        };

        assert scenario == 0;

        assert result.layout.code.address == rv64::RO_DATA_BASE as u64 + 8;

        assert result.code.len == 1 and result.code[0] == encode::nop();

        assert result.roDataSize == 3 and result.rwDataSize == 0;

        assert ro[0] == 42 and ro[4] == 42;

        assert ro[1] == 7 and ro[2] == 8 and ro[3] == 9;

    }

}