RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

Removed PROJECT_HOME and CONFIG_DIR variables.

Browse Source
This commit is contained in:
Joel Sherrill
1998-01-20 19:30:30 +00:00
parent 3294650cc3
commit bffb938799
53 changed files with 5718 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

518
c/src/make/README Normal file
View File

@@ -0,0 +1,518 @@
#
# $Id$
#
make/README
This file describes the layout and conventions of the make tree used in
the RTEMS software project and others.
All of these "make" trees are substantially similar; however this
file documents the current state of the rtems Makefile tree.
This make tree was developed originally to simplify porting projects
between various os's. The primary goals are:
. simple *and* customizable individual makefiles
. use widely available GNU make. There is no pre-processing or
automatic generation of Makefiles.
. Same makefiles work on *many* host os's due to portability
of GNU make and the host os config files.
. Support for different compilers and operating systems
on a per-user basis. Using the same sources (including
Makefiles) one developer can develop and test under SVR4,
another under 4.x, another under HPUX.
. Builtin support for compiling "variants" such as debug,
profile, and tcov versions. These variants can be built
recursively.
. Control of system dependencies. "hidden" dependencies on
environment variables (such as PATH)
have been removed whenever possible. No matter what your
PATH variable is set to, you should get the same thing
when you 'make' as everyone else on the project.
This description attempts to cover all aspects of the Makefile tree. Most
of what is described here is maintained automatically by the configuration
files.
The example makefiles in make/Templates should be used as a starting
point for new directories.
There are 2 main types of Makefile:
directory and leaf.
Directory Makefiles
-------------------
A Makefile in a source directory with sub-directories is called a
"directory" Makefile.
Directory Makefile's are simply responsible for acting as "middle-men"
and recursing into their sub-directories and propagating the make.
For example, directory src/bin will contain only a Makefile and
sub-directories. No actual source code will reside in the directory.
The following commands:
$ cd src/bin
$ make all
would descend into all the subdirectories of 'src/bin' and recursively
perform a 'make all'.
A 'make debug' will recurse thru sub-directories as a debug build.
A template directory Makefile which should work in almost all
cases is in make/Templates/Makefile.dir
Leaf Makefiles
--------------
Source directories that contain source code for libraries or
programs use a "leaf" Makefile.
These makefiles contain the rules necessary to build programs
(or libraries).
A template leaf Makefile is in Templates/Makefile.leaf . A template
leaf Makefile for building libraries is in Templates/Makefile.lib .
NOTE: To simplify nested makefile's and source maintenance, we disallow
combining source and directories (that make(1) would be expected to
recurse into) in one source directory. Ie., a directory in the source
tree may contain EITHER source files OR recursive sub directories, but NOT
both.
Variants (where objects go)
---------------------------
All binary targets are placed in a sub-directory whose name is (for
example):
o-force386/ -- binaries (no debug, no profile)
o-force386-debug/ -- debug binaries
o-force386-profile/ -- profiling binaries
Using the template Makefiles, this will all happen automatically.
Within a Makefile, the ${ARCH} variable is set to o-force386,
o-force386-debug, etc., as appropriate.
Typing 'make' will place objects in o-force386.
'make debug' will place objects in o-force386-debug.
'make profile' will place objects in o-force386-profile.
NOTE: For RTEMS work, the word 'force386' is the specified
RTEMS_BSP (specified in the modules file)
The debug and profile targets are equivalent to 'all' except that
CFLAGS and/or LDFLAGS are modified as per the compiler config file for
debug and profile support.
Targets debug_install and profile_install are equivalent to 'make
install' except that debug (or profile) variants are built and
installed.
The targets debug, profile, debug_install, profile_install, etc., can be
invoked recursively at the directory make level. So from the top of a
tree, one could install a debug version of everything under that point
by:
$ cd src/lib
$ gmake debug_install
When building a command that is linked with a generated library, the
appropriate version of the library will be linked in.
For example, the following fragments link the normal, debug, or
profile version of "libmine.a" as appropriate:
LDLIBS += $(LIBMINE)
LIBMINE = ../libmine/${ARCH}/libmine.a
${ARCH}/pgm: $(LIBMINE) ${OBJS}
$(LINK.c) -o $@ ${OBJS} $(LDLIBS)
If we do 'gmake debug', then the library in
../libmine/sparc-debug/libmine.a will be linked in. If $(LIBMINE)
might not exist (or might be out of date) at this point, we could add
${LIBMINE}: FORCEIT
cd ../libmine; ${MAKE} ${VARIANT_VA}
The above would generate the following command to build libmine.a:
cd ../libmine; gmake debug
The macro reference ${VARIANT_VA} converts ${ARCH} to the word 'debug'
(in this example) and thus ensures the proper version of the library
is built.
Targets
-------
All Makefile's support the following targets:
all -- make "everything"
install -- install "everything"
The following targets are provided automatically by
the included config files:
clean -- delete all targets
clobber -- 'clean' plus delete sccs'd files
lint -- run lint or lint-like tool
get -- "sccs get" all sources
depend -- build a make dependency file
"variant targets" -- special variants, see below
All directory Makefiles automatically propagate all these targets. If
you don't wish to support 'all' or 'install' in your source directory,
you must leave the rules section empty, as the parent directory Makefile
will attempt it on recursive make's.
Configuration
-------------
All the real work described here happens in file(s) included
from your Makefile.
All Makefiles include a customization file which is used to select
compiler and host operating system. The environment variable
RTEMS_CUSTOM must point to this file; eg:
/.../make/custom/force386.cfg
All leaf Makefile's also include either 'make/leaf.cfg' (or
'make/lib.cfg' for building libraries). These config files provide
default rules and set up the command macros as appropriate.
All directory Makefiles include 'make/directory.cfg'. directory.cfg
provides all the rules for recursing through sub directories.
The Makefile templates already perform these include's.
'make/leaf.cfg' (or directory.cfg) in turn includes:
a file specifying general purpose rules appropriate for
both leaf and directory makefiles.
( make/main.cfg )
personality modules specified by the customization file for:
compiler ( make/compilers/??.cfg )
operating system ( make/os/??.cfg )
private customization files
---------------------------
[ $(RTEMS_CUSTOM) ]
Your own private configuration file. Specifies which of the above
files you want to include.
Example: custom/force386.cfg
CONFIG.$(HOST_ARCH).OS = $(RTEMS_ROOT)/make/os/HPUX-9.0.cfg
# HOST Compiler config file
# You may also want to specify where the compiler resides here.
CC_$(HOST_ARCH)_DIR=/usr/local
CONFIG.$(HOST_ARCH).CC = $(RTEMS_ROOT)/make/compilers/gcc.cfg
## Target compiler config file, if any
CC_$(TARGET_ARCH)_DIR=$(RTEMS_GNUTOOLS)
CONFIG.$(TARGET_ARCH).CC = $(RTEMS_ROOT)/make/compilers/gcc-force386.cfg
generic rules file
------------------
[ make/main.cfg ]
included by leaf.cfg or directory.cfg.
This file contains some standard rules and variable assignments
that all Makefiles need.
It also includes the FORCEIT: pseudo target.
OS config file for host machine
-------------------------------
[ make/os/OS-NAME.cfg ]
included by main.cfg
Figures out the target architecture and specifies command names
for the OS tools including RCS/CVS (but NOT for the compiler tools).
Compiler configuration for the target
-------------------------------------
[ compilers/COMPILER-NAME.cfg ]
included by leaf.cfg
Specifies the names of tools for compiling programs.
Names in here should be fully qualified, and NOT depend on $PATH.
Also specifies compiler flags to be used to generate optimized,
debugging and profile versions, as well as rules to compile
assembly language and make makefile dependencies.
Configuration Variables
-----------------------
Variables you have to set in the environment or in your Makefile.
Note: the rtems module files set RTEMS_ROOT and RTEMS_CUSTOM
for you.
Environment Variables
---------------------
RTEMS_BSP -- name of your 'bsp' eg: force386
RTEMS_ROOT -- The root of your source tree.
All other file names are derived from this.
[ eg: % setenv RTEMS_ROOT $HOME/work/rtems ]
RTEMS_CUSTOM -- name of your config files in make/custom
Example:
$(RTEMS_ROOT)/make/custom/$(RTEMS_BSP).cfg
RTEMS_GNUTOOLS -- root of the gcc tools for the target
The value RTEMS_ROOT is used in the custom
files to generate the make(1) variables:
PROJECT_ROOT
PROJECT_RELEASE
PROJECT_TOOLS
etc., which are used within the make config files themselves.
(The files in make/*.cfg try to avoid use of word RTEMS so
they can be more easily shared by other projects)
Preset variables
----------------
Aside from command names set by the os and compiler config files,
a number of MAKE variables are automatically set and maintained by
the config files.
CONFIG.$(HOST_ARCH).OS
-- full path of OS config file, set by
custom config file.
CONFIG.$(HOST_ARCH).CC
-- full path of C compilation config file, set by custom
config file.
PROJECT_RELEASE
-- release/install directory
[ $(PROJECT_ROOT) ]
PROJECT_BIN
-- directory for installed binaries
[ $(PROJECT_ROOT)/bin ]
PROJECT_TOOLS
-- directory for build environment commands
[ eg: $(PROJECT_ROOT)/build-tools ]
TARCH -- ${TARGET_ARCH}
[ eg: o-forc386 ]
obsolete and should not be referenced
ARCH -- target sub-directory for object code
[ eg: o-force386 or o-force386-debug ]
HOST_ARCH
-- host machine architecture name
[ eg: sun4, sparc on SVR4 ]
VARIANTS -- full list of all possible values for $(ARCH);
used mainly for 'make clean'
[ eg: "o-force386 o-force386-debug o-force386-profile" ]
VARIANT_VA -- Variant name.
Normally "", but for 'make debug' it is "debug",
for 'make profile', "profile, etc.
see make/leaf.cfg for more info.
Preset compilation variables
----------------------------
This is a list of some of the compilation variables.
Refer to the compiler config files for the complete list.
CFLAGS_OPTIMIZE_V -- value of optimize flag for compiler
[ eg: -O ]
CFLAGS_DEBUG_V -- value of debug flag for compiler
[ eg: -g ]
CFLAGS_PROFILE_V -- compiler profile flags
[ eg: -pg ]
CFLAGS_DEBUG_OPTIMIZE_V
-- optimize flag if compiling for debug
[ eg: "" ]
CFLAGS_DEBUG
CFLAGS_PROFILE
CFLAGS_OPTIMIZE -- current values for each depending
on make variant.
LDFLAGS_STATIC_LIBRARIES_V
-- ld option for static libraries
-Bstatic or -dy (svr4)
LDFLAGS_SHARED_LIBRARIES_V
-- ld option for dynamic libraries
-Bdynamic or -dn (svr4)
LIB_SOCKET
-- ld(1) -l option(s) to provide
socket support.
LIB_MATH -- ld(1) -l option(s) to provide
math library.
Makefile Variables
------------------
The following variables may be set in a typical Makefile.
C_PIECES -- File names of your .c files without '.c' suffix.
[ eg: C_PIECES=main funcs stuff ]
CC_PIECES -- ditto, except for .cc files
S_PIECES -- ditto, except for .S files.
LIB -- target library name in leaf library makefiles.
[ eg: LIB=${ARCH}/libmine.a ]
H_FILES -- your .h files in this directory.
[ eg: H_FILES=stuff.h extra.h ]
DEFINES -- cc -D items. Included in CPPFLAGS.
leaf Makefiles.
[ eg: DEFINES += -DUNIX ]
CPPFLAGS -- -I include directories.
leaf Makefiles.
[ eg: CPPFLAGS += -I../include ]
YFLAGS -- Yacc flags.
leaf Makefiles.
[ eg: YFLAGS += -v ]
LD_PATHS -- arguments to -L for ld.
Will be prefixed with '-L' or '-L ' as appropriate
and included in LDFLAGS.
LDFLAGS -- -L arguments to ld; more may be ADDed.
LD_LIBS -- libraries to be linked in.
[ eg: LDLIBS += ../libfoo/${ARCH}/libfoo.a ]
XCFLAGS -- "extra" CFLAGS for special needs. Pre-pended
to CFLAGS.
Not set or used by Makefiles.
Can be set on command line to pass extra flags
to the compiler.
XCPPFLAGS -- ditto for CPPFLAGS
Can be set on command line to pass extra flags
to the preprocessor.
XCCPPFLAGS -- same as XCPPFLAGS for C++.
XCCFLAGS -- same as XCFLAGS for C++.
SUB_DIRS -- list of sub directories for make recursion.
directory Makefiles only.
[ eg: SUB_DIRS=cpu bsp ]
CLEAN_ADDITIONS
-- list of files or directories that should
be deleted by 'make clean'
[ eg: CLEAN_ADDITIONS += y.tab.c ]
See 'leaf.cfg' for the 'clean:' rule and its
default deletions.
CLOBBER_ADDITIONS
-- list of files or directories that should
be deleted by 'make clobber'
Since 'make clobber' includes 'make clean',
you don't need to duplicate items in both.
TARGET_ARCH -- target architecture (eg: o-force386)
leaf makefiles only.
Should be specified before 'include leaf.cfg'.
Only needs to be specified if your target is
different from output of `arch`.
Command names
-------------
The following commands should only be called
as make variables:
MAKE,INSTALL,SHELL
ECHO,CAT,RM,CP,MV,LN,MKDIR,CHMOD
ED,SED
CC,CPP,AS,AR,LD,NM,SIZE,RANLIB,MKLIB,
YACC,LEX,LINT,CTAGS,ETAGS
Special Directory Makefile Targets
----------------------------------
all_WRAPUP
clean_WRAPUP
install_WRAPUP
clean_WRAPUP
clobber_WRAPUP
depend_WRAPUP
-- Specify additional commands for recursive
(directory level) targets.
This is handy in certain cases where you need
to do bit of work *after* a recursive make.
make/Templates
--------------
This directory contains Makefile and source file templates that
should help in creating or converting makefiles.
Makefile.leaf
Template leaf Makefiles.
Makefile.lib
Template leaf library Makefiles.
Makefile.dir
Template "directory" makefile.

285
c/src/make/compilers/gcc-target-default.cfg Normal file
View File

@@ -0,0 +1,285 @@
#
#
CPPFLAGS=$(CFLAGS) $(XCPPFLAGS)
CPLUS_CPPFLAGS=$(CFLAGS) $(XCPPFLAGS)
##
# 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
# We only include the header files for KA9Q if it is enabled.
INCLUDE_KA9Q_yes_V = -I$(PROJECT_INCLUDE)/ka9q
INCLUDE_KA9Q = $(INCLUDE_KA9Q_$(HAS_KA9Q)_V)
ifeq ($(RTEMS_USE_GCC272),yes)
# Ask gcc where it finds its own include files
GCC_INCLUDE=$(shell $(CC) $(CPU_CFLAGS) -print-file-name=include)
CFLAGS_DEFAULT = $(CPU_DEFINES) $(CPU_CFLAGS) -Wall -ansi -fasm -g \
-nostdinc -I$(PROJECT_INCLUDE) \
$(INCLUDE_KA9Q) \
-I$(RTEMS_LIBC_DIR)/include -I$(GCC_INCLUDE) $(DEFINES)
ASMFLAGS=$(CPU_DEFINES) $(CPU_CFLAGS) -g \
-nostdinc -I$(PROJECT_INCLUDE) \
-I$(RTEMS_LIBC_DIR)/include -I$(GCC_INCLUDE) $(DEFINES)
# 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
CFLAGS_DEFAULT = $(CPU_DEFINES) $(CPU_CFLAGS) -Wall -ansi -fasm -g \
-B$(PROJECT_RELEASE)/lib/ -specs bsp_specs -qrtems \
$(INCLUDE_KA9Q) $(DEFINES)
ASMFLAGS=$(CPU_DEFINES) $(CPU_CFLAGS) -g -I$(srcdir) \
-B$(PROJECT_RELEASE)/lib/ -specs bsp_specs -qrtems $(DEFINES)
# default location of Standard C Library
ifndef LIBC_LIBC
LIBC_LIBC=$(shell $(CC) $(CPU_CFLAGS) -print-file-name=libc.a)
endif
ifndef LIBC_LIBM
LIBC_LIBM=$(shell $(CC) $(CPU_CFLAGS) -print-file-name=libm.a)
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; typically -g
CFLAGS_DEBUG_V+=-g -Wno-unused
# when debugging, optimize flag: typically empty
# some compilers do allow optimization with their "-g"
#CFLAGS_DEBUG_OPTIMIZE_V=
# 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_DEFAULT) $(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
# flags set by cc when running cpp
CPP_CC_FLAGS=-D__STDC__
ASFLAGS=
ASM4FLAGS := -I $(PROJECT_INCLUDE)
# 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)
# Not needed on SVR4
#
MKLIB=echo library is complete:
#
# How to compile stuff into ${ARCH} subdirectory
#
# NOTE: we override COMPILE.c
#
# NOTE: Remove -pipe if it causes you problems. Using it can decrease
# compile time.
#
COMPILE.c=$(CC) $(CFLAGS) $(XCFLAGS) -c
${ARCH}/%.o: %.c
${COMPILE.c} -pipe -o $@ $<
${ARCH}/%.o: %.cc
${COMPILE.c} -pipe -o $@ $<
${ARCH}/%.o: %.S
${COMPILE.c} -pipe -DASM -o $@ $<
# strip out C++ style comments.
${ARCH}/%.o: %.s
sed -e 's/\/\/.*$$//' < $< | \
$(CPP) $(ASMFLAGS) -I. -I$(srcdir) -DASM - >$(ARCH)/$*.i
$(AS) $(ASFLAGS) -o $@ $(ARCH)/$*.i
# $(CPP) $(CPPFLAGS) -DASM - < $< >$(ARCH)/$*.i
# $(AS) $(ASFLAGS) -o $@ $(ARCH)/$*.i
# $(RM) $(ARCH)/$*.i
# Specify our own default rule for this to prevent having CFLAGS and
# CPPFLAGS being passed to linker
${ARCH}/%: ${ARCH}/%.o
${CC} ${LDFLAGS} -o $@ $@.o ${LD_LIBS}
# 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
# List (possibly empty) of required managers
# We require:
# region -- used by lib/libcsupport for malloc()
# ext -- used by libc for libc reentrancy hooks
MANAGERS_REQUIRED=region ext sem
# Create a RTEMS executable based on MANAGERS which was set in
# app's Makefile
MANAGERS_NOT_WANTED=$(filter-out $(MANAGERS), $(MANAGER_LIST))
MANAGERS_NOT_WANTED:=$(filter-out $(MANAGERS_REQUIRED), $(MANAGERS_NOT_WANTED))
# 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=
LIBGCC = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
LINK_OBJS=\
$(CONSTRUCTOR) \
$(OBJS) \
$(MANAGERS_NOT_WANTED:%=$(PROJECT_RELEASE)/lib/no-%$(LIB_VARIANT).rel) \
$(LD_LIBS) \
$(PROJECT_RELEASE)/lib/libtest$(LIBSUFFIX_VA)
LINK_LIBS=\
$(LD_LIBS) \
$(LIBC_EXTRA_LIBS) \
$(PROJECT_RELEASE)/lib/librtemsall$(LIBSUFFIX_VA) \
$(LIBC_LIBM) $(LIBC_LIBC) $(LIBGCC)
LINK_FILES=\
$(START_FILE) \
$(LINK_OBJS) \
$(LINK_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

43
c/src/make/directory.cfg Normal file
View File

@@ -0,0 +1,43 @@
#
# $Id$
#
# make/directory.cfg
#
# Make(1) configuration file include'd by all directory-level Makefile's.
#
# See also make/main.cfg
#
# include $(RTEMS_ROOT)/make/main.cfg
# on a 'make -k' we don't want to bomb out of directory list
EXIT_CMD=exit 1
ifeq (k, $(findstring k, $(MAKEFLAGS)))
EXIT_CMD=true
endif
RULE=$(shell echo $@ | $(SED) -e s/debug_// -e s/profile_//)
ifeq ($(RTEMS_USE_OWN_PDIR),yes)
$(RECURSE_TARGETS):
@$(ECHO); \
BASEDIR=`pwd`; \
for subd in $(SUB_DIRS) xxx; \
do if [ $$subd != xxx ] ; then \
cd $$BASEDIR; \
$(ECHO); \
$(ECHO) "*** $$BASEDIR/$$subd ($@)" ; \
cmd="cd $$subd; $(MAKE) $(RULE)"; \
$(ECHO) $$cmd; \
eval $$cmd || $(EXIT_CMD); \
fi; done; \
$(ECHO); \
$(ECHO) "*** $$BASEDIR/$@ ($@) Finished."; \
$(ECHO)
$($@_WRAPUP)
else
ifdef RECURSE_TARGETS
$(RECURSE_TARGETS):
set -e; for subd in $(SUB_DIRS); do $(MAKE) -w -C $$subd $@; done
endif
endif

68
c/src/make/host.cfg.in Normal file
View File

@@ -0,0 +1,68 @@
#
# $Id $
#
# OS-specific configuration
#
# Author: Ralf Corsepius (corsepiu@faw.uni-ulm.de) 97/11/08
#
# Derived from rtems/c/make/os/*.cfg in previous RTEMS version.
#
RTEMS_HOST = @RTEMS_HOST@
#
# Stuff to clean and clobber for the OS
#
CLEAN_OS =
CLOBBER_OS = *~ *.bak TAGS tags
SHELL=/bin/sh
ECHO=echo
CAT=@CAT@
RM=@RM@ -f
CP=@CP@
MV=@MV@
LN=@LN@
MKDIR=@MKDIR@
CHMOD=@CHMOD@
ED=@ED@
SED=@SED@
M4=@M4@
INSTALL=$(PROJECT_TOOLS)/install-if-change
INSTALL_VARIANT=$(PROJECT_TOOLS)/install-if-change -V "$(LIB_VARIANT)"
FGREP=@FGREP@
GREP=@GREP@
EGREP=@EGREP@
# ksh (or bash) is used by some shell scripts; ref build-tools/scripts/Makefile
#
# Must have shell functions. Some ksh's core dump mysteriously and
# unreliably on RTEMS shell scripts. bash appears to be the most
# reliable but late model ksh's are usually OK.
KSH=@KSH@
#
# RCS support
#
RCS_CLEAN=$(PROJECT_TOOLS)/rcs-clean
#
# Rule to install a shell script with the proper shell to run it.
#
# when debugging, one may want to save the previous incarnation of the
# installed script. Replace the first line of this rule to do this.
#
# -$(RM) $@.old
# -$(MV) $@ $@.old >/dev/null 2>&1
define make-script
-$(RM) $@
$(SED) -e '1,1s?^#!KSHELL?#!$(KSH)?' \
-e '1,1s?^#!SHELL?#!$(SHELL)?' < $< > $@
$(CHMOD) 0555 $@
endef

20
c/src/make/lib.cfg Normal file
View File

@@ -0,0 +1,20 @@
#
# $Id$
#
# make/lib.cfg
#
# Make(1) configuration file include'd by all "library" Makefile
# Assumes $(LIB) is set to $(ARCH)/libfoo.a
#
include $(RTEMS_ROOT)/make/leaf.cfg
define make-library
$(RM) $@
$(AR) $(ARFLAGS) $@ $(OBJS)
$(MKLIB) $@
endef
CLEAN_ADDITIONS +=
.PRECIOUS: $(LIB)