.githooks/
compiler/
kernel/
lib/
scripts/
seed/
sublime/
test/
boot/
bootstrap/
compiler/
cycles/
dispatch/
format/
host/
integration/
kernel/
loader/
manifests/
mmio/
native/
packages/
runtime/
scheduling/
shared/
errors/
app.manifest
8 B
app.rad
983 B
build.rad
12.1 KiB
support.rad
1.7 KiB
slots/
smp/
std/
sync/
termination/
tests/
trap/
verify/
Makefile
9.2 KiB
kernel.rad
776 B
runner.rad
11.6 KiB
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
test/shared/build.rad
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 | } |