Makefile

CROSS    ?= x86_64-elf

AS       := $(CROSS)-as
GCC      := $(CROSS)-gcc
GCCGO    := $(CROSS)-gccgo
OBJCOPY  := $(CROSS)-objcopy
GCCGOFLAGS := -m64 -mno-sse -mno-sse2 -mno-mmx
GRUB_CFG      := iso/grub/grub.cfg

GRUBMKRESCUE  := grub-mkrescue
QEMU          := qemu-system-x86_64

DOCKER_PLATFORM := linux/amd64
DOCKER_IMAGE    := go-dav-os-toolchain
DOCKER_RUN_FLAGS=-it

BUILD_DIR := build
ISO_DIR   := $(BUILD_DIR)/isodir

KERNEL_ELF := $(BUILD_DIR)/kernel.elf
ISO_IMAGE   := $(BUILD_DIR)/dav-go-os.iso

BOOT_SRCS := $(wildcard boot/*.s)
LINKER_SCRIPT := boot/linker.ld

MODPATH          := github.com/dmarro89/go-dav-os
TERMINAL_IMPORT  := $(MODPATH)/terminal
KEYBOARD_IMPORT  := $(MODPATH)/keyboard
KEYBOARD_LAYOUT_IMPORT := $(MODPATH)/keyboard/layout
SHELL_IMPORT     := $(MODPATH)/shell
AGENT_IMPORT     := $(MODPATH)/agent
MEM_IMPORT     := $(MODPATH)/mem
FS_IMPORT := $(MODPATH)/fs
ATA_IMPORT := $(MODPATH)/drivers/ata
FAT16_IMPORT := $(MODPATH)/fs/fat16
SCHEDULER_IMPORT := $(MODPATH)/kernel/scheduler
GDT_IMPORT := $(MODPATH)/kernel/gdt
TSS_IMPORT := $(MODPATH)/kernel/tss
SYSCALL_IMPORT := $(MODPATH)/kernel/syscall

KERNEL_SRCS := $(filter-out %_test.go %stubs.go, $(wildcard kernel/*.go))
USER_HELLO_SRC := user/hello.s
TERMINAL_SRC := terminal/format.go terminal/terminal.go terminal/terminal_gccgo.go
KEYBOARD_SRCS := $(filter-out %_test.go %stubs.go, $(wildcard keyboard/*.go))
KEYBOARD_LAYOUT_SRCS := $(filter-out %_test.go, $(wildcard keyboard/layout/*.go))
SHELL_SRCS := $(filter-out %_test.go %stubs.go, $(wildcard shell/*.go))
AGENT_SRCS := $(filter-out %_test.go %stubs.go %_host.go %_llm.go, $(wildcard agent/*.go))
MEM_SRCS       := $(filter-out %_test.go %_stub.go %stubs.go, $(wildcard mem/*.go))
FS_SRCS   := $(filter-out %_test.go %stubs.go %_host.go, $(wildcard fs/*.go))
ATA_SRCS  := drivers/ata/ata.go drivers/ata/ata_gccgo.go
FAT16_SRCS := fs/fat16/fat16.go
SCHEDULER_SRCS := $(filter-out %_test.go %_stub.go %stubs.go, $(wildcard kernel/scheduler/*.go))
GDT_SRCS := $(filter-out %_test.go %stubs.go, $(wildcard kernel/gdt/*.go))
TSS_SRCS := $(filter-out %_test.go %stubs.go, $(wildcard kernel/tss/*.go))
SYSCALL_SRCS := $(filter-out %_test.go %stubs.go, $(wildcard kernel/syscall/*.go))
SCH_SWITCH_SRC := asm/switch.s
TEST_PKGS := $(shell find . -name '*_test.go' -not -path './build/*' -exec dirname {} \; | sed 's|^\./|./|' | sort -u)

BOOT_OBJ   := $(BUILD_DIR)/boot.o
USER_HELLO_OBJ := $(BUILD_DIR)/user_hello.o
KERNEL_OBJ := $(BUILD_DIR)/kernel.o
TERMINAL_OBJ := $(BUILD_DIR)/terminal.o
TERMINAL_GOX := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/terminal.gox
KEYBOARD_OBJ   := $(BUILD_DIR)/keyboard.o
KEYBOARD_GOX   := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/keyboard.gox
KEYBOARD_LAYOUT_OBJ := $(BUILD_DIR)/keyboard_layout.o
KEYBOARD_LAYOUT_GOX := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/keyboard/layout.gox
SHELL_OBJ   := $(BUILD_DIR)/shell.o
SHELL_GOX   := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/shell.gox
AGENT_OBJ   := $(BUILD_DIR)/agent.o
AGENT_GOX   := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/agent.gox
MEM_OBJ   := $(BUILD_DIR)/mem.o
MEM_GOX        := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/mem.gox
FS_OBJ    := $(BUILD_DIR)/fs.o
FS_GOX    := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/fs.gox
ATA_OBJ   := $(BUILD_DIR)/ata.o
ATA_GOX   := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/drivers/ata.gox
FAT16_OBJ := $(BUILD_DIR)/fat16.o
FAT16_GOX := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/fs/fat16.gox
SCHEDULER_OBJ := $(BUILD_DIR)/scheduler.o
GDT_OBJ := $(BUILD_DIR)/gdt.o
TSS_OBJ := $(BUILD_DIR)/tss.o
SYSCALL_OBJ := $(BUILD_DIR)/syscall.o
SCH_SWITCH_OBJ := $(BUILD_DIR)/switch.o
SCHEDULER_GOX := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/kernel/scheduler.gox
GDT_GOX := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/kernel/gdt.gox
TSS_GOX := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/kernel/tss.gox
SYSCALL_GOX := $(BUILD_DIR)/github.com/dmarro89/go-dav-os/kernel/syscall.gox

.PHONY: all kernel iso run clean docker-build docker-shell docker-run test

all: $(ISO_IMAGE)

kernel: $(KERNEL_ELF)

iso: $(ISO_IMAGE)

run: $(ISO_IMAGE) disk.img
	$(QEMU) -cdrom $(ISO_IMAGE) -drive file=disk.img,format=raw

disk.img:
	dd if=/dev/zero of=disk.img bs=1M count=20

clean:
	rm -rf $(BUILD_DIR) disk.img

# -----------------------
# Build directory
# -----------------------
$(BUILD_DIR):
	mkdir -p $(BUILD_DIR)

# -----------------------
# Assembly: boot.s -> boot.o
# -----------------------
$(BOOT_OBJ): $(BOOT_SRCS) | $(BUILD_DIR)
	$(AS) $(BOOT_SRCS) -o $(BOOT_OBJ)

$(USER_HELLO_OBJ): $(USER_HELLO_SRC) | $(BUILD_DIR)
	$(AS) $(USER_HELLO_SRC) -o $(USER_HELLO_OBJ)

# --- 2. Compile terminal.go (package terminal) with gccgo ---
$(TERMINAL_OBJ): $(TERMINAL_SRC) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-fgo-pkgpath=$(TERMINAL_IMPORT) \
		-c $(TERMINAL_SRC) -o $(TERMINAL_OBJ)

# --- 3. Extract .go_export into terminal.gox ---
$(TERMINAL_GOX): $(TERMINAL_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(TERMINAL_GOX))
	$(OBJCOPY) -j .go_export $(TERMINAL_OBJ) $(TERMINAL_GOX)

# --- 4. Compile keyboard.go and layout.go (package keyboard) with gccgo ---
$(KEYBOARD_OBJ): $(KEYBOARD_SRCS) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-fgo-pkgpath=$(KEYBOARD_IMPORT) \
		-c $(KEYBOARD_SRCS) -o $(KEYBOARD_OBJ)

# --- 5. Extract .go_export into keyboard.gox ---
$(KEYBOARD_GOX): $(KEYBOARD_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(KEYBOARD_GOX))
	$(OBJCOPY) -j .go_export $(KEYBOARD_OBJ) $(KEYBOARD_GOX)

# --- 5b. Compile keyboard/layout (package layout, depends on keyboard) ---
$(KEYBOARD_LAYOUT_OBJ): $(KEYBOARD_LAYOUT_SRCS) $(KEYBOARD_GOX) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-I $(BUILD_DIR) \
		-fgo-pkgpath=$(KEYBOARD_LAYOUT_IMPORT) \
		-c $(KEYBOARD_LAYOUT_SRCS) -o $(KEYBOARD_LAYOUT_OBJ)

# --- 5c. Extract .go_export into keyboard/layout.gox ---
$(KEYBOARD_LAYOUT_GOX): $(KEYBOARD_LAYOUT_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(KEYBOARD_LAYOUT_GOX))
	$(OBJCOPY) -j .go_export $(KEYBOARD_LAYOUT_OBJ) $(KEYBOARD_LAYOUT_GOX)

$(MEM_OBJ): $(MEM_SRCS) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-fgo-pkgpath=$(MEM_IMPORT) \
		-c $(MEM_SRCS) -o $(MEM_OBJ)

$(MEM_GOX): $(MEM_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(MEM_GOX))
	$(OBJCOPY) -j .go_export $(MEM_OBJ) $(MEM_GOX)

$(ATA_OBJ): $(ATA_SRCS) | $(BUILD_DIR)
	mkdir -p $(dir $(ATA_OBJ))
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-fgo-pkgpath=$(ATA_IMPORT) \
		-c $(ATA_SRCS) -o $(ATA_OBJ)

$(ATA_GOX): $(ATA_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(ATA_GOX))
	$(OBJCOPY) -j .go_export $(ATA_OBJ) $(ATA_GOX)

$(FS_OBJ): $(FS_SRCS) $(MEM_GOX) $(ATA_GOX) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-I $(BUILD_DIR) \
		-fgo-pkgpath=$(FS_IMPORT) \
		-c $(FS_SRCS) -o $(FS_OBJ)

$(FS_GOX): $(FS_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(FS_GOX))
	$(OBJCOPY) -j .go_export $(FS_OBJ) $(FS_GOX)

# --- 6. Compile shell.go (package shell) with gccgo ---
$(AGENT_OBJ): $(AGENT_SRCS) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-fgo-pkgpath=$(AGENT_IMPORT) \
		-c $(AGENT_SRCS) -o $(AGENT_OBJ)

$(AGENT_GOX): $(AGENT_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(AGENT_GOX))
	$(OBJCOPY) -j .go_export $(AGENT_OBJ) $(AGENT_GOX)

$(SHELL_OBJ): $(SHELL_SRCS) $(AGENT_GOX) $(TERMINAL_GOX) $(MEM_GOX) $(FS_GOX) $(ATA_GOX) $(FAT16_GOX) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-I $(BUILD_DIR) \
		-fgo-pkgpath=$(SHELL_IMPORT) \
		-c $(SHELL_SRCS) -o $(SHELL_OBJ)

# --- 7. Extract .go_export into shell.gox ---
$(SHELL_GOX): $(SHELL_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(SHELL_GOX))
	$(OBJCOPY) -j .go_export $(SHELL_OBJ) $(SHELL_GOX)

$(FAT16_OBJ): $(FAT16_SRCS) $(ATA_GOX) $(TERMINAL_GOX) | $(BUILD_DIR)
	mkdir -p $(dir $(FAT16_OBJ))
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-I $(BUILD_DIR) \
		-fgo-pkgpath=$(FAT16_IMPORT) \
		-c $(FAT16_SRCS) -o $(FAT16_OBJ)


$(FAT16_GOX): $(FAT16_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(FAT16_GOX))
	$(OBJCOPY) -j .go_export $(FAT16_OBJ) $(FAT16_GOX)

# --- Scheduler ---
$(SCHEDULER_OBJ): $(SCHEDULER_SRCS) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-fgo-pkgpath=$(SCHEDULER_IMPORT) \
		-c $(SCHEDULER_SRCS) -o $(SCHEDULER_OBJ)

$(SCHEDULER_GOX): $(SCHEDULER_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(SCHEDULER_GOX))
	$(OBJCOPY) -j .go_export $(SCHEDULER_OBJ) $(SCHEDULER_GOX)

$(GDT_OBJ): $(GDT_SRCS) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-fgo-pkgpath=$(GDT_IMPORT) \
		-c $(GDT_SRCS) -o $(GDT_OBJ)

$(GDT_GOX): $(GDT_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(GDT_GOX))
	$(OBJCOPY) -j .go_export $(GDT_OBJ) $(GDT_GOX)

$(TSS_OBJ): $(TSS_SRCS) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-fgo-pkgpath=$(TSS_IMPORT) \
		-c $(TSS_SRCS) -o $(TSS_OBJ)

$(TSS_GOX): $(TSS_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(TSS_GOX))
	$(OBJCOPY) -j .go_export $(TSS_OBJ) $(TSS_GOX)

$(SYSCALL_OBJ): $(SYSCALL_SRCS) $(TERMINAL_GOX) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-I $(BUILD_DIR) \
		-fgo-pkgpath=$(SYSCALL_IMPORT) \
		-c $(SYSCALL_SRCS) -o $(SYSCALL_OBJ)

$(SYSCALL_GOX): $(SYSCALL_OBJ) | $(BUILD_DIR)
	mkdir -p $(dir $(SYSCALL_GOX))
	$(OBJCOPY) -j .go_export $(SYSCALL_OBJ) $(SYSCALL_GOX)

$(SCH_SWITCH_OBJ): $(SCH_SWITCH_SRC) | $(BUILD_DIR)
	$(AS) $(SCH_SWITCH_SRC) -o $(SCH_SWITCH_OBJ)

# --- 8. Compile kernel.go (package kernel, imports "github.com/dmarro89/go-dav-os/terminal") ---
$(KERNEL_OBJ): $(KERNEL_SRCS) $(AGENT_GOX) $(TERMINAL_GOX) $(KEYBOARD_GOX) $(KEYBOARD_LAYOUT_GOX) $(SHELL_GOX) $(MEM_GOX) $(FS_GOX) $(SCHEDULER_GOX) $(GDT_GOX) $(TSS_GOX) $(SYSCALL_GOX) | $(BUILD_DIR)
	$(GCCGO) $(GCCGOFLAGS) -static -Werror -nostdlib -nostartfiles -nodefaultlibs \
		-I $(BUILD_DIR) \
		-c $(KERNEL_SRCS) -o $(KERNEL_OBJ)

# -----------------------
# Link: boot.o + kernel.o -> kernel.elf
# -----------------------
$(KERNEL_ELF): $(BOOT_OBJ) $(USER_HELLO_OBJ) $(TERMINAL_OBJ) $(KEYBOARD_LAYOUT_OBJ) $(KEYBOARD_OBJ) $(SHELL_OBJ) $(AGENT_OBJ) $(MEM_OBJ) $(FS_OBJ) $(ATA_OBJ) $(FAT16_OBJ) $(SCHEDULER_OBJ) $(GDT_OBJ) $(TSS_OBJ) $(SYSCALL_OBJ) $(SCH_SWITCH_OBJ) $(KERNEL_OBJ) $(LINKER_SCRIPT)
	$(GCC) -T $(LINKER_SCRIPT) -o $(KERNEL_ELF) \
		-ffreestanding -O2 -nostdlib \
		$(BOOT_OBJ) $(USER_HELLO_OBJ) $(TERMINAL_OBJ) $(KEYBOARD_LAYOUT_OBJ) $(KEYBOARD_OBJ) $(SHELL_OBJ) $(AGENT_OBJ) $(MEM_OBJ) $(FS_OBJ) $(ATA_OBJ) $(FAT16_OBJ) $(SCHEDULER_OBJ) $(GDT_OBJ) $(TSS_OBJ) $(SYSCALL_OBJ) $(SCH_SWITCH_OBJ) $(KERNEL_OBJ) -lgcc

# -----------------------
# ISO with GRUB
# -----------------------
$(ISO_DIR)/boot/grub:
	mkdir -p $(ISO_DIR)/boot/grub

$(ISO_DIR)/boot/kernel.elf: $(KERNEL_ELF) $(GRUB_CFG) | $(ISO_DIR)/boot/grub
	cp $(KERNEL_ELF) $(ISO_DIR)/boot/kernel.elf
	cp $(GRUB_CFG) $(ISO_DIR)/boot/grub/grub.cfg

$(ISO_IMAGE): $(ISO_DIR)/boot/kernel.elf
	$(GRUBMKRESCUE) -o $(ISO_IMAGE) $(ISO_DIR)

# -----------------------
# Docker helpers
# -----------------------
docker-image:
	docker build --platform=$(DOCKER_PLATFORM) -t $(DOCKER_IMAGE) .

docker-run: docker-image
	docker run ${DOCKER_RUN_FLAGS} --rm --platform=$(DOCKER_PLATFORM) \
	  -v "$(CURDIR)":/work -w /work $(DOCKER_IMAGE) \
	  make run

docker-build-only: docker-image
	docker run --rm --platform=$(DOCKER_PLATFORM) \
	  -v "$(CURDIR)":/work -w /work $(DOCKER_IMAGE) \
	  make

docker-shell: docker-image
	docker run -it --rm --platform=$(DOCKER_PLATFORM) \
	  -v "$(CURDIR)":/work -w /work $(DOCKER_IMAGE) bash

# -----------------------
# Unit tests and vet
# -----------------------
vet:
	mkdir -p $(BUILD_DIR)/.gocache
	GOCACHE=$(CURDIR)/$(BUILD_DIR)/.gocache go vet -tags testing -unsafeptr=false ./...

test:
	mkdir -p $(BUILD_DIR)/.gocache
	GOCACHE=$(CURDIR)/$(BUILD_DIR)/.gocache go test -tags testing $(TEST_PKGS)

# -----------------------
# User hello
# -----------------------
HELLO_ELF := $(BUILD_DIR)/hello.elf
HELLO_BIN := $(BUILD_DIR)/hello.bin

user-hello: $(HELLO_BIN)

$(HELLO_ELF): $(USER_HELLO_OBJ)
	$(GCC) -nostdlib -static -Wl,--build-id=none \
		-Wl,-Ttext=0x400000 -Wl,-e,go_0kernel.userHelloStart -o $(HELLO_ELF) $(USER_HELLO_OBJ)

$(HELLO_BIN): $(HELLO_ELF)
	$(OBJCOPY) -O binary $(HELLO_ELF) $(HELLO_BIN)