Thema: makefile vereinfachen

[ehenkes]

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:

Code: [Auswählen]

# 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

Code: [Auswählen]

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:

Code: [Auswählen]

compile:
??? #Idee: $(CC) $(CFLAGS) -c $(SOURCES) -o $(OBJECTS)
Please help.

[Jidder]

Ich hab deine Version 36y damals mit folgendem Makefile gebaut:

Code: [Auswählen]

# 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 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.

[Jidder]

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.