compiler: Reduce package output overhead
7e07477a2468282fd623482dcb7fe2f9ea89040991e541dc59a1ffebe35e8d72
Intern function symbols during RIL encoding and render generated interfaces with fixed line placements. Keep BLAKE3 working words live between rounds and construct block words directly. Trust recorded payload identities in automatic cache entries and keep full content validation for explicit artifacts. Keep symbol tables consistent after allocation and insertion failures. Document cache trust and retain byte-equivalence and error-recovery checks. Assisted-by: Codex:gpt-6 Change-Id: Ice965727a8fee6ea0a1da9f79597f95f64253c15
1 parent
a4674701
compiler/radiance/artifact.rad
+18 -9
| 23 | 23 | text: *[u8], |
|
| 24 | 24 | /// First unread byte. |
|
| 25 | 25 | offset: u32, |
|
| 26 | 26 | } |
|
| 27 | 27 | ||
| 28 | + | /// Content validation required when loading a package artifact set. |
|
| 29 | + | export union Validation { |
|
| 30 | + | /// Trust content identities recorded in a compiler cache entry. |
|
| 31 | + | Trusted, |
|
| 32 | + | /// Compare every recorded content identity with its file bytes. |
|
| 33 | + | Full, |
|
| 34 | + | } |
|
| 35 | + | ||
| 28 | 36 | /// One generated interface module in logical registration order. |
|
| 29 | 37 | export record Module: Copy { |
|
| 30 | 38 | /// Relative path in the interface tree, including the `.rid` extension. |
|
| 31 | 39 | path: *[u8], |
|
| 32 | 40 | /// Complete immutable interface text. |
| 65 | 73 | bytes: *[u8], |
|
| 66 | 74 | /// Use of these bytes during native linking. |
|
| 67 | 75 | role: FileRole, |
|
| 68 | 76 | } |
|
| 69 | 77 | ||
| 70 | - | /// Validated package artifact retained in immutable compiler storage. |
|
| 78 | + | /// Package artifact retained in immutable compiler storage. |
|
| 71 | 79 | export record Package: Copy { |
|
| 72 | 80 | /// Package name and root module identity. |
|
| 73 | 81 | name: *[u8], |
|
| 74 | 82 | /// Complete binary RIL image. |
|
| 75 | 83 | image: *[u8], |
| 322 | 330 | ||
| 323 | 331 | /// Encode the descriptors that bind all interface files and the image. |
|
| 324 | 332 | export fn metadata(package: &Package, buffer: *mut [u8]) -> *[u8] |
|
| 325 | 333 | throws (binary::Error) |
|
| 326 | 334 | { |
|
| 327 | - | let mut out = writer::new(buffer, &[]); |
|
| 335 | + | let mut out = writer::new(buffer); |
|
| 328 | 336 | try writeNumber(&mut out, "version", VERSION); |
|
| 329 | 337 | try writeField(&mut out, "package", package.name); |
|
| 330 | 338 | try writeId(&mut out, "inputs", package.inputs); |
|
| 331 | 339 | try writeId(&mut out, "image", package.identity); |
|
| 332 | 340 | try writeNumber(&mut out, "size", package.image.len); |
| 351 | 359 | try writeId(&mut out, "declarations", dependency.declarations); |
|
| 352 | 360 | } |
|
| 353 | 361 | return &out.bytes[.. out.offset]; |
|
| 354 | 362 | } |
|
| 355 | 363 | ||
| 356 | - | /// Read and validate every file named by package metadata. |
|
| 364 | + | /// Read package files and check their metadata with the selected content validation. |
|
| 357 | 365 | export fn read( |
|
| 358 | - | root: *[u8], name: *[u8], arena: &heap::Heap |
|
| 366 | + | root: *[u8], name: *[u8], validation: Validation, arena: &heap::Heap |
|
| 359 | 367 | ) -> Package throws (sys::Error) { |
|
| 360 | 368 | let tree = try join(arena, &[root, "/", name, ".interface/"]); |
|
| 361 | 369 | let path = try join(arena, &[tree, "package.metadata"]); |
|
| 362 | 370 | let info = try fs::stat(path) else throw sys::Error::NotFound; |
|
| 363 | 371 | if info.size > MAX_METADATA as u64 { |
|
| 364 | 372 | throw sys::Error::Invalid; |
|
| 365 | 373 | } |
|
| 366 | 374 | let encoded = try readFile(path, arena); |
|
| 367 | 375 | return try decode( |
|
| 368 | - | root, tree, name, encoded, arena |
|
| 376 | + | root, tree, name, encoded, validation, arena |
|
| 369 | 377 | ) catch err as binary::Error { |
|
| 370 | 378 | if err == binary::Error::Storage { |
|
| 371 | 379 | throw sys::Error::TooLarge; |
|
| 372 | 380 | } |
|
| 373 | 381 | throw sys::Error::Invalid; |
|
| 374 | 382 | } catch err as sys::Error { |
|
| 375 | 383 | throw err; |
|
| 376 | 384 | }; |
|
| 377 | 385 | } |
|
| 378 | 386 | ||
| 379 | - | /// Decode metadata and compare each descriptor with its immutable file snapshot. |
|
| 387 | + | /// Decode metadata, check file structure, and apply the selected content validation. |
|
| 380 | 388 | fn decode( |
|
| 381 | 389 | root: *[u8], |
|
| 382 | 390 | tree: *[u8], |
|
| 383 | 391 | name: *[u8], |
|
| 384 | 392 | encoded: *[u8], |
|
| 393 | + | validation: Validation, |
|
| 385 | 394 | arena: &heap::Heap |
|
| 386 | 395 | ) -> Package throws (binary::Error, sys::Error) { |
|
| 387 | 396 | let mut input = MetadataReader { text: encoded, offset: 0 }; |
|
| 388 | 397 | if try readNumber(&mut input, "version", arena) <> VERSION |
|
| 389 | 398 | or not mem::eq(try readField(&mut input, "package", arena), name) |
| 397 | 406 | if image.len <> length |
|
| 398 | 407 | or image.len < 12 |
|
| 399 | 408 | or mem::load32Le(image, 0) <> binary::MAGIC |
|
| 400 | 409 | or mem::load32Le(image, 4) <> binary::FORMAT_VERSION |
|
| 401 | 410 | or mem::load32Le(image, 8) <> binary::ABI_VERSION |
|
| 402 | - | or linkage::imageId(image) <> identity |
|
| 411 | + | or (validation == Validation::Full and linkage::imageId(image) <> identity) |
|
| 403 | 412 | { |
|
| 404 | 413 | throw binary::Error::Invalid; |
|
| 405 | 414 | } |
|
| 406 | 415 | let count = try readCount(&mut input, "modules", arena); |
|
| 407 | 416 | if count == 0 { |
| 426 | 435 | } |
|
| 427 | 436 | } else if not mem::startsWith(path, try join(arena, &[name, "/"])) { |
|
| 428 | 437 | throw binary::Error::Invalid; |
|
| 429 | 438 | } |
|
| 430 | 439 | let text = try readFile(try join(arena, &[tree, path]), arena); |
|
| 431 | - | if text.len <> length or digest(text) <> hash { |
|
| 440 | + | if text.len <> length or (validation == Validation::Full and digest(text) <> hash) { |
|
| 432 | 441 | throw binary::Error::Invalid; |
|
| 433 | 442 | } |
|
| 434 | 443 | try modules.append(Module { path, text, hash }, arena) catch { |
|
| 435 | 444 | throw binary::Error::Storage; |
|
| 436 | 445 | }; |
| 458 | 467 | throw binary::Error::Invalid; |
|
| 459 | 468 | } |
|
| 460 | 469 | let length = try readNumber(&mut input, "size", arena); |
|
| 461 | 470 | let hash = try readId(&mut input, "hash", arena); |
|
| 462 | 471 | let bytes = try readFile(try join(arena, &[tree, path]), arena); |
|
| 463 | - | if bytes.len <> length or digest(bytes) <> hash { |
|
| 472 | + | if bytes.len <> length or (validation == Validation::Full and digest(bytes) <> hash) { |
|
| 464 | 473 | throw binary::Error::Invalid; |
|
| 465 | 474 | } |
|
| 466 | 475 | let role = FileRole::Startup |
|
| 467 | 476 | if kind == 1 |
|
| 468 | 477 | else FileRole::Debug |
compiler/radiance/build.rad
+5 -5
| 205 | 205 | /// Capture immutable inputs without entering the implementation parser. |
|
| 206 | 206 | fn snapshot(options: super::PackageInput, arena: &heap::Heap, artifacts: &heap::Heap) -> Input |
|
| 207 | 207 | throws (sys::Error) |
|
| 208 | 208 | { |
|
| 209 | 209 | if let root = options.artifactRoot { |
|
| 210 | - | let compiled = try artifact::read(root, options.name, artifacts); |
|
| 210 | + | let compiled = try artifact::read( |
|
| 211 | + | root, options.name, artifact::Validation::Full, artifacts |
|
| 212 | + | ); |
|
| 211 | 213 | let mut dependencies: *mut [*[u8]] = &mut []; |
|
| 212 | 214 | for dependency in compiled.dependencies { |
|
| 213 | 215 | try dependencies.append(dependency.name, arena) catch { |
|
| 214 | 216 | throw sys::Error::TooLarge; |
|
| 215 | 217 | }; |
| 892 | 894 | let layoutStart = heap::mark(work.functions); |
|
| 893 | 895 | let tree = try interface(root, &res, work.functions) catch { |
|
| 894 | 896 | throw super::error(&["cannot render interface", entry.filePath]); |
|
| 895 | 897 | }; |
|
| 896 | 898 | let mut output = sexpr::Buffer { buf: text.take(), pos: 0 }; |
|
| 897 | - | layout::text::render( |
|
| 898 | - | tree, layout::text::Options { width: 100, indent: 4 }, &mut output |
|
| 899 | - | ); |
|
| 899 | + | layout::text::renderFixed(tree, 4, &mut output); |
|
| 900 | 900 | if output.pos == output.buf.len { |
|
| 901 | 901 | throw super::error(&["cannot render interface", entry.filePath]); |
|
| 902 | 902 | } |
|
| 903 | 903 | let bytes = try keep(work.artifacts, &output.buf[.. output.pos]) catch { |
|
| 904 | 904 | throw super::error(&["package encoding storage exhausted", pkg.name]); |
| 964 | 964 | // Only the copied export descriptors survive header decoding. |
|
| 965 | 965 | unsafe { |
|
| 966 | 966 | heap::rewind(work.functions, checkpoint); |
|
| 967 | 967 | } |
|
| 968 | 968 | } |
|
| 969 | - | let mut locationWriter = writer::new(debug, &[]); |
|
| 969 | + | let mut locationWriter = writer::new(debug); |
|
| 970 | 970 | let root = pkg.rootModuleId else panic "compile: missing root"; |
|
| 971 | 971 | if ctx.debug { |
|
| 972 | 972 | let count = modules.entries.len - root as u32; |
|
| 973 | 973 | try writer::word(&mut locationWriter, count as u64) catch { |
|
| 974 | 974 | throw super::Error::Other; |
compiler/radiance/cache.rad
+5 -2
| 20 | 20 | throw sys::Error::TooLarge; |
|
| 21 | 21 | }; |
|
| 22 | 22 | return try artifact::join(arena, &[root, "/", &name[..]]); |
|
| 23 | 23 | } |
|
| 24 | 24 | ||
| 25 | - | /// Load a complete cache entry. Corruption is a miss; unrelated I/O errors propagate. |
|
| 25 | + | /// Load a cache entry using its recorded content identities. |
|
| 26 | + | /// Missing files and invalid metadata are misses; unrelated I/O errors propagate. |
|
| 26 | 27 | export fn lookup( |
|
| 27 | 28 | root: *[u8], name: *[u8], key: binary::Id, arena: &heap::Heap |
|
| 28 | 29 | ) -> ?artifact::Package throws (sys::Error) { |
|
| 29 | 30 | let saved = heap::mark(arena); |
|
| 30 | 31 | let path = try entry(root, key, arena); |
|
| 31 | - | let result = try artifact::read(path, name, arena) catch error { |
|
| 32 | + | let result = try artifact::read( |
|
| 33 | + | path, name, artifact::Validation::Trusted, arena |
|
| 34 | + | ) catch error { |
|
| 32 | 35 | // Failed reads publish no pointers into their temporary allocations. |
|
| 33 | 36 | unsafe { |
|
| 34 | 37 | heap::rewind(arena, saved); |
|
| 35 | 38 | } |
|
| 36 | 39 | if error == sys::Error::NotFound or error == sys::Error::Invalid { |
compiler/radiance/codegen.rad
+5 -3
| 204 | 204 | } |
|
| 205 | 205 | if spool.packages[i].count > 0 and spool.packages[i].end <> spool.used { |
|
| 206 | 206 | throw binary::Error::Invalid; |
|
| 207 | 207 | } |
|
| 208 | 208 | let name = spool.packages[i].name; |
|
| 209 | - | let stored = try collect::function(&mut spool.packages[i].names, name, func, spool.arena); |
|
| 209 | + | let stored = try collect::definition( |
|
| 210 | + | &mut spool.packages[i].names, name, func.name, spool.arena |
|
| 211 | + | ); |
|
| 210 | 212 | if let case lower::Linkage::Exported = origin.linkage { |
|
| 211 | 213 | let definition = binary::Export { |
|
| 212 | 214 | name: stored, |
|
| 213 | 215 | kind: binary::ExportKind::Function, |
|
| 214 | 216 | startable: false, |
| 218 | 220 | }; |
|
| 219 | 221 | } |
|
| 220 | 222 | if let case lower::FnRole::Default = role { |
|
| 221 | 223 | set spool.packages[i].entry = stored; |
|
| 222 | 224 | } |
|
| 223 | - | let end = try program::appendFunction( |
|
| 224 | - | &mut spool.bytes, spool.used, &mut spool.packages[i].names.index, func |
|
| 225 | + | let end = try program::appendCollected( |
|
| 226 | + | &mut spool.bytes, spool.used, &mut spool.packages[i].names, func, spool.arena |
|
| 225 | 227 | ); |
|
| 226 | 228 | if spool.packages[i].count == 0 { |
|
| 227 | 229 | set spool.packages[i].start = spool.used; |
|
| 228 | 230 | } |
|
| 229 | 231 | set spool.packages[i].end = end; |
lib/std/hash/blake3.rad
+151 -137
| 74 | 74 | stack: [0; 432], |
|
| 75 | 75 | depth: 0, |
|
| 76 | 76 | }; |
|
| 77 | 77 | } |
|
| 78 | 78 | ||
| 79 | - | /// Apply one BLAKE3 round to the columns and diagonals. Word sums wrap. |
|
| 80 | - | fn round(state: &mut [u32; 16], m: &[u32; 16]) { |
|
| 79 | + | /// Apply seven BLAKE3 rounds with wrapping word sums and three live state columns. |
|
| 80 | + | /// The working words and loop state fit the backend's block argument bound. |
|
| 81 | + | fn rounds(state: &mut [u32; 16], message: &[u32; 16]) { |
|
| 81 | 82 | let mut v0 = state[0]; |
|
| 82 | 83 | let mut v1 = state[1]; |
|
| 83 | 84 | let mut v2 = state[2]; |
|
| 84 | 85 | let mut v3 = state[3]; |
|
| 85 | 86 | let mut v4 = state[4]; |
| 88 | 89 | let mut v7 = state[7]; |
|
| 89 | 90 | let mut v8 = state[8]; |
|
| 90 | 91 | let mut v9 = state[9]; |
|
| 91 | 92 | let mut v10 = state[10]; |
|
| 92 | 93 | let mut v11 = state[11]; |
|
| 93 | - | let mut v12 = state[12]; |
|
| 94 | - | let mut v13 = state[13]; |
|
| 95 | - | let mut v14 = state[14]; |
|
| 96 | - | let mut v15 = state[15]; |
|
| 97 | - | set v0 += v4 + m[0]; |
|
| 98 | - | set v12 ^= v0; |
|
| 99 | - | set v12 = bits::rotateRight32(v12, 16); |
|
| 100 | - | set v8 += v12; |
|
| 101 | - | set v4 ^= v8; |
|
| 102 | - | set v4 = bits::rotateRight32(v4, 12); |
|
| 103 | - | set v0 += v4 + m[1]; |
|
| 104 | - | set v12 ^= v0; |
|
| 105 | - | set v12 = bits::rotateRight32(v12, 8); |
|
| 106 | - | set v8 += v12; |
|
| 107 | - | set v4 ^= v8; |
|
| 108 | - | set v4 = bits::rotateRight32(v4, 7); |
|
| 109 | - | set v1 += v5 + m[2]; |
|
| 110 | - | set v13 ^= v1; |
|
| 111 | - | set v13 = bits::rotateRight32(v13, 16); |
|
| 112 | - | set v9 += v13; |
|
| 113 | - | set v5 ^= v9; |
|
| 114 | - | set v5 = bits::rotateRight32(v5, 12); |
|
| 115 | - | set v1 += v5 + m[3]; |
|
| 116 | - | set v13 ^= v1; |
|
| 117 | - | set v13 = bits::rotateRight32(v13, 8); |
|
| 118 | - | set v9 += v13; |
|
| 119 | - | set v5 ^= v9; |
|
| 120 | - | set v5 = bits::rotateRight32(v5, 7); |
|
| 121 | - | set v2 += v6 + m[4]; |
|
| 122 | - | set v14 ^= v2; |
|
| 123 | - | set v14 = bits::rotateRight32(v14, 16); |
|
| 124 | - | set v10 += v14; |
|
| 125 | - | set v6 ^= v10; |
|
| 126 | - | set v6 = bits::rotateRight32(v6, 12); |
|
| 127 | - | set v2 += v6 + m[5]; |
|
| 128 | - | set v14 ^= v2; |
|
| 129 | - | set v14 = bits::rotateRight32(v14, 8); |
|
| 130 | - | set v10 += v14; |
|
| 131 | - | set v6 ^= v10; |
|
| 132 | - | set v6 = bits::rotateRight32(v6, 7); |
|
| 133 | - | set v3 += v7 + m[6]; |
|
| 134 | - | set v15 ^= v3; |
|
| 135 | - | set v15 = bits::rotateRight32(v15, 16); |
|
| 136 | - | set v11 += v15; |
|
| 137 | - | set v7 ^= v11; |
|
| 138 | - | set v7 = bits::rotateRight32(v7, 12); |
|
| 139 | - | set v3 += v7 + m[7]; |
|
| 140 | - | set v15 ^= v3; |
|
| 141 | - | set v15 = bits::rotateRight32(v15, 8); |
|
| 142 | - | set v11 += v15; |
|
| 143 | - | set v7 ^= v11; |
|
| 144 | - | set v7 = bits::rotateRight32(v7, 7); |
|
| 145 | - | set v0 += v5 + m[8]; |
|
| 146 | - | set v15 ^= v0; |
|
| 147 | - | set v15 = bits::rotateRight32(v15, 16); |
|
| 148 | - | set v10 += v15; |
|
| 149 | - | set v5 ^= v10; |
|
| 150 | - | set v5 = bits::rotateRight32(v5, 12); |
|
| 151 | - | set v0 += v5 + m[9]; |
|
| 152 | - | set v15 ^= v0; |
|
| 153 | - | set v15 = bits::rotateRight32(v15, 8); |
|
| 154 | - | set v10 += v15; |
|
| 155 | - | set v5 ^= v10; |
|
| 156 | - | set v5 = bits::rotateRight32(v5, 7); |
|
| 157 | - | set v1 += v6 + m[10]; |
|
| 158 | - | set v12 ^= v1; |
|
| 159 | - | set v12 = bits::rotateRight32(v12, 16); |
|
| 160 | - | set v11 += v12; |
|
| 161 | - | set v6 ^= v11; |
|
| 162 | - | set v6 = bits::rotateRight32(v6, 12); |
|
| 163 | - | set v1 += v6 + m[11]; |
|
| 164 | - | set v12 ^= v1; |
|
| 165 | - | set v12 = bits::rotateRight32(v12, 8); |
|
| 166 | - | set v11 += v12; |
|
| 167 | - | set v6 ^= v11; |
|
| 168 | - | set v6 = bits::rotateRight32(v6, 7); |
|
| 169 | - | set v2 += v7 + m[12]; |
|
| 170 | - | set v13 ^= v2; |
|
| 171 | - | set v13 = bits::rotateRight32(v13, 16); |
|
| 172 | - | set v8 += v13; |
|
| 173 | - | set v7 ^= v8; |
|
| 174 | - | set v7 = bits::rotateRight32(v7, 12); |
|
| 175 | - | set v2 += v7 + m[13]; |
|
| 176 | - | set v13 ^= v2; |
|
| 177 | - | set v13 = bits::rotateRight32(v13, 8); |
|
| 178 | - | set v8 += v13; |
|
| 179 | - | set v7 ^= v8; |
|
| 180 | - | set v7 = bits::rotateRight32(v7, 7); |
|
| 181 | - | set v3 += v4 + m[14]; |
|
| 182 | - | set v14 ^= v3; |
|
| 183 | - | set v14 = bits::rotateRight32(v14, 16); |
|
| 184 | - | set v9 += v14; |
|
| 185 | - | set v4 ^= v9; |
|
| 186 | - | set v4 = bits::rotateRight32(v4, 12); |
|
| 187 | - | set v3 += v4 + m[15]; |
|
| 188 | - | set v14 ^= v3; |
|
| 189 | - | set v14 = bits::rotateRight32(v14, 8); |
|
| 190 | - | set v9 += v14; |
|
| 191 | - | set v4 ^= v9; |
|
| 192 | - | set v4 = bits::rotateRight32(v4, 7); |
|
| 193 | - | set state[0] = v0; |
|
| 194 | - | set state[1] = v1; |
|
| 195 | - | set state[2] = v2; |
|
| 196 | - | set state[3] = v3; |
|
| 197 | - | set state[4] = v4; |
|
| 198 | - | set state[5] = v5; |
|
| 199 | - | set state[6] = v6; |
|
| 200 | - | set state[7] = v7; |
|
| 201 | - | set state[8] = v8; |
|
| 202 | - | set state[9] = v9; |
|
| 203 | - | set state[10] = v10; |
|
| 204 | - | set state[11] = v11; |
|
| 205 | - | set state[12] = v12; |
|
| 206 | - | set state[13] = v13; |
|
| 207 | - | set state[14] = v14; |
|
| 208 | - | set state[15] = v15; |
|
| 209 | - | } |
|
| 210 | - | ||
| 211 | - | /// Compress a node and return its first eight output words. |
|
| 212 | - | fn compress(input: &Output) -> [u32; 8] { |
|
| 213 | - | let mut state: [u32; 16] = [ |
|
| 214 | - | input.words[0], input.words[1], input.words[2], input.words[3], |
|
| 215 | - | input.words[4], input.words[5], input.words[6], input.words[7], |
|
| 216 | - | IV[0], IV[1], IV[2], IV[3], input.counter as u32, |
|
| 217 | - | (input.counter >> 32) as u32, input.length, input.flags, |
|
| 218 | - | ]; |
|
| 219 | - | let mut m = input.block; |
|
| 220 | - | for i in 0 as u32 .. 7 { |
|
| 221 | - | round(&mut state, &m); |
|
| 222 | - | if i < 6 { |
|
| 94 | + | let mut m = *message; |
|
| 95 | + | for round in 0 as u32 .. 7 { |
|
| 96 | + | let mut v12 = state[12]; |
|
| 97 | + | let mut v13 = state[13]; |
|
| 98 | + | let mut v14 = state[14]; |
|
| 99 | + | let mut v15 = state[15]; |
|
| 100 | + | set v0 += v4 + m[0]; |
|
| 101 | + | set v12 ^= v0; |
|
| 102 | + | set v12 = bits::rotateRight32(v12, 16); |
|
| 103 | + | set v8 += v12; |
|
| 104 | + | set v4 ^= v8; |
|
| 105 | + | set v4 = bits::rotateRight32(v4, 12); |
|
| 106 | + | set v0 += v4 + m[1]; |
|
| 107 | + | set v12 ^= v0; |
|
| 108 | + | set v12 = bits::rotateRight32(v12, 8); |
|
| 109 | + | set v8 += v12; |
|
| 110 | + | set v4 ^= v8; |
|
| 111 | + | set v4 = bits::rotateRight32(v4, 7); |
|
| 112 | + | set v1 += v5 + m[2]; |
|
| 113 | + | set v13 ^= v1; |
|
| 114 | + | set v13 = bits::rotateRight32(v13, 16); |
|
| 115 | + | set v9 += v13; |
|
| 116 | + | set v5 ^= v9; |
|
| 117 | + | set v5 = bits::rotateRight32(v5, 12); |
|
| 118 | + | set v1 += v5 + m[3]; |
|
| 119 | + | set v13 ^= v1; |
|
| 120 | + | set v13 = bits::rotateRight32(v13, 8); |
|
| 121 | + | set v9 += v13; |
|
| 122 | + | set v5 ^= v9; |
|
| 123 | + | set v5 = bits::rotateRight32(v5, 7); |
|
| 124 | + | set v2 += v6 + m[4]; |
|
| 125 | + | set v14 ^= v2; |
|
| 126 | + | set v14 = bits::rotateRight32(v14, 16); |
|
| 127 | + | set v10 += v14; |
|
| 128 | + | set v6 ^= v10; |
|
| 129 | + | set v6 = bits::rotateRight32(v6, 12); |
|
| 130 | + | set v2 += v6 + m[5]; |
|
| 131 | + | set v14 ^= v2; |
|
| 132 | + | set v14 = bits::rotateRight32(v14, 8); |
|
| 133 | + | set v10 += v14; |
|
| 134 | + | set v6 ^= v10; |
|
| 135 | + | set v6 = bits::rotateRight32(v6, 7); |
|
| 136 | + | set v3 += v7 + m[6]; |
|
| 137 | + | set v15 ^= v3; |
|
| 138 | + | set v15 = bits::rotateRight32(v15, 16); |
|
| 139 | + | set v11 += v15; |
|
| 140 | + | set v7 ^= v11; |
|
| 141 | + | set v7 = bits::rotateRight32(v7, 12); |
|
| 142 | + | set v3 += v7 + m[7]; |
|
| 143 | + | set v15 ^= v3; |
|
| 144 | + | set v15 = bits::rotateRight32(v15, 8); |
|
| 145 | + | set v11 += v15; |
|
| 146 | + | set v7 ^= v11; |
|
| 147 | + | set v7 = bits::rotateRight32(v7, 7); |
|
| 148 | + | set v0 += v5 + m[8]; |
|
| 149 | + | set v15 ^= v0; |
|
| 150 | + | set v15 = bits::rotateRight32(v15, 16); |
|
| 151 | + | set v10 += v15; |
|
| 152 | + | set v5 ^= v10; |
|
| 153 | + | set v5 = bits::rotateRight32(v5, 12); |
|
| 154 | + | set v0 += v5 + m[9]; |
|
| 155 | + | set v15 ^= v0; |
|
| 156 | + | set v15 = bits::rotateRight32(v15, 8); |
|
| 157 | + | set v10 += v15; |
|
| 158 | + | set v5 ^= v10; |
|
| 159 | + | set v5 = bits::rotateRight32(v5, 7); |
|
| 160 | + | set v1 += v6 + m[10]; |
|
| 161 | + | set v12 ^= v1; |
|
| 162 | + | set v12 = bits::rotateRight32(v12, 16); |
|
| 163 | + | set v11 += v12; |
|
| 164 | + | set v6 ^= v11; |
|
| 165 | + | set v6 = bits::rotateRight32(v6, 12); |
|
| 166 | + | set v1 += v6 + m[11]; |
|
| 167 | + | set v12 ^= v1; |
|
| 168 | + | set v12 = bits::rotateRight32(v12, 8); |
|
| 169 | + | set v11 += v12; |
|
| 170 | + | set v6 ^= v11; |
|
| 171 | + | set v6 = bits::rotateRight32(v6, 7); |
|
| 172 | + | set v2 += v7 + m[12]; |
|
| 173 | + | set v13 ^= v2; |
|
| 174 | + | set v13 = bits::rotateRight32(v13, 16); |
|
| 175 | + | set v8 += v13; |
|
| 176 | + | set v7 ^= v8; |
|
| 177 | + | set v7 = bits::rotateRight32(v7, 12); |
|
| 178 | + | set v2 += v7 + m[13]; |
|
| 179 | + | set v13 ^= v2; |
|
| 180 | + | set v13 = bits::rotateRight32(v13, 8); |
|
| 181 | + | set v8 += v13; |
|
| 182 | + | set v7 ^= v8; |
|
| 183 | + | set v7 = bits::rotateRight32(v7, 7); |
|
| 184 | + | set v3 += v4 + m[14]; |
|
| 185 | + | set v14 ^= v3; |
|
| 186 | + | set v14 = bits::rotateRight32(v14, 16); |
|
| 187 | + | set v9 += v14; |
|
| 188 | + | set v4 ^= v9; |
|
| 189 | + | set v4 = bits::rotateRight32(v4, 12); |
|
| 190 | + | set v3 += v4 + m[15]; |
|
| 191 | + | set v14 ^= v3; |
|
| 192 | + | set v14 = bits::rotateRight32(v14, 8); |
|
| 193 | + | set v9 += v14; |
|
| 194 | + | set v4 ^= v9; |
|
| 195 | + | set v4 = bits::rotateRight32(v4, 7); |
|
| 196 | + | set state[12] = v12; |
|
| 197 | + | set state[13] = v13; |
|
| 198 | + | set state[14] = v14; |
|
| 199 | + | set state[15] = v15; |
|
| 200 | + | if round < 6 { |
|
| 223 | 201 | // Permute the message words for the next round. The permutation |
|
| 224 | 202 | // has two cycles of eight words. |
|
| 225 | 203 | let first = m[0]; |
|
| 226 | 204 | set m[0] = m[2]; |
|
| 227 | 205 | set m[2] = m[3]; |
| 240 | 218 | set m[14] = m[15]; |
|
| 241 | 219 | set m[15] = m[8]; |
|
| 242 | 220 | set m[8] = second; |
|
| 243 | 221 | } |
|
| 244 | 222 | } |
|
| 223 | + | set state[0] = v0; |
|
| 224 | + | set state[1] = v1; |
|
| 225 | + | set state[2] = v2; |
|
| 226 | + | set state[3] = v3; |
|
| 227 | + | set state[4] = v4; |
|
| 228 | + | set state[5] = v5; |
|
| 229 | + | set state[6] = v6; |
|
| 230 | + | set state[7] = v7; |
|
| 231 | + | set state[8] = v8; |
|
| 232 | + | set state[9] = v9; |
|
| 233 | + | set state[10] = v10; |
|
| 234 | + | set state[11] = v11; |
|
| 235 | + | } |
|
| 236 | + | ||
| 237 | + | /// Compress a node and return its first eight output words. |
|
| 238 | + | fn compress(input: &Output) -> [u32; 8] { |
|
| 239 | + | let mut state: [u32; 16] = [ |
|
| 240 | + | input.words[0], input.words[1], input.words[2], input.words[3], |
|
| 241 | + | input.words[4], input.words[5], input.words[6], input.words[7], |
|
| 242 | + | IV[0], IV[1], IV[2], IV[3], input.counter as u32, |
|
| 243 | + | (input.counter >> 32) as u32, input.length, input.flags, |
|
| 244 | + | ]; |
|
| 245 | + | rounds(&mut state, &input.block); |
|
| 245 | 246 | return [ |
|
| 246 | 247 | state[0] ^ state[8], state[1] ^ state[9], |
|
| 247 | 248 | state[2] ^ state[10], state[3] ^ state[11], |
|
| 248 | 249 | state[4] ^ state[12], state[5] ^ state[13], |
|
| 249 | 250 | state[6] ^ state[14], state[7] ^ state[15], |
|
| 250 | 251 | ]; |
|
| 251 | 252 | } |
|
| 252 | 253 | ||
| 253 | 254 | /// Read one complete block as little-endian words. |
|
| 254 | 255 | fn readBlock(bytes: &[u8]) -> [u32; 16] { |
|
| 255 | - | let mut words: [u32; 16] = [0; 16]; |
|
| 256 | - | for i in 0 as u32 .. 16 { |
|
| 257 | - | set words[i] = mem::load32Le(bytes, i * 4); |
|
| 258 | - | } |
|
| 259 | - | return words; |
|
| 256 | + | return [ |
|
| 257 | + | mem::load32Le(bytes, 0), |
|
| 258 | + | mem::load32Le(bytes, 4), |
|
| 259 | + | mem::load32Le(bytes, 8), |
|
| 260 | + | mem::load32Le(bytes, 12), |
|
| 261 | + | mem::load32Le(bytes, 16), |
|
| 262 | + | mem::load32Le(bytes, 20), |
|
| 263 | + | mem::load32Le(bytes, 24), |
|
| 264 | + | mem::load32Le(bytes, 28), |
|
| 265 | + | mem::load32Le(bytes, 32), |
|
| 266 | + | mem::load32Le(bytes, 36), |
|
| 267 | + | mem::load32Le(bytes, 40), |
|
| 268 | + | mem::load32Le(bytes, 44), |
|
| 269 | + | mem::load32Le(bytes, 48), |
|
| 270 | + | mem::load32Le(bytes, 52), |
|
| 271 | + | mem::load32Le(bytes, 56), |
|
| 272 | + | mem::load32Le(bytes, 60), |
|
| 273 | + | ]; |
|
| 260 | 274 | } |
|
| 261 | 275 | ||
| 262 | 276 | /// Join two subtree values into a parent compression input. |
|
| 263 | 277 | fn parent(left: &[u32], right: &[u32]) -> Output { |
|
| 264 | 278 | let mut block: [u32; 16] = [0; 16]; |
lib/std/lang/il/binary/collect.rad
+20 -178
| 30 | 30 | throw binary::Error::Storage; |
|
| 31 | 31 | }; |
|
| 32 | 32 | return Names { symbols: &mut [], index: dict::fresh(table) }; |
|
| 33 | 33 | } |
|
| 34 | 34 | ||
| 35 | - | /// Add a unique name and return the stored copy. |
|
| 36 | - | export fn intern(names: &mut Names, name: *[u8], a: &heap::Heap) -> *[u8] |
|
| 35 | + | /// Add a unique name and return its first-use index. |
|
| 36 | + | export fn intern(names: &mut Names, name: *[u8], a: &heap::Heap) -> u32 |
|
| 37 | 37 | throws (binary::Error) |
|
| 38 | 38 | { |
|
| 39 | 39 | if name.len == 0 { |
|
| 40 | 40 | throw binary::Error::Invalid; |
|
| 41 | 41 | } |
|
| 42 | 42 | if let i = dict::get(&names.index, name) { |
|
| 43 | - | return names.symbols[i as u32]; |
|
| 43 | + | return i as u32; |
|
| 44 | 44 | } |
|
| 45 | 45 | let copy = try alloc::copyBytes(a, name) catch { |
|
| 46 | 46 | throw binary::Error::Storage; |
|
| 47 | 47 | }; |
|
| 48 | 48 | let stored: *[u8] = ©[..]; |
|
| 49 | - | try dict::insert(&mut names.index, stored, names.symbols.len as i32) catch { |
|
| 49 | + | let index = names.symbols.len; |
|
| 50 | + | try names.symbols.append(stored, a) catch { |
|
| 50 | 51 | throw binary::Error::Storage; |
|
| 51 | 52 | }; |
|
| 52 | - | try names.symbols.append(stored, a) catch { |
|
| 53 | + | try dict::insert(&mut names.index, stored, index as i32) catch { |
|
| 54 | + | // Shrinking a reserved slice cannot allocate. |
|
| 55 | + | try! names.symbols.resize(index, "", a); |
|
| 53 | 56 | throw binary::Error::Storage; |
|
| 54 | 57 | }; |
|
| 55 | - | return stored; |
|
| 56 | - | } |
|
| 57 | - | ||
| 58 | - | /// Add a qualified reference with a nonempty package and local name. |
|
| 59 | - | fn reference(names: &mut Names, name: *[u8], a: &heap::Heap) |
|
| 60 | - | throws (binary::Error) |
|
| 61 | - | { |
|
| 62 | - | let stored = try intern(names, name, a); |
|
| 63 | - | for i in 0 .. stored.len { |
|
| 64 | - | if stored[i] == ':' and i + 1 < stored.len and stored[i + 1] == ':' { |
|
| 65 | - | if i == 0 or i + 2 == stored.len { |
|
| 66 | - | throw binary::Error::Invalid; |
|
| 67 | - | } |
|
| 68 | - | return; |
|
| 69 | - | } |
|
| 70 | - | } |
|
| 71 | - | throw binary::Error::Invalid; |
|
| 72 | - | } |
|
| 73 | - | ||
| 74 | - | /// Collect names referenced by one IL value. |
|
| 75 | - | fn value(names: &mut Names, item: il::Val, a: &heap::Heap) |
|
| 76 | - | throws (binary::Error) |
|
| 77 | - | { |
|
| 78 | - | match item { |
|
| 79 | - | case il::Val::DataSym(name) => try reference(names, name, a), |
|
| 80 | - | case il::Val::FnAddr(name) => try reference(names, name, a), |
|
| 81 | - | else => {} |
|
| 82 | - | } |
|
| 58 | + | return index; |
|
| 83 | 59 | } |
|
| 84 | 60 | ||
| 85 | - | /// Collect names from an instruction's variable-length operand sequence. |
|
| 86 | - | fn values(names: &mut Names, items: &[il::Val], a: &heap::Heap) |
|
| 61 | + | /// Add a qualified reference with a nonempty package and local name, returning its index. |
|
| 62 | + | export fn reference(names: &mut Names, name: *[u8], a: &heap::Heap) -> u32 |
|
| 87 | 63 | throws (binary::Error) |
|
| 88 | 64 | { |
|
| 89 | - | for item in items { |
|
| 90 | - | try value(names, item, a); |
|
| 91 | - | } |
|
| 92 | - | } |
|
| 93 | - | ||
| 94 | - | /// Collect all symbolic instruction operands of `func`. |
|
| 95 | - | fn instruction( |
|
| 96 | - | names: &mut Names, |
|
| 97 | - | func: &il::Fn, |
|
| 98 | - | instr: il::Instr, |
|
| 99 | - | a: &heap::Heap |
|
| 100 | - | ) throws (binary::Error) { |
|
| 101 | - | match instr { |
|
| 102 | - | case il::Instr::Store { src, .. } => try value(names, src, a), |
|
| 103 | - | case il::Instr::Copy { val, .. } => try value(names, val, a), |
|
| 104 | - | case il::Instr::Zext { val, .. } => try value(names, val, a), |
|
| 105 | - | case il::Instr::Sext { val, .. } => try value(names, val, a), |
|
| 106 | - | case il::Instr::BinOp { a: left, b: right, .. } => { |
|
| 107 | - | try value(names, left, a); |
|
| 108 | - | try value(names, right, a); |
|
| 109 | - | } |
|
| 110 | - | case il::Instr::UnOp { a: operand, .. } => try value(names, operand, a), |
|
| 111 | - | case il::Instr::Call { func: callee, args, .. } => { |
|
| 112 | - | try value(names, callee, a); |
|
| 113 | - | try values(names, il::argVals(func, args), a); |
|
| 114 | - | } |
|
| 115 | - | case il::Instr::Ret { val } => { |
|
| 116 | - | if let item = val { |
|
| 117 | - | try value(names, item, a); |
|
| 118 | - | } |
|
| 119 | - | } |
|
| 120 | - | case il::Instr::Jmp { args, .. } => try values(names, il::argVals(func, args), a), |
|
| 121 | - | case il::Instr::Br { a: left, b: right, thenArgs, elseArgs, .. } => { |
|
| 122 | - | try value(names, left, a); |
|
| 123 | - | try value(names, right, a); |
|
| 124 | - | try values(names, il::argVals(func, thenArgs), a); |
|
| 125 | - | try values(names, il::argVals(func, elseArgs), a); |
|
| 126 | - | } |
|
| 127 | - | case il::Instr::Switch { val, defaultArgs, cases, .. } => { |
|
| 128 | - | try value(names, val, a); |
|
| 129 | - | try values(names, il::argVals(func, defaultArgs), a); |
|
| 130 | - | for branch in il::switchCases(func, cases) { |
|
| 131 | - | try values(names, il::argVals(func, branch.args), a); |
|
| 132 | - | } |
|
| 133 | - | } |
|
| 134 | - | case il::Instr::Ecall { num, a0, a1, a2, a3, .. } => { |
|
| 135 | - | try value(names, num, a); |
|
| 136 | - | try value(names, a0, a); |
|
| 137 | - | try value(names, a1, a); |
|
| 138 | - | try value(names, a2, a); |
|
| 139 | - | try value(names, a3, a); |
|
| 140 | - | } |
|
| 141 | - | case il::Instr::PageSlice { handle, .. } => try value(names, handle, a), |
|
| 142 | - | case il::Instr::PageHeap { handle, .. } => try value(names, handle, a), |
|
| 143 | - | case il::Instr::HeapReset { heap } => try value(names, heap, a), |
|
| 144 | - | case il::Instr::DeviceRead { handle, offset, .. } => { |
|
| 145 | - | try value(names, handle, a); |
|
| 146 | - | try value(names, offset, a); |
|
| 147 | - | } |
|
| 148 | - | case il::Instr::DeviceWrite { handle, offset, value: source, .. } => { |
|
| 149 | - | try value(names, handle, a); |
|
| 150 | - | try value(names, offset, a); |
|
| 151 | - | try value(names, source, a); |
|
| 152 | - | } |
|
| 153 | - | case il::Instr::SliceNew { base, start, end, .. } => { |
|
| 154 | - | try value(names, base, a); |
|
| 155 | - | try value(names, start, a); |
|
| 156 | - | try value(names, end, a); |
|
| 157 | - | } |
|
| 158 | - | case il::Instr::SliceSub { start, end, .. } => { |
|
| 159 | - | try value(names, start, a); |
|
| 160 | - | try value(names, end, a); |
|
| 161 | - | } |
|
| 162 | - | case il::Instr::SliceGrow { heap, capacity, .. } => { |
|
| 163 | - | try value(names, heap, a); |
|
| 164 | - | try value(names, capacity, a); |
|
| 165 | - | } |
|
| 166 | - | case il::Instr::SliceLen { length, .. } => try value(names, length, a), |
|
| 167 | - | case il::Instr::Elem { index, .. } => try value(names, index, a), |
|
| 168 | - | case il::Instr::BytesLoad { offset, .. } => try value(names, offset, a), |
|
| 169 | - | case il::Instr::BytesStore { offset, value: val, .. } => { |
|
| 170 | - | try value(names, offset, a); |
|
| 171 | - | try value(names, val, a); |
|
| 172 | - | } |
|
| 173 | - | case il::Instr::SliceElem { index, .. } => try value(names, index, a), |
|
| 174 | - | case il::Instr::StorePtr { src, .. } => try value(names, src, a), |
|
| 175 | - | case il::Instr::TraitNew { table, .. } => try value(names, table, a), |
|
| 176 | - | case il::Instr::UnionSet { src, .. } => try value(names, src, a), |
|
| 177 | - | case il::Instr::TraitCall { args, .. } => |
|
| 178 | - | try values(names, il::argVals(func, args), a), |
|
| 179 | - | case |
|
| 180 | - | il::Instr::Field { .. }, |
|
| 181 | - | il::Instr::TraitCopy { .. }, |
|
| 182 | - | il::Instr::UnionGet { .. }, |
|
| 183 | - | il::Instr::SliceCopy { .. }, |
|
| 184 | - | il::Instr::LoadPtr { .. }, |
|
| 185 | - | il::Instr::Reserve { .. }, |
|
| 186 | - | il::Instr::Blit { .. }, |
|
| 187 | - | il::Instr::Load { .. }, |
|
| 188 | - | il::Instr::Sload { .. }, |
|
| 189 | - | il::Instr::Unreachable, |
|
| 190 | - | il::Instr::Ebreak, |
|
| 191 | - | il::Instr::MemoryFence => |
|
| 192 | - | {} |
|
| 65 | + | let separator = mem::find(name, "::") else throw binary::Error::Invalid; |
|
| 66 | + | if separator == 0 or separator + 2 == name.len { |
|
| 67 | + | throw binary::Error::Invalid; |
|
| 193 | 68 | } |
|
| 69 | + | return try intern(names, name, a); |
|
| 194 | 70 | } |
|
| 195 | 71 | ||
| 196 | 72 | /// Check that a definition belongs to the selected package. |
|
| 197 | - | fn definition( |
|
| 73 | + | export fn definition( |
|
| 198 | 74 | names: &mut Names, owner: *[u8], name: *[u8], a: &heap::Heap |
|
| 199 | 75 | ) -> *[u8] throws (binary::Error) { |
|
| 200 | 76 | let rest = mem::stripPrefix(owner, name) else { |
|
| 201 | 77 | throw binary::Error::Invalid; |
|
| 202 | 78 | }; |
|
| 203 | 79 | if rest.len < 3 or rest[0] <> ':' or rest[1] <> ':' { |
|
| 204 | 80 | throw binary::Error::Invalid; |
|
| 205 | 81 | } |
|
| 206 | - | return try intern(names, name, a); |
|
| 82 | + | let index = try intern(names, name, a); |
|
| 83 | + | return names.symbols[index]; |
|
| 207 | 84 | } |
|
| 208 | 85 | ||
| 209 | - | /// Add the package name to the tables. Call it before the first [`function`]. |
|
| 86 | + | /// Add the package name before its definitions and references. |
|
| 210 | 87 | export fn start(names: &mut Names, owner: *[u8], a: &heap::Heap) |
|
| 211 | 88 | throws (binary::Error) |
|
| 212 | 89 | { |
|
| 213 | 90 | try intern(names, owner, a); |
|
| 214 | 91 | } |
|
| 215 | 92 | ||
| 216 | - | /// Collect the definition and the references of one function. Return the |
|
| 217 | - | /// stored copy of its name. Nothing in `func` is retained, so the caller may |
|
| 218 | - | /// release the function afterward. |
|
| 219 | - | export fn function( |
|
| 220 | - | names: &mut Names, |
|
| 221 | - | owner: *[u8], |
|
| 222 | - | func: *il::Fn, |
|
| 223 | - | a: &heap::Heap |
|
| 224 | - | ) -> *[u8] throws (binary::Error) { |
|
| 225 | - | let stored = try definition(names, owner, func.name, a); |
|
| 226 | - | for block in func.blocks { |
|
| 227 | - | for instr in block.instrs { |
|
| 228 | - | try instruction(names, func, instr, a); |
|
| 229 | - | } |
|
| 230 | - | } |
|
| 231 | - | return stored; |
|
| 232 | - | } |
|
| 233 | - | ||
| 234 | 93 | /// Build package tables from explicit dependencies and local definitions. |
|
| 235 | 94 | /// The tables move out of `names`, but its name index stays valid. |
|
| 236 | - | /// The functions of `program` must have been collected with [`function`]. |
|
| 95 | + | /// Function names and symbolic operands must already be interned. |
|
| 237 | 96 | export fn finish( |
|
| 238 | 97 | names: &mut Names, |
|
| 239 | 98 | owner: *[u8], |
|
| 240 | 99 | dependencies: *[*[u8]], |
|
| 241 | 100 | program: il::Program, |
| 271 | 130 | entry, |
|
| 272 | 131 | program, |
|
| 273 | 132 | links: binary::EMPTY_LINKS, |
|
| 274 | 133 | }; |
|
| 275 | 134 | } |
|
| 276 | - | ||
| 277 | - | /// Build package tables for a complete program with explicit dependencies. |
|
| 278 | - | export fn package( |
|
| 279 | - | names: &mut Names, |
|
| 280 | - | owner: *[u8], |
|
| 281 | - | dependencies: *[*[u8]], |
|
| 282 | - | program: il::Program, |
|
| 283 | - | exports: *[binary::Export], |
|
| 284 | - | entry: ?*[u8], |
|
| 285 | - | a: &heap::Heap |
|
| 286 | - | ) -> binary::Package throws (binary::Error) { |
|
| 287 | - | try start(names, owner, a); |
|
| 288 | - | for func in program.fns { |
|
| 289 | - | try function(names, owner, func, a); |
|
| 290 | - | } |
|
| 291 | - | return try finish(names, owner, dependencies, program, exports, entry, a); |
|
| 292 | - | } |
lib/std/lang/il/binary/linkage.rad
+5 -3
| 44 | 44 | } |
|
| 45 | 45 | return result; |
|
| 46 | 46 | } |
|
| 47 | 47 | ||
| 48 | 48 | /// Encode persistent declarations. Verification state has no wire representation. |
|
| 49 | - | export fn write(out: &mut writer::Writer, links: &binary::Links) throws (binary::Error) { |
|
| 49 | + | export fn write( |
|
| 50 | + | out: &mut writer::Writer, links: &binary::Links, symbols: &mut opaque writer::SymbolTable |
|
| 51 | + | ) throws (binary::Error) { |
|
| 50 | 52 | try writer::word(out, links.pins.len as u64); |
|
| 51 | 53 | for pin in links.pins { |
|
| 52 | 54 | try writeId(out, &pin); |
|
| 53 | 55 | } |
|
| 54 | 56 | try writer::word(out, links.imports.len as u64); |
|
| 55 | 57 | for item in links.imports { |
|
| 56 | - | try writer::symbol(out, item.name); |
|
| 58 | + | try writer::symbol(out, item.name, symbols); |
|
| 57 | 59 | try writer::word(out, item.dependency as u64); |
|
| 58 | - | try writer::symbol(out, item.exported); |
|
| 60 | + | try writer::symbol(out, item.exported, symbols); |
|
| 59 | 61 | match item.kind { |
|
| 60 | 62 | case binary::ImportKind::Function(signature) => { |
|
| 61 | 63 | try writer::byte(out, binary::SYMBOL_FUNCTION); |
|
| 62 | 64 | try writer::word(out, signature as u64); |
|
| 63 | 65 | } |
lib/std/lang/il/binary/program.rad
+59 -50
| 6 | 6 | ||
| 7 | 7 | use std::collections::dict; |
|
| 8 | 8 | use std::lang::il; |
|
| 9 | 9 | use std::lang::il::binary; |
|
| 10 | 10 | use std::lang::il::binary::cfg; |
|
| 11 | + | use std::lang::il::binary::collect; |
|
| 11 | 12 | use std::lang::il::binary::linkage; |
|
| 12 | 13 | use std::lang::il::binary::reader; |
|
| 13 | 14 | use std::lang::il::binary::writer; |
|
| 14 | 15 | use std::mem; |
|
| 15 | 16 | use std::mem::heap; |
| 35 | 36 | try writer::valType(out, param.type); |
|
| 36 | 37 | } |
|
| 37 | 38 | } |
|
| 38 | 39 | ||
| 39 | 40 | /// Write the package tables through `out`, up to and including the function count. |
|
| 40 | - | fn writeHead(out: &mut writer::Writer, package: &binary::Package, fnCount: u32) |
|
| 41 | - | throws (binary::Error) |
|
| 42 | - | { |
|
| 41 | + | fn writeHead( |
|
| 42 | + | out: &mut writer::Writer, |
|
| 43 | + | package: &binary::Package, |
|
| 44 | + | fnCount: u32, |
|
| 45 | + | symbols: &mut opaque writer::SymbolTable |
|
| 46 | + | ) throws (binary::Error) { |
|
| 43 | 47 | try writer::word(out, binary::MAGIC as u64); |
|
| 44 | 48 | try writer::word(out, binary::FORMAT_VERSION as u64); |
|
| 45 | 49 | try writer::word(out, binary::ABI_VERSION as u64); |
|
| 46 | 50 | try writer::word(out, package.symbols.len as u64); |
|
| 47 | 51 | for name in package.symbols { |
|
| 48 | 52 | try writer::bytes(out, name); |
|
| 49 | 53 | } |
|
| 50 | - | try writer::symbol(out, package.name); |
|
| 54 | + | try writer::symbol(out, package.name, symbols); |
|
| 51 | 55 | try writer::word(out, package.dependencies.len as u64); |
|
| 52 | 56 | for name in package.dependencies { |
|
| 53 | - | try writer::symbol(out, name); |
|
| 57 | + | try writer::symbol(out, name, symbols); |
|
| 54 | 58 | } |
|
| 55 | 59 | try writer::word(out, package.exports.len as u64); |
|
| 56 | 60 | for item in package.exports { |
|
| 57 | - | try writer::symbol(out, item.name); |
|
| 61 | + | try writer::symbol(out, item.name, symbols); |
|
| 58 | 62 | match item.kind { |
|
| 59 | 63 | case binary::ExportKind::Function => try writer::byte(out, 0), |
|
| 60 | 64 | case binary::ExportKind::Data => try writer::byte(out, 1), |
|
| 61 | 65 | } |
|
| 62 | 66 | } |
|
| 63 | 67 | if let entry = package.entry { |
|
| 64 | 68 | try writer::byte(out, 1); |
|
| 65 | - | try writer::symbol(out, entry); |
|
| 69 | + | try writer::symbol(out, entry, symbols); |
|
| 66 | 70 | } else { |
|
| 67 | 71 | try writer::byte(out, 0); |
|
| 68 | 72 | } |
|
| 69 | - | try linkage::write(out, &package.links); |
|
| 73 | + | try linkage::write(out, &package.links, symbols); |
|
| 70 | 74 | try writer::word(out, package.program.layouts.len as u64); |
|
| 71 | 75 | try writer::word(out, package.program.signatures.len as u64); |
|
| 72 | 76 | try writer::word(out, package.program.traits.len as u64); |
|
| 73 | 77 | for item in package.program.layouts { |
|
| 74 | 78 | try writer::layout(out, item); |
| 79 | 83 | for item in package.program.traits { |
|
| 80 | 84 | try writer::traitRecord(out, item); |
|
| 81 | 85 | } |
|
| 82 | 86 | try writer::word(out, package.program.data.len as u64); |
|
| 83 | 87 | for item in package.program.data { |
|
| 84 | - | try writer::symbol(out, item.name); |
|
| 88 | + | try writer::symbol(out, item.name, symbols); |
|
| 85 | 89 | try writer::word(out, item.layout as u64); |
|
| 86 | 90 | try writer::byte(out, 1 if item.readOnly else 0); |
|
| 87 | 91 | try writer::byte(out, 1 if item.isZeroInit else 0); |
|
| 88 | 92 | if let heap = item.heap { |
|
| 89 | 93 | try writer::byte(out, 1 + writer::heapFlags(heap) as u64); |
|
| 90 | 94 | } else { |
|
| 91 | 95 | try writer::byte(out, 0); |
|
| 92 | 96 | } |
|
| 93 | 97 | try writer::word(out, item.values.len as u64); |
|
| 94 | 98 | for value in item.values { |
|
| 95 | - | try writer::dataValue(out, value); |
|
| 99 | + | try writer::dataValue(out, value, symbols); |
|
| 96 | 100 | } |
|
| 97 | 101 | } |
|
| 98 | 102 | try writer::word(out, fnCount as u64); |
|
| 99 | 103 | } |
|
| 100 | 104 | ||
| 101 | 105 | /// Write one length-delimited function: name, signature, and blocks. |
|
| 102 | - | fn writeFunction(out: &mut writer::Writer, func: *il::Fn) throws (binary::Error) { |
|
| 106 | + | fn writeFunction(out: &mut writer::Writer, func: *il::Fn, symbols: &mut opaque writer::SymbolTable) |
|
| 107 | + | throws (binary::Error) |
|
| 108 | + | { |
|
| 103 | 109 | let lengthOffset = out.offset; |
|
| 104 | 110 | try writer::word(out, 0); |
|
| 105 | 111 | let start = out.offset; |
|
| 106 | - | try writer::symbol(out, func.name); |
|
| 112 | + | try writer::symbol(out, func.name, symbols); |
|
| 107 | 113 | try writer::valType(out, func.returnType); |
|
| 108 | 114 | try writer::borrows(out, func.borrows); |
|
| 109 | 115 | try writer::byte(out, 1 if func.isExtern else 0); |
|
| 110 | 116 | try writeParams(out, func.params); |
|
| 111 | 117 | try writer::word(out, func.blocks.len as u64); |
| 118 | 124 | try writer::byte(out, 0); |
|
| 119 | 125 | } |
|
| 120 | 126 | try writeParams(out, block.params); |
|
| 121 | 127 | try writer::word(out, block.instrs.len as u64); |
|
| 122 | 128 | for instr in block.instrs { |
|
| 123 | - | try writer::instr(out, func, instr); |
|
| 129 | + | try writer::instr(out, func, instr, symbols); |
|
| 124 | 130 | } |
|
| 125 | 131 | } |
|
| 126 | 132 | mem::store32Le(&mut out.bytes[..], lengthOffset, out.offset - start); |
|
| 127 | 133 | } |
|
| 128 | 134 | ||
| 129 | 135 | /// Write a complete package at the current cursor. Return the final cursor offset. |
|
| 130 | 136 | export fn write(out: &mut writer::Writer, package: &binary::Package) -> u32 throws (binary::Error) { |
|
| 131 | - | try writeHead(out, package, package.program.fns.len); |
|
| 137 | + | let mut table = writer::Listed { names: package.symbols }; |
|
| 138 | + | let symbols: &mut opaque writer::SymbolTable = &mut table; |
|
| 139 | + | try writeHead(out, package, package.program.fns.len, symbols); |
|
| 132 | 140 | for func in package.program.fns { |
|
| 133 | - | try writeFunction(out, func); |
|
| 141 | + | try writeFunction(out, func, symbols); |
|
| 134 | 142 | } |
|
| 135 | 143 | return out.offset; |
|
| 136 | 144 | } |
|
| 137 | 145 | ||
| 138 | - | /// Move the buffer and index of `out` back to their owners. |
|
| 139 | - | fn release(out: &mut writer::Writer, bytes: &mut *mut [u8], index: &mut dict::Dict) { |
|
| 140 | - | set *bytes = out.bytes.take(); |
|
| 141 | - | set *index = dict::take(&mut out.index); |
|
| 142 | - | } |
|
| 143 | - | ||
| 144 | - | /// Write a package into `bytes`. Return the number of encoded bytes. The |
|
| 145 | - | /// buffer is lent to the writer for the call and is back in `bytes` after it, |
|
| 146 | - | /// also on failure. |
|
| 146 | + | /// Write a package into `bytes`, returning the buffer on success or failure. |
|
| 147 | 147 | export fn encode(bytes: &mut *mut [u8], package: &binary::Package) -> u32 throws (binary::Error) { |
|
| 148 | - | let mut out = writer::new(bytes.take(), package.symbols); |
|
| 149 | - | let length = try write(&mut out, package) catch err { |
|
| 148 | + | let mut out = writer::new(bytes.take()); |
|
| 149 | + | let length = try write(&mut out, package) catch error { |
|
| 150 | 150 | set *bytes = out.bytes.take(); |
|
| 151 | - | throw err; |
|
| 151 | + | throw error; |
|
| 152 | 152 | }; |
|
| 153 | 153 | set *bytes = out.bytes.take(); |
|
| 154 | 154 | return length; |
|
| 155 | 155 | } |
|
| 156 | 156 | ||
| 157 | - | /// Write the package tables and the function count into `bytes`. The functions |
|
| 158 | - | /// follow in the file, encoded with [`appendFunction`]. `index` maps each name |
|
| 159 | - | /// of the package symbol table to its wire index. Return the number of bytes. |
|
| 160 | - | /// The buffer and the index are lent to the writer for the call and are back |
|
| 161 | - | /// after it, also on failure. |
|
| 157 | + | /// Write package tables through the function count using a complete name index. |
|
| 158 | + | /// The buffer and index return to the caller on success or failure. |
|
| 162 | 159 | export fn encodeHead( |
|
| 163 | 160 | bytes: &mut *mut [u8], package: &binary::Package, index: &mut dict::Dict, fnCount: u32 |
|
| 164 | 161 | ) -> u32 throws (binary::Error) { |
|
| 165 | - | let mut out = writer::withIndex(bytes.take(), 0, dict::take(index)); |
|
| 166 | - | try writeHead(&mut out, package, fnCount) catch err { |
|
| 167 | - | release(&mut out, bytes, index); |
|
| 168 | - | throw err; |
|
| 162 | + | let mut out = writer::new(bytes.take()); |
|
| 163 | + | let mut table = writer::Indexed { table: dict::take(index) }; |
|
| 164 | + | try writeHead(&mut out, package, fnCount, &mut table) catch error { |
|
| 165 | + | set *bytes = out.bytes.take(); |
|
| 166 | + | set *index = dict::take(&mut table.table); |
|
| 167 | + | throw error; |
|
| 169 | 168 | }; |
|
| 170 | - | let length = out.offset; |
|
| 171 | - | release(&mut out, bytes, index); |
|
| 172 | - | return length; |
|
| 169 | + | let end = out.offset; |
|
| 170 | + | set *bytes = out.bytes.take(); |
|
| 171 | + | set *index = dict::take(&mut table.table); |
|
| 172 | + | return end; |
|
| 173 | 173 | } |
|
| 174 | 174 | ||
| 175 | - | /// Encode `func` into `bytes` at `used`. Return the new used length. `index` |
|
| 176 | - | /// must map every name that `func` references to its wire index. The buffer and |
|
| 177 | - | /// the index are lent to the writer for the call and are back after it, also on |
|
| 178 | - | /// failure. |
|
| 179 | - | export fn appendFunction( |
|
| 180 | - | bytes: &mut *mut [u8], used: u32, index: &mut dict::Dict, func: *il::Fn |
|
| 175 | + | /// Encode one function and intern its qualified names in first-use order. |
|
| 176 | + | /// Buffer and name storage return to their owners on success and failure. |
|
| 177 | + | export fn appendCollected( |
|
| 178 | + | bytes: &mut *mut [u8], used: u32, names: &mut collect::Names, func: *il::Fn, arena: *heap::Heap |
|
| 181 | 179 | ) -> u32 throws (binary::Error) { |
|
| 182 | - | let mut out = writer::withIndex(bytes.take(), used, dict::take(index)); |
|
| 183 | - | try writeFunction(&mut out, func) catch err { |
|
| 184 | - | release(&mut out, bytes, index); |
|
| 185 | - | throw err; |
|
| 180 | + | assert used <= bytes.len; |
|
| 181 | + | let mut out = writer::Writer { bytes: bytes.take(), offset: used }; |
|
| 182 | + | let mut table = writer::Collected { |
|
| 183 | + | names: collect::Names { |
|
| 184 | + | symbols: names.symbols.take(), index: dict::take(&mut names.index) |
|
| 185 | + | }, |
|
| 186 | + | arena, |
|
| 187 | + | }; |
|
| 188 | + | try writeFunction(&mut out, func, &mut table) catch error { |
|
| 189 | + | set *bytes = out.bytes.take(); |
|
| 190 | + | set names.symbols = table.names.symbols.take(); |
|
| 191 | + | set names.index = dict::take(&mut table.names.index); |
|
| 192 | + | throw error; |
|
| 186 | 193 | }; |
|
| 187 | 194 | let end = out.offset; |
|
| 188 | - | release(&mut out, bytes, index); |
|
| 195 | + | set *bytes = out.bytes.take(); |
|
| 196 | + | set names.symbols = table.names.symbols.take(); |
|
| 197 | + | set names.index = dict::take(&mut table.names.index); |
|
| 189 | 198 | return end; |
|
| 190 | 199 | } |
|
| 191 | 200 | ||
| 192 | 201 | /// Read typed SSA parameters with checked register indices. |
|
| 193 | 202 | fn readParams( |
lib/std/lang/il/binary/tests.rad
+92 -51
| 13 | 13 | static MEMORY: [u8; 512] = [0; 512]; |
|
| 14 | 14 | ||
| 15 | 15 | /// Check little-endian encoding for every integer width. |
|
| 16 | 16 | @test unsafe fn integers() throws (testing::TestError) { |
|
| 17 | 17 | static buffer: [u8; 15] = [0; 15]; |
|
| 18 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &[]); |
|
| 18 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 19 | 19 | try writer::integer(&mut out, 0x12, 1) catch { |
|
| 20 | 20 | throw testing::TestError::Failed; |
|
| 21 | 21 | }; |
|
| 22 | 22 | try writer::integer(&mut out, 0x3456, 2) catch { |
|
| 23 | 23 | throw testing::TestError::Failed; |
| 61 | 61 | return input; |
|
| 62 | 62 | } |
|
| 63 | 63 | ||
| 64 | 64 | /// Compare one instruction with its fixed wire representation. |
|
| 65 | 65 | unsafe fn instruction(item: il::Instr, expected: &'wire [u8]) throws (testing::TestError) { |
|
| 66 | + | let mut symbols = writer::Listed { names: &["data", "fn"] }; |
|
| 66 | 67 | let func = il::Fn { |
|
| 67 | 68 | name: "f", |
|
| 68 | 69 | params: &[], |
|
| 69 | 70 | returnType: il::ValType::Data(il::Type::W64), |
|
| 70 | 71 | isExtern: false, |
| 73 | 74 | vals: &ARGS[..], |
|
| 74 | 75 | cases: &CASES[..], |
|
| 75 | 76 | borrows: &[], |
|
| 76 | 77 | }; |
|
| 77 | 78 | static buffer: [u8; 256] = [0; 256]; |
|
| 78 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &["data", "fn"]); |
|
| 79 | - | try writer::instr(&mut out, &func, item) catch { |
|
| 79 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 80 | + | try writer::instr(&mut out, &func, item, &mut symbols) catch { |
|
| 80 | 81 | throw testing::TestError::Failed; |
|
| 81 | 82 | }; |
|
| 82 | 83 | try testing::expectBytesEq(&buffer[.. out.offset], expected); |
|
| 83 | 84 | for capacity in 0 .. expected.len { |
|
| 84 | - | let mut short = writer::new(&mut buffer[.. capacity] as *mut [u8], &["data", "fn"]); |
|
| 85 | + | let mut short = writer::new(&mut buffer[.. capacity] as *mut [u8]); |
|
| 85 | 86 | let mut failed = false; |
|
| 86 | - | try writer::instr(&mut short, &func, item) catch err { |
|
| 87 | + | try writer::instr(&mut short, &func, item, &mut symbols) catch err { |
|
| 87 | 88 | try testing::expect(err == binary::Error::Capacity); |
|
| 88 | 89 | set failed = true; |
|
| 89 | 90 | }; |
|
| 90 | 91 | try testing::expect(failed); |
|
| 91 | 92 | try testing::expect(short.offset <= capacity); |
| 108 | 109 | vals: &vals[..], |
|
| 109 | 110 | cases: &cases[..], |
|
| 110 | 111 | borrows: &[], |
|
| 111 | 112 | }; |
|
| 112 | 113 | set out.offset = 0; |
|
| 113 | - | try writer::instr(&mut out, &decodedFn, decoded) catch { |
|
| 114 | + | try writer::instr(&mut out, &decodedFn, decoded, &mut symbols) catch { |
|
| 114 | 115 | throw testing::TestError::Failed; |
|
| 115 | 116 | }; |
|
| 116 | 117 | try testing::expectBytesEq(&buffer[.. out.offset], expected); |
|
| 117 | 118 | for length in 0 .. expected.len { |
|
| 118 | 119 | heap::reset(arena); |
| 364 | 365 | } |
|
| 365 | 366 | } |
|
| 366 | 367 | ||
| 367 | 368 | /// Check every value tag and empty and nonempty sequences. |
|
| 368 | 369 | @test unsafe fn values() throws (testing::TestError) { |
|
| 370 | + | let mut symbols = writer::Listed { names: &["data", "fn"] }; |
|
| 369 | 371 | static buffer: [u8; 64] = [0; 64]; |
|
| 370 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &["data", "fn"]); |
|
| 371 | - | try writer::values(&mut out, &[]) catch { |
|
| 372 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 373 | + | try writer::values(&mut out, &[], &mut symbols) catch { |
|
| 372 | 374 | throw testing::TestError::Failed; |
|
| 373 | 375 | }; |
|
| 374 | 376 | try writer::values( |
|
| 375 | 377 | &mut out, |
|
| 376 | 378 | &[ |
|
| 377 | 379 | il::Val::Reg(il::Reg { n: 0x12345678 }), |
|
| 378 | 380 | il::Val::Imm(-2), il::Val::DataSym("data"), |
|
| 379 | 381 | il::Val::FnAddr("fn"), il::Val::Undef, |
|
| 380 | - | ] |
|
| 382 | + | ], |
|
| 383 | + | &mut symbols |
|
| 381 | 384 | ) catch { |
|
| 382 | 385 | throw testing::TestError::Failed; |
|
| 383 | 386 | }; |
|
| 384 | 387 | try testing::expectBytesEq( |
|
| 385 | 388 | &buffer[.. out.offset], |
| 403 | 406 | try testing::expect(empty.len == 0); |
|
| 404 | 407 | try testing::expect(decoded.len == 5); |
|
| 405 | 408 | try testing::expect(input.offset == out.offset); |
|
| 406 | 409 | let pool = input.vals.take(); |
|
| 407 | 410 | static repeated: [u8; 64] = [0; 64]; |
|
| 408 | - | let mut copy = writer::new(&mut repeated[..] as *mut [u8], &["data", "fn"]); |
|
| 409 | - | try writer::values(&mut copy, &pool[empty.start .. empty.start + empty.len]) catch { |
|
| 411 | + | let mut copy = writer::new(&mut repeated[..] as *mut [u8]); |
|
| 412 | + | try writer::values( |
|
| 413 | + | &mut copy, &pool[empty.start .. empty.start + empty.len], &mut symbols |
|
| 414 | + | ) catch { |
|
| 410 | 415 | throw testing::TestError::Failed; |
|
| 411 | 416 | }; |
|
| 412 | - | try writer::values(&mut copy, &pool[decoded.start .. decoded.start + decoded.len]) catch { |
|
| 417 | + | try writer::values( |
|
| 418 | + | &mut copy, &pool[decoded.start .. decoded.start + decoded.len], &mut symbols |
|
| 419 | + | ) catch { |
|
| 413 | 420 | throw testing::TestError::Failed; |
|
| 414 | 421 | }; |
|
| 415 | 422 | try testing::expectBytesEq(wire, &repeated[.. copy.offset]); |
|
| 416 | 423 | } |
|
| 417 | 424 | } |
|
| 418 | 425 | ||
| 419 | 426 | /// Check initializer bytes and repetition counts. |
|
| 420 | 427 | @test unsafe fn initializers() throws (testing::TestError) { |
|
| 428 | + | let mut symbols = writer::Listed { names: &["data", "fn"] }; |
|
| 421 | 429 | static buffer: [u8; 128] = [0; 128]; |
|
| 422 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &["data", "fn"]); |
|
| 423 | - | try writer::dataValue(&mut out, il::DataValue { |
|
| 424 | - | item: il::DataItem::Val { |
|
| 425 | - | typ: il::Type::W8, val: -1 |
|
| 430 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 431 | + | try writer::dataValue( |
|
| 432 | + | &mut out, |
|
| 433 | + | il::DataValue { |
|
| 434 | + | item: il::DataItem::Val { |
|
| 435 | + | typ: il::Type::W8, val: -1 |
|
| 436 | + | }, |
|
| 437 | + | count: 0, |
|
| 426 | 438 | }, |
|
| 427 | - | count: 0, |
|
| 428 | - | }) catch { |
|
| 439 | + | &mut symbols |
|
| 440 | + | ) catch { |
|
| 429 | 441 | throw testing::TestError::Failed; |
|
| 430 | 442 | }; |
|
| 431 | - | try writer::dataValue(&mut out, il::DataValue { |
|
| 432 | - | item: il::DataItem::Val { |
|
| 433 | - | typ: il::Type::W16, val: -2 |
|
| 443 | + | try writer::dataValue( |
|
| 444 | + | &mut out, |
|
| 445 | + | il::DataValue { |
|
| 446 | + | item: il::DataItem::Val { |
|
| 447 | + | typ: il::Type::W16, val: -2 |
|
| 448 | + | }, |
|
| 449 | + | count: 1, |
|
| 434 | 450 | }, |
|
| 435 | - | count: 1, |
|
| 436 | - | }) catch { |
|
| 451 | + | &mut symbols |
|
| 452 | + | ) catch { |
|
| 437 | 453 | throw testing::TestError::Failed; |
|
| 438 | 454 | }; |
|
| 439 | - | try writer::dataValue(&mut out, il::DataValue { |
|
| 440 | - | item: il::DataItem::Val { |
|
| 441 | - | typ: il::Type::W32, val: -3 |
|
| 455 | + | try writer::dataValue( |
|
| 456 | + | &mut out, |
|
| 457 | + | il::DataValue { |
|
| 458 | + | item: il::DataItem::Val { |
|
| 459 | + | typ: il::Type::W32, val: -3 |
|
| 460 | + | }, |
|
| 461 | + | count: 2, |
|
| 442 | 462 | }, |
|
| 443 | - | count: 2, |
|
| 444 | - | }) catch { |
|
| 463 | + | &mut symbols |
|
| 464 | + | ) catch { |
|
| 445 | 465 | throw testing::TestError::Failed; |
|
| 446 | 466 | }; |
|
| 447 | - | try writer::dataValue(&mut out, il::DataValue { |
|
| 448 | - | item: il::DataItem::Val { |
|
| 449 | - | typ: il::Type::W64, val: -4 |
|
| 467 | + | try writer::dataValue( |
|
| 468 | + | &mut out, |
|
| 469 | + | il::DataValue { |
|
| 470 | + | item: il::DataItem::Val { |
|
| 471 | + | typ: il::Type::W64, val: -4 |
|
| 472 | + | }, |
|
| 473 | + | count: 3, |
|
| 450 | 474 | }, |
|
| 451 | - | count: 3, |
|
| 452 | - | }) catch { |
|
| 475 | + | &mut symbols |
|
| 476 | + | ) catch { |
|
| 453 | 477 | throw testing::TestError::Failed; |
|
| 454 | 478 | }; |
|
| 455 | - | try writer::dataValue(&mut out, il::DataValue { |
|
| 456 | - | item: il::DataItem::Sym("data"), count: 4 |
|
| 457 | - | }) catch { |
|
| 479 | + | try writer::dataValue( |
|
| 480 | + | &mut out, |
|
| 481 | + | il::DataValue { |
|
| 482 | + | item: il::DataItem::Sym("data"), count: 4 |
|
| 483 | + | }, |
|
| 484 | + | &mut symbols |
|
| 485 | + | ) catch { |
|
| 458 | 486 | throw testing::TestError::Failed; |
|
| 459 | 487 | }; |
|
| 460 | - | try writer::dataValue(&mut out, il::DataValue { |
|
| 461 | - | item: il::DataItem::Fn("fn"), count: 5 |
|
| 462 | - | }) catch { |
|
| 488 | + | try writer::dataValue( |
|
| 489 | + | &mut out, |
|
| 490 | + | il::DataValue { |
|
| 491 | + | item: il::DataItem::Fn("fn"), count: 5 |
|
| 492 | + | }, |
|
| 493 | + | &mut symbols |
|
| 494 | + | ) catch { |
|
| 463 | 495 | throw testing::TestError::Failed; |
|
| 464 | 496 | }; |
|
| 465 | - | try writer::dataValue(&mut out, il::DataValue { |
|
| 466 | - | item: il::DataItem::Str("ab"), count: 6 |
|
| 467 | - | }) catch { |
|
| 497 | + | try writer::dataValue( |
|
| 498 | + | &mut out, |
|
| 499 | + | il::DataValue { |
|
| 500 | + | item: il::DataItem::Str("ab"), count: 6 |
|
| 501 | + | }, |
|
| 502 | + | &mut symbols |
|
| 503 | + | ) catch { |
|
| 468 | 504 | throw testing::TestError::Failed; |
|
| 469 | 505 | }; |
|
| 470 | - | try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Str(""), count: 7 }) catch { |
|
| 506 | + | try writer::dataValue( |
|
| 507 | + | &mut out, il::DataValue { item: il::DataItem::Str(""), count: 7 }, &mut symbols |
|
| 508 | + | ) catch { |
|
| 471 | 509 | throw testing::TestError::Failed; |
|
| 472 | 510 | }; |
|
| 473 | - | try writer::dataValue(&mut out, il::DataValue { item: il::DataItem::Undef, count: 8 }) catch { |
|
| 511 | + | try writer::dataValue( |
|
| 512 | + | &mut out, il::DataValue { item: il::DataItem::Undef, count: 8 }, &mut symbols |
|
| 513 | + | ) catch { |
|
| 474 | 514 | throw testing::TestError::Failed; |
|
| 475 | 515 | }; |
|
| 476 | 516 | try testing::expectBytesEq( |
|
| 477 | 517 | &buffer[.. out.offset], |
|
| 478 | 518 | &[ |
| 535 | 575 | ); |
|
| 536 | 576 | } |
|
| 537 | 577 | ||
| 538 | 578 | /// Reject invalid widths, insufficient storage, and absent symbols. |
|
| 539 | 579 | @test unsafe fn errors() throws (testing::TestError) { |
|
| 580 | + | let mut symbols = writer::Listed { names: &[] }; |
|
| 540 | 581 | static buffer: [u8; 8] = [0; 8]; |
|
| 541 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &[]); |
|
| 582 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 542 | 583 | let mut failures: u32 = 0; |
|
| 543 | 584 | try writer::integer(&mut out, 1, 3) catch err { |
|
| 544 | 585 | try testing::expect(err == binary::Error::Invalid); |
|
| 545 | 586 | set failures += 1; |
|
| 546 | 587 | }; |
|
| 547 | - | try writer::symbol(&mut out, "absent") catch err { |
|
| 588 | + | try writer::symbol(&mut out, "absent", &mut symbols) catch err { |
|
| 548 | 589 | try testing::expect(err == binary::Error::Symbol); |
|
| 549 | 590 | set failures += 1; |
|
| 550 | 591 | }; |
|
| 551 | 592 | try testing::expect(out.offset == 0); |
|
| 552 | 593 | try writer::integer(&mut out, 0, 8) catch { |
| 601 | 642 | ||
| 602 | 643 | /// Check byte-sequence bounds at every output size. |
|
| 603 | 644 | @test unsafe fn byteCapacity() throws (testing::TestError) { |
|
| 604 | 645 | static buffer: [u8; 7] = [0; 7]; |
|
| 605 | 646 | for capacity in 0 .. 7 { |
|
| 606 | - | let mut out = writer::new(&mut buffer[.. capacity] as *mut [u8], &[]); |
|
| 647 | + | let mut out = writer::new(&mut buffer[.. capacity] as *mut [u8]); |
|
| 607 | 648 | let mut failed = false; |
|
| 608 | 649 | try writer::bytes(&mut out, "abc") catch err { |
|
| 609 | 650 | try testing::expect(err == binary::Error::Capacity); |
|
| 610 | 651 | set failed = true; |
|
| 611 | 652 | }; |
|
| 612 | 653 | try testing::expect(failed); |
|
| 613 | 654 | try testing::expect(out.offset <= capacity); |
|
| 614 | 655 | } |
|
| 615 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &[]); |
|
| 656 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 616 | 657 | try writer::bytes(&mut out, "abc") catch { |
|
| 617 | 658 | throw testing::TestError::Failed; |
|
| 618 | 659 | }; |
|
| 619 | 660 | try testing::expectBytesEq(&buffer[..], &[3, 0, 0, 0, 97, 98, 99]); |
|
| 620 | 661 | } |
| 634 | 675 | &[0], &[1, 2], &[2, 3, 0, 0, 0, 5], &[2, 0, 0, 0, 0, 2], &[3, 1, 0, 0, 0], &[3, 0, 0, 0, 0], |
|
| 635 | 676 | &[4, 0], &[4, 1], &[4, 2], |
|
| 636 | 677 | ]; |
|
| 637 | 678 | for item, i in &fixtures[..] { |
|
| 638 | 679 | static buffer: [u8; 8] = [0; 8]; |
|
| 639 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &[]); |
|
| 680 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 640 | 681 | try writer::valType(&mut out, item) catch { |
|
| 641 | 682 | throw testing::TestError::Failed; |
|
| 642 | 683 | }; |
|
| 643 | 684 | try testing::expectBytesEq(&buffer[.. out.offset], expected[i]); |
|
| 644 | 685 |
| 671 | 712 | } |
|
| 672 | 713 | ||
| 673 | 714 | /// Check the wire form of a layout with every kind of slot, and of a signature. |
|
| 674 | 715 | @test unsafe fn layoutsAndSignatures() throws (testing::TestError) { |
|
| 675 | 716 | static buffer: [u8; 160] = [0; 160]; |
|
| 676 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &[]); |
|
| 717 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 677 | 718 | let layout = il::Layout { |
|
| 678 | 719 | size: 64, |
|
| 679 | 720 | alignment: 8, |
|
| 680 | 721 | slots: &[ |
|
| 681 | 722 | il::Slot { |
| 764 | 805 | } |
|
| 765 | 806 | ||
| 766 | 807 | /// Check the wire form of a layout with a union slot. |
|
| 767 | 808 | @test unsafe fn unionSlotWire() throws (testing::TestError) { |
|
| 768 | 809 | static buffer: [u8; 64] = [0; 64]; |
|
| 769 | - | let mut out = writer::new(&mut buffer[..] as *mut [u8], &[]); |
|
| 810 | + | let mut out = writer::new(&mut buffer[..] as *mut [u8]); |
|
| 770 | 811 | let layout = il::Layout { |
|
| 771 | 812 | size: 16, |
|
| 772 | 813 | alignment: 8, |
|
| 773 | 814 | slots: &[ |
|
| 774 | 815 | il::Slot { |
lib/std/lang/il/binary/tests/decode.rad
+61 -33
| 517 | 517 | }, |
|
| 518 | 518 | LIMITS |
|
| 519 | 519 | ); |
|
| 520 | 520 | } |
|
| 521 | 521 | ||
| 522 | - | /// Check that the indexed writer yields the bytes of a whole-package encoding, |
|
| 523 | - | /// and that the buffer and the index return to their owners after each call. |
|
| 524 | - | @test unsafe fn indexedEncoding() throws (testing::TestError) { |
|
| 522 | + | /// Indexed headers and streaming functions match a complete package encoding. |
|
| 523 | + | /// Encoding errors return buffer and symbol storage to their owners. |
|
| 524 | + | @test unsafe fn streamingEncoding() throws (testing::TestError) { |
|
| 525 | 525 | static whole: [u8; 128] = [0; 128]; |
|
| 526 | 526 | static split: [u8; 128] = [0; 128]; |
|
| 527 | 527 | unsafe static slots: [dict::Entry; 8] = [dict::Entry { key: "", value: 0 }; 8]; |
|
| 528 | - | static fixture: [u8; 512] = [0; 512]; |
|
| 528 | + | static fixture: [u8; 2048] = [0; 2048]; |
|
| 529 | 529 | let arena = heap::over(&mut fixture[..]); |
|
| 530 | 530 | let func = retainFn( |
|
| 531 | 531 | il::Fn { |
|
| 532 | 532 | name: "p::f", |
|
| 533 | 533 | params: &[], |
| 561 | 561 | program: il::Program { |
|
| 562 | 562 | data: &[], fns: &list[..], layouts: &[], signatures: &[], traits: &[] |
|
| 563 | 563 | }, |
|
| 564 | 564 | links: binary::EMPTY_LINKS, |
|
| 565 | 565 | }; |
|
| 566 | - | let length = try encodeInto(&mut whole[..] as *mut [u8], &package) catch { |
|
| 567 | - | throw testing::TestError::Failed; |
|
| 568 | - | }; |
|
| 566 | + | let length = try! encodeInto(&mut whole[..] as *mut [u8], &package); |
|
| 569 | 567 | let mut index = dict::init(&mut slots[..] as *mut [dict::Entry]); |
|
| 570 | - | try dict::insert(&mut index, "p", 0) catch { |
|
| 571 | - | throw testing::TestError::Failed; |
|
| 572 | - | }; |
|
| 573 | - | try dict::insert(&mut index, "p::f", 1) catch { |
|
| 574 | - | throw testing::TestError::Failed; |
|
| 575 | - | }; |
|
| 568 | + | try! dict::insert(&mut index, "p", 0); |
|
| 569 | + | try! dict::insert(&mut index, "p::f", 1); |
|
| 576 | 570 | let mut bytes = &mut split[..] as *mut [u8]; |
|
| 577 | - | let head = try program::encodeHead(&mut bytes, &package, &mut index, 1) catch { |
|
| 578 | - | throw testing::TestError::Failed; |
|
| 579 | - | }; |
|
| 580 | - | try testing::expect(bytes.len == 128 and index.count == 2 and dict::get(&index, "p::f") == 1); |
|
| 581 | - | let end = try program::appendFunction(&mut bytes, head, &mut index, func) catch { |
|
| 582 | - | throw testing::TestError::Failed; |
|
| 583 | - | }; |
|
| 584 | - | try testing::expect(bytes.len == 128 and index.count == 2 and dict::get(&index, "p") == 0); |
|
| 571 | + | let head = try! program::encodeHead(&mut bytes, &package, &mut index, 1); |
|
| 572 | + | assert bytes.len == 128 and index.count == 2 and dict::get(&index, "p::f") == 1; |
|
| 573 | + | ||
| 574 | + | // Streaming collection assigns first-use indices while encoding the same bytes. |
|
| 575 | + | let mut names = try! collect::new(8, arena); |
|
| 576 | + | try! collect::start(&mut names, "p", arena); |
|
| 577 | + | let end = try! program::appendCollected(&mut bytes, head, &mut names, func, arena); |
|
| 578 | + | assert names.symbols.len == 2 and mem::eq(names.symbols[1], "p::f"); |
|
| 579 | + | assert names.index.count == 2 and bytes.len == 128; |
|
| 585 | 580 | try testing::expectBytesEq(&whole[.. length], &bytes[.. end]); |
|
| 581 | + | let mut limited = &mut split[.. head + 8] as *mut [u8]; |
|
| 582 | + | let mut failed = false; |
|
| 583 | + | try program::appendCollected(&mut limited, head, &mut names, func, arena) catch error { |
|
| 584 | + | assert error == binary::Error::Capacity; |
|
| 585 | + | set failed = true; |
|
| 586 | + | }; |
|
| 587 | + | assert failed and limited.len == head + 8 and names.index.count == 2; |
|
| 586 | 588 | ||
| 587 | 589 | // A short buffer and an unknown name fail, and both owners get their storage back. |
|
| 588 | - | let mut short = &mut split[.. head] as *mut [u8]; |
|
| 589 | - | let mut failed = false; |
|
| 590 | - | try program::appendFunction(&mut short, head - 1, &mut index, func) catch err { |
|
| 591 | - | try testing::expect(err == binary::Error::Capacity); |
|
| 590 | + | let mut short = &mut split[.. head - 1] as *mut [u8]; |
|
| 591 | + | set failed = false; |
|
| 592 | + | try program::encodeHead(&mut short, &package, &mut index, 1) catch error { |
|
| 593 | + | assert error == binary::Error::Capacity; |
|
| 592 | 594 | set failed = true; |
|
| 593 | 595 | }; |
|
| 594 | - | try testing::expect(failed and short.len == head and dict::get(&index, "p::f") == 1); |
|
| 596 | + | assert failed and short.len == head - 1 and dict::get(&index, "p::f") == 1; |
|
| 595 | 597 | let mut missing = dict::init(&mut slots[..] as *mut [dict::Entry]); |
|
| 596 | - | try dict::insert(&mut missing, "p", 0) catch { |
|
| 597 | - | throw testing::TestError::Failed; |
|
| 598 | - | }; |
|
| 599 | 598 | set failed = false; |
|
| 600 | - | try program::appendFunction(&mut bytes, head, &mut missing, func) catch err { |
|
| 601 | - | try testing::expect(err == binary::Error::Symbol); |
|
| 599 | + | try program::encodeHead(&mut bytes, &package, &mut missing, 1) catch error { |
|
| 600 | + | assert error == binary::Error::Symbol; |
|
| 602 | 601 | set failed = true; |
|
| 603 | 602 | }; |
|
| 604 | - | try testing::expect(failed and bytes.len == 128 and dict::get(&missing, "p") == 0); |
|
| 603 | + | assert failed and bytes.len == 128 and missing.count == 0; |
|
| 605 | 604 | } |
|
| 606 | 605 | ||
| 607 | 606 | /// Reject unknown initializer tags and widths before reading their payloads. |
|
| 608 | 607 | @test unsafe fn malformedInitializers() throws (testing::TestError) { |
|
| 609 | 608 | let arena = heap::withCapacity(&mut MEMORY[..], 8); |
| 626 | 625 | owner: *[u8], dependencies: *[*[u8]], local: il::Program, arena: &heap::Heap |
|
| 627 | 626 | ) -> binary::Package |
|
| 628 | 627 | throws (binary::Error) |
|
| 629 | 628 | { |
|
| 630 | 629 | let mut names = try collect::new(64, arena); |
|
| 631 | - | return try collect::package(&mut names, owner, dependencies, local, &[], nil, arena); |
|
| 630 | + | try collect::start(&mut names, owner, arena); |
|
| 631 | + | return try collect::finish(&mut names, owner, dependencies, local, &[], nil, arena); |
|
| 632 | 632 | } |
|
| 633 | 633 | ||
| 634 | 634 | /// Check explicit dependencies, collection storage and package ownership. |
|
| 635 | 635 | @test unsafe fn collectionBounds() throws (testing::TestError) { |
|
| 636 | 636 | let local = il::Program { |
| 1560 | 1560 | for split in 0 .. payload.len + 1 { |
|
| 1561 | 1561 | assert linkage::imageParts(&payload[.. split], &payload[split ..]) == image; |
|
| 1562 | 1562 | } |
|
| 1563 | 1563 | } |
|
| 1564 | 1564 | ||
| 1565 | + | /// Name allocation failures keep the index and first-use table in agreement. |
|
| 1566 | + | @test unsafe fn collectionRollback() throws (testing::TestError) { |
|
| 1567 | + | static storage: [u8; 512] = [0; 512]; |
|
| 1568 | + | let mut failures: u32 = 0; |
|
| 1569 | + | for capacity in 192 as u32 .. 384 { |
|
| 1570 | + | let arena = heap::withCapacity(&mut storage[..], capacity); |
|
| 1571 | + | let mut names = try collect::new(8, arena) catch { |
|
| 1572 | + | continue; |
|
| 1573 | + | }; |
|
| 1574 | + | try collect::start(&mut names, "p", arena) catch error { |
|
| 1575 | + | assert error == binary::Error::Storage; |
|
| 1576 | + | assert names.index.count == names.symbols.len; |
|
| 1577 | + | set failures += 1; |
|
| 1578 | + | }; |
|
| 1579 | + | } |
|
| 1580 | + | assert failures > 0; |
|
| 1581 | + | let arena = heap::over(&mut storage[..]); |
|
| 1582 | + | let mut names = try! collect::new(2, arena); |
|
| 1583 | + | try! collect::start(&mut names, "p", arena); |
|
| 1584 | + | let mut full = false; |
|
| 1585 | + | try collect::reference(&mut names, "p::f", arena) catch error { |
|
| 1586 | + | assert error == binary::Error::Storage; |
|
| 1587 | + | set full = true; |
|
| 1588 | + | }; |
|
| 1589 | + | assert full and names.symbols.len == 1 and names.index.count == 1; |
|
| 1590 | + | assert dict::get(&names.index, "p") == 0; |
|
| 1591 | + | assert dict::get(&names.index, "p::f") == nil; |
|
| 1592 | + | } |
lib/std/lang/il/binary/writer.rad
+128 -91
| 2 | 2 | //! After an error, discard bytes written by the failed operation. |
|
| 3 | 3 | ||
| 4 | 4 | use std::collections::dict; |
|
| 5 | 5 | use std::lang::il; |
|
| 6 | 6 | use std::lang::il::binary; |
|
| 7 | + | use std::lang::il::binary::collect; |
|
| 7 | 8 | use std::mem; |
|
| 9 | + | use std::mem::heap; |
|
| 8 | 10 | ||
| 9 | - | /// Output buffer, cursor and the symbol table used by this package. |
|
| 10 | - | /// The writer owns the buffer and the index while it is in use. The caller moves |
|
| 11 | - | /// them out with `take` before a write and back after it. |
|
| 11 | + | /// Names used by a binary encoder. |
|
| 12 | + | export trait SymbolTable { |
|
| 13 | + | /// Return the stable wire index of a name, adding it when collection is enabled. |
|
| 14 | + | fn (&mut SymbolTable) index(name: *[u8]) -> u32 throws (binary::Error); |
|
| 15 | + | } |
|
| 16 | + | ||
| 17 | + | /// Complete wire-order symbol table resolved by direct comparison. |
|
| 18 | + | export record Listed { |
|
| 19 | + | /// Names in wire-index order. |
|
| 20 | + | names: *[*[u8]], |
|
| 21 | + | } |
|
| 22 | + | ||
| 23 | + | /// Complete indexed symbol table owned during an encoding call. |
|
| 24 | + | export record Indexed { |
|
| 25 | + | /// Name-to-index table returned to the caller after encoding. |
|
| 26 | + | table: dict::Dict, |
|
| 27 | + | } |
|
| 28 | + | ||
| 29 | + | /// Growing symbol table owned during a streaming encoding call. |
|
| 30 | + | export record Collected { |
|
| 31 | + | /// Names in first-use order with their stable index. |
|
| 32 | + | names: collect::Names, |
|
| 33 | + | /// Storage of copied names and their growing table. |
|
| 34 | + | arena: *heap::Heap, |
|
| 35 | + | } |
|
| 36 | + | ||
| 37 | + | instance SymbolTable for Listed { |
|
| 38 | + | /// Resolve a name in the supplied table. |
|
| 39 | + | fn (symbols: &mut Listed) index(name: *[u8]) -> u32 throws (binary::Error) { |
|
| 40 | + | for candidate, i in symbols.names { |
|
| 41 | + | if mem::eq(candidate, name) { |
|
| 42 | + | return i; |
|
| 43 | + | } |
|
| 44 | + | } |
|
| 45 | + | throw binary::Error::Symbol; |
|
| 46 | + | } |
|
| 47 | + | } |
|
| 48 | + | ||
| 49 | + | instance SymbolTable for Indexed { |
|
| 50 | + | /// Resolve a name through the index. |
|
| 51 | + | fn (symbols: &mut Indexed) index(name: *[u8]) -> u32 throws (binary::Error) { |
|
| 52 | + | let found = dict::get(&symbols.table, name) else throw binary::Error::Symbol; |
|
| 53 | + | return found as u32; |
|
| 54 | + | } |
|
| 55 | + | } |
|
| 56 | + | ||
| 57 | + | instance SymbolTable for Collected { |
|
| 58 | + | /// Intern a qualified name and return its first-use index. |
|
| 59 | + | fn (symbols: &mut Collected) index(name: *[u8]) -> u32 throws (binary::Error) { |
|
| 60 | + | return try collect::reference(&mut symbols.names, name, symbols.arena); |
|
| 61 | + | } |
|
| 62 | + | } |
|
| 63 | + | ||
| 64 | + | /// Output buffer and cursor. The caller moves the buffer back after encoding. |
|
| 12 | 65 | export record Writer { |
|
| 13 | 66 | /// Destination bytes. |
|
| 14 | 67 | bytes: *mut [u8], |
|
| 15 | 68 | /// Number of bytes written. |
|
| 16 | 69 | offset: u32, |
|
| 17 | - | /// Names in wire-index order. The caller supplies unique names. |
|
| 18 | - | symbols: *[*[u8]], |
|
| 19 | - | /// Optional map from name to wire index. It replaces the scan of `symbols` |
|
| 20 | - | /// and is in use when it has slots. |
|
| 21 | - | index: dict::Dict, |
|
| 22 | - | } |
|
| 23 | - | ||
| 24 | - | /// Create an output cursor over `bytes` that scans `symbols` for names. |
|
| 25 | - | export fn new(bytes: *mut [u8], symbols: *[*[u8]]) -> Writer { |
|
| 26 | - | return Writer { bytes, offset: 0, symbols, index: dict::Dict { entries: &mut [], count: 0 } }; |
|
| 27 | 70 | } |
|
| 28 | 71 | ||
| 29 | - | /// Create an output cursor at `offset` that maps names to wire indices with `index`. |
|
| 30 | - | /// The index must have slots and must remain unchanged while the cursor is in use. |
|
| 31 | - | export fn withIndex(bytes: *mut [u8], offset: u32, index: dict::Dict) -> Writer { |
|
| 32 | - | assert offset <= bytes.len; |
|
| 33 | - | assert index.entries.len > 0; |
|
| 34 | - | return Writer { bytes, offset, symbols: &[], index }; |
|
| 72 | + | /// Create an output cursor over `bytes`. |
|
| 73 | + | export fn new(bytes: *mut [u8]) -> Writer { |
|
| 74 | + | return Writer { bytes, offset: 0 }; |
|
| 35 | 75 | } |
|
| 36 | 76 | ||
| 37 | 77 | /// Write the low byte of an integer. |
|
| 38 | 78 | export fn byte(out: &mut Writer, value: u64) throws (binary::Error) { |
|
| 39 | 79 | if out.offset >= out.bytes.len { |
| 82 | 122 | }; |
|
| 83 | 123 | set out.offset += value.len; |
|
| 84 | 124 | } |
|
| 85 | 125 | ||
| 86 | 126 | /// Write the index of a name in the package symbol table. |
|
| 87 | - | export fn symbol(out: &mut Writer, name: *[u8]) throws (binary::Error) { |
|
| 88 | - | if out.index.entries.len > 0 { |
|
| 89 | - | let i = dict::get(&out.index, name) else { |
|
| 90 | - | throw binary::Error::Symbol; |
|
| 91 | - | }; |
|
| 92 | - | try word(out, i as u32 as u64); |
|
| 93 | - | return; |
|
| 94 | - | } |
|
| 95 | - | for candidate, i in out.symbols { |
|
| 96 | - | if mem::eq(candidate, name) { |
|
| 97 | - | try word(out, i as u64); |
|
| 98 | - | return; |
|
| 99 | - | } |
|
| 100 | - | } |
|
| 101 | - | throw binary::Error::Symbol; |
|
| 127 | + | export fn symbol( |
|
| 128 | + | out: &mut Writer, name: *[u8], symbols: &mut opaque SymbolTable |
|
| 129 | + | ) throws (binary::Error) { |
|
| 130 | + | try word(out, try symbols.index(name) as u64); |
|
| 102 | 131 | } |
|
| 103 | 132 | ||
| 104 | 133 | /// Write an IL type as its byte width. |
|
| 105 | 134 | export fn typ(out: &mut Writer, value: il::Type) throws (binary::Error) { |
|
| 106 | 135 | try byte(out, il::typeSize(value) as u64); |
| 276 | 305 | try optionalIndex(out, item.source); |
|
| 277 | 306 | } |
|
| 278 | 307 | } |
|
| 279 | 308 | ||
| 280 | 309 | /// Write a tagged value. Symbol addresses use table indices. |
|
| 281 | - | export fn val(out: &mut Writer, value: il::Val) throws (binary::Error) { |
|
| 310 | + | export fn val(out: &mut Writer, value: il::Val, symbols: &mut opaque SymbolTable) |
|
| 311 | + | throws (binary::Error) |
|
| 312 | + | { |
|
| 282 | 313 | match value { |
|
| 283 | 314 | case il::Val::Reg(reg) => { |
|
| 284 | 315 | try byte(out, super::VALUE_REG as u64); |
|
| 285 | 316 | try word(out, reg.n as u64); |
|
| 286 | 317 | } |
| 288 | 319 | try byte(out, super::VALUE_IMM as u64); |
|
| 289 | 320 | try integer(out, n as u64, 8); |
|
| 290 | 321 | } |
|
| 291 | 322 | case il::Val::DataSym(name) => { |
|
| 292 | 323 | try byte(out, super::VALUE_DATASYM as u64); |
|
| 293 | - | try symbol(out, name); |
|
| 324 | + | try symbol(out, name, symbols); |
|
| 294 | 325 | } |
|
| 295 | 326 | case il::Val::FnAddr(name) => { |
|
| 296 | 327 | try byte(out, super::VALUE_FNADDR as u64); |
|
| 297 | - | try symbol(out, name); |
|
| 328 | + | try symbol(out, name, symbols); |
|
| 298 | 329 | } |
|
| 299 | 330 | case il::Val::Undef => try byte(out, super::VALUE_UNDEF as u64), |
|
| 300 | 331 | } |
|
| 301 | 332 | } |
|
| 302 | 333 | ||
| 303 | 334 | /// Write a sequence of values. |
|
| 304 | - | export fn values(out: &mut Writer, items: &[il::Val]) throws (binary::Error) { |
|
| 335 | + | export fn values(out: &mut Writer, items: &[il::Val], symbols: &mut opaque SymbolTable) |
|
| 336 | + | throws (binary::Error) |
|
| 337 | + | { |
|
| 305 | 338 | try word(out, items.len as u64); |
|
| 306 | 339 | for item in items { |
|
| 307 | - | try val(out, item); |
|
| 340 | + | try val(out, item, symbols); |
|
| 308 | 341 | } |
|
| 309 | 342 | } |
|
| 310 | 343 | ||
| 311 | 344 | /// Write an explicit bin operation tag. |
|
| 312 | 345 | fn binOp(out: &mut Writer, value: il::BinOp) throws (binary::Error) { |
| 357 | 390 | } |
|
| 358 | 391 | } |
|
| 359 | 392 | ||
| 360 | 393 | /// Write one instruction of `func`. Fields follow the IL record declaration order. |
|
| 361 | 394 | /// Argument and case ranges are read from the pools of `func`. |
|
| 362 | - | export fn instr(out: &mut Writer, func: &il::Fn, item: il::Instr) throws (binary::Error) { |
|
| 395 | + | export fn instr(out: &mut Writer, func: &il::Fn, item: il::Instr, symbols: &mut opaque SymbolTable) |
|
| 396 | + | throws (binary::Error) |
|
| 397 | + | { |
|
| 363 | 398 | match item { |
|
| 364 | 399 | case il::Instr::Reserve { dst: vdst, layout: vlayout } => { |
|
| 365 | 400 | try byte(out, super::INSTR_RESERVE as u64); |
|
| 366 | 401 | try word(out, vdst.n as u64); |
|
| 367 | 402 | try word(out, vlayout as u64); |
| 381 | 416 | try word(out, voffset as u64); |
|
| 382 | 417 | } |
|
| 383 | 418 | case il::Instr::Store { typ: vtyp, src: vsrc, dst: vdst, offset: voffset } => { |
|
| 384 | 419 | try byte(out, super::INSTR_STORE as u64); |
|
| 385 | 420 | try typ(out, vtyp); |
|
| 386 | - | try val(out, vsrc); |
|
| 421 | + | try val(out, vsrc, symbols); |
|
| 387 | 422 | try word(out, vdst.n as u64); |
|
| 388 | 423 | try word(out, voffset as u64); |
|
| 389 | 424 | } |
|
| 390 | 425 | case il::Instr::Blit { dst: vdst, src: vsrc, layout: vlayout } => { |
|
| 391 | 426 | try byte(out, super::INSTR_BLIT as u64); |
| 394 | 429 | try word(out, vlayout as u64); |
|
| 395 | 430 | } |
|
| 396 | 431 | case il::Instr::Copy { dst: vdst, val: vval } => { |
|
| 397 | 432 | try byte(out, super::INSTR_COPY as u64); |
|
| 398 | 433 | try word(out, vdst.n as u64); |
|
| 399 | - | try val(out, vval); |
|
| 434 | + | try val(out, vval, symbols); |
|
| 400 | 435 | } |
|
| 401 | 436 | case il::Instr::BinOp { op: vop, typ: vtyp, dst: vdst, a: va, b: vb } => { |
|
| 402 | 437 | try byte(out, super::INSTR_BINOP as u64); |
|
| 403 | 438 | try binOp(out, vop); |
|
| 404 | 439 | try typ(out, vtyp); |
|
| 405 | 440 | try word(out, vdst.n as u64); |
|
| 406 | - | try val(out, va); |
|
| 407 | - | try val(out, vb); |
|
| 441 | + | try val(out, va, symbols); |
|
| 442 | + | try val(out, vb, symbols); |
|
| 408 | 443 | } |
|
| 409 | 444 | case il::Instr::UnOp { op: vop, typ: vtyp, dst: vdst, a: va } => { |
|
| 410 | 445 | try byte(out, super::INSTR_UNOP as u64); |
|
| 411 | 446 | try unOp(out, vop); |
|
| 412 | 447 | try typ(out, vtyp); |
|
| 413 | 448 | try word(out, vdst.n as u64); |
|
| 414 | - | try val(out, va); |
|
| 449 | + | try val(out, va, symbols); |
|
| 415 | 450 | } |
|
| 416 | 451 | case il::Instr::Zext { typ: vtyp, dst: vdst, val: vval } => { |
|
| 417 | 452 | try byte(out, super::INSTR_ZEXT as u64); |
|
| 418 | 453 | try typ(out, vtyp); |
|
| 419 | 454 | try word(out, vdst.n as u64); |
|
| 420 | - | try val(out, vval); |
|
| 455 | + | try val(out, vval, symbols); |
|
| 421 | 456 | } |
|
| 422 | 457 | case il::Instr::Sext { typ: vtyp, dst: vdst, val: vval } => { |
|
| 423 | 458 | try byte(out, super::INSTR_SEXT as u64); |
|
| 424 | 459 | try typ(out, vtyp); |
|
| 425 | 460 | try word(out, vdst.n as u64); |
|
| 426 | - | try val(out, vval); |
|
| 461 | + | try val(out, vval, symbols); |
|
| 427 | 462 | } |
|
| 428 | 463 | case il::Instr::Call { retTy: vretTy, dst: vdst, func: vfunc, args: vargs } => { |
|
| 429 | 464 | try byte(out, super::INSTR_CALL as u64); |
|
| 430 | 465 | try valType(out, vretTy); |
|
| 431 | 466 | if let present = vdst { |
|
| 432 | 467 | try byte(out, 1); |
|
| 433 | 468 | try word(out, present.n as u64); |
|
| 434 | 469 | } else { |
|
| 435 | 470 | try byte(out, 0); |
|
| 436 | 471 | } |
|
| 437 | - | try val(out, vfunc); |
|
| 438 | - | try values(out, il::argVals(func, vargs)); |
|
| 472 | + | try val(out, vfunc, symbols); |
|
| 473 | + | try values(out, il::argVals(func, vargs), symbols); |
|
| 439 | 474 | } |
|
| 440 | 475 | case il::Instr::Ret { val: vval } => { |
|
| 441 | 476 | try byte(out, super::INSTR_RET as u64); |
|
| 442 | 477 | if let present = vval { |
|
| 443 | 478 | try byte(out, 1); |
|
| 444 | - | try val(out, present); |
|
| 479 | + | try val(out, present, symbols); |
|
| 445 | 480 | } else { |
|
| 446 | 481 | try byte(out, 0); |
|
| 447 | 482 | } |
|
| 448 | 483 | } |
|
| 449 | 484 | case il::Instr::Jmp { target: vtarget, args: vargs } => { |
|
| 450 | 485 | try byte(out, super::INSTR_JMP as u64); |
|
| 451 | 486 | try word(out, vtarget as u64); |
|
| 452 | - | try values(out, il::argVals(func, vargs)); |
|
| 487 | + | try values(out, il::argVals(func, vargs), symbols); |
|
| 453 | 488 | } |
|
| 454 | 489 | case il::Instr::Br { |
|
| 455 | 490 | op: vop, |
|
| 456 | 491 | typ: vtyp, |
|
| 457 | 492 | a: va, |
| 462 | 497 | elseArgs: velseArgs, |
|
| 463 | 498 | } => { |
|
| 464 | 499 | try byte(out, super::INSTR_BR as u64); |
|
| 465 | 500 | try cmpOp(out, vop); |
|
| 466 | 501 | try typ(out, vtyp); |
|
| 467 | - | try val(out, va); |
|
| 468 | - | try val(out, vb); |
|
| 502 | + | try val(out, va, symbols); |
|
| 503 | + | try val(out, vb, symbols); |
|
| 469 | 504 | try word(out, vthenTarget as u64); |
|
| 470 | - | try values(out, il::argVals(func, vthenArgs)); |
|
| 505 | + | try values(out, il::argVals(func, vthenArgs), symbols); |
|
| 471 | 506 | try word(out, velseTarget as u64); |
|
| 472 | - | try values(out, il::argVals(func, velseArgs)); |
|
| 507 | + | try values(out, il::argVals(func, velseArgs), symbols); |
|
| 473 | 508 | } |
|
| 474 | 509 | case il::Instr::Switch { |
|
| 475 | 510 | val: vval, defaultTarget: vdefaultTarget, defaultArgs: vdefaultArgs, cases: vcases |
|
| 476 | 511 | } => { |
|
| 477 | 512 | try byte(out, super::INSTR_SWITCH as u64); |
|
| 478 | - | try val(out, vval); |
|
| 513 | + | try val(out, vval, symbols); |
|
| 479 | 514 | try word(out, vdefaultTarget as u64); |
|
| 480 | - | try values(out, il::argVals(func, vdefaultArgs)); |
|
| 515 | + | try values(out, il::argVals(func, vdefaultArgs), symbols); |
|
| 481 | 516 | let branches = il::switchCases(func, vcases); |
|
| 482 | 517 | try word(out, branches.len as u64); |
|
| 483 | 518 | for branch in branches { |
|
| 484 | 519 | try integer(out, branch.value as u64, 8); |
|
| 485 | 520 | try word(out, branch.target as u64); |
|
| 486 | - | try values(out, il::argVals(func, branch.args)); |
|
| 521 | + | try values(out, il::argVals(func, branch.args), symbols); |
|
| 487 | 522 | } |
|
| 488 | 523 | } |
|
| 489 | 524 | case il::Instr::Unreachable => { |
|
| 490 | 525 | try byte(out, super::INSTR_UNREACHABLE as u64); |
|
| 491 | 526 | } |
|
| 492 | 527 | case il::Instr::Ecall { |
|
| 493 | 528 | dst: vdst, num: vnum, a0: va0, a1: va1, a2: va2, a3: va3, buf: vbuf |
|
| 494 | 529 | } => { |
|
| 495 | 530 | try byte(out, super::INSTR_ECALL as u64); |
|
| 496 | 531 | try word(out, vdst.n as u64); |
|
| 497 | - | try val(out, vnum); |
|
| 498 | - | try val(out, va0); |
|
| 499 | - | try val(out, va1); |
|
| 500 | - | try val(out, va2); |
|
| 501 | - | try val(out, va3); |
|
| 532 | + | try val(out, vnum, symbols); |
|
| 533 | + | try val(out, va0, symbols); |
|
| 534 | + | try val(out, va1, symbols); |
|
| 535 | + | try val(out, va2, symbols); |
|
| 536 | + | try val(out, va3, symbols); |
|
| 502 | 537 | if let b = vbuf { |
|
| 503 | 538 | try byte(out, 1); |
|
| 504 | 539 | try word(out, b.ptr.n as u64); |
|
| 505 | 540 | try word(out, b.size as u64); |
|
| 506 | 541 | } else { |
| 511 | 546 | err: verr, slot: vslot, handle: vhandle, write: vwrite, layout: vlayout |
|
| 512 | 547 | } => { |
|
| 513 | 548 | try byte(out, super::INSTR_PAGE_SLICE as u64); |
|
| 514 | 549 | try word(out, verr.n as u64); |
|
| 515 | 550 | try word(out, vslot.n as u64); |
|
| 516 | - | try val(out, vhandle); |
|
| 551 | + | try val(out, vhandle, symbols); |
|
| 517 | 552 | try byte(out, 1 if vwrite else 0); |
|
| 518 | 553 | try word(out, vlayout as u64); |
|
| 519 | 554 | } |
|
| 520 | 555 | case il::Instr::PageHeap { err: verr, slot: vslot, handle: vhandle } => { |
|
| 521 | 556 | try byte(out, super::INSTR_PAGE_HEAP as u64); |
|
| 522 | 557 | try word(out, verr.n as u64); |
|
| 523 | 558 | try word(out, vslot.n as u64); |
|
| 524 | - | try val(out, vhandle); |
|
| 559 | + | try val(out, vhandle, symbols); |
|
| 525 | 560 | } |
|
| 526 | 561 | case il::Instr::HeapReset { heap } => { |
|
| 527 | 562 | try byte(out, super::INSTR_HEAP_RESET as u64); |
|
| 528 | - | try val(out, heap); |
|
| 563 | + | try val(out, heap, symbols); |
|
| 529 | 564 | } |
|
| 530 | 565 | case il::Instr::DeviceRead { typ: t, dst, handle, offset } => { |
|
| 531 | 566 | try byte(out, super::INSTR_DEVICE_READ as u64); |
|
| 532 | 567 | try typ(out, t); |
|
| 533 | 568 | try word(out, dst.n as u64); |
|
| 534 | - | try val(out, handle); |
|
| 535 | - | try val(out, offset); |
|
| 569 | + | try val(out, handle, symbols); |
|
| 570 | + | try val(out, offset, symbols); |
|
| 536 | 571 | } |
|
| 537 | 572 | case il::Instr::DeviceWrite { typ: t, handle, offset, value } => { |
|
| 538 | 573 | try byte(out, super::INSTR_DEVICE_WRITE as u64); |
|
| 539 | 574 | try typ(out, t); |
|
| 540 | - | try val(out, handle); |
|
| 541 | - | try val(out, offset); |
|
| 542 | - | try val(out, value); |
|
| 575 | + | try val(out, handle, symbols); |
|
| 576 | + | try val(out, offset, symbols); |
|
| 577 | + | try val(out, value, symbols); |
|
| 543 | 578 | } |
|
| 544 | 579 | case il::Instr::Field { dst: vdst, src: vsrc, offset: voffset } => { |
|
| 545 | 580 | try byte(out, super::INSTR_FIELD as u64); |
|
| 546 | 581 | try word(out, vdst.n as u64); |
|
| 547 | 582 | try word(out, vsrc.n as u64); |
| 551 | 586 | dst: vdst, base: vbase, index: vindex, layout: vlayout, count: vcount |
|
| 552 | 587 | } => { |
|
| 553 | 588 | try byte(out, super::INSTR_ELEM as u64); |
|
| 554 | 589 | try word(out, vdst.n as u64); |
|
| 555 | 590 | try word(out, vbase.n as u64); |
|
| 556 | - | try val(out, vindex); |
|
| 591 | + | try val(out, vindex, symbols); |
|
| 557 | 592 | try word(out, vlayout as u64); |
|
| 558 | 593 | try word(out, vcount as u64); |
|
| 559 | 594 | } |
|
| 560 | 595 | case il::Instr::BytesLoad { typ: width, dst, slice, offset } => { |
|
| 561 | 596 | try byte(out, super::INSTR_BYTES_LOAD as u64); |
|
| 562 | 597 | try typ(out, width); |
|
| 563 | 598 | try word(out, dst.n as u64); |
|
| 564 | 599 | try word(out, slice.n as u64); |
|
| 565 | - | try val(out, offset); |
|
| 600 | + | try val(out, offset, symbols); |
|
| 566 | 601 | } |
|
| 567 | 602 | case il::Instr::BytesStore { typ: width, slice, offset, value } => { |
|
| 568 | 603 | try byte(out, super::INSTR_BYTES_STORE as u64); |
|
| 569 | 604 | try typ(out, width); |
|
| 570 | 605 | try word(out, slice.n as u64); |
|
| 571 | - | try val(out, offset); |
|
| 572 | - | try val(out, value); |
|
| 606 | + | try val(out, offset, symbols); |
|
| 607 | + | try val(out, value, symbols); |
|
| 573 | 608 | } |
|
| 574 | 609 | case il::Instr::SliceElem { dst: vdst, slice: vslice, index: vindex, layout: vlayout } => { |
|
| 575 | 610 | try byte(out, super::INSTR_SLICE_ELEM as u64); |
|
| 576 | 611 | try word(out, vdst.n as u64); |
|
| 577 | 612 | try word(out, vslice.n as u64); |
|
| 578 | - | try val(out, vindex); |
|
| 613 | + | try val(out, vindex, symbols); |
|
| 579 | 614 | try word(out, vlayout as u64); |
|
| 580 | 615 | } |
|
| 581 | 616 | case il::Instr::SliceNew { |
|
| 582 | 617 | dst: vdst, base: vbase, layout: vlayout, count: vcount, start: vstart, end: vend |
|
| 583 | 618 | } => { |
|
| 584 | 619 | try byte(out, super::INSTR_SLICE_NEW as u64); |
|
| 585 | 620 | try word(out, vdst.n as u64); |
|
| 586 | - | try val(out, vbase); |
|
| 621 | + | try val(out, vbase, symbols); |
|
| 587 | 622 | try word(out, vlayout as u64); |
|
| 588 | 623 | try word(out, vcount as u64); |
|
| 589 | - | try val(out, vstart); |
|
| 590 | - | try val(out, vend); |
|
| 624 | + | try val(out, vstart, symbols); |
|
| 625 | + | try val(out, vend, symbols); |
|
| 591 | 626 | } |
|
| 592 | 627 | case il::Instr::SliceSub { |
|
| 593 | 628 | dst: vdst, src: vsrc, layout: vlayout, start: vstart, end: vend |
|
| 594 | 629 | } => { |
|
| 595 | 630 | try byte(out, super::INSTR_SLICE_SUB as u64); |
|
| 596 | 631 | try word(out, vdst.n as u64); |
|
| 597 | 632 | try word(out, vsrc.n as u64); |
|
| 598 | 633 | try word(out, vlayout as u64); |
|
| 599 | - | try val(out, vstart); |
|
| 600 | - | try val(out, vend); |
|
| 634 | + | try val(out, vstart, symbols); |
|
| 635 | + | try val(out, vend, symbols); |
|
| 601 | 636 | } |
|
| 602 | 637 | case il::Instr::SliceLen { dst: vdst, layout: vlayout, length: vlength } => { |
|
| 603 | 638 | try byte(out, super::INSTR_SLICE_LEN as u64); |
|
| 604 | 639 | try word(out, vdst.n as u64); |
|
| 605 | 640 | try word(out, vlayout as u64); |
|
| 606 | - | try val(out, vlength); |
|
| 641 | + | try val(out, vlength, symbols); |
|
| 607 | 642 | } |
|
| 608 | 643 | case il::Instr::SliceCopy { dst: vdst, src: vsrc, layout: vlayout } => { |
|
| 609 | 644 | try byte(out, super::INSTR_SLICE_COPY as u64); |
|
| 610 | 645 | try word(out, vdst.n as u64); |
|
| 611 | 646 | try word(out, vsrc.n as u64); |
| 615 | 650 | ok: vok, slice: vslice, heap: vheap, layout: vlayout, capacity: vcapacity |
|
| 616 | 651 | } => { |
|
| 617 | 652 | try byte(out, super::INSTR_SLICE_GROW as u64); |
|
| 618 | 653 | try word(out, vok.n as u64); |
|
| 619 | 654 | try word(out, vslice.n as u64); |
|
| 620 | - | try val(out, vheap); |
|
| 655 | + | try val(out, vheap, symbols); |
|
| 621 | 656 | try word(out, vlayout as u64); |
|
| 622 | - | try val(out, vcapacity); |
|
| 657 | + | try val(out, vcapacity, symbols); |
|
| 623 | 658 | } |
|
| 624 | 659 | case il::Instr::LoadPtr { dst: vdst, src: vsrc, offset: voffset, nullable } => { |
|
| 625 | 660 | try byte(out, super::INSTR_LOAD_PTR as u64); |
|
| 626 | 661 | try word(out, vdst.n as u64); |
|
| 627 | 662 | try word(out, vsrc.n as u64); |
|
| 628 | 663 | try word(out, voffset as u64); |
|
| 629 | 664 | try byte(out, 1 if nullable else 0); |
|
| 630 | 665 | } |
|
| 631 | 666 | case il::Instr::StorePtr { src: vsrc, dst: vdst, offset: voffset } => { |
|
| 632 | 667 | try byte(out, super::INSTR_STORE_PTR as u64); |
|
| 633 | - | try val(out, vsrc); |
|
| 668 | + | try val(out, vsrc, symbols); |
|
| 634 | 669 | try word(out, vdst.n as u64); |
|
| 635 | 670 | try word(out, voffset as u64); |
|
| 636 | 671 | } |
|
| 637 | 672 | case il::Instr::TraitNew { dst: vdst, recv: vrecv, table: vtable } => { |
|
| 638 | 673 | try byte(out, super::INSTR_TRAIT_NEW as u64); |
|
| 639 | 674 | try word(out, vdst.n as u64); |
|
| 640 | 675 | try word(out, vrecv.n as u64); |
|
| 641 | - | try val(out, vtable); |
|
| 676 | + | try val(out, vtable, symbols); |
|
| 642 | 677 | } |
|
| 643 | 678 | case il::Instr::TraitCopy { dst: vdst, src: vsrc } => { |
|
| 644 | 679 | try byte(out, super::INSTR_TRAIT_COPY as u64); |
|
| 645 | 680 | try word(out, vdst.n as u64); |
|
| 646 | 681 | try word(out, vsrc.n as u64); |
| 656 | 691 | case il::Instr::UnionSet { dst: vdst, tag, offset, src: vsrc, layout: vlayout } => { |
|
| 657 | 692 | try byte(out, super::INSTR_UNION_SET as u64); |
|
| 658 | 693 | try word(out, vdst.n as u64); |
|
| 659 | 694 | try word(out, tag as u64); |
|
| 660 | 695 | try word(out, offset as u64); |
|
| 661 | - | try val(out, vsrc); |
|
| 696 | + | try val(out, vsrc, symbols); |
|
| 662 | 697 | try optionalIndex(out, vlayout); |
|
| 663 | 698 | } |
|
| 664 | 699 | case il::Instr::TraitCall { |
|
| 665 | 700 | retTy: vretTy, dst: vdst, obj: vobj, method: vmethod, receiver: vreceiver, args: vargs |
|
| 666 | 701 | } => { |
| 673 | 708 | try byte(out, 0); |
|
| 674 | 709 | } |
|
| 675 | 710 | try word(out, vobj.n as u64); |
|
| 676 | 711 | try word(out, vmethod as u64); |
|
| 677 | 712 | try word(out, vreceiver as u64); |
|
| 678 | - | try values(out, il::argVals(func, vargs)); |
|
| 713 | + | try values(out, il::argVals(func, vargs), symbols); |
|
| 679 | 714 | } |
|
| 680 | 715 | case il::Instr::Ebreak => { |
|
| 681 | 716 | try byte(out, super::INSTR_EBREAK as u64); |
|
| 682 | 717 | } |
|
| 683 | 718 | case il::Instr::MemoryFence => { |
| 685 | 720 | } |
|
| 686 | 721 | } |
|
| 687 | 722 | } |
|
| 688 | 723 | ||
| 689 | 724 | /// Write one data initializer and its repetition count. |
|
| 690 | - | export fn dataValue(out: &mut Writer, value: il::DataValue) throws (binary::Error) { |
|
| 725 | + | export fn dataValue(out: &mut Writer, value: il::DataValue, symbols: &mut opaque SymbolTable) |
|
| 726 | + | throws (binary::Error) |
|
| 727 | + | { |
|
| 691 | 728 | match value.item { |
|
| 692 | 729 | case il::DataItem::Val { typ: t, val: n } => { |
|
| 693 | 730 | try byte(out, super::DATA_VAL as u64); |
|
| 694 | 731 | try typ(out, t); |
|
| 695 | 732 | try integer(out, n as u64, il::typeSize(t)); |
|
| 696 | 733 | } |
|
| 697 | 734 | case il::DataItem::Sym(name) => { |
|
| 698 | 735 | try byte(out, super::DATA_SYM as u64); |
|
| 699 | - | try symbol(out, name); |
|
| 736 | + | try symbol(out, name, symbols); |
|
| 700 | 737 | } |
|
| 701 | 738 | case il::DataItem::Fn(name) => { |
|
| 702 | 739 | try byte(out, super::DATA_FN as u64); |
|
| 703 | - | try symbol(out, name); |
|
| 740 | + | try symbol(out, name, symbols); |
|
| 704 | 741 | } |
|
| 705 | 742 | case il::DataItem::Str(text) => { |
|
| 706 | 743 | try byte(out, super::DATA_STR as u64); |
|
| 707 | 744 | try bytes(out, text); |
|
| 708 | 745 | } |
lib/std/lang/layout/tests.rad
+39 -2
| 1 | 1 | //! Tests for the text renderer. |
|
| 2 | 2 | ||
| 3 | 3 | use std::io; |
|
| 4 | + | use std::lang::sexpr; |
|
| 4 | 5 | use std::mem; |
|
| 5 | - | use std::testing; |
|
| 6 | 6 | use std::mem::heap; |
|
| 7 | - | use std::lang::sexpr; |
|
| 7 | + | use std::testing; |
|
| 8 | 8 | ||
| 9 | 9 | use std::lang::layout; |
|
| 10 | 10 | use std::lang::layout::Child; |
|
| 11 | 11 | use std::lang::layout::Gap; |
|
| 12 | 12 | use std::lang::layout::Item; |
| 827 | 827 | try expectRender(outer, 24, 2, "f(\n call(aaaa, bbbb, cccc)\n)\n"); |
|
| 828 | 828 | try expectRender( |
|
| 829 | 829 | outer, 12, 2, "f(\n call(\n aaaa,\n bbbb,\n cccc\n )\n)\n" |
|
| 830 | 830 | ); |
|
| 831 | 831 | } |
|
| 832 | + | ||
| 833 | + | /// Fixed rendering selects first alternatives and retains explicit breaks and comments. |
|
| 834 | + | @test unsafe fn fixedRendering() throws (testing::TestError) { |
|
| 835 | + | static storage: [u8; 8192] = [0; 8192]; |
|
| 836 | + | static bytes: [u8; 128] = [0; 128]; |
|
| 837 | + | let arena = heap::over(&mut storage[..]); |
|
| 838 | + | let a: &heap::Heap = arena; |
|
| 839 | + | let mandatory = broken( |
|
| 840 | + | a, |
|
| 841 | + | box( |
|
| 842 | + | a, |
|
| 843 | + | &[ |
|
| 844 | + | at(none(), text(a, "three")), |
|
| 845 | + | at(Placement::SoftIndent(Gap::Space), text(a, "four")), |
|
| 846 | + | at(none(), brokenText(a, ",")), |
|
| 847 | + | ] |
|
| 848 | + | ) |
|
| 849 | + | ); |
|
| 850 | + | let root = box( |
|
| 851 | + | a, |
|
| 852 | + | &[ |
|
| 853 | + | at(none(), text(a, "one")), |
|
| 854 | + | at(none(), tab(a, 0)), |
|
| 855 | + | at(none(), brokenText(a, "?")), |
|
| 856 | + | at(softSpace(), choice(a, &[text(a, "two"), text(a, "other")])), |
|
| 857 | + | at(Placement::Line, mandatory), |
|
| 858 | + | at(Placement::Line, comment(a, "// note")), |
|
| 859 | + | at(space(), text(a, "after")), |
|
| 860 | + | ] |
|
| 861 | + | ); |
|
| 862 | + | let mut output = sexpr::Buffer { buf: &mut bytes[..] as *mut [u8], pos: 0 }; |
|
| 863 | + | layout::text::renderFixed(root, 4, &mut output); |
|
| 864 | + | assert mem::eq(&output.buf[.. output.pos], "one two\nthree\n four,\n// note\nafter\n"); |
|
| 865 | + | set output.pos = 0; |
|
| 866 | + | layout::text::renderFixed(box(a, &[]), 4, &mut output); |
|
| 867 | + | assert output.pos == 0; |
|
| 868 | + | } |
lib/std/lang/layout/text.rad
+46 -4
| 108 | 108 | /// Boxes are flat when they fit in `options.width` columns. The output ends |
|
| 109 | 109 | /// with one newline if anything was written. |
|
| 110 | 110 | export fn render( |
|
| 111 | 111 | root: *super::Layout, options: Options, out: &mut opaque sexpr::Output |
|
| 112 | 112 | ) { |
|
| 113 | - | let mut st = State { |
|
| 113 | + | let mut st = state(options); |
|
| 114 | + | renderLayout(&mut st, out, root, 0, emptySpan(), false); |
|
| 115 | + | if st.written > 0 { |
|
| 116 | + | out.write("\n"); |
|
| 117 | + | } |
|
| 118 | + | } |
|
| 119 | + | ||
| 120 | + | /// Render first alternatives with fixed line breaks and indentation. |
|
| 121 | + | /// Soft placements stay flat unless their box is explicitly broken. Tab stops add no padding. |
|
| 122 | + | export fn renderFixed( |
|
| 123 | + | root: *super::Layout, indent: u32, out: &mut opaque sexpr::Output |
|
| 124 | + | ) { |
|
| 125 | + | let mut st = state(Options { width: 0, indent }); |
|
| 126 | + | fixedLayout(&mut st, out, root, Mode::Flat, 0); |
|
| 127 | + | if st.written > 0 { |
|
| 128 | + | out.write("\n"); |
|
| 129 | + | } |
|
| 130 | + | } |
|
| 131 | + | ||
| 132 | + | /// Initialize output position and pending whitespace for a renderer. |
|
| 133 | + | fn state(options: Options) -> State { |
|
| 134 | + | return State { |
|
| 114 | 135 | options, |
|
| 115 | 136 | col: 0, |
|
| 116 | 137 | newlines: 0, |
|
| 117 | 138 | spaces: 0, |
|
| 118 | 139 | written: 0, |
|
| 119 | 140 | tail: Tail::Code, |
|
| 120 | 141 | pads: [0; super::CELL_COLUMNS], |
|
| 121 | 142 | }; |
|
| 122 | - | renderLayout(&mut st, out, root, 0, emptySpan(), false); |
|
| 123 | - | if st.written > 0 { |
|
| 124 | - | out.write("\n"); |
|
| 143 | + | } |
|
| 144 | + | ||
| 145 | + | /// Render fixed placements without line measurements or alignment runs. |
|
| 146 | + | fn fixedLayout( |
|
| 147 | + | st: &mut State, out: &mut opaque sexpr::Output, layout: *super::Layout, mode: Mode, indent: u32 |
|
| 148 | + | ) { |
|
| 149 | + | match layout.item { |
|
| 150 | + | case super::Item::Text { text, role } => writeText(st, out, text, role), |
|
| 151 | + | case super::Item::Blank, super::Item::Tab(_), super::Item::BrokenText { .. } => {} |
|
| 152 | + | case super::Item::Broken(inner) => fixedLayout(st, out, inner, Mode::Broken, indent), |
|
| 153 | + | case super::Item::Choice(alts) => fixedLayout(st, out, alts[0], mode, indent), |
|
| 154 | + | case super::Item::Box(children) => { |
|
| 155 | + | for child in children { |
|
| 156 | + | if let case super::Item::BrokenText { text, role } = child.layout.item { |
|
| 157 | + | if mode == Mode::Broken { |
|
| 158 | + | place(st, child.placement, mode, indent); |
|
| 159 | + | writeText(st, out, text, role); |
|
| 160 | + | } |
|
| 161 | + | } else { |
|
| 162 | + | let level = place(st, child.placement, mode, indent); |
|
| 163 | + | fixedLayout(st, out, child.layout, Mode::Flat, level); |
|
| 164 | + | } |
|
| 165 | + | } |
|
| 166 | + | } |
|
| 125 | 167 | } |
|
| 126 | 168 | } |
|
| 127 | 169 | ||
| 128 | 170 | /// Number of columns of a gap. |
|
| 129 | 171 | fn gapWidth(gap: super::Gap) -> u32 { |
test/integration/packages.rad
+12 -3
| 207 | 207 | h.compile("read artifacts from another compiler image", h.out(&["alternate-artifact.log"])); |
|
| 208 | 208 | set h.compiler = original; |
|
| 209 | 209 | execute(h, h.path(&["alternate-artifact.rv64"])); |
|
| 210 | 210 | } |
|
| 211 | 211 | ||
| 212 | - | /// Check source/artifact parity, warm reuse, source changes, and damaged cache recovery. |
|
| 212 | + | /// Check source/artifact parity, warm reuse, source changes, and explicit artifact hashes. |
|
| 213 | 213 | export fn check(h: &mut Harness, args: *[*[u8]]) throws (sys::Error) { |
|
| 214 | 214 | try h.begin("packages"); |
|
| 215 | 215 | let mark = h.failed; |
|
| 216 | 216 | let dep = h.path(&["dep.rad"]); |
|
| 217 | 217 | let app = h.path(&["app.rad"]); |
| 352 | 352 | source(h, h.path(&["opaque.rv64"]), "-o"); |
|
| 353 | 353 | let inaccessible = h.cc(h.take(), h.out(&["opaque.log"])); |
|
| 354 | 354 | h.run("preserve opaque representation privacy", inaccessible, process::Outcome::Exited(1), &[ |
|
| 355 | 355 | harness::Expect::Contains("opaque record representation is private") |
|
| 356 | 356 | ]); |
|
| 357 | - | try fs::writeFile(h.join(&[exported, "/dep.interface/dep.rid"]), "export fn forged();\n"); |
|
| 357 | + | let original = try h.load(declarations); |
|
| 358 | + | let mut altered: *mut [u8] = &mut []; |
|
| 359 | + | try! altered.extend(original, h.arena); |
|
| 360 | + | set altered[0] = altered[0] ^ 1; |
|
| 361 | + | try fs::writeFile(declarations, &altered[..]); |
|
| 358 | 362 | h.add(&["-no-cache", "-pkg", "app", "-artifact", exported, "-o", h.path(&["bad.rv64"])]); |
|
| 359 | 363 | let rejected = h.cc(h.take(), h.out(&["corrupt.log"])); |
|
| 360 | - | h.run("reject a mismatched explicit interface", rejected, process::Outcome::Exited(1), &[]); |
|
| 364 | + | h.run( |
|
| 365 | + | "reject a same-length mismatched explicit interface", |
|
| 366 | + | rejected, |
|
| 367 | + | process::Outcome::Exited(1), |
|
| 368 | + | &[] |
|
| 369 | + | ); |
|
| 361 | 370 | try reexports(h); |
|
| 362 | 371 | try large(h); |
|
| 363 | 372 | h.done(mark, "packages: source-free linking, cache reuse, and integrity checks passed"); |
|
| 364 | 373 | } |