Bootloader Manager con Makefile Avanzado

Este proyecto incluye un código avanzado para manejar múltiples arquitecturas en un bootloader manager, junto con un Makefile modular para ensamblar y enlazar automáticamente según la arquitectura seleccionada.

Código fuente avanzado: bootloaderManager.asm

%ifdef ARCH_x86
    %include "bootloader_x86.asm"
%elif ARCH_x64
    %include "bootloader_x64.asm"
%elif ARCH_riscv
    %include "bootloader_riscv.asm"
%elif ARCH_arm
    %include "bootloader_arm.asm"
%else
    %error "Arquitectura no soportada. Define ARCH_x86, ARCH_x64, ARCH_riscv o ARCH_arm."
%endif
    

Componentes individuales de los bootloaders

1. bootloader_x86.asm

section .text
global _start

_start:
    cli                     ; Desactiva interrupciones
    mov ax, 0x0             ; Limpia el registro AX
    mov ds, ax              ; Configura el segmento de datos
    mov es, ax              ; Configura el segmento adicional
    mov sp, 0x7C00          ; Configura el stack
    jmp $                   ; Ciclo infinito (completar con lógica)
    

2. bootloader_x64.asm

section .text
global _start

_start:
    cli                     ; Desactiva interrupciones
    mov ax, 0x10            ; Segmento de datos (x64)
    mov ds, ax              ; Configuración del segmento
    mov es, ax              ; Configuración adicional
    mov rsp, 0x7C00         ; Configura el stack
    jmp $                   ; Ciclo infinito (completar con lógica)
    

3. bootloader_riscv.asm

.section .text
.global _start

_start:
    la sp, 0x200000         # Configura el stack (RISC-V)
    j main                  # Salta a la lógica principal

main:
    j .                     # Ciclo infinito (completar con lógica)
    

4. bootloader_arm.asm

.syntax unified
.cpu cortex-m3
.thumb

.section .text
.global _start

_start:
    ldr sp, =0x200000       @ Configura el stack (ARM)
    b main                  @ Salta a la lógica principal

main:
    b .                     @ Ciclo infinito (completar con lógica)
    

Makefile avanzado

# Herramientas y configuraciones
ASM=nasm
ARM_ASM=arm-none-eabi-as
RISC_ASM=riscv64-unknown-elf-as
LD=ld
LD_FLAGS_COMMON=--oformat binary -Ttext 0x7C00

# Detectar la arquitectura
ARCH ?= x86

ifeq ($(ARCH), x86)
    ASM_FLAGS=-f elf32
    MANAGER_SRC=bootloaderManager.asm
    ARCH_DEFINE=ARCH_x86
    OUTPUT=bootloader_x86.bin
    LD_FLAGS=$(LD_FLAGS_COMMON) -m elf_i386
else ifeq ($(ARCH), x64)
    ASM_FLAGS=-f elf64
    MANAGER_SRC=bootloaderManager.asm
    ARCH_DEFINE=ARCH_x64
    OUTPUT=bootloader_x64.bin
    LD_FLAGS=$(LD_FLAGS_COMMON) -m elf_x86_64
else ifeq ($(ARCH), riscv)
    ASM=$(RISC_ASM)
    MANAGER_SRC=bootloaderManager.asm
    ARCH_DEFINE=ARCH_riscv
    OUTPUT=bootloader_riscv.bin
    LD_FLAGS=$(LD_FLAGS_COMMON)
else ifeq ($(ARCH), arm)
    ASM=$(ARM_ASM)
    MANAGER_SRC=bootloaderManager.asm
    ARCH_DEFINE=ARCH_arm
    OUTPUT=bootloader_arm.bin
    LD_FLAGS=$(LD_FLAGS_COMMON)
else
    $(error "Arquitectura desconocida: $(ARCH). Usa x86, x64, riscv o arm.")
endif

# Marcamos los objetivos como phony
.PHONY: all clean

# Objetivo principal
all: $(OUTPUT)

# Regla general para ensamblar y enlazar
$(OUTPUT):
    $(ASM) $(ASM_FLAGS) -D$(ARCH_DEFINE) -o bootloaderManager.o $(MANAGER_SRC)
    $(LD) $(LD_FLAGS) -e _start -o $(OUTPUT) bootloaderManager.o

# Limpieza
clean:
    rm -f *.o *.bin
    

Cómo compilar el proyecto

Sigue los pasos a continuación:

1. Seleccionar arquitectura y compilar:

# Para x86:
make ARCH=x86

# Para x64:
make ARCH=x64

# Para ARM:
make ARCH=arm

# Para RISC-V:
make ARCH=riscv
    

2. Limpiar archivos generados:

make clean