# Radiance build file.

# Core standard library modules.

STD := -pkg std $(patsubst %,-mod %,$(shell cat std.lib))

# Session allocation support for standalone lowering fixtures.

TEST_FIXTURE_STD_LIB := $(shell cat test/support/std.lib)

TEST_FIXTURE_STD := -pkg std $(patsubst %,-mod %,$(TEST_FIXTURE_STD_LIB))

# Test modules are partitioned so each native image fits the emulator.

STD_TEST_MODULES := $(shell cat std.lib.test)

STD_TEST_SUPPORT := lib/std/testing.rad

# Resolver tests use parser test helpers.

STD_TEST_FRONTEND := $(filter lib/std/lang/parser/% lib/std/lang/resolver/%,$(STD_TEST_MODULES))

STD_TEST_CORE := $(filter-out $(STD_TEST_SUPPORT) $(STD_TEST_FRONTEND),$(STD_TEST_MODULES))

STD_TEST = $(STD) $(patsubst %,-mod %,$(STD_TEST_SUPPORT) $(STD_TEST_SOURCES))

# Source files.

STD_LIB := $(shell find lib -name '*.rad')

BIN_DIR := bin

RAD_BIN := $(BIN_DIR)/radiance.rv64.dev

# Emulator command used to invoke the self-hosted compiler.

EMU       := $(or $(RAD_EMULATOR),emulator)

EMU_FLAGS := -memory-size=385024 \

			 -data-size=348160 \

			 -stack-size=512 \

			 -count-instructions

RADIANCE  := $(EMU) $(EMU_FLAGS) -run $(RAD_BIN)

# Verify the emulator binary exists.

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

default: emulator $(RAD_BIN)

test: emulator seed-test std-test bin-test driver-test

seed-test:

	@seed/test

# Emulator command check

emulator:

ifeq ($(EMU_PATH),)

	$(error Emulator not found. Install it or set RAD_EMULATOR to its path)

endif

# Compiler build

SEED      := seed/radiance.rv64

COMPILER_SRC := compiler/radiance.rad compiler/radiance/codegen.rad

SEED_OPTS := $(STD) -pkg radiance $(patsubst %,-mod %,$(COMPILER_SRC)) -entry radiance

$(RAD_BIN): $(STD_LIB) $(COMPILER_SRC) std.lib | $(BIN_DIR)

	@echo "radiance $(SEED) => $@"

	@$(EMU) $(EMU_FLAGS) -run $(SEED) $(SEED_OPTS) -o $@

$(BIN_DIR):

	@mkdir -p $@

# Standard Library Tests

STD_LIB_TEST := lib/std.core.test.rv64 lib/std.frontend.test.rv64

lib/std.core.test.rv64: STD_TEST_SOURCES := $(STD_TEST_CORE)

lib/std.frontend.test.rv64: STD_TEST_SOURCES := $(STD_TEST_FRONTEND)

std-test: $(STD_LIB_TEST)

	@echo

	@set -e; for image in $(STD_LIB_TEST); do \

		$(EMU) $(EMU_FLAGS) -run $$image; \

	done

$(STD_LIB_TEST): $(STD_LIB) $(RAD_BIN) std.lib std.lib.test Makefile

	@echo "radiance -test $(STD_TEST) -entry std -o $@"

	@$(RADIANCE) -test $(STD_TEST) -entry std -o $@

clean-std-test:

	@rm -f $(STD_LIB_TEST) \

		$(addsuffix .debug,$(STD_LIB_TEST)) \

		$(addsuffix .s,$(STD_LIB_TEST)) \

		$(addsuffix .o,$(STD_LIB_TEST))

# Binary Tests

# Driver fixtures exercise argument parsing and test discovery.

driver-test: $(RAD_BIN)

	@RAD_EMULATOR="$(EMU)" RAD_BIN="$(RAD_BIN)" test/command

	@RAD_EMULATOR="$(EMU)" RAD_BIN="$(RAD_BIN)" test/driver

driver-command: $(RAD_BIN)

	@$(RADIANCE) $(DRIVER_ARGUMENTS)

driver-test-image: $(RAD_BIN)

	@$(RADIANCE) -test $(STD) -mod lib/std/testing.rad $(DRIVER_TEST_INPUTS) $(DRIVER_TEST_FLAGS) \

		-entry selected -o $(DRIVER_TEST_OUTPUT)

BIN_TEST_DIR := test/tests

# 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_RAD_START_SRC := $(wildcard $(BIN_TEST_RAD_EXE_SRC:.rad=.start.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

bin-test: $(BIN_RUNNER) $(BIN_TEST_EXE_BIN)

	@echo

	@RAD_BIN="$(RAD_BIN)" $(BIN_TEST_RUN)

# Runner binary: the lowering IL checker.

$(BIN_RUNNER): test/runner.rad $(STD_LIB) $(RAD_BIN)

	@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

$(patsubst %.start.ras,%.rv64,$(BIN_TEST_RAD_START_SRC)): %.rv64: %.start.ras

# Package fixtures can request session support.

BIN_TEST_SESSION_SRC := $(shell grep -l '^//! session-support$$' $(BIN_TEST_RAD_EXE_SRC))

$(BIN_TEST_SESSION_SRC:.rad=.rv64): TEST_STD_FLAGS := $(TEST_FIXTURE_STD)

$(BIN_TEST_SESSION_SRC:.rad=.rv64): TEST_ENTRY_FLAGS := -entry test

$(BIN_TEST_SESSION_SRC:.rad=.rv64): $(TEST_FIXTURE_STD_LIB) test/support/std.lib

# Compile each executable test to a binary.

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

	@echo "radiance $< => $@"

	@$(RADIANCE) $(TEST_STD_FLAGS) -pkg test -mod $< $(TEST_ENTRY_FLAGS) $(patsubst %,-mod %,$(wildcard $(@:.rv64=)/*.rad)) $(patsubst %,-start %,$(wildcard $(@:.rv64=.start.ras))) $(patsubst %,-mod %,$(wildcard $(@:.rv64=.ras))) -o $@

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

	@echo "asm $< => $@"

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

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) \

		$(wildcard $(BIN_TEST_DIR)/*.rv64.s)

seed:

	seed/update

clean-rad:

	rm -rf bin/*

	rm -f seed/radiance.rv64.s[0-9]*

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

t: test

c: clean

.PHONY: test clean default seed-test std-test bin-test seed \

	clean-std-test clean-bin-test clean-rad emulator driver-test driver-test-image driver-command

.SUFFIXES:

.DELETE_ON_ERROR:

.SILENT: