Makefile avanzado para Etapa 1 - bootloader

Makefile Avanzado para Etapa 1 (Integración Completa)

Makefile

# Variables
TARGET_BIN = stage1.bin
TARGET_IMG = stage1.img
TARGET_ELF = stage1.elf
AS = nasm
LD = ld
OBJCOPY = objcopy
CPU_ARCHS = arm riscv x86 x64   # Todas las arquitecturas soportadas

# Carpeta raíz de los módulos
MODULES_DIR = modules
BIN_DIR = bin
IMG_DIR = img

# Archivos fuente específicos de cada plataforma
ARM_SOURCES = bootloader_arm/bootloader_arm.asm bootloader_arm/uart_arm.asm bootloader_arm/gpio_arm.asm
RISCV_SOURCES = bootloader_riscv/bootloader_riscv.asm bootloader_riscv/uart_riscv.asm bootloader_riscv/gpio_riscv.asm
X86_SOURCES = bootloader_x86/bootloader_x86.asm bootloader_x86/uart_x86.asm bootloader_x86/gpio_x86.asm
X64_SOURCES = bootloader_x64/bootloader_x64.asm bootloader_x64/uart_x64.asm bootloader_x64/gpio_x64.asm

# Archivos reutilizables para detección de entorno y arquitectura
MODULES = $(MODULES_DIR)/BIOS_Support.asm \
          $(MODULES_DIR)/UEFI_Support.asm \
          $(MODULES_DIR)/detect_environment.asm \
          $(MODULES_DIR)/detect_architecture.asm

# Regla principal
all: $(TARGET_BIN) $(TARGET_IMG)

# Compilación y enlace para generar el ELF
$(TARGET_ELF): $(ARM_SOURCES) $(RISCV_SOURCES) $(X86_SOURCES) $(X64_SOURCES) $(MODULES)
    @echo "Compilando y enlazando todas las plataformas en un ELF único..."
    $(AS) -f elf64 -o bootloader_arm.o bootloader_arm/bootloader_arm.asm
    $(AS) -f elf64 -o bootloader_riscv.o bootloader_riscv/bootloader_riscv.asm
    $(AS) -f elf64 -o bootloader_x86.o bootloader_x86/bootloader_x86.asm
    $(AS) -f elf64 -o bootloader_x64.o bootloader_x64/bootloader_x64.asm
    $(AS) -f elf64 -o detect_environment.o $(MODULES_DIR)/detect_environment.asm
    $(AS) -f elf64 -o detect_architecture.o $(MODULES_DIR)/detect_architecture.asm
    $(LD) -m elf_x86_64 -Ttext=0x7C00 -o $@ bootloader_arm.o bootloader_riscv.o bootloader_x86.o bootloader_x64.o detect_environment.o detect_architecture.o

# Generar binario a partir del ELF
$(TARGET_BIN): $(TARGET_ELF)
    @echo "Creando binario..."
    $(OBJCOPY) -O binary $(TARGET_ELF) $(BIN_DIR)/$@

# Crear imagen para disco
$(TARGET_IMG): $(TARGET_BIN)
    @echo "Creando imagen disco a partir del binario..."
    dd if=$(BIN_DIR)/$(TARGET_BIN) of=$(IMG_DIR)/$(TARGET_IMG) bs=512 count=1 status=none
    @echo "Imagen creada en $(IMG_DIR)/$(TARGET_IMG)"

# Limpiar archivos generados
clean:
    @echo "Limpiando archivos..."
    rm -f *.o $(TARGET_ELF) $(BIN_DIR)/* $(IMG_DIR)/*

.PHONY: all clean
            

Comandos para Pruebas en QEMU

• Ejecutar el binario (stage1.bin):

  qemu-system-x86_64 -drive file=bin/stage1.bin,format=raw

• Probar la imagen (stage1.img):

  qemu-system-x86_64 -drive file=img/stage1.img,format=raw

• Depurar con QEMU:

  qemu-system-x86_64 -drive file=img/stage1.img,format=raw -d int,cpu_reset -no-reboot

 Probar en Diferentes Arquitecturas

Para x86:

qemu-system-i386 -drive file=bin/stage1.bin,format=raw

Para ARM:

qemu-system-arm -M versatilepb -kernel bin/bootloader_arm.bin

Para RISC-V: 

qemu-system-riscv64 -machine virt -kernel bin/bootloader_riscv.bin

Monitorear la Salida UART

qemu-system-x86_64 -drive file=img/stage1.img,format=raw -d int,cpu_reset -no-reboot

Agregar Opciones de Depuración 

qemu-system-x86_64 -drive file=bin/stage1.bin,format=raw -serial stdio

 

Resultados Esperados

1. El stage1.bin debería cargar y ejecutar correctamente en las plataformas soportadas.
2. En QEMU, podrías observar mensajes de inicialización de UART, GPIO, y detección de hardware.
3. La imagen stage1.img será una réplica del contenido del binario, lista para probar en discos virtuales o hardware real.

Con este Makefile y las pruebas, tienes un entorno funcional para la Etapa 1 con soporte multiplataforma.