/.ai

# Compiler/build output

/bin

*.rv64

*.rv64.debug

*.o

# Seed binary (tracked, but not stage intermediates)

!seed/

# Verify the emulator binary exists.

EMU_PATH := $(shell command -v $(EMU) 2>/dev/null)

default: emulator $(RAD_BIN)

# Emulator command check

emulator:

ifeq ($(EMU_PATH),)

clean-std-test:

	@rm -f lib/std.test.rv64 \

		lib/std.test.rv64.debug \

		lib/std.test.rv64.s \

# Binary Tests

BIN_TEST_DIR := test/tests

# Only tests with `//! returns:` are compiled to binaries and executed.

clean-bin-test:

	@rm -f $(BIN_RUNNER) \

		$(BIN_RUNNER:.rv64=.rv64.debug) \

		$(BIN_RUNNER:.rv64=.rv64.s) \

		$(BIN_RUNNER:.rv64=.rv64.o) \

		$(BIN_TEST_EXE_BIN) \

		$(wildcard $(BIN_TEST_DIR)/*.rv64.debug) \

seed:

	seed/update

clean-rad:

clean: clean-std-test clean-bin-test clean-rad

t: test

c: clean

	clean-std-test clean-bin-test clean-rad emulator

.SUFFIXES:

.DELETE_ON_ERROR:

.SILENT:

static CODEGEN_DATA_SYM_ENTRIES: [dict::Entry; data::DATA_SYM_TABLE_SIZE] = undefined;

/// Debug info file extension.

constant DEBUG_EXT: *[u8] = ".debug";

/// Maximum rodata size (4MB).

constant MAX_RO_DATA_SIZE: u32 = 4194304;

/// Maximum rwdata size (4MB).

constant MAX_RW_DATA_SIZE: u32 = 4194304;

/// Maximum path length.

    };

    let stmts = block.statements.append(decl, alloc::arenaAllocator(&mut arena.arena));

    set blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });

}

}

/// Write a data section to a file at `basePath` + `ext`.

/// Empty data truncates any stale sidecar left by an earlier build.

fn writeDataWithExt(

) -> rv64::Program throws (Error) {

    let entryIdx = ctx.entryPkgIdx else {

        panic "lowerAndGenerateAllPackages: no entry package";

    };

    let entryPkg = &ctx.packages[entryIdx];

    let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };

    let storage = rv64::Storage {

        dataSyms: &mut CODEGEN_DATA_SYMS[..],

        dataSymEntries: &mut CODEGEN_DATA_SYM_ENTRIES[..],

    };

    set low.output = lower::FnOutput::Stream(lower::FnSink {

        ctx: &mut codegenCtx as *mut opaque,

        emitFn: generateLoweredFn,

    });

    let mut asmDataLen: u32 = 0;

    }

    try lowerAllPackagesInto(ctx, res, &mut low);

    let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, &mut res.arena);

    match generator.entryPatch {

    // Generate binary output if path specified.

    let outPath = ctx.outputPath else {

        try lowerAllPackages(ctx, res);

        return;

    };

    let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {

        logPath: outPath,

        debug: ctx.debug,

        entryMode: CodegenEntryMode::None

            else CodegenEntryMode::DefaultEntry,

    });

        throw error(&["fatal:", "failed to write output file"]);

    }

    // Write debug info file if enabled.

    if ctx.debug {

        try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);

    }

export constant RO_DATA_BASE: u32 = 0x10000;

/// Base address where read-write data is loaded.

export constant RW_DATA_BASE: u32 = 0xFFFFF0;

/// Storage buffers passed from driver for code generation.

export record Storage {

    /// Buffer for data symbols.

    dataSyms: *mut [data::DataSym],

    /// Hash table entries for data symbol lookup.

/// Record a function address load needing later patching.

/// Emits placeholder instructions that will be patched to load the function's address.

/// Uses two slots to compute long-distance addresses.

export fn recordAddrLoad(e: *mut Emitter, target: *[u8], rd: gen::Reg) {

    emit(e, encode::nop()); // Placeholder for AUIPC.

    emit(e, encode::nop()); // Placeholder for ADDI.

}

/// Returns the number of bytes written, or a negative value on error.

export fn write(fd: i64, buf: *[u8]) -> i64 {

    return intrinsics::ecall(64, fd, buf.ptr as i64, buf.len as i64, 0);

}

/// Closes a file descriptor.

/// Returns `0` on success, or a negative value on error.

export fn close(fd: i64) -> i64 {

    return intrinsics::ecall(57, fd, 0, 0, 0);

}

/// Writes the entire contents of a buffer to a file at the given path.

/// Creates the file if it doesn't exist, truncates if it does.

/// Returns `true` on success.

export fn writeFile(path: *[u8], data: *[u8]) -> bool {

    let flags = OpenFlags(*O_WRONLY | *O_CREAT | *O_TRUNC);

    let fd = openOpts(path, flags, 420); // 0644 in octal.

    if fd < 0 {

        return false;

    }

            close(fd);

            return false;

        }

    }

}

use std::fmt;

use std::mem;

use std::vec;

use std::testing;

// Data types //////////////////////////////////////////////////////////////////

record Point {

    x: i32,

        set threw = true;

    };

    try testing::expect(threw);

}

@test fn testStripPrefixMatch() throws (testing::TestError) {

    let input: *[u8] = "hello world";

    let prefix: *[u8] = "hello";

    let result = mem::stripPrefix(prefix, input) else {

                  affected by.

FILES

  seed/radiance.rv64.git       SHA-256 of the git commit whose *source*

                               was compiled to produce this seed.

  seed/update                  Tool that finds the fixed point and

                               updates the seed.

# ---------------------------------------------------------------------------

# Compare two stage binaries. Returns 0 if identical, 1 if they differ.

# ---------------------------------------------------------------------------

compareStages() {

    printf " IDENTICAL\n  sha256: %s\n" "$(sha256sum "$2" | cut -d' ' -f1)"

    return 0

  else

    printf " DIFFERENT\n"

    return 1

# ---------------------------------------------------------------------------

# Copy the fixed-point binary to the seed.

# ---------------------------------------------------------------------------

updateSeed() {

  git rev-parse HEAD > seed/radiance.rv64.git

  printf "\n"

  printf "Fixed point reached at %s\n" "$2"

# For each test:

#   - If a `.ril` file exists alongside it, the IL output is checked

#     against it via the runner binary.

#   - If `//! returns: N` appears in the file, the test is compiled to

#     a binary and executed; the exit code must match N.

RUNNER="test/runner.rv64"

TEST_DIR="test/tests"

EMU="${RAD_EMULATOR:-emulator} -stack-size=1024 -run"

EMU_RUN="${RAD_EMULATOR:-emulator} -no-jit -run"

    *) base="$test" ;;

  esac

  ril="${base}.ril"

  bin="${base}.rv64"

  # IL check: run the runner if a .ril file exists.

  if [ -f "$ril" ]; then

    if $EMU "$RUNNER" -- "$test"; then

      passed=$((passed + 1))

    else

      echo "FAILED (binary not found: $bin)"

      failed=$((failed + 1))

      continue

    fi

    if [ "$actual_rw_data_size" -eq "$rw_data_size" ]; then

      echo "ok"

      passed=$((passed + 1))

    else

constant MAX_ERRORS: u32 = 16;

/// Maximum number of text words in a `.ras` test binary.

constant ASM_TEXT_CAPACITY: u32 = 256;

/// Maximum number of data bytes in a `.ras` test binary.

constant ASM_DATA_CAPACITY: u32 = 1024;

// Static storage for large buffers to avoid stack overflow.

// Tests run serially so sharing these is safe.

static SOURCE_BUF: [u8; SOURCE_BUF_SIZE] = undefined;

static EXPECTED_BUF: [u8; EXPECTED_BUF_SIZE] = undefined;

    set buf[len] = 0;

    return &buf[..len];

}

}

fn assembleBinary(sourcePath: *[u8], outputPath: *[u8]) -> bool {

    let source = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {

        io::printError("error: could not read source: ");

        io::printError(sourcePath);

        io::printError("\n");

        return false;

    };

    let mut arena = alloc::new(&mut AST_ARENA_STORAGE[..]);

    let program = try asm::assemble(

        asm::scanner::SourceKind::File { path: sourcePath },

        source,

        io::printError("error: assembly failed: ");

        io::printError(sourcePath);

        io::printError("\n");

        return false;

    };

    if not writeImage(program.text, program.data, &[], outputPath) {

        io::printError("error: could not write output: ");

        io::printError(outputPath);

        io::printError("\n");

        return false;

    }

    return true;

}

/// Run a single IL snapshot test case. Returns `true` on success.

fn runTest(sourcePath: *[u8]) -> bool {

//! returns: 0

//! Test mutating a static array.

static BUFFER: [i32; 3] = [1, 2, 3];

fn bump(slot: u32, amount: i32) -> i32 {