gbadev.org forum archive

This is a read-only mirror of the content originally found on forum.gbadev.org (now offline), salvaged from Wayback machine copies. A new forum can be found here.

Coding > compiling to thumb and arm

#174436 - brave_orakio - Fri Jun 11, 2010 4:09 am

Hi guys . I recently decided to use the standard makefile for my current GBA project since my makefile doesn't work with version r30. Or at least I think it doesn't thats why I'm going to try and use the default makefile and see if it works that way.

now here is my makefile:
Code:

#---------------------------------------------------------------------------------
# Clear the implicit built in rules
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM)
endif

include $(DEVKITARM)/gba_rules

#---------------------------------------------------------------------------------
# TARGET is the name of the output, if this ends with _mb a multiboot image is generated
# BUILD is the directory where object files & intermediate files will be placed
# SOURCES is a list of directories containing source code
# DATA is a list of directories containing data files
# INCLUDES is a list of directories containing header files
#---------------------------------------------------------------------------------
TARGET      :=   $(shell basename $(CURDIR))
BUILD      :=   build
SOURCEA      :=   sourceArm
SOURCET      :=   sourceThumb
DATA      :=
INCLUDES   :=   includes

#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH   :=   -mthumb -mthumb-interwork

CFLAGS   :=   -g -Wall -O3\
      -mcpu=arm7tdmi -mtune=arm7tdmi\
       -fomit-frame-pointer\
      -ffast-math \
      $(ARCH)

CFLAGS   +=   $(INCLUDE)

CXXFLAGS   :=   $(CFLAGS) -fno-rtti -fno-exceptions

ASFLAGS   :=   $(ARCH)
LDFLAGS   =   -g $(ARCH) -Wl,-Map,$(notdir $@).map

ARCHA   :=   -marm -mlong-calls -mthumb-interwork

CFLAGSA   :=   -g -Wall -O3\
      -mcpu=arm7tdmi -mtune=arm7tdmi\
       -fomit-frame-pointer\
      -ffast-math \
      $(ARCHA)

CFLAGSA   +=   $(INCLUDE)

CXXFLAGSA   :=   $(CFLAGSA) -fno-rtti -fno-exceptions

ASFLAGSA   :=   $(ARCHA)
LDFLAGSA   =   -g $(ARCHA) -Wl,-Map,$(notdir $@).map

#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
#---------------------------------------------------------------------------------
LIBS   :=   -lgba

#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS   :=   $(LIBGBA)

#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
# rules for different file extensions
#---------------------------------------------------------------------------------
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------

export OUTPUT   :=   $(CURDIR)/$(TARGET)
export VPATH   :=   $(foreach dir,$(SOURCEA),$(CURDIR)/$(dir)) \
               $(foreach dir,$(SOURCET),$(CURDIR)/$(dir)) \
         $(foreach dir,$(DATA),$(CURDIR)/$(dir))

export DEPSDIR   :=   $(CURDIR)/$(BUILD)

#---------------------------------------------------------------------------------
# automatically build a list of object files for our project
#---------------------------------------------------------------------------------
CFILES      :=   $(foreach dir,$(SOURCEA),$(notdir $(wildcard $(dir)/*.c)))
CFILES      :=   $(foreach dir,$(SOURCET),$(notdir $(wildcard $(dir)/*.c)))
#CPPFILES   :=   $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
#SFILES      :=   $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
#BINFILES   :=   $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
#BMPFILES   :=   $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.bmp)))

#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
   export LD   :=   $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
   export LD   :=   $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------

export OFILES   :=   $(addsuffix .o,$(BINFILES)) \
               $(BMPFILES:.bmp=.o) \
               $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)

#---------------------------------------------------------------------------------
# build a list of include paths
#---------------------------------------------------------------------------------
export INCLUDE   :=   $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
         $(foreach dir,$(LIBDIRS),-I$(dir)/include) \
         -I$(CURDIR)/$(BUILD)

#---------------------------------------------------------------------------------
# build a list of library paths
#---------------------------------------------------------------------------------
export LIBPATHS   :=   $(foreach dir,$(LIBDIRS),-L$(dir)/lib)

.PHONY: $(BUILD) clean

#---------------------------------------------------------------------------------
$(BUILD):
   @[ -d $@ ] || mkdir -p $@
   @make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile

all   : $(BUILD)
#---------------------------------------------------------------------------------
clean:
   @echo clean ...
   @rm -fr $(BUILD) $(TARGET).elf $(TARGET).gba

#---------------------------------------------------------------------------------
else

DEPENDS   :=   $(OFILES:.o=.d)

#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
$(OUTPUT).gba   :   $(OUTPUT).elf

$(OUTPUT).elf   :   $(OFILES)


#---------------------------------------------------------------------------------
# The bin2o rule should be copied and modified
# for each extension used in the data directories
#---------------------------------------------------------------------------------

#---------------------------------------------------------------------------------
# This rule links in binary data with the .bin extension
#---------------------------------------------------------------------------------
%.bin.o   :   %.bin
#---------------------------------------------------------------------------------
   @echo $(notdir $<)
   @$(bin2o)

#---------------------------------------------------------------------------------
# This rule links in binary data with the .raw extension
#---------------------------------------------------------------------------------
%.raw.o   :   %.raw
#---------------------------------------------------------------------------------
   @echo $(notdir $<)
   @$(bin2o)

#---------------------------------------------------------------------------------
# This rule creates assembly source files using grit
# grit takes an image file and a .grit describing how the file is to be processed
# add additional rules like this for each image extension
# you use in the graphics folders
#---------------------------------------------------------------------------------
%.s %.h   : %.bmp %.grit
#---------------------------------------------------------------------------------
   grit $< -fts -o$*

-include $(DEPENDS)

#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------


The ones with A at the end (ARCHA, CFLAGSA, etc.) indicate that the it is in ARM code and the rest THUMB. At the top SOURCA is the directory that contains the c files required to be compiled in ARM and SOURCET is the directory that contains the files for THUMB. INCLUDES contains all *.h files from both SOURCET and SOURCA.

Question is, what am I doing wrong here? I have no idea how to connect the ARCH and ARCHA to SOURCET and SOURCEA respectively so I doubt that SOURCEA is being compiled to ARM code.

Also what do I need to change so it doesn't compile as multiboot? My old one had a -specs=gba.specs but I don't know what to use in this case.

many thanks!
_________________
help me

#174439 - elhobbs - Fri Jun 11, 2010 1:40 pm

The rules for compiling source files are being pulled in through this line
Code:
include $(DEVKITARM)/gba_rules
which in turn brings in the base_rules file. the base_rules file has rules already for forcing thumb or arm output. it uses file extensions (technically filenames) to determine if it should compile for arm or thumb. If the file is named somename.arm.c it will be complied for arm. If it is named somename.thumb.c it will be compiled for thumb. you could modify the rules yourself or you could just use the default makefile and use the naming convention to force thumb/arm.

#174472 - brave_orakio - Tue Jun 15, 2010 1:58 am

Thanks, I'll try that out. How about compiling so the code will execute from ROM(non-multiboot)? gba_rules has it as well?

Also what does this part do?
Quote:

ARCH := -mthumb -mthumb-interwork

CFLAGS := -g -Wall -O3\
-mcpu=arm7tdmi -mtune=arm7tdmi\
-fomit-frame-pointer\
-ffast-math \
$(ARCH)

CFLAGS += $(INCLUDE)

CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions

ASFLAGS := $(ARCH)
LDFLAGS = -g $(ARCH) -Wl,-Map,$(notdir $@).map

In my other makefile, I have a similar part, or rather two similar parts. One for ARM and one for THUMB and also -mspecs=gba.specs for the part where all *.o files get converted to a *.elf file.

edit: never mind about the multiboot thing. I read gba_rules and I have it. However, whats the above line for? Is it used basically if the source files have no .arm and .thumb in the filename?
_________________
help me