Lowlevel
Lowlevel => Lowlevel-Coding => Thema gestartet von: ehenkes am 19. June 2009, 17:02
-
Ich habe folgendes makefile, das bestens funktioniert. Ich möchte die Umsetzung c --> o gerne weiter vereinfachen, aber möglichst "leserlich". Habe leider im Internet keine brauchbare Vorlage gefunden:
# Makefile for PrettyOS
ASFLAGS= -O32 -f coff
TARGET= ckernel.bin
OBJ= kernel.o ckernel.o isr.o video.o flush.o gdt.o \
idt.o isrs.o irq.o util.o math.o timer.o keyboard.o \
process.o ordered_array.o paging.o kheap.o descriptor_tables.o \
task.o fs.o initrd.o syscall.o
LDFLAGS= -T kernel.ld -Map kernel.map
LD= ld
CFLAGS= -Wall -O
CC= gcc
all:
nasmw -f bin file_data.asm -o file_data.dat
nasmw -O32 -f bin boot.asm -o boot.bin
nasmw $(ASFLAGS) kernel.asm -o kernel.o
nasmw $(ASFLAGS) isr.asm -o isr.o
nasmw $(ASFLAGS) process.asm -o process.o
nasmw $(ASFLAGS) flush.asm -o flush.o
make compile
make link
make image
compile:
$(CC) $(CFLAGS) -c ckernel.c -o ckernel.o
$(CC) $(CFLAGS) -c video.c -o video.o -O1
$(CC) $(CFLAGS) -c math.c -o math.o -O1
$(CC) -O -c util.c -o util.o -O1
$(CC) $(CFLAGS) -c gdt.c -o gdt.o
$(CC) $(CFLAGS) -c idt.c -o idt.o
$(CC) $(CFLAGS) -c isrs.c -o isrs.o
$(CC) $(CFLAGS) -c irq.c -o irq.o
$(CC) $(CFLAGS) -c timer.c -o timer.o
$(CC) $(CFLAGS) -c keyboard.c -o keyboard.o
$(CC) $(CFLAGS) -c ordered_array.c -o ordered_array.o
$(CC) $(CFLAGS) -c paging.c -o paging.o
$(CC) $(CFLAGS) -c kheap.c -o kheap.o
$(CC) $(CFLAGS) -c descriptor_tables.c -o descriptor_tables.o
$(CC) $(CFLAGS) -c task.c -o task.o
$(CC) $(CFLAGS) -c fs.c -o fs.o
$(CC) $(CFLAGS) -c initrd.c -o initrd.o
$(CC) $(CFLAGS) -c syscall.c -o syscall.o
link:
$(LD) $(LDFLAGS) -o $(TARGET) $(OBJ)
image:
cmd /c copy /b boot.bin + ckernel.bin MyOS
del *.coff
del *.o
del *.bin
cmd /c rename MyOS MyOS.bin
del MyOS
partcopy MyOS.bin 0 7000 -f0
So etws wie
c.o.:
$(CC) -c $(CFLAGS) -o $@ $<
hatte ich schon anhängen, wusste dann aber nicht, wie ich das zum Laufen bekomme.
Ich hätte wegen der Verständlichkeit gerne so etwas in der Art wie:
compile:
??? #Idee: $(CC) $(CFLAGS) -c $(SOURCES) -o $(OBJECTS)
Please help.
-
Ich hab deine Version 36y damals mit folgendem Makefile gebaut:
# zu den Dateien, die direkt in den Kernel gelinkt werden, gehören
# alle *.asm- und *.c-Dateien außer file_data.asm boot.asm und make_initrd.c
# Außerdem wird kernel.asm noch an den Anfang der Liste gesetzt, weil irgendwas an deinem OS komisch war
SRCS = kernel.asm $(filter-out file_data.asm boot.asm kernel.asm make_initrd.c,$(wildcard *.asm *.c))
# von den Namen der Dateien die Endung entfernen und mit .o ersetzen
OBJS = $(addsuffix .o,$(basename $(SRCS)))
# Per default boot.bin und ckernel.bin bauen
all: boot.bin ckernel.bin
# process.asm braucht file_data.dat und file_data.da1
process.asm: file_data.dat file_data.da1
# file_data.dat wird aus fila_data.asm erstellt
file_data.dat: file_data.asm
nasm -f bin $< -o $@
# boot.bin wird aus boot.asm erstellt
boot.bin: boot.asm
nasm -f bin $< -o $@
# alle anderen Assemblerdateien werden mit dieser Regel erfasst
%.o: %.asm
nasm -f elf $< -o $@
# der Kernel benötigt alle Objekt-Dateien
ckernel.bin: $(OBJS)
ld -T kernel.ld $+ -o $@ -Map kernel.map
# Standardregel, um alle Objekt-Dateien mit "make clean" zu löschen
phony: .clean
clean:
rm -f *.o
rm -f *.bin
rm -f MyOS
Wenn dir das Konstrukt mit SRCS/OBJS zu kompliziert ist, dann kannste das natürlich durch OBJ = kernel.o ckernel.o isr.o ... ersetzen.
Das meiste wird im Manual (http://www.gnu.org/software/make/manual/make.html) in den Kapiteln 2-4 erklärt. Da kannste dir ja zumindest mal einen Überblick verschaffen.
Den Code für ein Image hatte ich damals glaub ich rausgenommen, weil ich kein partcopy habe. Aber im Prinzip kannst du all abhängig von image machen, und image dann ckernel.bin und boot.bin. In den Anweisungen für image baust du dann das Image.
-
Alles, was in den impliziten Regeln definiert ist. Was das ist, steht glaub ich (zumindest teilweise) im Manual, oder du lässt es dir anzeigen mit make -d.
Das ist ne ganze Menge, aber dazwischen sollten folgende Definitionen sein:
OUTPUT_OPTION = -o $@
...
COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
...
.c.o:
$(COMPILE.c) $(OUTPUT_OPTION) $<
Natürlich kannst du das auch von Hand nachbauen.