RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity
Files
54d3d1e1558d6b44a406d4afee12bcd203d02dff
rtems/make/compilers/gcc-target-default.cfg
Joel Sherrill 4d20133bef Patch from Ralf Corsepius <corsepiu@faw.uni-ulm.de>. The following email 
is long but I hate to lose the information so I am including it here.


> I am still fixing and recompiling but this is the issue that was not the
> result of another patch.  This is a fundamental build issue that I value
> your opinion on.

This is difficult issue (I.e. I have no destinct solution for it)

Background:

(gnu-) make's  implicit rules apply CFLAGS, CPPFLAGS, CXXFLAGS, ASFLAGS and
LDFLAGS (cf. make.info/Implicit Rules/Catalogue of Rules), only.

In brief:
CPPFLAGS .. passed to the c-preprocessor
CFLAGS ... passed to the c-compiler
CXXFLAGS ... equivalent to CFLAGS but passed to the c++ compiler
(Attention: CFLAGS is not passed to the c++ compiler)
ASFLAGS .. equivalent to CFLAGS, but passed to the assembler
LDFLAGS .. equivalent to CFLAGS, but passed to the linker

A bit oversimplifying, these make rules are as follows
.c.o:
    $(CC) $(CPPFLAGS) $(CFLAGS) -c
.cc.o:
    $(CXX) $(CPPFLAGS) $(CXXFLAGS) -c
.S.s:
    $(CPP) $(CPPFLAGS)
.s.o:
    $(AS) $(ASFLAGS)

My reading of the documentation (make.info) is that {AS|AR|CC|CXX|CPP}FLAGS
are ment to be passed to the related tools directly, however examinating
the rule set of gmake (gmake -p -f /dev/null")  shows that many rules use
$(CC) instead of the related tools (eg. linker rules) etc.

I.e. these flags should not rely on being passed through cpp or gcc. With
gcc being the common frontend for all of these tools of a gnu-toolchain the
situation becomes difficult (Which option is passed to whom and which tool
really uses it?), because these variable can also contain the toolchain's
frontend (eg. AS=gcc, LD=gcc, CPP=gcc -E).

For some commonly used options the situation is quite clear:
* -g -> CFLAGS
* -OX -> CFLAGS
* -D -> CPPFLAGS
* -A -> CPPFLAGS

But where to add -m, -B, -specs, -qrtems_XXX ?
* -B, -specs, -qrtems_XXX are gcc-frontend options
* -m is a combinations of flags to go to different destinations, in many
(all?) cases, the following is valid
-m is expanded by gcc into a set of -D and -A options
-m is interpreted by cc1 as a machine flag to generate a specific
instruction set.
-m is interpreted by gcc as an implicit linker search path for multilibs to
set up calls to LD.

>From my point of view this indicates we can either destingush between these
different usages (= separately add -m to CFLAGS, LDFLAGS etc) or to add it
to CPPFLAGS and use gcc (the frontend) instead of calling each tool
directly (less error prone) -- I vote for CPPFLAGS, but I am not sure.

-----------------

Now, where to add CPU_CFLAGS?

AFAIS, in probably all cases CPU_CFLAGS contain -D -A, and -m options,
only.
* -D and -A are supposed to go to CPPFLAGS
* -mXXX options can have multiple meanings (It can be gcc, collect2/ld and
cc1/cc1plus option simultaneously)

Here, I made a mistake - I destinguished between CPU_DEFINES to be added to
CPPFLAGS and CPU_CFLAGS to be added to CFLAGS and CXXFLAGS (cf.
gcc-target-default.cfg), generally assuming CPU_CFLAGS are CFLAGS.

This breaks preprocessing *.S into *.i files because CPU_CFLAGS flags were
not added to CPPFLAGS. Hence *all* *.S were compiled without taking
-mXX-flags into account. The i960/cvme BSP was the only one which
explicitly checked for a specific -m flag (-mca) and refused to compile
without it -- all other CPUs/BSPs silently swallowed this.

IMO, we can either
1) add CPU_CFLAGS and CPU_DEFINES to CPPFLAGS, thus silently convert
CPU_CFLAGS's meaning into CPU_DEFINES (Alternative solution: rename
CPU_CFLAGS to CPU_DEFINES and merge CPU_FLAGS with CPU_DEFINES).
or
2) destinguish between CPU_DEFINES and CPU_CFLAGS. In this case we would
need to check the contents of each CPU_CFLAGS in custom/*.cfg and move the
some parts of the contents to CPU_DEFINES and keep other parts in
CPU_CFLAGS (CFLAGS must contain options for the c/c++-compiler only!).

Though Solution 2) is the clearer one, I implemented 1) which is the
simplier one (the patch below).

ATTENTION: This patch is small in size, but affects almost everything.

------------

Additional complications araise with linking:

Some BSPs call  LD and AS directly (esp. gcc-2.7 make-exe rules). If LD=gcc
then LDFLAGS are supposed to be gcc-options, but if LD=ld then LDFLAGS is
supposed to contain ld-options.

An analog thought is valid for AS, but luckily enough ASFLAGS is not used
of inside the whole source tree.

Most RTEMS' custom/*.cfg use $(CC) $(CFLAGS) to link with gcc-2.8 make-exe
rules. With the patch below (CPU_CFLAGS added to CPPFLAGS) this means
CPU_CFLAGS will not be passed to the linker, which is incorrect for
multilibbed CPU's.

gmake's default rule set contains a variety of rules for linking, all
ending up in calling $(CC) $(LDFLAGS) for linking at their very end.

IMO, this means we should use something like

LINK.o = $(CC) $(LDFLAGS) in gcc-target-default.cfg

+ modify all gcc-2.8 make-exe rules to use
$(LINK.o) .......

+ setup LDFLAGS according to the requirements of the above.

I.e. we should use $(CC) for linking instead of calling the linker (LD)
directly and set LDFLAGS = $(CPPFLAGS) $(CFLAGS) or similar.
1999-02-24 15:15:29 +00:00

316 lines
7.9 KiB
INI
Raw Blame History

#
# Shared compiler for all GNU tools configurations
#
# $Id$
#
##
# CFLAGS_OPTIMIZE_V, CFLAGS_DEBUG_V, CFLAGS_PROFILE_V are the values we
# would want the corresponding macros to be set to.
#
# CFLAGS_OPTIMIZE, CFLAGS_DEBUG, CFLAGS_PROFILE are set in the leaf
# Makefiles by the 'debug:' and 'profile:' targets to their _V values.
#
# default flags
# XCPPFLAGS, XCFLAGS, XCXXFLAGS, XASFLAGS
# are used to add flags from the shell
# cf. make.info ("Implicit rules/variables" for details)
# NOTE: Should these go to CPPFLAGS ?
CFLAGS_DEFAULT=-g -Wall -ansi -fasm
# NOTE: CPU_CFLAGS should probably be renamed to CPU_CPPFLAGS
# NOTE: CPU_DEFINES should probably be merged with CPU_CFLAGS
CPPFLAGS = $(CPU_DEFINES) $(CPU_CFLAGS) $(DEFINES) $(XCPPFLAGS)
CFLAGS = $(CFLAGS_DEFAULT) $(XCFLAGS)
CXXFLAGS = $(CFLAGS_DEFAULT) $(XCXXFLAGS)
ASFLAGS = $(CPU_ASFLAGS) $(XASFLAGS)
# We only include the header files for networking if it is enabled.
INCLUDE_NETWORKING_yes_V = -I$(PROJECT_INCLUDE)/networking
INCLUDE_NETWORKING = $(INCLUDE_NETWORKING_$(HAS_NETWORKING)_V)
ifeq ($(RTEMS_USE_GCC272),yes)
ifeq ($(RTEMS_CROSS_TARGET),no)
ifdef RTEMS_LIBC_DIR
RTEMS_LIBC_INCLUDES := -I$(RTEMS_LIBC_DIR)/include
endif
# Used for posix bsps
CPPFLAGS += \
-I$(PROJECT_INCLUDE) $(INCLUDE_NETWORKING) \
$(RTEMS_LIBC_INCLUDES)
else
# Used for embedded bsps
# Ask gcc where it finds its own include files
GCC_INCLUDE=$(shell $(CC) $(CPU_CFLAGS) -print-file-name=include $(GCCSED))
CPPFLAGS += -nostdinc \
-I$(PROJECT_INCLUDE) $(INCLUDE_NETWORKING) \
-I$(GCC_INCLUDE) \
-I$(RTEMS_LIBC_DIR)/sys-include \
-I$(RTEMS_LIBC_DIR)/include
endif
# default location of Standard C Library
ifndef LIBC_LIBC
LIBC_LIBC=$(RTEMS_LIBC_DIR)/lib/libc.a
endif
ifndef LIBC_LIBM
LIBC_LIBM=$(RTEMS_LIBC_DIR)/lib/libm.a
endif
else
# NOTE: GCCSPECS probably belongs to CPPFLAGS
# Unfortunately, many custom/*.cfg files do not pass CPPFLAGS
# to their gcc-2.8 make-exe rules
GCCSPECS = -B$(PROJECT_RELEASE)/lib/ -specs bsp_specs -qrtems
CC += $(GCCSPECS)
CXX += $(GCCSPECS)
CPPFLAGS += -I$(srcdir) $(INCLUDE_NETWORKING)
# default location of Standard C Library
ifndef LIBC_LIBC
LIBC_LIBC=$(shell $(CC) $(CPU_CFLAGS) -print-file-name=libc.a $(GCCSED))
endif
ifndef LIBC_LIBM
LIBC_LIBM=$(shell $(CC) $(CPU_CFLAGS) -print-file-name=libm.a $(GCCSED))
endif
endif
# Define this to yes if C++ is included in the development environment.
# This requires that at least the GNU C++ compiler and libg++ be installed.
ifeq ($(RTEMS_HAS_CPLUSPLUS),yes)
HAS_CPLUSPLUS=yes
CPLUS_LD_LIBS += $(PROJECT_RELEASE)/lib/librtems++$(LIBSUFFIX_VA)
else
HAS_CPLUSPLUS=no
endif
# debug flag;
CFLAGS_DEBUG_V+=-Wno-unused
ifeq ($(RTEMS_USE_GCC272),no)
CFLAGS_DEBUG_V+=-qrtems_debug
endif
# when debugging, optimize flag: typically empty
# some compilers do allow optimization with their "-g"
CFLAGS_DEBUG_OPTIMIZE_V=-g
# profile flag; use gprof(1)
CFLAGS_PROFILE_V=-pg
# default is to optimize
CFLAGS_OPTIMIZE=$(CFLAGS_OPTIMIZE_V)
# dynamic libraries
#CFLAGS_DYNAMIC_V=-fpic
#ASFLAGS_DYNAMIC_V=
CFLAGS += $(CFLAGS_OPTIMIZE) $(CFLAGS_DEBUG) $(CFLAGS_PROFILE)
# List of library paths without -L
LD_PATHS= $(PROJECT_RELEASE)/lib
# libraries you want EVERYONE to link with
#LD_LIBS=
# ld flag to ensure pure-text
#LDFLAGS_MUST_BE_PURE_V =
# ld flag for [un]shared objects
#LDFLAGS_STATIC_LIBRARIES_V =
#LDFLAGS_SHARED_LIBRARIES_V =
# ld flag for incomplete link
LDFLAGS_INCOMPLETE = -r
# Special linker options when building lib.so
LDFLAGS_DYNAMIC_V = ??
# Some dynamic linking systems want the preferred name recorded in the binary
# ref: src/libxil/Makefile
LDFLAGS_DYNAMIC_LIBNAME_V = -h $(DYNAMIC_VERSION_LIBNAME)
# ld flags for profiling, debugging
LDFLAGS_PROFILE_V =
LDFLAGS_DEBUG_V =
LDFLAGS=$(LDFLAGS_PROFILE) $(LDFLAGS_DEBUG) $(LD_PATHS:%=-L %)
#
# Stuff to clean and clobber for the compiler and its tools
#
CLEAN_CC = a.out *.o *.BAK
CLOBBER_CC =
#
# Client compiler and support tools
#
# CPP command to write file to standard output
CPP=$(CC) -E -ansi -w -Wp,-$$
# flags set by cc when running cpp
# NOTE: CPP_CC_FLAGS does not seem to be used anywhere
# CPP_CC_FLAGS=-D__STDC__
# egrep regexp to ignore symbol table entries in ar archives.
# Only used to make sure we skip them when coalescing libraries.
# skip __.SYMDEF and empty names (maybe bug in ranlib??).
AR_SYMBOL_TABLE="HIGHLY-UNLIKELY-TO-CONFLICT"
ARFLAGS=ruv
#
# Command to convert a normal archive to one searchable by $(LD)
#
# NOTE: Obsolete, use $(RANLIB) instead, MKLIB may disappear soon
MKLIB=$(RANLIB)
#
# How to compile stuff into ${ARCH} subdirectory
#
# NOTE: we override COMPILE.[c|cc|S]
# because gmake default rules use TARGET_ARCH for different purposes
#
COMPILE.c=$(CC) $(CPPFLAGS) $(CFLAGS) -c
COMPILE.cc=$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c
COMPILE.S=$(CC) $(ASFLAGS) $(CPPFLAGS) -c
${ARCH}/%.o: %.c
${COMPILE.c} -o $@ $<
${ARCH}/%.o: %.cc
${COMPILE.cc} -o $@ $<
${ARCH}/%.o: %.S
${COMPILE.S} -DASM -o $@ $<
# OBSOLETE: the rule above should be equivalent.
# strip out C++ style comments.
# ${ARCH}/%.o: %.S
# sed -e 's/\/\/.*$$//' < $< | \
# $(CPP) $(CPPFLAGS) -I. -I$(srcdir) -DASM - >$(ARCH)/$*.i
# $(AS) $(ASFLAGS) -o $@ $(ARCH)/$*.i
# Make foo.rel from foo.o
${ARCH}/%.rel: ${ARCH}/%.o
${LD} $(LDFLAGS_INCOMPLETE) -o $@ $^
# create $(ARCH)/pgm from pgm.sh
${ARCH}/%: %.sh
$(RM) $@
$(CP) $< $@
$(CHMOD) +x $@
# Dependency files for use by gmake
# NOTE: we don't put in $(TARGET_ARCH)
# so that 'make clean' doesn't blow it away
DEPEND=Depends-$(TARGET_ARCH:o-%=%)
CLEAN_DEPEND=$(DEPEND).tmp
CLOBBER_DEPEND=$(DEPEND)
# We deliberately don't have anything depend on the
# $(DEPEND) file; otherwise it will get rebuilt even
# on 'make clean'
#
depend: $(C_FILES) $(CC_FILES) $(S_FILES)
ifneq ($(words $(C_FILES) $(CC_FILES) $(S_FILES)), 0)
# Use gcc -M to generate dependencies
# Replace foo.o with $(ARCH)/foo.o
# Replace $(ARCH) value with string $(ARCH)
# so that it will for debug and profile cases
$(COMPILE.c) -M $^ | \
$(SED) -e 's?^\(.*\)\.o[ ]*:?$$(ARCH)/\1.o:?' \
-e 's?$(ARCH)/?$$(ARCH)/?' >$(DEPEND).tmp
$(MV) $(DEPEND).tmp $(DEPEND)
endif
# spell out all the LINK_FILE's, rather than using -lbsp, so
# that $(LINK_FILES) can be a dependency
# Start file must be one of
# $(PROJECT_RELEASE)/lib/start$(LIB_VARIANT).o
# $(PROJECT_RELEASE)/lib/asmiface$(LIB_VARIANT).o
# It defaults to start.o, but an app can override it.
ifeq ($(START_BASE),)
START_FILE=
else
START_FILE=$(PROJECT_RELEASE)/lib/$(START_BASE)$(LIB_VARIANT).o
endif
CONSTRUCTOR=
LIBC_LOW=
ifndef LIBGCC
LIBGCC = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name $(GCCSED))
endif
#
# NOTE: a rule to link an rtems' application should look similar to this
# (cf. "make-exe" in make/custom/*.cfg):
#
# gcc27:
# $(PGM): $(LINK_FILES)
# $(LD) $(LDFLAGS) -o $@ $(LINK_OBJS) \
# --start-group $(LINK_LIBS) --end-group
#
# gcc28:
# $(PGM): $(LINK_FILES)
# $(CC) $(CFLAGS) -o $@ $(LINK_OBJS) $(LINK_LIBS)
#
LINK_OBJS =\
$(CONSTRUCTOR) \
$(OBJS) \
$(MANAGERS_NOT_WANTED:%=$(PROJECT_RELEASE)/lib/no-%$(LIB_VARIANT).rel) \
$(PROJECT_RELEASE)/lib/libtest$(LIBSUFFIX_VA)
LINK_FILES =\
$(START_FILE) \
$(CONSTRUCTOR) \
$(OBJS) \
$(MANAGERS_NOT_WANTED:%=$(PROJECT_RELEASE)/lib/no-%$(LIB_VARIANT).rel) \
$(PROJECT_RELEASE)/lib/libtest$(LIBSUFFIX_VA) \
$(PROJECT_RELEASE)/lib/librtemsall$(LIBSUFFIX_VA)
ifeq ($(RTEMS_USE_GCC272),yes)
LINK_LIBS = $(PROJECT_RELEASE)/lib/librtemsall$(LIBSUFFIX_VA)
ifeq ($(RTEMS_CROSS_TARGET),yes)
# NOTE: add libc and libgcc only for embedded targets
# LIBC_LIBM should not be needed by rtems itself.
# FIXME: If a BSP requires libm, its make/custom/*.cfg file should add
# LIBC_LIBM to LINK_LIBS (untested)
LINK_LIBS += $(LIBC_LIBC) $(LIBGCC)
endif
endif
LINK_LIBS += $(LD_LIBS)
#
# Allow user to override link commands (to build a prom image, perhaps)
#
ifndef LINKCMDS
LINKCMDS=$(PROJECT_RELEASE)/lib/linkcmds
endif
define make-rel
$(LD) $(LDFLAGS_INCOMPLETE) $(XLDFLAGS) -o $@ $(OBJS)
endef
View Git Blame Copy Permalink