test/shared/build.rad 12.1 KiB raw
1
//! Build a machine fixture from separately decoded and linked packages.
2
3
use std::arch::rv64;
4
use std::arch::rv64::emit;
5
use std::arch::rv64::encode;
6
use std::arch::rv64::image;
7
use std::arch::rv64::shared;
8
use std::collections::dict;
9
use std::fs;
10
use std::io;
11
use std::lang::gen::data;
12
use std::lang::gen::labels;
13
use std::lang::gen::regalloc::liveness;
14
use std::lang::il::binary;
15
use std::lang::il::binary::linkage;
16
use std::lang::il::binary::program;
17
use std::lang::il::verify;
18
use std::lang::il::verify::linking;
19
use std::mem;
20
use std::mem::heap;
21
use std::sys;
22
23
/// Native fixture entry trampoline address.
24
constant CODE_BASE: u64 = 0x80010000;
25
/// First linked package code address.
26
constant PACKAGE_CODE_BASE: u64 = 0x80011000;
27
/// Bytes reserved for each code slot.
28
constant CODE_SLOT_BYTES: u32 = 4096;
29
/// Instructions reserved for each code slot.
30
constant CODE_SLOT_WORDS: u32 = CODE_SLOT_BYTES / rv64::INSTR_SIZE as u32;
31
/// Native fixture private state segment base.
32
constant RW_BASE: u64 = 0x80020000;
33
/// Bytes reserved for one private package graph.
34
constant GRAPH_BYTES: u32 = 32768;
35
/// Bytes reserved for one package private state.
36
constant PACKAGE_STATE_BYTES: u32 = 16384;
37
/// Byte offset of package base tables in the state segment.
38
constant TABLES_OFFSET: u32 = 65536;
39
/// Bytes in one graph package base table.
40
constant TABLE_BYTES: u32 = shared::MAX_PACKAGES * rv64::DWORD_SIZE as u32;
41
/// Machine completion device address.
42
constant FINISH_ADDRESS: i64 = 0x10001000;
43
/// Completion value for a successful machine test.
44
constant FINISH_PASS: i64 = 0x5555;
45
/// Completion value for a failed machine test.
46
constant FINISH_FAIL: i64 = 0x13333;
47
48
/// Number of elements reserved for code storage.
49
constant CODE_CAPACITY: u32 = 16777216;
50
/// Number of elements reserved for scratch storage.
51
constant SCRATCH_CAPACITY: u32 = 16777216;
52
/// Number of elements reserved for decode storage.
53
constant DECODE_CAPACITY: u32 = 1048576;
54
/// Number of elements reserved for input storage.
55
constant INPUT_CAPACITY: u32 = 131072;
56
/// Number of elements reserved for templates storage.
57
constant TEMPLATES_CAPACITY: u32 = 16384;
58
/// Number of elements reserved for symbols storage.
59
constant SYMBOLS_CAPACITY: u32 = 128;
60
/// Number of elements reserved for exports storage.
61
constant EXPORTS_CAPACITY: u32 = 128;
62
/// Number of elements reserved for relocs storage.
63
constant RELOCS_CAPACITY: u32 = 128;
64
/// Number of elements reserved for data storage.
65
constant DATA_CAPACITY: u32 = 128;
66
/// Number of elements reserved for text storage.
67
constant TEXT_CAPACITY: u32 = 4096;
68
/// Number of elements reserved for state storage.
69
constant STATE_CAPACITY: u32 = 69632;
70
71
/// Separate code arenas preserve the boot catalog's package records.
72
unsafe static CODE: [[u8; CODE_CAPACITY]; 3] = undefined;
73
/// Reusable function workspace.
74
static SCRATCH: [u8; SCRATCH_CAPACITY] = [0; SCRATCH_CAPACITY];
75
/// Decoder arena shared by the two input packages.
76
static DECODE: [u8; DECODE_CAPACITY] = [0; DECODE_CAPACITY];
77
/// Input file buffer.
78
static INPUT: [u8; INPUT_CAPACITY] = [0; INPUT_CAPACITY];
79
/// Persistent private templates.
80
unsafe static TEMPLATES: [[u8; TEMPLATES_CAPACITY]; 2] = undefined;
81
/// Local symbol workspaces.
82
unsafe static SYMBOLS: [[shared::Symbol; SYMBOLS_CAPACITY]; 2] = undefined;
83
/// Package exports.
84
unsafe static EXPORTS: [[shared::Symbol; EXPORTS_CAPACITY]; 2] = undefined;
85
/// Private pointer fixups.
86
unsafe static RELOCS: [[shared::Relocation; RELOCS_CAPACITY]; 2] = undefined;
87
/// Data layout workspaces.
88
unsafe static DATA: [[data::DataSym; DATA_CAPACITY]; 2] = undefined;
89
/// Native instruction image, with fixed package placements.
90
static TEXT: [u32; TEXT_CAPACITY] = [0; TEXT_CAPACITY];
91
/// Two private graphs followed by their package-state tables.
92
static STATE: [u8; STATE_CAPACITY] = [0; STATE_CAPACITY];
93
94
/// Decode package IL into persistent storage.
95
unsafe fn load(path: *[u8], arena: &heap::Heap) -> binary::Package {
96
    let length = try fs::readFile(path, &mut INPUT[..]) catch {
97
        panic "load: missing package";
98
    };
99
    return try! program::decode(&INPUT[.. length], arena, binary::Limits {
100
        registers: liveness::MAX_SSA_REGS, blocks: labels::MAX_BLOCKS_PER_FN
101
    });
102
}
103
104
/// Compile through the same entry used for boot catalogs and runtime loading.
105
unsafe fn compile(
106
    input: &binary::Package, index: u32, imports: &[shared::Symbol]
107
) -> shared::Package throws (shared::Error) {
108
    let arena = heap::over(&mut CODE[index][..]);
109
    let scratch = heap::over(&mut SCRATCH[..]);
110
    return try shared::compile(
111
        input,
112
        index,
113
        PACKAGE_CODE_BASE
114
            + index as u64 * CODE_SLOT_BYTES as u64,
115
        imports,
116
        shared::Storage {
117
            data: &mut DATA[index][..],
118
            symbols: &mut SYMBOLS[index][..],
119
            exports: &mut EXPORTS[index][..],
120
            template: &mut TEMPLATES[index][..],
121
            relocations: &mut RELOCS[index][..],
122
            stack: rv64::StackCheck::TpLimit,
123
        },
124
        arena,
125
        scratch
126
    );
127
}
128
129
/// Append a call result check and return its branch patch location.
130
fn check(e: &mut emit::Emitter, entry: u64, expected: i64) -> u32 {
131
    let delta = entry - (CODE_BASE
132
        + e.code.len as u64 * rv64::INSTR_SIZE as u64);
133
    try! emit::emit(e, encode::jal(rv64::RA, delta as i32));
134
    try! emit::loadImm(e, rv64::T0, expected);
135
    let index = e.code.len;
136
    try! emit::emit(e, encode::nop());
137
    return index;
138
}
139
140
/// Emit an explicit platform completion status.
141
fn finish(e: &mut emit::Emitter, status: i64) {
142
    try! emit::loadImm(e, rv64::T0, FINISH_ADDRESS);
143
    try! emit::loadImm(e, rv64::T1, status);
144
    try! emit::emit(e, encode::sw(rv64::T1, rv64::T0, 0));
145
    try! emit::emit(e, encode::ebreak());
146
}
147
148
/// Verify catalog linking, then execute one code copy against two private graphs.
149
@default unsafe fn main(env: *sys::Env) -> i32 {
150
    // A fourth argument selects the typed-catch scenario, whose entry returns 222.
151
    assert env.args.len == 3 or env.args.len == 4;
152
    let catchScenario = env.args.len == 4;
153
    let decoder = heap::over(&mut DECODE[..]);
154
    let mut supportInput = load(env.args[0], decoder);
155
    let mut appInput = load(env.args[1], decoder);
156
    let config = verify::Config {
157
        registers: liveness::MAX_SSA_REGS,
158
        blocks: labels::MAX_BLOCKS_PER_FN,
159
        layoutSize: 1048576,
160
        layoutDepth: 64,
161
        params: 64,
162
        envSize: 0,
163
    };
164
    let scratch = heap::over(&mut SCRATCH[..]);
165
    try verify::verifyPackage(&mut supportInput, config, scratch, decoder) catch err {
166
        io::print("support verification: ");
167
        io::printLn(verify::ruleName(err.rule));
168
        return 1;
169
    };
170
    let identity = supportInput.links.image else panic "main: missing image identity";
171
    let provider = linking::Provider {
172
        image: identity, contract: supportInput
173
    };
174
    let checking = heap::over(&mut SCRATCH[..]);
175
    try verify::verifyLinkedPackage(
176
        &mut appInput, &[provider], config, checking, decoder
177
    ) catch err {
178
        io::print("app verification: ");
179
        io::printLn(verify::ruleName(err.rule));
180
        if let case verify::Place::Instr { func, block, instr } = err.place {
181
            io::printLn(appInput.program.fns[func].name);
182
            io::printU32(block);
183
            io::print(":");
184
            io::printU32(instr);
185
            io::print("\n");
186
        }
187
        if let case verify::Place::Data(i) = err.place {
188
            io::printLn(appInput.program.data[i].name);
189
        }
190
        return 1;
191
    };
192
    assert appInput.links.pins[0] == supportInput.links.metadata;
193
    let support = try! compile(&supportInput, 0, &[]);
194
    let mut far: [shared::Symbol; EXPORTS_CAPACITY] = undefined;
195
    for symbol, i in support.exports {
196
        set far[i] = symbol;
197
        match symbol.target {
198
            case shared::Target::Function(_) => {
199
                set far[i].target = shared::Target::Function(0x180000000);
200
            }
201
            else => {}
202
        }
203
    }
204
    let mut rejected = false;
205
    try compile(&appInput, 1, &far[.. support.exports.len]) catch err {
206
        assert err == shared::Error::Range;
207
        set rejected = true;
208
    };
209
    assert rejected;
210
    let mut imports: [shared::Symbol; EXPORTS_CAPACITY] = undefined;
211
    assert appInput.links.imports.len <= imports.len;
212
    for imported, i in appInput.links.imports {
213
        let mut target: ?shared::Target = nil;
214
        for symbol in support.exports {
215
            if mem::eq(symbol.name, imported.exported) {
216
                set target = symbol.target;
217
            }
218
        }
219
        let resolved = target else panic "main: missing export";
220
        set imports[i] = shared::Symbol {
221
            name: imported.exported, target: resolved, startable: false
222
        };
223
    }
224
    let app = try! compile(&appInput, 1, &imports[.. appInput.links.imports.len]);
225
    assert support.contract.verification == shared::Verification::Verified;
226
    assert app.contract.verification == shared::Verification::Verified;
227
    let catalog = [support, app];
228
    assert catchScenario or app.relocations.len > 0;
229
    let entry = app.entry else panic "main: missing entry";
230
    for i in 0 .. STATE.len {
231
        set STATE[i] = 0;
232
    }
233
    for domain in 0 .. 2 {
234
        let mut bases: [u64; shared::MAX_PACKAGES] = [0; shared::MAX_PACKAGES];
235
        for package, i in &catalog[..] {
236
            let offset = domain * GRAPH_BYTES + i * PACKAGE_STATE_BYTES;
237
            set bases[i] = RW_BASE + offset as u64;
238
        }
239
        for package, i in &catalog[..] {
240
            let offset = domain * GRAPH_BYTES + i * PACKAGE_STATE_BYTES;
241
            try! shared::instantiate(
242
                &package, &bases[..], &mut STATE[offset .. offset + PACKAGE_STATE_BYTES]
243
            );
244
        }
245
        let table = @sliceOf(&bases[0] as *unsafe u8, @sizeOf(
246
            [u64; shared::MAX_PACKAGES]
247
        ));
248
        let tableOffset: u32 = TABLES_OFFSET + domain * TABLE_BYTES;
249
        try! mem::copy(&mut STATE[tableOffset ..], table);
250
    }
251
    let arena = heap::over(&mut CODE[2][..]);
252
    let mut blockOffsets: *mut [i32] = &mut [];
253
    try! blockOffsets.resize(labels::MAX_BLOCKS_PER_FN, 0, arena);
254
    let mut funcEntries: *mut [dict::Entry] = &mut [];
255
    try! funcEntries.resize(
256
        labels::FUNC_TABLE_SIZE, dict::Entry { key: &[], value: 0 }, arena
257
    );
258
    let mut e = try! emit::emitter(arena, false, labels::fresh(blockOffsets, funcEntries));
259
    try! emit::loadImm(
260
        &mut e,
261
        rv64::GP,
262
        (RW_BASE
263
            + TABLES_OFFSET as u64) as i64
264
    );
265
    try! emit::loadImm(&mut e, rv64::TP, 0);
266
    let first = check(&mut e, entry, 222 if catchScenario else 142);
267
    let second = check(&mut e, entry, 222 if catchScenario else 143);
268
    try! emit::loadImm(
269
        &mut e,
270
        rv64::GP,
271
        (RW_BASE
272
            + TABLES_OFFSET as u64
273
            + TABLE_BYTES as u64) as i64
274
    );
275
    let other = check(&mut e, entry, 222 if catchScenario else 142);
276
    try! emit::loadImm(
277
        &mut e,
278
        rv64::GP,
279
        (RW_BASE
280
            + TABLES_OFFSET as u64) as i64
281
    );
282
    let resumed = check(&mut e, entry, 222 if catchScenario else 144);
283
    finish(&mut e, FINISH_PASS);
284
    let failure = e.code.len;
285
    finish(&mut e, FINISH_FAIL);
286
    for index in &[first, second, other, resumed] {
287
        emit::patch(&mut e, index, encode::bne(
288
            rv64::A0, rv64::T0, (failure - index) as i32 * rv64::INSTR_SIZE
289
        ));
290
    }
291
    for i in 0 .. TEXT.len {
292
        set TEXT[i] = encode::nop();
293
    }
294
    assert e.code.len <= CODE_SLOT_WORDS;
295
    for word, i in &e.code[..] {
296
        set TEXT[i] = word;
297
    }
298
    for package, i in &catalog[..] {
299
        assert package.code.len <= CODE_SLOT_WORDS;
300
        for word, j in package.code {
301
            set TEXT[CODE_SLOT_WORDS + i * CODE_SLOT_WORDS + j] = word;
302
        }
303
    }
304
    let header = try! image::header(image::Layout {
305
        code: image::Segment { address: CODE_BASE, size: TEXT_CAPACITY * rv64::INSTR_SIZE as u32 },
306
        roData: image::Segment { address: 0, size: 0 },
307
        rwData: image::Segment { address: RW_BASE, size: STATE.len },
308
        rwTail: 0,
309
    });
310
    let mut out = try! fs::create(env.args[2]);
311
    out.write(&header[..]);
312
    out.write(@sliceOf(&TEXT[0] as *u8, TEXT_CAPACITY * rv64::INSTR_SIZE as u32));
313
    out.write(&STATE[..]);
314
    try! out.close();
315
    return 0;
316
}