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

BIN_TEST_EXE_SRC := $(shell grep -rl '^//! returns:' $(BIN_TEST_DIR))

BIN_TEST_RAD_EXE_SRC := $(filter %.rad,$(BIN_TEST_EXE_SRC))

BIN_TEST_RAS_EXE_SRC := $(filter %.ras,$(BIN_TEST_EXE_SRC))

BIN_TEST_RAD_ASM_SRC := $(wildcard $(BIN_TEST_RAD_EXE_SRC:.rad=.ras))

BIN_TEST_EXE_BIN := $(patsubst %.rad,%.rv64,$(BIN_TEST_RAD_EXE_SRC)) \

	$(patsubst %.ras,%.rv64,$(BIN_TEST_RAS_EXE_SRC))

BIN_RUNNER   := test/runner.rv64

BIN_TEST_RUN := test/run

	@echo "radiance test/runner.rad => $@"

	@$(RADIANCE) $(STD) -pkg runner -mod test/runner.rad -entry runner -o $@

# A `.rad` executable test can have a same-basename `.ras` module.

$(patsubst %.ras,%.rv64,$(BIN_TEST_RAD_ASM_SRC)): %.rv64: %.ras

# Compile each executable test to a binary.

$(BIN_TEST_DIR)/%.rv64: $(BIN_TEST_DIR)/%.rad $(RAD_BIN)

	@echo "radiance $< => $@"

$(BIN_TEST_DIR)/%.rv64: $(BIN_TEST_DIR)/%.ras $(BIN_RUNNER)

	@echo "asm $< => $@"

	@$(EMU) $(EMU_FLAGS) -run $(BIN_RUNNER) -- assemble $< $@

/// Accumulated assembly read-only data.

static ASM_RO_DATA_BUF: [u8; MAX_RO_DATA_SIZE] = undefined;

/// Assembly source file extension.

constant ASM_SOURCE_EXT: *[u8] = ".ras";

/// Usage string.

constant USAGE: *[u8] =

/// Compiler error.

union Error {

    Other,

}

/// Source inputs belonging to one command-line package.

record PackageInput {

    /// Package name from the `-pkg` argument.

    name: *[u8],

    /// Radiance source paths for this package.

    radPaths: [*[u8]; MAX_LOADED_MODULES],

    /// Number of Radiance source paths.

    radPathCount: u32,

    /// Assembly source paths for this package.

/// State carried by the streaming lowerer/codegen callback.

record CodegenSinkContext {

    /// RV64 generator receiving lowered functions.

    generator: *mut rv64::Generator,

    /// Arena holding the current function's lowered IL.

    fnArena: *mut alloc::Arena,

}

/// Entry handling for streamed code generation.

/// Create an empty source input set for one package.

fn packageInput(name: *[u8]) -> PackageInput {

    return PackageInput {

        name,

        radPaths: undefined,

        radPathCount: 0,

        asmPaths: undefined,

        asmPathCount: 0,

    };

                    throw error(&["too many modules specified for package"]);

                }

                set input.radPaths[input.radPathCount] = args[idx];

                set input.radPathCount += 1;

            }

        } else if mem::eq(arg, "-entry") {

            try nextArg(args, &mut idx, &["`-entry` requires a package name"]);

            set entryPkgName = args[idx];

        } else if mem::eq(arg, "-test") {

            set buildTest = true;

        }

        if entryPkgIdx == nil {

            throw error(&["fatal:", "entry package", entryName, "not found"]);

        }

    }

    let graph = module::moduleGraph(&mut MODULE_ENTRIES[..], &mut STRING_POOL, arena);

    let mut ctx = CompileContext {

        packages: undefined,

        inputs,

        packageCount: pkgCount,

        throw error(&["no entry package specified"]);

    };

    return &ctx.packages[entryIdx];

}

/// Get root module info from a package.

fn getRootModule(pkg: *package::Package, graph: *module::ModuleGraph) -> RootModule throws (Error) {

    let rootId = pkg.rootModuleId else {

        throw error(&["no root module found"]);

    };

fn generateLoweredFn(ctxPtr: *mut opaque, func: *il::Fn, role: lower::FnRole) {

    let ctx = ctxPtr as *mut CodegenSinkContext;

    match role {

        case lower::FnRole::Default => {

            match ctx.generator.entryPatch {

                case rv64::EntryPatch::Reserved(_) => {

                    set ctx.generator.entryPatch = rv64::EntryPatch::Reserved(func.name);

                }

            }

        }

        else => {}

    }

    alloc::reset(ctx.fnArena);

}

/// Assemble one `.ras` input and merge it into the active code generator.

///

/// Assemble all inputs collected in the package inputs.

fn assembleAsmInputs(

    ctx: *CompileContext,

    generator: *mut rv64::Generator,

    arena: *mut alloc::Arena

) -> *[u8] throws (Error) {

    for i in 0..ctx.packageCount {

        let input = &ctx.inputs[i];

        for j in 0..input.asmPathCount {

            try assembleAsmModule(

                generator,

                &ctx.packages[i],

                input.asmPaths[j],

                arena

            );

        }

    }

}

/// Lower all packages while streaming each lowered function into RV64 codegen.

fn lowerAndGenerateAllPackages(

    ctx: *mut CompileContext,

        rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug },

        &mut res.arena

    );

    let mut codegenCtx = CodegenSinkContext {

        generator: &mut generator,

        fnArena,

    };

    let mut low = lower::lowerer(

        res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena, options

    );

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

        ctx: &mut codegenCtx as *mut opaque,

        emitFn: generateLoweredFn,

    });

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

    match generator.entryPatch {

        case rv64::EntryPatch::Reserved(targetName) => {

            if targetName == nil {

                throw error(&["fatal:", "no default function found"]);

        return;

    };

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

        logPath: outPath,

        debug: ctx.debug,

    });

    if not writeCode(result.code, outPath) {

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

    }

    // Reclaim unused memory after instruction selection.

    alloc::restore(arena, checkpoint);

}

/// Add the text section of an assembled program to the generator.

///

/// This function snapshots the generator's current code length as the base

/// index, converts each text symbol's byte offset to an instruction index, adds

/// that base, and records the final address for printing. Only `.export` text

            if symbol.isExported {

                emit::recordFuncOffsetAt(&mut generator.e, symbol.name, index);

            }

        }

    }

    for word in program.text {

        emit::emit(&mut generator.e, word);

    }

}

            emit::patch(&mut generator.e, 1, encode::jalr(ZERO, SCRATCH1, s.lo));

        }

        else => {}

    }

    // Patch function calls and address loads now that all functions are emitted.

    emit::patchCalls(&mut generator.e);

    emit::patchAddrLoads(&mut generator.e, &dataSymMap);

    // Emit data sections.

    assert roDataPrefix.len <= roDataBuf.len, "finishProgram: rodata prefix buffer overflow";

    let rwDataSize = data::emitSection(

        globalData, &dataSymMap, &generator.e.labels, codeBase, rwDataBuf, false

    );

    return Program {

        code: emit::getCode(&generator.e),

        roDataSize,

        rwDataSize,

        debugEntries: emit::getDebugEntries(&generator.e),

    };

}

    text: *[u32],

    /// Raw bytes in the data section.

    data: *[u8],

    /// Symbols defined by the source.

    symbols: *[Symbol],

}

/// Errors reported while assembling source text.

export union Error {

    /// Invalid syntax or operand form at a source offset.

    constMap: dict::Dict,

    /// Names marked by `.export`.

    exportMap: dict::Dict,

    /// Pending fixups.

    fixups: *mut [Fixup],

    /// Absolute runtime address of data-section offset zero.

    dataBase: u32,

}

/// Assemble source using `dataBase` as the runtime address of the data-section.

    let slotCap = source.len + SOURCE_CAP_PADDING;

    let tableCap = nextPowerOfTwo(slotCap * TABLE_CAPACITY_SCALE);

    let symbols = try! alloc::allocSlice(arena, @sizeOf(Symbol), @alignOf(Symbol), slotCap);

    let fixups = try! alloc::allocSlice(arena, @sizeOf(Fixup), @alignOf(Fixup), slotCap);

    let entries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);

    let constEntries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);

    let exportEntries = try! alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), tableCap);

    let mut a = Assembler {

        symbols: @sliceOf((symbols as *mut [Symbol]).ptr, 0, (symbols as *mut [Symbol]).len),

        symbolMap: dict::init(entries as *mut [dict::Entry]),

        constMap: dict::init(constEntries as *mut [dict::Entry]),

        exportMap: dict::init(exportEntries as *mut [dict::Entry]),

        fixups: @sliceOf((fixups as *mut [Fixup]).ptr, 0, (fixups as *mut [Fixup]).len),

        dataBase,

    };

    // Parse assembly source and emit instructions.

    try parser::parseProgram(&mut a);

    // Resolve fixups and finalize program.

    return Program {

        text: a.text,

        data: a.data,

        symbols: a.symbols,

    };

}

/// Return the next power of two at least as large as `value`.

fn nextPowerOfTwo(value: u32) -> u32 {

use std::arch::rv64::encode;

use std::arch::rv64;

use std::fmt;

use std::collections::dict;

use std::lang::gen;

/// Define a symbol at the current text or data offset.

export fn defineSymbol(a: *mut super::Assembler, name: *[u8]) {

    let idx = a.symbols.len;

    let offset: i32 = a.data.len as i32

        if a.section == super::Section::Data

        else a.text.len as i32 * rv64::INSTR_SIZE;

        name,

        section: a.section,

        offset,

        isExported: dict::get(&a.exportMap, name) <> nil,

    dict::insert(&mut a.symbolMap, name, idx as i32);

}

/// Append one encoded instruction word to the text section.

export fn emitText(a: *mut super::Assembler, word: u32) throws (super::Error) {

}

/// Append `words` no-op instructions to the text section.

export fn emitTextPadding(a: *mut super::Assembler, words: u32) throws (super::Error) {

    for _ in 0..words {

    }

}

/// Append one byte to the data section.

export fn emitByte(a: *mut super::Assembler, byte: u8) throws (super::Error) {

}

/// Emit a little-endian integer with `bytes` bytes.

fn emitDataInt(a: *mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {

    for i in 0..bytes {

    }

}

/// Record a pending symbol fixup.

fn recordFixup(a: *mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {

}

/// Record a text-section symbol fixup and reserve its instruction words.

export fn recordTextFixup(a: *mut super::Assembler, symbol: *[u8], info: super::FixupInfo, words: u32) throws (super::Error) {

    recordFixup(a, symbol, info);

/// Resolve final symbol references and patch all delayed output.

export fn finishProgram(a: *mut super::Assembler) throws (super::Error) {

    for i in 0..a.fixups.len {

        let fixup = a.fixups[i];

        let symbol = findSymbol(a, fixup.symbol) else {

        };

        match fixup.info {

            case super::FixupInfo::Branch { op, rs1, rs2, index } => {

                if symbol.section <> super::Section::Text {

                    throw super::Error::Invalid { offset: 0, message: "branch target must be in text section" };

fn parseSpaceDirective(a: *mut super::Assembler) throws (super::Error) {

    let count = try parseValue(a);

    if count < 0 {

        throw fail(a, "space size must be non-negative");

    }

        throw super::Error::DataOverflow;

    }

    for _ in 0..count as u32 {

        try emit::emitByte(a, 0);

    }

            let bytes = a.text.len * rv64::INSTR_SIZE as u32;

            let aligned = checkedAlignUp(bytes, amount) else {

                throw super::Error::TextOverflow;

            };

            let words = (aligned - bytes) / rv64::INSTR_SIZE as u32;

            try emit::emitTextPadding(a, words);

        }

        case super::Section::Data => {

            let aligned = checkedAlignUp(a.data.len, amount) else {

                throw super::Error::DataOverflow;

            };

            for _ in a.data.len..aligned {

                try emit::emitByte(a, 0);

            }

        }

    }

    index: u32,

    /// Target function name.

    target: *[u8],

}

/// Address load that needs patching after layout is known.

export record PendingAddrLoad {

    /// Index in code buffer where the load was emitted.

    index: u32,

    /// Target function or data symbol name.

    offset: i32,

}

/// Emission context. Tracks state during code generation.

export record Emitter {

    /// Emitted instructions storage.

    code: *mut [u32],

    /// Current number of emitted instructions.

    codeLen: u32,

    /// Local branches needing offset patching.

    pendingBranches: *mut [PendingBranch],

    /// Function calls needing offset patching.

    pendingCalls: *mut [PendingCall],

    /// Function address loads needing offset patching.

    pendingAddrLoads: *mut [PendingAddrLoad],

    /// Block label tracking.

    labels: labels::Labels,

    /// Function start positions for printing.

    funcs: *mut [types::FuncAddr],

    /// Debug entries mapping PCs to source locations.

    debugEntries: *mut [types::DebugEntry],

    /// Number of debug entries recorded.

    debugEntriesLen: u32,

}

/// Create a new emitter.

export fn emitter(arena: *mut alloc::Arena, debug: bool) -> Emitter throws (alloc::AllocError) {

    let code = try alloc::allocSlice(arena, @sizeOf(u32), @alignOf(u32), MAX_INSTRS);

    let pendingBranches = try alloc::allocSlice(arena, @sizeOf(PendingBranch), @alignOf(PendingBranch), MAX_PENDING);

    let pendingCalls = try alloc::allocSlice(arena, @sizeOf(PendingCall), @alignOf(PendingCall), MAX_PENDING);

    let pendingAddrLoads = try alloc::allocSlice(arena, @sizeOf(PendingAddrLoad), @alignOf(PendingAddrLoad), MAX_PENDING);

    let blockOffsets = try alloc::allocSlice(arena, @sizeOf(i32), @alignOf(i32), labels::MAX_BLOCKS_PER_FN);

    let funcEntries = try alloc::allocSlice(arena, @sizeOf(dict::Entry), @alignOf(dict::Entry), labels::FUNC_TABLE_SIZE);

    let funcs = try alloc::allocSlice(arena, @sizeOf(types::FuncAddr), @alignOf(types::FuncAddr), MAX_FUNCS);

        set debugEntries = try alloc::allocSlice(

            arena, @sizeOf(types::DebugEntry), @alignOf(types::DebugEntry), MAX_DEBUG_ENTRIES

        ) as *mut [types::DebugEntry];

    }

    return Emitter {

        code: code as *mut [u32],

        codeLen: 0,

        labels: labels::init(blockOffsets as *mut [i32], funcEntries as *mut [dict::Entry]),

        debugEntries,

        debugEntriesLen: 0,

    };

}

    recordFuncAt(e, name, e.codeLen);

}

/// Record a function's start position at `index` for printing.

export fn recordFuncAt(e: *mut Emitter, name: *[u8], index: u32) {

}

/// Record a local branch needing later patching.

/// Unconditional jumps use a single slot (J-type, +-1MB range).

/// Conditional branches use two slots (B-type has only +-4KB range,

/// so large functions may need the inverted-branch + JAL fallback).

export fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {

        index: e.codeLen,

        target: targetBlock,

        kind: kind,

    emit(e, encode::nop()); // First slot, always needed.

    match kind {

        case BranchKind::Jump => {},

/// Record a function call needing later patching.

/// Emits placeholder instructions that will be patched later.

/// Uses two slots to support long-distance calls.

export fn recordCall(e: *mut Emitter, target: *[u8]) {

        index: e.codeLen,

        target,

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

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

}

/// 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) {

        index: e.codeLen,

        target,

        rd: rd,

        isData: false,

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

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

}

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

/// Uses an absolute 32-bit load sequence matching the current data memory map.

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

        index: e.codeLen,

        target,

        rd: rd,

        isData: true,

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

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

}

/// Called after each function.

///

/// Uses two-instruction sequences: short branches use `branch` and `nop`,

/// long branches use inverted branch  and `jal` or `auipc` and `jalr`.

export fn patchLocalBranches(e: *mut Emitter) {

        let p = e.pendingBranches[i];

        let offset = labels::branchToBlock(&e.labels, p.index, p.target, super::INSTR_SIZE);

        match p.kind {

            case BranchKind::Cond { op, rs1, rs2 } => {

                if encode::isBranchImm(offset) {

                assert encode::isJumpImm(offset), "patchLocalBranches: jump offset too large";

                patch(e, p.index, encode::jal(super::ZERO, offset));

            },

        }

    }

}

/// Encode a conditional branch instruction.

fn encodeCondBranch(op: il::CmpOp, rs1: gen::Reg, rs2: gen::Reg, offset: i32) -> u32 {

    match op {

}

/// Patch all pending function calls.

/// Called after all functions have been generated.

export fn patchCalls(e: *mut Emitter) {

        let p = e.pendingCalls[i];

        let offset = branchOffsetToFunc(e, p.index, p.target);

        let s = splitImm(offset);

        // `AUIPC scratch, hi(offset)`.

        // `JALR ra, scratch, lo(offset)`.

        patch(e, p.index + 1, encode::jalr(super::RA, super::SCRATCH1, s.lo));

    }

}

/// Patch all pending function and data address loads.

/// Called after all functions have been generated and data layout is known.

export fn patchAddrLoads(e: *mut Emitter, dataSymMap: *data::DataSymMap) {

        let p = e.pendingAddrLoads[i];

        if p.isData {

            let addr = data::lookupAddr(dataSymMap, p.target) else {

                panic "patchAddrLoads: data symbol not found";

            };

/// Get emitted code as a slice.

export fn getCode(e: *Emitter) -> *[u32] {

    return &e.code[..e.codeLen];

}

/// Record a debug entry mapping the current PC to a source location.

/// Deduplicates consecutive entries with the same location.

export fn recordSrcLoc(e: *mut Emitter, loc: il::SrcLoc) {

    let pc = e.codeLen * super::INSTR_SIZE as u32;

        super::ProgramOptions { entryPatch: super::EntryPatch::None, debug: false },

        &mut arena

    );

    super::addAssembly(

        &mut generator,

    );

    try testing::expect(dict::get(&generator.e.labels.funcs, "local") == nil);

    let exportedOffset = dict::get(&generator.e.labels.funcs, "exported") else {

        throw testing::TestError::Failed;

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

        io::printError(sourcePath);

        io::printError("\n");

        return false;

    };

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

        io::printError(outputPath);

        io::printError("\n");

        return false;

    }