Compiler Bootstrap

Obtain TCC source. Why it matters: pinning the exact TCC version/commit ensures the compiler inside the OS is reproducible and known-good. Focus on `build_tcc` in `xtask/src/main.rs` while you trace the snippet.

/// Phase 31: Cross-compile TCC for x86-64 Linux with musl (static binary).
///
/// Strategy: clone TCC source from repo.or.cz (or use cached clone in
/// target/tcc-src/), configure with `--prefix=/usr` so TCC knows where
/// to find headers and libraries at runtime inside the OS, build with
/// `x86_64-linux-musl-gcc -static`, strip, and place the resulting
/// binary in a staging directory.
///
/// Returns the path to the staging directory containing the TCC binary,
/// or `None` if the build fails (musl cross-compiler not available, etc.).
///
/// The staging directory layout:
///   target/tcc-staging/usr/bin/tcc          — TCC binary
///   target/tcc-staging/usr/lib/libc.a       — musl libc
///   target/tcc-staging/usr/lib/crt1.o       — CRT start
///   target/tcc-staging/usr/lib/crti.o       — CRT init prologue
///   target/tcc-staging/usr/lib/crtn.o       — CRT init epilogue
///   target/tcc-staging/usr/lib/tcc/include/ — TCC-specific headers
///   target/tcc-staging/usr/include/         — musl system headers
///   target/tcc-staging/usr/src/hello.c      — test program
///   target/tcc-staging/usr/src/tcc/         — TCC source for self-hosting
fn build_tcc() -> Option<PathBuf> {
    let root = workspace_root();
    let staging = root.join("target/tcc-staging");

View on GitHub

sys_open FD lifecycle audit. Why it matters: TCC opens dozens of header files sequentially; closed FDs must be recycled so the process does not exhaust the per-process FD table. Focus on `alloc_fd` in `kernel/src/arch/x86_64/syscall.rs` while you trace the snippet.

/// Allocate the lowest available FD slot (starting from `min_fd`) in the
/// current process's FD table. Returns the FD number or `None` if full.
fn alloc_fd(min_fd: usize, entry: FdEntry) -> Option<usize> {
    let pid = crate::process::CURRENT_PID.load(core::sync::atomic::Ordering::Relaxed);
    let mut table = crate::process::PROCESS_TABLE.lock();
    let proc = table.find_mut(pid)?;
    for i in min_fd..MAX_FDS {
        if proc.fd_table[i].is_none() {
            proc.fd_table[i] = Some(entry);
            return Some(i);
        }
    }
    None
}

View on GitHub

Edit-compile-run cycle. Why it matters: confirms the complete authoring workflow — create source in the editor, compile with TCC, run the result — all within the OS. Focus on `edit_main` and `.c` in `userspace/edit/src/main.rs` while you trace the snippet.

fn edit_main(args: &[&str]) -> i32 {
    register_sigwinch_handler();

    let mut editor = Editor::new();

    if args.len() >= 2 {
        editor.open_file(args[1]);
    } else {
        editor.rows.push(Row::new(Vec::new()));
    }

    editor.run();

    // Restore terminal
    let orig = editor.orig_termios;
    disable_raw_mode(&orig);

    // Clear screen on exit
    syscall_lib::write(1, b"\x1b[2J\x1b[H");

    0
}

View on GitHub