# Nuke built-in rules and variables.
override MAKEFLAGS += -rR
 
# This is the name that our final kernel executable will have.
# Change as needed.
override KERNEL := kumios
 
# Convenience macro to reliably declare user overridable variables.
define DEFAULT_VAR =
	ifeq ($(origin $1),default)
		override $(1) := $(2)
	endif
	ifeq ($(origin $1),undefined)
		override $(1) := $(2)
	endif
endef
 
# It is suggested to use a custom built cross toolchain to build a kernel.
# We are using the standard "cc" here, it may work by using
# the host system's toolchain, but this is not guaranteed.
override DEFAULT_CC := cc
$(eval $(call DEFAULT_VAR,CC,$(DEFAULT_CC)))
 
# Same thing for "ld" (the linker).
override DEFAULT_LD := ld
$(eval $(call DEFAULT_VAR,LD,$(DEFAULT_LD)))
 
# User controllable C flags.
override DEFAULT_CFLAGS := -g -O2 -pipe
$(eval $(call DEFAULT_VAR,CFLAGS,$(DEFAULT_CFLAGS)))
 
# User controllable C preprocessor flags. We set none by default.
override DEFAULT_CPPFLAGS :=
$(eval $(call DEFAULT_VAR,CPPFLAGS,$(DEFAULT_CPPFLAGS)))
 
# User controllable nasm flags.
override DEFAULT_NASMFLAGS := -F dwarf -g
$(eval $(call DEFAULT_VAR,NASMFLAGS,$(DEFAULT_NASMFLAGS)))
 
# User controllable linker flags. We set none by default.
override DEFAULT_LDFLAGS :=
$(eval $(call DEFAULT_VAR,LDFLAGS,$(DEFAULT_LDFLAGS)))
 
# Internal C flags that should not be changed by the user.
override CFLAGS += \
	-Wall \
	-Wextra \
	-std=gnu11 \
	-ffreestanding \
	-fno-stack-protector \
	-fno-stack-check \
	-fno-lto \
	-fPIE \
	-m64 \
	-march=x86-64 \
	-mno-80387 \
	-mno-mmx \
	-mno-red-zone
 
#-mno-sse \
	-mno-sse2 \	

# Internal C preprocessor flags that should not be changed by the user.
override CPPFLAGS := \
	-I src \
	$(CPPFLAGS) \
	-MMD \
	-MP

# Internal linker flags that should not be changed by the user.
override LDFLAGS += \
	-m elf_x86_64 \
	-nostdlib \
	-static \
	-pie \
	--no-dynamic-linker \
	-z text \
	-z max-page-size=0x1000 \
	-T linker.ld
 
# Internal nasm flags that should not be changed by the user.
override NASMFLAGS += \
	-Wall \
	-f elf64

# Use "find" to glob all *.c, *.S, and *.asm files in the tree and obtain the
# object and header dependency file names.
override CFILES := $(shell cd src && find -L * -type f -name '*.c')
override ASFILES := $(shell cd src && find -L * -type f -name '*.S')
override NASMFILES := $(shell cd src && find -L * -type f -name '*.asm')
override OBJ := $(addprefix obj/,$(CFILES:.c=.c.o) $(ASFILES:.S=.S.o) $(NASMFILES:.asm=.asm.o))
override HEADER_DEPS := $(addprefix obj/,$(CFILES:.c=.c.d) $(ASFILES:.S=.S.d))

## STB

STB_INCLUDE_PATH = vendor/stb
override CFLAGS += -I$(STB_INCLUDE_PATH)

## End STB

# Default target.
.PHONY: all
all: bin/$(KERNEL) iso hdd

# Link rules for the final kernel executable.
bin/$(KERNEL): submodules GNUmakefile linker.ld $(OBJ)
	mkdir -p "$$(dirname $@)"
	$(LD) $(OBJ) $(LDFLAGS) -o $@
 
# Include header dependencies.
-include $(HEADER_DEPS)
 
# Compilation rules for *.c files.
obj/%.c.o: src/%.c GNUmakefile
	mkdir -p "$$(dirname $@)"
	$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@
 
# Compilation rules for *.S files.
obj/%.S.o: src/%.S GNUmakefile
	mkdir -p "$$(dirname $@)"
	$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@
 
# Compilation rules for *.asm (nasm) files.
obj/%.asm.o: src/%.asm GNUmakefile
	mkdir -p "$$(dirname $@)"
	nasm $(NASMFLAGS) $< -o $@
 
# Remove object files and the final executable.
.PHONY: clean
clean:
	rm -rf bin obj iso_root vendor/*

# Initialize and update git submodules.
.PHONY: submodules
submodules:
	git submodule update --init --recursive

# The `limine` target builds the Limine bootloader.
.PHONY: limine
limine: submodules
	$(MAKE) -C vendor/limine

# The `iso` target builds the bootable ISO image using Limine.
.PHONY: iso
iso: bin/$(KERNEL) limine
	# Create the iso_root directory and copy relevant files.
	mkdir -p iso_root
	cp -v bin/$(KERNEL) limine.cfg vendor/limine/limine-bios.sys vendor/limine/limine-bios-cd.bin vendor/limine/limine-uefi-cd.bin iso_root/

	# Create the EFI boot directory and copy EFI executables.
	mkdir -p iso_root/EFI/BOOT
	cp -v vendor/limine/BOOTX64.EFI iso_root/EFI/BOOT/
	cp -v vendor/limine/BOOTIA32.EFI iso_root/EFI/BOOT/

	# Create the bootable ISO.
	xorriso -as mkisofs -b limine-bios-cd.bin -no-emul-boot \
			-boot-load-size 4 -boot-info-table --efi-boot limine-uefi-cd.bin \
			-efi-boot-part --efi-boot-image --protective-msdos-label \
			iso_root -o image.iso

	# Install Limine stage 1 and 2 for legacy BIOS boot.
	./vendor/limine/limine bios-install image.iso

	mv image.iso bin/$(KERNEL).iso

	@echo "Bootable ISO created as bin/$(KERNEL).iso"

# The `hdd` target builds the bootable HDD image using Limine.
.PHONY: hdd
hdd: bin/$(KERNEL) limine
	# Create empty HDD image file.
	dd if=/dev/zero bs=1M count=0 seek=64 of=image.hdd

	# Create GPT partition.
	sgdisk image.hdd -n 1:2048 -t 1:ef00

	# Install Limine BIOS stages.
	./vendor/limine/limine bios-install image.hdd

	# Format the partition to fat32 filesystem.
	mformat -i image.hdd@@1M -F ::

	# Create directory structure in HDD image.
	mmd -i image.hdd@@1M ::/EFI ::/EFI/BOOT

	# Copy kernel and Limine config over to the HDD image.
	mcopy -i image.hdd@@1M bin/$(KERNEL) limine.cfg vendor/limine/limine-bios.sys ::/
	mcopy -i image.hdd@@1M vendor/limine/BOOTX64.EFI ::/EFI/BOOT
	mcopy -i image.hdd@@1M vendor/limine/BOOTIA32.EFI ::/EFI/BOOT

	mv image.hdd bin/$(KERNEL).hdd

	@echo "Bootable HDD image created as bin/$(KERNEL).hdd"