RE: [avr-gcc-list] Make file to recursivly generate code for more than one target ?

[Anton Erasmus]

Hi,

For anyone interested here is my current modification of the example makefile 
that comes
with WinAVR to handle sub directories containing code for libraries, as well as 
the generatation
of a named target.
one can do
make btgt2 MCU=atmega16
This will define BUILDTGT2 and change the target filename by adding
btgt2_atmega16_ to each output file name (.o and .lst files)
The current makefile handles 4 named targets.
When I get some more time I will try and enhance the makefile to
recursivly build the named target for a list of MCUs. i.e. so that one
can have MCU=atmega16 atmega8, which will build everything for both
the atmega16 and atmega8.

Regards
  Anton Erasmus

# WinAVR Sample makefile written by Eric B. Weddington, et al.
# Released to the Public Domain
# Please read the make user manual!
#
#
# On command line:
# make all = Make software.
# make clean = Clean out built project files.
# make coff = Convert ELF to COFF using objtool.
#
# To rebuild project do "make clean" then "make all".
#
# Updated AJ Erasmus to compile libraries is subdirectories and
# link in these libraries. if the subdir is foo, then the makefile
# in directory foo should generate foo.a.
# Add specific named targets compiled from the same source tree.
# Update generated file names based on MCU chosen.

# MCU name, can be overidden command line option e.g. make MCU=atmega16
MCU = atmega32

# Output format. (can be srec, ihex)
FORMAT = srec


# Optimization level (can be 0, 1, 2, 3, s)
# (Note: 3 is not always the best optimization level. See avr-libc FAQ)
OPT = s


# List C source files here. (C dependencies are automatically generated.)
SRC = isohc.c \
      version.c ad5312.c eep_parm.c teg.c avratod.c hcdata.c \
      lufunct.c lutable.c

# List Assembler source files here.
# Make them always end in a capital .S.  Files ending in a lowercase .s
# will not be considered source files but generated files (assembler
# output from the compiler), and will be deleted upon "make clean"!
# Even though the DOS/Win* filesystem matches both .s and .S the same,
# it will preserve the spelling of the filenames, and gcc itself does
# care about how the name is spelled on its command-line.
ASRC =


# List subdirectories in which to run make here
# Make will be run in each before running compiling here
SUBDIRS = subdir1 subdir2


# Generate Library filenames from directory names
# if SUBDIRS = foo bar  and MCU = atmega32
# then
#  SUBLIBS = foo/foo_atmega32.a bar/bar_atmega32.a
SUBLIBS := $(foreach dir,$(SUBDIRS),$(dir)/$(dir)_$(MCU).a)

# Optional compiler flags.
CFLAGS =  -O$(OPT) -funsigned-char -funsigned-bitfields -fpack-struct \
-fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=$(<:.c=_$(TARGET).lst)

# Optional assembler flags.
ASFLAGS = -Wa,-ahlms=$(<:.S=.lst),-gstabs

# Optional linker flags.
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref

# Additional libraries
#
# Minimalistic printf version
#LDFLAGS += -Wl,-u,vfprintf -lprintf_min
#
# Floating point printf version (requires -lm below)
#LDFLAGS +=  -Wl,-u,vfprintf -lprintf_flt
#
# -lm = math library
#LDFLAGS += -lm



# ---------------------------------------------------------------------------

# Define directories, if needed.
DIRAVR = c:/winavr
DIRAVRBIN = $(DIRAVR)/bin
DIRAVRUTILS = $(DIRAVR)/utils/bin
DIRINC = .
DIRLIB = $(DIRAVR)/avr/lib


# Define programs and commands.
SHELL = sh

CC = avr-gcc

OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump

REMOVE = rm -f
COPY = cp

ELFCOFF = objtool

HEXSIZE = avr-size --target=$(FORMAT) $(TARGET).rom
ELFSIZE = avr-size $(TARGET).elf

FINISH = echo Errors: none
BEGIN = echo -------- begin --------
END = echo --------  end  -------- Created $(TARGET)
INSTRUCT = echo Use make <target> (target=btgt4, btgt1, btgt2, btgt3)



# Define all object files.
OBJ = $(SRC:.c=_$(TARGET).o) $(ASRC:.S=_$(TARGET).o)

# Define all listing files.
LST = $(ASRC:.S=_$(TARGET).lst) $(SRC:.c=_$(TARGET).lst)

# Combine all necessary flags and optional flags. Add target processor to flags.
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)

# Add extra command line define for different targets
# One must now do make btgt1
ifeq ($(MAKECMDGOALS),btgt1)
EXTDEF = BUILDTGT1
ALL_CFLAGS = -D $(EXTDEF) -mmcu=$(MCU) -I. $(CFLAGS)
TARGET = $(join btgt1_,$(MCU))
endif

# Generate Code for BUILDTGT1 Target
btgt1: all

ifeq ($(MAKECMDGOALS),btgt2)
EXTDEF = BUILDTGT2
ALL_CFLAGS = -D $(EXTDEF) -mmcu=$(MCU) -I. $(CFLAGS)
TARGET = $(join btgt2_,$(MCU))
endif

# Generate Code for BUILDTGT2 Target
btgt2: all

ifeq ($(MAKECMDGOALS),btgt3)
EXTDEF = BUILDTGT3
ALL_CFLAGS = -D $(EXTDEF) -mmcu=$(MCU) -I. $(CFLAGS)
TARGET = $(join btgt3_,$(MCU))
endif

# Generate Code for BUILDTGT3 Target
btgt3: all

ifeq ($(MAKECMDGOALS),btgt4)
EXTDEF = BUILDTGT4
ALL_CFLAGS = -D $(EXTDEF) -mmcu=$(MCU) -I. $(CFLAGS)
TARGET = $(join btgt4_,$(MCU))
endif

# Generate Code for BUILDTGT4 Target
btgt4: all


export EXTDEF


ifeq ($(MAKECMDGOALS),)
$(error No Target: (btgt1, btgt2, btgt3, btgt4))
endif

ifeq ($(MAKECMDGOALS),clean)
$(error No Target: (clbtgt1, clbtgt2, clbtgt3, clbtgt4))
endif



# Default target.
all: submakes begin  gccversion sizebefore $(TARGET).elf $(TARGET).rom 
$(TARGET).eep \
$(TARGET).lss sizeafter finished end



# Eye candy.
begin:
        @$(BEGIN)
        $(REMOVE) version*.o
        $(REMOVE) version*.lst
        $(REMOVE) version*.d

finished:
        @$(FINISH)

end:
        @$(END)
        echo $(MAKECMDGOALS)


# Display size of file.
sizebefore:
        @if [ -f $(TARGET).elf ]; then echo Size before:; $(ELFSIZE);fi

sizeafter:
        @if [ -f $(TARGET).elf ]; then echo Size after:; $(ELFSIZE);fi



# Display compiler version information.
gccversion :
        $(CC) --version

# Do makes in library directories
# Will run make in all directories listed in SUBDIRS
submakes:
        for i in $(SUBDIRS); do $(MAKE) -C $$i; done

# Do makes in library directories
# Will run make in all directories listed in SUBDIRS
submakesclean:
        for i in $(SUBDIRS); do $(MAKE) -C $$i clean; done






# Target: Convert ELF to COFF for use in debugging / simulating in AVR Studio.
coff: $(TARGET).cof end

%.cof: %.elf
        $(ELFCOFF) loadelf $< mapfile $*.map writecof $@




# Create final output files (.rom, .eep) from ELF output file.
%.rom: %.elf
        $(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@

%.eep: %.elf
        -$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" 
--change-section-lma .eeprom=0 -O $(FORMAT) $< $@

# Create extended listing file from ELF output file.
%.lss: %.elf
        $(OBJDUMP) -h -S $< > $@



# Link: create ELF output file from object files.
.SECONDARY : $(TARGET).elf
.PRECIOUS : $(OBJ)
%.elf: $(OBJ)
        $(CC) $(ALL_CFLAGS) $(OBJ) $(SUBLIBS) --output $@ $(LDFLAGS)


# Compile: create object files from C source files.
%_$(TARGET).o : %.c
        $(CC) -c $(ALL_CFLAGS) $< -o $@


# Compile: create assembler files from C source files.
%.s : %.c
        $(CC) -S $(ALL_CFLAGS) $< -o $@


# Assemble: create object files from assembler source files.
%_$(TARGET).o : %.S
        $(CC) -c $(ALL_ASFLAGS) $< -o $@


# Add extra command line define for different targets
ifeq ($(MAKECMDGOALS),clbtgt1)
TARGET = $(join btgt1_,$(MCU))
endif

# Clean BUILDTGT1 Files
clbtgt1: cleantarget

# Add extra command line define for different targets
ifeq ($(MAKECMDGOALS),clbtgt4)
TARGET = $(join btgt4_,$(MCU))
endif

# Clean BUILDTGT4 Code
clbtgt4: cleantarget

# Add extra command line define for different targets
ifeq ($(MAKECMDGOALS),clbtgt2)
TARGET = $(join btgt2_,$(MCU))
endif

# Clean BUILDTGT2 Code
clbtgt2: cleantarget

# Add extra command line define for different targets
ifeq ($(MAKECMDGOALS),clbtgt3)
TARGET = $(join btgt3_,$(MCU))
endif

# Clean BUILDTGT2 Code
clbtgt3: cleantarget



# Target: clean project.
cleantarget: begin submakesclean clean_list finished end

clean_list :
        $(REMOVE) $(TARGET).rom
        $(REMOVE) $(TARGET).eep
        $(REMOVE) $(TARGET).obj
        $(REMOVE) $(TARGET).cof
        $(REMOVE) $(TARGET).elf
        $(REMOVE) $(TARGET).map
        $(REMOVE) $(TARGET).obj
        $(REMOVE) $(TARGET).a90
        $(REMOVE) $(TARGET).sym
        $(REMOVE) $(TARGET).lnk
        $(REMOVE) $(TARGET).lss
        $(REMOVE) $(OBJ)
        $(REMOVE) $(LST)
        $(REMOVE) $(SRC:.c=.s)
        $(REMOVE) $(SRC:.c=.d)


# Automatically generate C source code dependencies.
# (Code originally taken from the GNU make user manual and modified (See 
README.txt Credits).)
# Note that this will work with sh (bash) and sed that is shipped with WinAVR 
(see the SHELL variable defined above).
# This may not work with other shells or other seds.
%.d: %.c
        set -e; $(CC) -MM $(ALL_CFLAGS) $< \
        | sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > $@; \
        [ -s $@ ] || rm -f $@


# Remove the '-' if you want to see the dependency files generated.
-include $(SRC:.c=.d)



# Listing of phony targets.
.PHONY : all begin finish end sizebefore sizeafter gccversion coff cleantarget 
clean_list \
         submakes submakesclean btgt1 btgt2 btgt3 btgt4