kernel/tools/build.rad 22.8 KiB raw
1
//! Build a native kernel image with shared packages and a persistent boot catalog.
2
3
use std::arch::rv64;
4
use std::arch::rv64::asm;
5
use std::arch::rv64::emit;
6
use std::arch::rv64::encode;
7
use std::arch::rv64::image;
8
use std::arch::rv64::shared;
9
use std::arch::rv64::shared::catalog;
10
use std::collections::dict;
11
use std::fs;
12
use std::io;
13
use std::lang::gen::data;
14
use std::lang::gen::labels;
15
use std::lang::gen::regalloc::liveness;
16
use std::lang::il::binary;
17
use std::lang::il::binary::program;
18
use std::lang::il::verify;
19
use std::lang::il::verify::linking;
20
use std::lang::ast;
21
use std::lang::manifest;
22
use std::lang::parser;
23
use std::lang::strings;
24
use std::mem;
25
use std::mem::heap;
26
use std::sys;
27
28
/// Byte alignment of boot package code and data segments.
29
constant CODE_ALIGNMENT: u32 = 4096;
30
/// Bytes reserved for the boot entry trampoline.
31
constant TRAMPOLINE_BYTES: u32 = 4096;
32
33
/// Number of elements reserved for code storage.
34
constant CODE_CAPACITY: u32 = 16777216;
35
/// Number of elements reserved for scratch storage.
36
constant SCRATCH_CAPACITY: u32 = 16777216;
37
/// Number of elements reserved for decode storage. It holds the decoded IL of
38
/// the standard library and the kernel, which a machine fixture kernel brings
39
/// past 64 MB.
40
constant DECODE_CAPACITY: u32 = 83886080;
41
/// Number of elements reserved for input storage.
42
constant INPUT_CAPACITY: u32 = 8388608;
43
/// Number of elements reserved for source storage.
44
constant SOURCE_CAPACITY: u32 = 65536;
45
/// Number of elements reserved for manifest syntax and value storage.
46
constant MANIFEST_CAPACITY: u32 = 1048576;
47
/// Number of elements reserved for assembly storage.
48
constant ASSEMBLY_CAPACITY: u32 = 4194304;
49
/// Number of elements reserved for text storage.
50
constant TEXT_CAPACITY: u32 = 16384;
51
/// Number of elements reserved for data storage.
52
constant DATA_CAPACITY: u32 = 4096;
53
/// Number of elements reserved for symbols storage.
54
constant SYMBOLS_CAPACITY: u32 = 4096;
55
/// Number of elements reserved for exports storage.
56
constant EXPORTS_CAPACITY: u32 = 4096;
57
/// Number of elements reserved for imports storage.
58
constant IMPORTS_CAPACITY: u32 = 16384;
59
/// Number of elements reserved for relocs storage.
60
constant RELOCS_CAPACITY: u32 = 4096;
61
/// Number of elements reserved for templates storage.
62
constant TEMPLATES_CAPACITY: u32 = 1048576;
63
/// Number of elements reserved for ro storage.
64
constant RO_CAPACITY: u32 = 16777216;
65
/// Number of elements reserved for rw storage.
66
constant RW_CAPACITY: u32 = 33554432;
67
/// Number of elements reserved for native storage.
68
constant NATIVE_CAPACITY: u32 = 4194304;
69
70
/// Native entry page, above the platform firmware data.
71
constant CODE_ADDRESS: u64 = 0x81000000;
72
/// Size in bytes of the kernel's `Env` record, which a package entry may receive.
73
constant ENV_SIZE: u32 = 24;
74
/// Maximum shared packages in the boot image.
75
constant PACKAGES: u32 = 4;
76
/// Package code arenas retained until image output completes.
77
unsafe static CODE: [[u8; CODE_CAPACITY]; PACKAGES] = undefined;
78
/// Reusable function workspace.
79
static SCRATCH: [u8; SCRATCH_CAPACITY] = [0; SCRATCH_CAPACITY];
80
/// Persistent decoded RIL storage.
81
static DECODE: [u8; DECODE_CAPACITY] = [0; DECODE_CAPACITY];
82
/// Exact package bytes retained in the native catalog.
83
unsafe static INPUT: [[u8; INPUT_CAPACITY]; PACKAGES] = undefined;
84
/// Combined startup and boundary assembly source.
85
static SOURCE: [u8; SOURCE_CAPACITY] = [0; SOURCE_CAPACITY];
86
/// Standard library assembly source.
87
static LIBRARY_SOURCE: [u8; SOURCE_CAPACITY] = [0; SOURCE_CAPACITY];
88
/// Manifest syntax trees, reused for each manifest.
89
static MANIFEST_SYNTAX: [u8; MANIFEST_CAPACITY] = [0; MANIFEST_CAPACITY];
90
/// Manifest text and the values read from it.
91
static MANIFESTS: [u8; MANIFEST_CAPACITY] = [0; MANIFEST_CAPACITY];
92
/// String pool table of the manifest parser.
93
unsafe static MANIFEST_NAMES: [*[u8]; strings::TABLE_SIZE] = undefined;
94
/// Standard library assembly words.
95
static LIBRARY_TEXT: [u32; TEXT_CAPACITY] = [0; TEXT_CAPACITY];
96
/// Assembler workspace.
97
static ASSEMBLY: [u8; ASSEMBLY_CAPACITY] = [0; ASSEMBLY_CAPACITY];
98
/// Assembled startup words.
99
static TEXT: [u32; TEXT_CAPACITY] = [0; TEXT_CAPACITY];
100
/// Assembly identifiers retained through package linking.
101
unsafe static NAMES: [*[u8]; strings::TABLE_SIZE] = undefined;
102
/// Per-package data layout workspaces.
103
unsafe static DATA: [[data::DataSym; DATA_CAPACITY]; PACKAGES] = undefined;
104
/// Local function and data definitions.
105
unsafe static SYMBOLS: [[shared::Symbol; SYMBOLS_CAPACITY]; PACKAGES] =
106
    undefined;
107
/// Public package symbols.
108
unsafe static EXPORTS: [[shared::Symbol; EXPORTS_CAPACITY]; PACKAGES] =
109
    undefined;
110
/// Exports from dependencies compiled before the current package.
111
unsafe static IMPORTS: [shared::Symbol; IMPORTS_CAPACITY] = undefined;
112
/// Private-state relocation records.
113
unsafe static RELOCS: [[shared::Relocation; RELOCS_CAPACITY]; PACKAGES] =
114
    undefined;
115
/// Initialized package templates.
116
unsafe static TEMPLATES: [[u8; TEMPLATES_CAPACITY]; PACKAGES] = undefined;
117
/// Read-only catalog and retained package payloads.
118
static RO: [u8; RO_CAPACITY] = [0; RO_CAPACITY];
119
/// Kernel state table and initialized private package graph.
120
static RW: [u8; RW_CAPACITY] = [0; RW_CAPACITY];
121
/// Contiguous native code segment, including entry trampoline and alignment padding.
122
static NATIVE: [u32; NATIVE_CAPACITY] = [0; NATIVE_CAPACITY];
123
124
/// Round an extent up to a power-of-two alignment.
125
fn aligned(value: u64, alignment: u32) -> u64 {
126
    assert alignment > 0 and (alignment & (alignment - 1)) == 0;
127
    assert value <= mem::U64_MAX - alignment as u64 + 1;
128
    return (value + alignment as u64 - 1) & ~(alignment as u64 - 1);
129
}
130
131
/// Print a bounded shared-backend failure class.
132
fn report(error: shared::Error) {
133
    match error {
134
        case shared::Error::Codegen(_) => io::printLn("native build: code generation failed"),
135
        case shared::Error::Capacity => io::printLn("native build: output capacity exhausted"),
136
        case shared::Error::Symbol => io::printLn("native build: unresolved or duplicate symbol"),
137
        case shared::Error::Range => io::printLn("native build: address out of range"),
138
        case shared::Error::Alignment => io::printLn("native build: invalid alignment"),
139
        case shared::Error::Instance => io::printLn("native build: missing package instance"),
140
    }
141
}
142
143
/// Compile one boot package into resident code and private-state metadata.
144
unsafe fn compile(
145
    input: &binary::Package,
146
    slot: u32,
147
    address: u64,
148
    imports: &[shared::Symbol],
149
    assembly: &asm::Program,
150
    stack: rv64::StackCheck
151
) -> shared::Package throws (shared::Error) {
152
    let arena = heap::over(&mut CODE[slot][..]);
153
    let scratch = heap::over(&mut SCRATCH[..]);
154
    return try shared::compileAssembly(
155
        input,
156
        assembly,
157
        slot,
158
        address,
159
        imports,
160
        shared::Storage {
161
            data: &mut DATA[slot][..],
162
            symbols: &mut SYMBOLS[slot][..],
163
            exports: &mut EXPORTS[slot][..],
164
            template: &mut TEMPLATES[slot][..],
165
            relocations: &mut RELOCS[slot][..],
166
            stack: stack,
167
        },
168
        arena,
169
        scratch
170
    );
171
}
172
173
/// Emit a trampoline that preserves firmware arguments and supplies the native catalog.
174
unsafe fn trampoline(kernel: u64, ro: u64, rw: u64, count: u32) {
175
    let arena = heap::over(&mut SCRATCH[..]);
176
    let mut blockOffsets: *mut [i32] = &mut [];
177
    try! blockOffsets.resize(labels::MAX_BLOCKS_PER_FN, 0, arena);
178
    let mut funcEntries: *mut [dict::Entry] = &mut [];
179
    try! funcEntries.resize(
180
        labels::FUNC_TABLE_SIZE, dict::Entry { key: &[], value: 0 }, arena
181
    );
182
    let mut e = try! emit::emitter(arena, false, labels::fresh(blockOffsets, funcEntries));
183
    try! emit::loadImm(&mut e, rv64::GP, rw as i64);
184
    try! emit::loadImm(&mut e, rv64::A3, ro as i64);
185
    try! emit::loadImm(&mut e, rv64::A4, count as i64);
186
    try! emit::loadImm(&mut e, rv64::T0, kernel as i64);
187
    try! emit::emit(&mut e, encode::jalr(rv64::ZERO, rv64::T0, 0));
188
    assert e.code.len <= TRAMPOLINE_BYTES / rv64::INSTR_SIZE as u32;
189
    for word, i in &e.code[..] {
190
        set NATIVE[i] = word;
191
    }
192
}
193
194
/// Select one verified provider with matching metadata from boot entries.
195
fn dependency(entries: &[catalog::Entry], name: *[u8], pin: binary::Id) -> catalog::Entry
196
    throws (shared::Error)
197
{
198
    let mut selected: ?catalog::Entry = nil;
199
    for entry in entries {
200
        let package = entry.package;
201
        if package.contract.verification <> shared::Verification::Verified
202
            or not mem::eq(package.name, name)
203
        {
204
            continue;
205
        }
206
        let metadata = package.contract.metadata;
207
        if not mem::eq(&metadata.bytes[..], &pin.bytes[..]) {
208
            continue;
209
        }
210
        set selected = entry;
211
    }
212
    let entry = selected else throw shared::Error::Symbol;
213
    return entry;
214
}
215
216
/// Build typed provider declarations and the same native aliases for a user boot package.
217
fn userImports(
218
    input: &binary::Package,
219
    entries: &[catalog::Entry],
220
    output: &mut [shared::Symbol],
221
    arena: &heap::Heap
222
) -> *[linking::Provider] throws (shared::Error) {
223
    if input.links.pins.len <> input.dependencies.len {
224
        throw shared::Error::Symbol;
225
    }
226
    if input.links.imports.len > output.len {
227
        throw shared::Error::Capacity;
228
    }
229
    let mut providers: *mut [linking::Provider] = &mut [];
230
    let mut exports: *mut [*[shared::Symbol]] = &mut [];
231
    for pin, i in input.links.pins {
232
        let selected = try dependency(entries, input.dependencies[i], pin);
233
        let declarations = try program::declarations(selected.source, arena) catch error {
234
            if error == binary::Error::Storage {
235
                throw shared::Error::Capacity;
236
            }
237
            throw shared::Error::Symbol;
238
        };
239
        try exports.append(selected.package.exports, arena) catch {
240
            throw shared::Error::Capacity;
241
        };
242
        let image = selected.package.contract.image else throw shared::Error::Symbol;
243
        try providers.append(
244
            linking::Provider { image, contract: declarations },
245
            arena
246
        ) catch {
247
            throw shared::Error::Capacity;
248
        };
249
    }
250
    for imported, i in input.links.imports {
251
        if imported.dependency >= input.links.pins.len {
252
            throw shared::Error::Symbol;
253
        }
254
        let target = shared::lookup(exports[imported.dependency], imported.exported)
255
            else throw shared::Error::Symbol;
256
        set output[i] = shared::Symbol { name: imported.exported, target, startable: false };
257
    }
258
    return &providers[..];
259
}
260
261
/// Read the manifest at `path`, from which its relative paths are resolved.
262
fn readManifest(path: *[u8], arena: &heap::Heap) -> ManifestFile {
263
    let text = try fs::readFileAlloc(path, arena) catch {
264
        panic "readManifest: cannot read manifest";
265
    };
266
    let mut syntax: parser::Parser = undefined;
267
    // Each call starts the syntax storage and string pool over. `manifest::read`
268
    // copies everything it returns into `arena`, so no result of an earlier call
269
    // refers to the reused storage.
270
    unsafe {
271
        set syntax = parser::newParser(ast::nodeArena(&mut MANIFEST_SYNTAX[..]), strings::pool(
272
            &mut MANIFEST_NAMES[..]
273
        ));
274
    }
275
    let package = try manifest::read(&mut syntax, path, text, arena) catch {
276
        panic "readManifest: invalid manifest";
277
    };
278
    return ManifestFile { path, package };
279
}
280
281
/// A package manifest and its location.
282
record ManifestFile: Copy {
283
    /// Manifest path.
284
    path: *[u8],
285
    /// Package that the manifest describes.
286
    package: manifest::Package,
287
}
288
289
/// Concatenate the assembly sources that `file` lists into `buffer`, and
290
/// return the text.
291
fn assemblySources(file: &ManifestFile, buffer: *mut [u8], arena: &heap::Heap) -> *[u8] {
292
    let mut length: u32 = 0;
293
    for assembly in file.package.assembly {
294
        let location = try manifest::resolve(file.path, assembly, arena) catch {
295
            panic "assemblySources: path too long";
296
        };
297
        let size = try fs::readFile(location, &mut buffer[length ..]) catch {
298
            panic "assemblySources: cannot read assembly";
299
        };
300
        set length += size;
301
    }
302
    return &buffer[.. length];
303
}
304
305
/// Assembly text and the name used in its diagnostics.
306
record AssemblySource: Copy {
307
    /// Source name for diagnostics.
308
    name: *[u8],
309
    /// Assembly text.
310
    text: *[u8],
311
}
312
313
/// Inputs and output named on the command line.
314
record Arguments: Copy {
315
    /// Binary IL of the standard library, the kernel, and the boot packages.
316
    packages: *[*[u8]],
317
    /// Output image path.
318
    output: *[u8],
319
    /// Kernel assembly.
320
    kernel: AssemblySource,
321
    /// Standard library assembly, if any.
322
    library: ?AssemblySource,
323
}
324
325
/// Read the command line `args`:
326
///
327
/// `[-std-asm <std.ras>] <std.ril.bin> <kernel.ril.bin> <kernel.ras> <output> [<boot.ril.bin>..]`
328
/// `-package <kernel directory> <std.ril.bin> <kernel.ril.bin> <output> [<boot.ril.bin>..]`
329
///
330
/// With `-package`, the assembly is what the manifests of the kernel package
331
/// and of its `std` dependency list. `std` is found in the library
332
/// directories of the kernel package, as the compiler finds it.
333
unsafe fn arguments(args: *[*[u8]]) -> Arguments {
334
    if args.len >= 2 and mem::eq(args[0], "-package") {
335
        let rest = &args[2 ..];
336
        assert rest.len >= 3 and rest.len <= PACKAGES + 1;
337
        let manifests = heap::over(&mut MANIFESTS[..]);
338
        let kernelPath = try manifest::find(args[1], manifests) catch {
339
            panic "arguments: no kernel package manifest";
340
        };
341
        let libraries = try manifest::libraries(args[1], &[], manifests) catch {
342
            panic "arguments: cannot search library directories";
343
        };
344
        let found = try manifest::lookup("std", libraries, manifests) catch {
345
            panic "arguments: cannot search library directories";
346
        };
347
        let case manifest::Found::Source(libraryPath) = found
348
            else panic "arguments: no `std` source package";
349
        let kernelFile = readManifest(kernelPath, manifests);
350
        let libraryFile = readManifest(libraryPath, manifests);
351
        let mut packages: *mut [*[u8]] = &mut [];
352
        try! packages.extend(&rest[.. 2], manifests);
353
        try! packages.extend(&rest[3 ..], manifests);
354
        return Arguments {
355
            packages: &packages[..],
356
            output: rest[2],
357
            kernel: AssemblySource {
358
                name: kernelFile.path,
359
                text: assemblySources(&kernelFile, &mut SOURCE[..], manifests),
360
            },
361
            library: AssemblySource {
362
                name: libraryFile.path,
363
                text: assemblySources(&libraryFile, &mut LIBRARY_SOURCE[..], manifests),
364
            },
365
        };
366
    }
367
    let mut rest = &args[..];
368
    let mut library: ?AssemblySource = nil;
369
    if args.len >= 2 and mem::eq(args[0], "-std-asm") {
370
        let size = try fs::readFile(args[1], &mut LIBRARY_SOURCE[..]) catch {
371
            panic "arguments: standard library assembly";
372
        };
373
        set library = AssemblySource { name: args[1], text: &LIBRARY_SOURCE[.. size] };
374
        set rest = &args[2 ..];
375
    }
376
    assert rest.len >= 4 and rest.len <= PACKAGES + 2;
377
    let size = try fs::readFile(rest[2], &mut SOURCE[..]) catch {
378
        panic "arguments: kernel assembly";
379
    };
380
    let manifests = heap::over(&mut MANIFESTS[..]);
381
    let mut packages: *mut [*[u8]] = &mut [];
382
    try! packages.extend(&rest[.. 2], manifests);
383
    try! packages.extend(&rest[4 ..], manifests);
384
    return Arguments {
385
        packages: &packages[..],
386
        output: rest[3],
387
        kernel: AssemblySource { name: rest[2], text: &SOURCE[.. size] },
388
        library,
389
    };
390
}
391
392
/// Link shared boot packages, retain their catalog, and instantiate the kernel graph.
393
/// [`arguments`] describes the command line.
394
@default unsafe fn main(env: *sys::Env) -> i32 {
395
    let args = arguments(env.args);
396
    let count = args.packages.len;
397
    let decoder = heap::over(&mut DECODE[..]);
398
    let libraryBytesLength = try fs::readFile(args.packages[0], &mut INPUT[0][..]) catch {
399
        panic "main: std RIL";
400
    };
401
    let libraryBytes = &INPUT[0][.. libraryBytesLength];
402
    let libraryInput = try! program::decode(libraryBytes, decoder, binary::Limits {
403
        registers: liveness::MAX_SSA_REGS, blocks: labels::MAX_BLOCKS_PER_FN
404
    });
405
    let kernelBytesLength = try fs::readFile(args.packages[1], &mut INPUT[1][..]) catch {
406
        panic "main: kernel RIL";
407
    };
408
    let kernelBytes = &INPUT[1][.. kernelBytesLength];
409
    let kernelInput = try! program::decode(kernelBytes, decoder, binary::Limits {
410
        registers: liveness::MAX_SSA_REGS, blocks: labels::MAX_BLOCKS_PER_FN
411
    });
412
    assert mem::eq(libraryInput.name, "std") and mem::eq(kernelInput.name, "kernel");
413
    assert libraryInput.dependencies.len == 0;
414
    for dependency in kernelInput.dependencies {
415
        assert mem::eq(dependency, "std");
416
    }
417
    let source = args.kernel.text;
418
    let assemblyArena = heap::over(&mut ASSEMBLY[..]);
419
    let empty: *mut [u8] = &mut [];
420
    let mut names = strings::pool(&mut NAMES[..]);
421
    let assembly = try asm::assemble(
422
        asm::scanner::SourceKind::String,
423
        source,
424
        &mut TEXT[..],
425
        empty,
426
        assemblyArena,
427
        &mut names,
428
        0
429
    ) catch error {
430
        asm::printError(error, args.kernel.name, source);
431
        return 1;
432
    };
433
    let mut libraryAssembly = asm::Program {
434
        text: &[], data: &[], symbols: &[], externalFixups: &[]
435
    };
436
    if let library = args.library {
437
        let source = library.text;
438
        let empty: *mut [u8] = &mut [];
439
        set libraryAssembly = try asm::assemble(
440
            asm::scanner::SourceKind::String,
441
            source,
442
            &mut LIBRARY_TEXT[..],
443
            empty,
444
            assemblyArena,
445
            &mut names,
446
            0
447
        ) catch error {
448
            asm::printError(error, library.name, source);
449
            return 1;
450
        };
451
    }
452
    let library = try compile(
453
        &libraryInput,
454
        0,
455
        CODE_ADDRESS
456
            + TRAMPOLINE_BYTES as u64,
457
        &[],
458
        &libraryAssembly,
459
        rv64::StackCheck::Off
460
    ) catch error {
461
        report(error);
462
        return 1;
463
    };
464
    let kernelAddress = aligned(
465
        library.codeAddress
466
            + library.code.len as u64 * rv64::INSTR_SIZE as u64,
467
        CODE_ALIGNMENT
468
    );
469
    let kernel = try compile(
470
        &kernelInput, 1, kernelAddress, library.exports, &assembly, rv64::StackCheck::Off
471
    ) catch error {
472
        report(error);
473
        return 1;
474
    };
475
    let mut catalogEntries: [catalog::Entry; PACKAGES] = undefined;
476
    set catalogEntries[0] = catalog::Entry { source: libraryBytes, package: library };
477
    set catalogEntries[1] = catalog::Entry { source: kernelBytes, package: kernel };
478
    let mut codeEnd = kernel.codeAddress
479
        + kernel.code.len as u64 * rv64::INSTR_SIZE as u64;
480
    for slot in 2 .. count {
481
        let bytesLength = try fs::readFile(
482
            args.packages[slot], &mut INPUT[slot][..]
483
        ) catch {
484
            panic "main: boot package RIL";
485
        };
486
        let bytes = &INPUT[slot][.. bytesLength];
487
        let mut input = try! program::decode(bytes, decoder, binary::Limits {
488
            registers: liveness::MAX_SSA_REGS, blocks: labels::MAX_BLOCKS_PER_FN
489
        });
490
        // User packages run in U-mode, so every one must verify; there is no way around this.
491
        let verifier = heap::over(&mut SCRATCH[..]);
492
        let providers = try userImports(
493
            &input, &catalogEntries[.. slot], &mut IMPORTS[..], decoder
494
        ) catch error {
495
            report(error);
496
            return 1;
497
        };
498
        try verify::verifyLinkedPackage(
499
            &mut input, &providers[..], shared::verifierConfig(ENV_SIZE), verifier, decoder
500
        ) catch error {
501
            io::print("native build: boot package fails verification: ");
502
            io::print(verify::ruleName(error.rule));
503
            io::print(" ");
504
            match error.place {
505
                case verify::Place::Fn(i) => {
506
                    io::print(" fn ");
507
                    io::print(input.program.fns[i].name);
508
                }
509
                else => {}
510
            }
511
            io::print(" in ");
512
            io::printLn(input.name);
513
            return 1;
514
        };
515
        let imported = input.links.imports.len;
516
        let package = try compile(
517
            &input,
518
            slot,
519
            aligned(
520
                codeEnd, CODE_ALIGNMENT
521
            ),
522
            &IMPORTS[.. imported],
523
            &asm::Program { text: &[], data: &[], symbols: &[], externalFixups: &[] },
524
            rv64::StackCheck::TpLimit
525
        ) catch error {
526
            report(error);
527
            return 1;
528
        };
529
        set catalogEntries[slot] = catalog::Entry { source: bytes, package };
530
        set codeEnd = package.codeAddress
531
            + package.code.len as u64 * rv64::INSTR_SIZE as u64;
532
    }
533
    let codeSize = (codeEnd - CODE_ADDRESS) as u32;
534
    assert codeEnd - CODE_ADDRESS <= @sizeOf([u32; NATIVE_CAPACITY]) as u64;
535
    let roAddress = aligned(codeEnd, CODE_ALIGNMENT);
536
    let roSize = try catalog::pack(&catalogEntries[.. count], roAddress, &mut RO[..]) catch error {
537
        report(error);
538
        return 1;
539
    };
540
    let rwAddress = aligned(roAddress + roSize as u64, CODE_ALIGNMENT);
541
    let mut bases: [u64; shared::MAX_PACKAGES] = [0; shared::MAX_PACKAGES];
542
    let mut rwSize: u32 = @sizeOf([u64; shared::MAX_PACKAGES]);
543
    for entry in &catalogEntries[.. 2] {
544
        let at = aligned(rwAddress + rwSize as u64, entry.package.alignment);
545
        assert at - rwAddress <= RW.len as u64
546
            and entry.package.memory <= RW.len - (at - rwAddress) as u32;
547
        set bases[entry.package.slot] = at;
548
        set rwSize = (at - rwAddress) as u32 + entry.package.memory;
549
    }
550
    try! mem::copy(&mut RW[.. @sizeOf([u64; shared::MAX_PACKAGES])], @sliceOf(
551
        &bases[0] as *unsafe u8, @sizeOf([u64; shared::MAX_PACKAGES])
552
    ));
553
    for entry in &catalogEntries[.. 2] {
554
        let at = (bases[entry.package.slot] - rwAddress) as u32;
555
        try shared::instantiate(
556
            &entry.package, &bases[..], &mut RW[at .. at + entry.package.memory]
557
        ) catch error {
558
            report(error);
559
            return 1;
560
        };
561
    }
562
    for i in 0 .. codeSize / 4 {
563
        set NATIVE[i] = encode::nop();
564
    }
565
    for entry in &catalogEntries[.. count] {
566
        let at = ((entry.package.codeAddress - CODE_ADDRESS) / 4) as u32;
567
        for word, i in entry.package.code {
568
            set NATIVE[at + i] = word;
569
        }
570
    }
571
    trampoline(kernelAddress, roAddress, rwAddress, count);
572
    let header = try! image::header(image::Layout {
573
        code: image::Segment { address: CODE_ADDRESS, size: codeSize },
574
        roData: image::Segment { address: roAddress, size: roSize },
575
        rwData: image::Segment { address: rwAddress, size: rwSize },
576
        rwTail: 0,
577
    });
578
    let mut out = try! fs::create(args.output);
579
    out.write(&header[..]);
580
    out.write(@sliceOf(&NATIVE[0] as *u8, codeSize));
581
    out.write(&RO[.. roSize]);
582
    out.write(&RW[.. rwSize]);
583
    try! out.close();
584
    return 0;
585
}