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
Alexis Sellier committed ago 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] = &copy[..];
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
}