i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

configure: prepare for hybrid support

Browse Source 
The goal is to do hybrid builds in a single jam (instead of calling a
sub-jam to build parts with the secondary tool chain). This changeset
adds support to configure to prepare multiple tool chains.

configure:
* Merge option --build-cross-tools-gcc4 into --build-cross-tools. The
  option does now always require a packaging architecture parameter,
  i.e. x86_gcc2 for the legacy tool chain.
* Multiple occurrences of the --build-cross-tools and
  --cross-tools-prefix options are allowed. The first one specifies the
  primary tool chain, the subsequent ones the secondary tool chains.
* All architecture dependent jam variables are now suffixed with the
  name of the packaging architecture. The new HAIKU_PACKAGING_ARCHS
  contains the packaging architectures for the prepared tool chains. The
  first element is for the primary tool chain.
* No longer generate a separate libgccObjects file. Just put the
  respective variable into BuildConfig as well.

build_cross_tools[_gcc4]:
* Replace the <haiku output dir> parameter by a <install dir>
  parameter. This allows to create different cross-tools directories.
  They are simply suffixed by the packaging architecture.

Jamrules:
* For the moment map the variables for the primary tool chain to the
  respective suffix-less variables, so that everything still works as
  before.

The next step is to actually support the secondary tool chains in the
jam build system. This will require quite a bit more butchering, though.
This commit is contained in:
Ingo Weinhold
2013-07-25 23:52:49 +02:00
parent ef57df3d81
commit c0e8cc1a13
5 changed files with 387 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Jamrules
+37
View File
@@ -29,6 +29,43 @@ if ! $(buildConfig) {
LOCATE on BuildConfig = $(HAIKU_BUILD_OUTPUT_DIR) ; LOCATE on BuildConfig = $(HAIKU_BUILD_OUTPUT_DIR) ;
include BuildConfig ; include BuildConfig ;
# Set simplified variables for primary architecture.
HAIKU_PACKAGING_ARCH = $(HAIKU_PACKAGING_ARCHS[1]) ;
local variable ;
for variable in
HAIKU_GCC_RAW_VERSION
HAIKU_GCC_MACHINE
HAIKU_GCC_LIB_DIR
HAIKU_GCC_HEADERS_DIR
HAIKU_GCC_LIBGCC
HAIKU_GCC_LIBGCC_OBJECTS
HAIKU_CPU
HAIKU_STATIC_LIBSTDC++
HAIKU_SHARED_LIBSTDC++
HAIKU_STATIC_LIBSUPC++
HAIKU_SHARED_LIBSUPC++
HAIKU_C++_HEADERS_DIR
HAIKU_KERNEL_LIBGCC
HAIKU_KERNEL_LIBSUPC++
HAIKU_BOOT_LIBGCC
HAIKU_BOOT_LIBSUPC++
HAIKU_AR
HAIKU_CC
HAIKU_LD
HAIKU_OBJCOPY
HAIKU_RANLIB
HAIKU_ELFEDIT
HAIKU_STRIP
HAIKU_CPPFLAGS
HAIKU_CCFLAGS
HAIKU_C++FLAGS
HAIKU_LDFLAGS
HAIKU_ARFLAGS
HAIKU_UNARFLAGS
HAIKU_USE_GCC_GRAPHITE {
$(variable) = $($(variable)_$(HAIKU_PACKAGING_ARCH)) ;
}
# The build setup and rules are neatly organized in several files. Include # The build setup and rules are neatly organized in several files. Include
# them now. Start with the side-effect-less rules, since they are the most # them now. Start with the side-effect-less rules, since they are the most
# likely to be used in the top level context (i.e. not only in rules). # likely to be used in the top level context (i.e. not only in rules).
build/jam/BuildSetup
-17
View File
@@ -83,23 +83,6 @@ HAIKU_DEFAULT_ANYBOOT_LABEL ?= Haiku ;
ProcessCommandLineArguments ; ProcessCommandLineArguments ;
# include libgccObjects
{
local libgccObjects = [ GLOB $(HAIKU_BUILD_OUTPUT_DIR) : libgccObjects ] ;
if ! $(libgccObjects) {
ECHO "No `libgccObjects' found in"
"$(HAIKU_BUILD_OUTPUT_DIR)!" ;
EXIT "Please run ./configure in the source tree's root directory"
"again!" ;
}
LOCATE on libgccObjects = $(HAIKU_BUILD_OUTPUT_DIR) ;
include libgccObjects ;
}
# supported debug levels # supported debug levels
HAIKU_DEBUG_LEVELS = 0 1 2 3 4 5 ; HAIKU_DEBUG_LEVELS = 0 1 2 3 4 5 ;
build/scripts/build_cross_tools
+8 -8
View File
@@ -1,19 +1,19 @@
#!/bin/sh #!/bin/sh
# Parameters <haiku sourcedir> <buildtools dir> <haiku output dir> # Parameters <haiku sourcedir> <buildtools dir> <install dir>
# Influential environmental variable: # Influential environmental variable:
# * haikuRequiredLegacyGCCVersion: The required version of the gcc. Will be # * haikuRequiredLegacyGCCVersion: The required version of the gcc. Will be
# checked against the version in the buildtools directory. # checked against the version in the buildtools directory.
# get and check the parameters # get and check the parameters
if [ $# -lt 3 ]; then if [ $# -lt 3 ]; then
echo Usage: $0 '<haiku sourcedir> <buildtools dir> <haiku output dir>' >&2 echo Usage: $0 '<haiku sourcedir> <buildtools dir> <install dir>' >&2
exit 1 exit 1
fi fi
haikuSourceDir=$1 haikuSourceDir=$1
buildToolsDir=$2/legacy buildToolsDir=$2/legacy
haikuOutputDir=$3 installDir=$3
shift 3 shift 3
additionalMakeArgs=$* additionalMakeArgs=$*
# Note: The gcc 2 build has trouble with -jN N > 1, hence we only use the # Note: The gcc 2 build has trouble with -jN N > 1, hence we only use the
@@ -62,7 +62,7 @@ fi
# create the output dir # create the output dir
mkdir -p $haikuOutputDir || exit 1 mkdir -p $installDir || exit 1
# get absolute paths # get absolute paths
@@ -76,13 +76,13 @@ cd $buildToolsDir
buildToolsDir=`pwd` buildToolsDir=`pwd`
cd $currentDir cd $currentDir
cd $haikuOutputDir cd $installDir
haikuOutputDir=`pwd` installDir=`pwd`
cd $currentDir
# create the object and installation directories for the cross compilation tools # create the object and installation directories for the cross compilation tools
installDir=$haikuOutputDir/cross-tools objDir=${installDir}-build
objDir=$haikuOutputDir/cross-tools-build
binutilsObjDir=$objDir/binutils binutilsObjDir=$objDir/binutils
gccObjDir=$objDir/gcc gccObjDir=$objDir/gcc
tmpIncludeDir=$objDir/sysincludes tmpIncludeDir=$objDir/sysincludes
build/scripts/build_cross_tools_gcc4
+8 -8
View File
@@ -1,18 +1,18 @@
#!/bin/sh #!/bin/sh
# #
# parameters <machine> <haiku sourcedir> <buildtools dir> <haiku output dir> # parameters <machine> <haiku sourcedir> <buildtools dir> <isntall dir>
# get and check the parameters # get and check the parameters
if [ $# -lt 4 ]; then if [ $# -lt 4 ]; then
echo Usage: $0 '<machine> <haiku sourcedir> <buildtools dir>' \ echo Usage: $0 '<machine> <haiku sourcedir> <buildtools dir>' \
'<haiku output dir>' >&2 '<install dir>' >&2
exit 1 exit 1
fi fi
haikuMachine=$1 haikuMachine=$1
haikuSourceDir=$2 haikuSourceDir=$2
buildToolsDir=$3 buildToolsDir=$3
haikuOutputDir=$4 installDir=$4
shift 4 shift 4
additionalMakeArgs=$* additionalMakeArgs=$*
@@ -68,7 +68,7 @@ fi
# create the output dir # create the output dir
mkdir -p $haikuOutputDir || exit 1 mkdir -p $installDir || exit 1
# get absolute paths # get absolute paths
@@ -82,8 +82,9 @@ cd $buildToolsDir
buildToolsDir=$(pwd) buildToolsDir=$(pwd)
cd $currentDir cd $currentDir
cd $haikuOutputDir cd $installDir
haikuOutputDir=$(pwd) installDir=$(pwd)
cd $currentDir
binutilsSourceDir=$buildToolsDir/binutils binutilsSourceDir=$buildToolsDir/binutils
gccSourceDir=$buildToolsDir/gcc gccSourceDir=$buildToolsDir/gcc
@@ -104,8 +105,7 @@ fi
find $binutilsSourceDir $gccSourceDir -name \*.info -print0 | xargs -0 touch find $binutilsSourceDir $gccSourceDir -name \*.info -print0 | xargs -0 touch
# create the object and installation directories for the cross compilation tools # create the object and installation directories for the cross compilation tools
installDir=$haikuOutputDir/cross-tools objDir=${installDir}-build
objDir=$haikuOutputDir/cross-tools-build
binutilsObjDir=$objDir/binutils binutilsObjDir=$objDir/binutils
gccObjDir=$objDir/gcc gccObjDir=$objDir/gcc
stdcxxObjDir=$objDir/stdcxx stdcxxObjDir=$objDir/stdcxx
configure
Vendored
+334 -210
View File
@@ -22,19 +22,22 @@ options:
out HaikuPorts cross-compilation repository. out HaikuPorts cross-compilation repository.
<HaikuPorts repo> is the path to a checked out <HaikuPorts repo> is the path to a checked out
HaikuPorts repository. HaikuPorts repository.
--build-cross-tools <build tools dir> --build-cross-tools <arch> [ <build tools dir> ]
Assume cross compilation. <build tools dir> Assume cross compilation. <build tools dir>
defines the location of the build tools sources. defines the location of the build tools sources.
They will be compiled and placed in the output They will be compiled and placed in the output
directory under "cross-tools". The HAIKU_* tools directory under "cross-tools". The HAIKU_* tools
variables will be set accordingly. variables will be set accordingly.
--build-cross-tools-gcc4 <arch> <build tools dir>
Like "--build-cross-tools" just that gcc 4 will
be used for cross-compilation. Note, that the
resulting Haiku installation built with gcc 4
will not be binary compatible with BeOS R5.
<arch> specifies the target architecture, either <arch> specifies the target architecture, either
"x86", "x86_64", "ppc", "m68k", "arm" or "mipsel". "x86_gcc2", "x86", "x86_64", "ppc", "m68k", "arm",
or "mipsel".
This option and --cross-tools-prefix can be
specified multiple times. The first cross tools
specify the primary tools, the subsequent ones the
secondary tools (for "hybrid" images).
For the first --build-cross-tools the
<build tools dir> argument must be specified and
for the subsequent ones it must be omitted.
--cross-tools-prefix <prefix> --cross-tools-prefix <prefix>
Assume cross compilation. <prefix> should be a Assume cross compilation. <prefix> should be a
path to the directory where the cross path to the directory where the cross
@@ -90,23 +93,32 @@ options:
less likely). less likely).
environment variables: environment variables:
HAIKU_AR The static library archiver. Defaults to "ar". HAIKU_AR_x86_gcc2 The static library archiver for x86_gcc2.
HAIKU_CC The compiler. Defaults to "gcc". Defaults to "ar".
HAIKU_LD The linker. Defaults to "ld". HAIKU_CC_x86_gcc2 The x86_gcc2 compiler. Defaults to "gcc".
HAIKU_OBJCOPY The objcopy to be used. Defaults to "objcopy". HAIKU_LD_x86_gcc2 The x86_gcc2 linker. Defaults to "ld".
HAIKU_RANLIB The static library indexer. Defaults to "ranlib". HAIKU_OBJCOPY_x86_gcc2 The x86_gcc2 objcopy to be used. Defaults to
"objcopy".
HAIKU_RANLIB_x86_gcc2 The static library indexer for x86_gcc2. Defaults
to "ranlib".
HAIKU_STRIP_x86_gcc2 The x86_gcc2 strip command. Defaults to "strip".
HAIKU_YASM The yasm assembler (x86 only). HAIKU_YASM The yasm assembler (x86 only).
HAIKU_STRIP The strip command. Defaults to "strip". HAIKU_CPPFLAGS_<arch> The preprocessor flags for target architecture
HAIKU_CPPFLAGS The preprocessor flags. Defaults to "". <arch>. Defaults to "".
HAIKU_CCFLAGS The C flags. Defaults to "". HAIKU_CCFLAGS_<arch> The C flags for target architecture <arch>.
HAIKU_CXXFLAGS The C++ flags. Defaults to "". Defaults to "".
HAIKU_LDFLAGS The linker flags. Defaults to "". HAIKU_CXXFLAGS_<arch> The C++ flags for target architecture <arch>.
HAIKU_ARFLAGS The flags passed to HAIKU_AR for archiving. Defaults to "".
Defaults to "cru". HAIKU_LDFLAGS_<arch> The linker flags for target architecture <arch>.
HAIKU_UNARFLAGS The flags passed to HAIKU_AR for unarchiving. Defaults to "".
Defaults to "x". HAIKU_ARFLAGS_<arch> The flags passed to HAIKU_AR for target
architecture <arch> for archiving. Defaults to
"cru".
HAIKU_UNARFLAGS_<arch> The flags passed to HAIKU_AR for target
architecture <arch> for unarchiving. Defaults to
"x".
Non-standard output directories: Non-default output directories:
By default all objects, build configuration, and other related files are By default all objects, build configuration, and other related files are
stored in /path/to/haiku_source/generated. To store objects in a non-default stored in /path/to/haiku_source/generated. To store objects in a non-default
location, run "../../relative/path/to/haiku_source/configure <options>" from location, run "../../relative/path/to/haiku_source/configure <options>" from
@@ -173,6 +185,8 @@ real_path()
# #
standard_gcc_settings() standard_gcc_settings()
{ {
local gcc=$1
if which greadlink > /dev/null 2>&1; then if which greadlink > /dev/null 2>&1; then
readlink="greadlink -e" readlink="greadlink -e"
elif which realpath > /dev/null 2>&1; then elif which realpath > /dev/null 2>&1; then
@@ -184,77 +198,67 @@ standard_gcc_settings()
fi fi
# PLATFORM_LINKLIBS # PLATFORM_LINKLIBS
gcclib=`$HAIKU_CC -print-libgcc-file-name` local gcclib=`$gcc -print-libgcc-file-name`
gccdir=`dirname ${gcclib}` local gccdir=`dirname ${gcclib}`
HAIKU_GCC_RAW_VERSION=`$HAIKU_CC -dumpversion` local gccRawVersion=`$gcc -dumpversion`
HAIKU_GCC_MACHINE=`$HAIKU_CC -dumpmachine` local gccMachine=`$gcc -dumpmachine`
if [ "$HAIKU_USE_GCC_GRAPHITE" != 0 ]; then
UNUSED=`echo "int main() {}" | $HAIKU_CC -xc -c -floop-block - 2>&1`
if [ $? != 0 ]; then
echo "GCC Graphite loop optimizations cannot be used"
HAIKU_USE_GCC_GRAPHITE=0
fi
fi
HAIKU_GCC_LIB_DIR=${gccdir} local libgcc=${gccdir}/libgcc.a
HAIKU_GCC_LIBGCC=${gccdir}/libgcc.a
HAIKU_GCC_GLUE_CODE="crtbegin.o crtend.o"
HAIKU_GCC_HEADERS_DIR="${gccdir}/include
${gccdir}/include-fixed"
HAIKU_GCC_LIBGCC_OBJECTS=`$HAIKU_AR t ${HAIKU_GCC_LIBGCC} | grep -v eabi.o`
# Note: We filter out eabi.o. It's present in gcc's libgcc for PPC and
# neither needed nor wanted.
# determine architecture from machine triple # determine architecture from machine triple
case $HAIKU_GCC_MACHINE in case $gccMachine in
arm-*) HAIKU_CPU=arm;; arm-*) targetCpu=arm;;
i?86-*) HAIKU_CPU=x86;; i?86-*) targetCpu=x86;;
m68k-*) HAIKU_CPU=m68k;; m68k-*) targetCpu=m68k;;
mipsel-*) HAIKU_CPU=mipsel;; mipsel-*) targetCpu=mipsel;;
powerpc-*) HAIKU_CPU=ppc;; powerpc-*) targetCpu=ppc;;
x86_64-*) HAIKU_CPU=x86_64;; x86_64-*) targetCpu=x86_64;;
*) *)
echo "Unsupported gcc target machine: $HAIKU_GCC_MACHINE" >&2 echo "Unsupported gcc target machine: $gccMachine" >&2
exit 1 exit 1
;; ;;
esac esac
HAIKU_PACKAGING_ARCH=$HAIKU_CPU local targetArch=$targetCpu
local staticLibStdCxx
local sharedLibStdCxx
local staticLibSupCxx
local sharedLibSupCxx
local kernelLibgcc
local cxxHeaders
case $HAIKU_GCC_RAW_VERSION in case $gccRawVersion in
4.*) 4.*)
# for gcc 4 we use the libstdc++ and libsupc++ that come with the # for gcc 4 we use the libstdc++ and libsupc++ that come with the
# compiler # compiler
HAIKU_STATIC_LIBSTDCXX=`$HAIKU_CC -print-file-name=libstdc++.a` staticLibStdCxx=`$gcc -print-file-name=libstdc++.a`
HAIKU_SHARED_LIBSTDCXX=`$HAIKU_CC -print-file-name=libstdc++.so` sharedLibStdCxx=`$gcc -print-file-name=libstdc++.so`
HAIKU_STATIC_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++.a` staticLibSupCxx=`$gcc -print-file-name=libsupc++.a`
HAIKU_SHARED_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++.so` sharedLibSupCxx=`$gcc -print-file-name=libsupc++.so`
# If the architecture has separate runtime libraries for the # If the architecture has separate runtime libraries for the
# kernel, use them. # kernel, use them.
HAIKU_KERNEL_LIBGCC=`$HAIKU_CC -print-file-name=libgcc-kernel.a` kernelLibgcc=`$gcc -print-file-name=libgcc-kernel.a`
if [ $HAIKU_KERNEL_LIBGCC = libgcc-kernel.a ]; then if [ $kernelLibgcc = libgcc-kernel.a ]; then
HAIKU_KERNEL_LIBGCC=$HAIKU_GCC_LIBGCC kernelLibgcc=$libgcc
fi fi
HAIKU_KERNEL_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++-kernel.a` kernelLibSupCxx=`$gcc -print-file-name=libsupc++-kernel.a`
if [ $HAIKU_KERNEL_LIBSUPCXX = libsupc++-kernel.a ]; then if [ $kernelLibSupCxx = libsupc++-kernel.a ]; then
HAIKU_KERNEL_LIBSUPCXX=$HAIKU_STATIC_LIBSUPCXX kernelLibSupCxx=$staticLibSupCxx
fi fi
local headers local headersBase=$gccdir/../../../..
if [ -d $gccdir/../../../../$HAIKU_GCC_MACHINE/include/c++/$HAIKU_GCC_RAW_VERSION ]; then local headers=$headersBase/$gccMachine/include/c++/$gccRawVersion
headers=$gccdir/../../../../$HAIKU_GCC_MACHINE/include/c++/$HAIKU_GCC_RAW_VERSION if [ ! -d $headers ]; then
else headers=$headersBase/include/c++/$gccRawVersion
headers=$gccdir/../../../../include/c++/$HAIKU_GCC_RAW_VERSION
fi fi
HAIKU_CXX_HEADERS_DIR=$headers cxxHeaders=$headers
for d in $HAIKU_GCC_MACHINE backward ext; do for d in $gccMachine backward ext; do
# Note: We need the line break, otherwise the line might become # Note: We need the line break, otherwise the line might become
# too long for jam (512 bytes max). # too long for jam (512 bytes max).
HAIKU_CXX_HEADERS_DIR="$HAIKU_CXX_HEADERS_DIR cxxHeaders="$cxxHeaders $headers/$d"
$headers/$d"
done done
# Unset the HAIKU_{SHARED,STATIC}_LIB{STD,SUP}CXX variables, if the # Unset the HAIKU_{SHARED,STATIC}_LIB{STD,SUP}CXX variables, if the
@@ -262,56 +266,113 @@ standard_gcc_settings()
# symlinks to avoid problems when copying the libraries to the # symlinks to avoid problems when copying the libraries to the
# image. # image.
if [ $HAIKU_STATIC_LIBSTDCXX = libstdc++.a ]; then if [ $staticLibStdCxx = libstdc++.a ]; then
HAIKU_STATIC_LIBSTDCXX= staticLibStdCxx=
else else
HAIKU_STATIC_LIBSTDCXX=`$readlink $HAIKU_STATIC_LIBSTDCXX` staticLibStdCxx=`$readlink $staticLibStdCxx`
fi fi
if [ $HAIKU_SHARED_LIBSTDCXX = libstdc++.so ]; then if [ $sharedLibStdCxx = libstdc++.so ]; then
HAIKU_SHARED_LIBSTDCXX= sharedLibStdCxx=
else else
HAIKU_SHARED_LIBSTDCXX=`$readlink $HAIKU_SHARED_LIBSTDCXX` sharedLibStdCxx=`$readlink $sharedLibStdCxx`
fi fi
if [ $HAIKU_STATIC_LIBSUPCXX = libsupc++.a ]; then if [ $staticLibSupCxx = libsupc++.a ]; then
HAIKU_STATIC_LIBSUPCXX= staticLibSupCxx=
else else
HAIKU_STATIC_LIBSUPCXX=`$readlink $HAIKU_STATIC_LIBSUPCXX` staticLibSupCxx=`$readlink $staticLibSupCxx`
fi fi
if [ $HAIKU_SHARED_LIBSUPCXX = libsupc++.so ]; then if [ $sharedLibSupCxx = libsupc++.so ]; then
HAIKU_SHARED_LIBSUPCXX= sharedLibSupCxx=
else else
HAIKU_SHARED_LIBSUPCXX=`$readlink $HAIKU_SHARED_LIBSUPCXX` sharedLibSupCxx=`$readlink $sharedLibSupCxx`
fi fi
;; ;;
2.9*) 2.9*)
# check for correct (most up-to-date) legacy compiler and complain # check for correct (most up-to-date) legacy compiler and complain
# if an older one is installed # if an older one is installed
if [ $HAIKU_GCC_RAW_VERSION != $haikuRequiredLegacyGCCVersion ]; then if [ $gccRawVersion != $haikuRequiredLegacyGCCVersion ]; then
echo "GCC version $haikuRequiredLegacyGCCVersion is required!"; echo "GCC version $haikuRequiredLegacyGCCVersion is required!";
echo "Please download it from www.haiku-os.org..."; echo "Please download it from www.haiku-os.org...";
exit 1; exit 1;
fi fi
HAIKU_KERNEL_LIBGCC=$HAIKU_GCC_LIBGCC kernelLibgcc=$libgcc
HAIKU_KERNEL_LIBSUPCXX= kernelLibSupCxx=
HAIKU_PACKAGING_ARCH=x86_gcc2 targetArch=x86_gcc2
;; ;;
esac esac
case $HAIKU_GCC_MACHINE in local bootLibgcc
local bootLibSupCxx
case $gccMachine in
x86_64-*) x86_64-*)
# Boot loader is 32-bit, need the 32-bit libs. # Boot loader is 32-bit, need the 32-bit libs.
HAIKU_BOOT_LIBGCC=`$HAIKU_CC -m32 -print-libgcc-file-name` bootLibgcc=`$gcc -m32 -print-libgcc-file-name`
HAIKU_BOOT_LIBSUPCXX=`$HAIKU_CC -m32 -print-file-name=libsupc++.a` bootLibSupCxx=`$gcc -m32 -print-file-name=libsupc++.a`
;; ;;
*) *)
HAIKU_BOOT_LIBGCC=$HAIKU_GCC_LIBGCC bootLibgcc=$libgcc
HAIKU_BOOT_LIBSUPCXX=$HAIKU_STATIC_LIBSUPCXX bootLibSupCxx=$staticLibSupCxx
;; ;;
esac esac
# determine whether graphite loop optimization should/can be used
local useGraphite=`get_variable HAIKU_USE_GCC_GRAPHITE_$targetCpu`
if [ -z "$useGraphite" ]; then
useGraphite=$useGccGraphiteDefault
fi
if [ "$useGraphite" != 0 ]; then
UNUSED=`echo "int main() {}" | $gcc -xc -c -floop-block - 2>&1`
if [ $? != 0 ]; then
echo "GCC Graphite loop optimizations cannot be used on $targetArch"
useGraphite=0
fi
fi
set_variable HAIKU_CPU_$targetArch $targetCpu
get_build_tool_path CC_$targetArch "$gcc"
set_variable HAIKU_GCC_RAW_VERSION_$targetArch $gccRawVersion
set_variable HAIKU_GCC_MACHINE_$targetArch $gccMachine
set_variable HAIKU_GCC_LIB_DIR_$targetArch $gccdir
set_variable HAIKU_GCC_LIBGCC_$targetArch $libgcc
set_variable HAIKU_GCC_GLUE_CODE_$targetArch "crtbegin.o crtend.o"
set_variable HAIKU_GCC_HEADERS_DIR_$targetArch \
"${gccdir}/include ${gccdir}/include-fixed"
set_variable HAIKU_STATIC_LIBSTDCXX_$targetArch "$staticLibStdCxx"
set_variable HAIKU_SHARED_LIBSTDCXX_$targetArch "$sharedLibStdCxx"
set_variable HAIKU_STATIC_LIBSUPCXX_$targetArch "$staticLibSupCxx"
set_variable HAIKU_SHARED_LIBSUPCXX_$targetArch "$sharedLibSupCxx"
set_variable HAIKU_KERNEL_LIBSUPCXX_$targetArch "$kernelLibSupCxx"
set_variable HAIKU_BOOT_LIBSUPCXX_$targetArch "$bootLibSupCxx"
set_variable HAIKU_KERNEL_LIBGCC_$targetArch $kernelLibgcc
set_variable HAIKU_CXX_HEADERS_DIR_$targetArch "$cxxHeaders"
set_variable HAIKU_BOOT_LIBGCC_$targetArch $bootLibgcc
set_variable HAIKU_USE_GCC_GRAPHITE_$targetArch $useGraphite
standard_gcc_settings_targetArch=$targetArch
}
# set_variable
#
# Set the value of a variable.
#
set_variable()
{
eval "$1=\"$2\""
}
# get_variable
#
# Echo the value of a variable.
#
get_variable()
{
eval "echo \${$1}"
} }
# set_default_value # set_default_value
@@ -330,8 +391,7 @@ set_default_value()
get_build_tool_path() get_build_tool_path()
{ {
local var="HAIKU_$1" local var="HAIKU_$1"
local tool=$2 local path=$2
local path="${crossToolsPrefix}$tool"
if [ -f "$path" ]; then if [ -f "$path" ]; then
# get absolute path # get absolute path
@@ -362,23 +422,15 @@ configureArgs="$@"
# #
platform=`uname` platform=`uname`
platformMachine=`uname -m` platformMachine=`uname -m`
crossToolsPrefix= targetArchs=
buildCrossTools= buildCrossTools=
buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools" buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
buildCrossToolsMachine=
buildCrossToolsJobs= buildCrossToolsJobs=
useGccGraphiteDefault=0
unknownArchIndex=1
# exported (BuildSetup) default parameter values # exported (BuildSetup) default parameter values
# #
HAIKU_GCC_RAW_VERSION=
HAIKU_CPU=x86
HAIKU_PACKAGING_ARCH=x86_gcc2
HAIKU_GCC_MACHINE=i586-pc-haiku
HAIKU_STATIC_LIBSTDCXX=
HAIKU_SHARED_LIBSTDCXX=
HAIKU_STATIC_LIBSUPCXX=
HAIKU_SHARED_LIBSUPCXX=
HAIKU_CXX_HEADERS_DIR=
HOST_GCC_RAW_VERSION=`gcc -dumpversion` HOST_GCC_RAW_VERSION=`gcc -dumpversion`
HOST_GCC_MACHINE=`gcc -dumpmachine` HOST_GCC_MACHINE=`gcc -dumpmachine`
HAIKU_INCLUDE_GPL_ADDONS=0 HAIKU_INCLUDE_GPL_ADDONS=0
@@ -389,7 +441,6 @@ HAIKU_ENABLE_MULTIUSER=0
HAIKU_DISTRO_COMPATIBILITY=default HAIKU_DISTRO_COMPATIBILITY=default
TARGET_PLATFORM=haiku TARGET_PLATFORM=haiku
HAIKU_USE_GCC_PIPE=0 HAIKU_USE_GCC_PIPE=0
HAIKU_USE_GCC_GRAPHITE=0
HAIKU_HOST_USE_32BIT=0 HAIKU_HOST_USE_32BIT=0
HAIKU_HOST_USE_XATTR=0 HAIKU_HOST_USE_XATTR=0
HAIKU_HOST_USE_XATTR_REF=0 HAIKU_HOST_USE_XATTR_REF=0
@@ -403,6 +454,10 @@ HOST_HAIKU_PORTER=
HAIKU_PORTS= HAIKU_PORTS=
HAIKU_PORTS_CROSS= HAIKU_PORTS_CROSS=
HAIKU_PACKAGING_ARCHS=
set_default_value HAIKU_YASM yasm
if sha256sum < /dev/null > /dev/null 2>&1; then if sha256sum < /dev/null > /dev/null 2>&1; then
HOST_SHA256=sha256sum HOST_SHA256=sha256sum
elif sha256 < /dev/null > /dev/null 2>&1; then elif sha256 < /dev/null > /dev/null 2>&1; then
@@ -416,21 +471,6 @@ haikuRequiredLegacyGCCVersion="2.95.3-haiku-2013_07_15"
export haikuRequiredLegacyGCCVersion export haikuRequiredLegacyGCCVersion
# version of legacy gcc required to build haiku # version of legacy gcc required to build haiku
set_default_value HAIKU_AR ar
set_default_value HAIKU_CC gcc
set_default_value HAIKU_LD ld
set_default_value HAIKU_OBJCOPY objcopy
set_default_value HAIKU_RANLIB ranlib
set_default_value HAIKU_ELFEDIT elfedit
set_default_value HAIKU_YASM yasm
set_default_value HAIKU_STRIP strip
set_default_value HAIKU_CPPFLAGS ""
set_default_value HAIKU_CCFLAGS ""
set_default_value HAIKU_CXXFLAGS ""
set_default_value HAIKU_LDFLAGS ""
set_default_value HAIKU_ARFLAGS cru
set_default_value HAIKU_UNARFLAGS x
# determine output directory # determine output directory
if [ "$currentDir" = "$sourceDir" ]; then if [ "$currentDir" = "$sourceDir" ]; then
outputDir=$currentDir/generated outputDir=$currentDir/generated
@@ -471,27 +511,41 @@ while [ $# -gt 0 ] ; do
HAIKU_PORTS="`absolute_path $4`" HAIKU_PORTS="`absolute_path $4`"
shift 4 shift 4
;; ;;
--build-cross-tools) assertparam "$1" $#; buildCrossTools=$2; shift 2;; --build-cross-tools)
--build-cross-tools-gcc4) if [ -z "$buildCrossTools" ]; then
assertparams "$1" 2 $# assertparams "$1" 2 $#
buildCrossTools=$3 targetArch=$2
buildCrossToolsScript="${buildCrossToolsScript}_gcc4" buildCrossTools=$3
case "$2" in shift 3
x86) HAIKU_GCC_MACHINE=i586-pc-haiku;; else
x86_64) HAIKU_GCC_MACHINE=x86_64-unknown-haiku;; assertparam "$1" $#
ppc) HAIKU_GCC_MACHINE=powerpc-apple-haiku;; targetArch=$2
m68k) HAIKU_GCC_MACHINE=m68k-unknown-haiku;; shift 2
arm) HAIKU_GCC_MACHINE=arm-unknown-haiku;; fi
mipsel) HAIKU_GCC_MACHINE=mipsel-unknown-haiku;; case "$targetArch" in
*) echo "Unsupported target architecture: $2" x86_gcc2) targetMachine=i586-pc-haiku;;
exit 1;; x86) targetMachine=i586-pc-haiku;;
x86_64) targetMachine=x86_64-unknown-haiku;;
ppc) targetMachine=powerpc-apple-haiku;;
m68k) targetMachine=m68k-unknown-haiku;;
arm) targetMachine=arm-unknown-haiku;;
mipsel) targetMachine=mipsel-unknown-haiku;;
*)
echo "Unsupported target architecture: $2" >&2
exit 1
;;
esac esac
buildCrossToolsMachine=$HAIKU_GCC_MACHINE set_variable buildCrossToolsMachine_$targetArch $targetMachine
shift 3 targetArchs="$targetArchs $targetArch"
HAIKU_PACKAGING_ARCHS=
;; ;;
--cross-tools-prefix) --cross-tools-prefix)
assertparam "$1" $# assertparam "$1" $#
crossToolsPrefix=$2 targetArch=unknown${unknownArchIndex}
set_variable crossToolsPrefix_$targetArch "$2"
targetArchs="$targetArchs $targetArch"
HAIKU_PACKAGING_ARCHS=
unknownArchIndex=$[$unknownArchIndex + 1]
shift 2 shift 2
;; ;;
--distro-compatibility) --distro-compatibility)
@@ -517,7 +571,7 @@ while [ $# -gt 0 ] ; do
-j*) buildCrossToolsJobs="$1"; shift 1;; -j*) buildCrossToolsJobs="$1"; shift 1;;
--target=*) TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;; --target=*) TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;;
--use-gcc-pipe) HAIKU_USE_GCC_PIPE=1; shift 1;; --use-gcc-pipe) HAIKU_USE_GCC_PIPE=1; shift 1;;
--use-gcc-graphite) HAIKU_USE_GCC_GRAPHITE=1; shift 1;; --use-gcc-graphite) useGccGraphiteDefault=1; shift 1;;
--use-32bit) HAIKU_HOST_USE_32BIT=1; shift 1;; --use-32bit) HAIKU_HOST_USE_32BIT=1; shift 1;;
--use-xattr) HAIKU_HOST_USE_XATTR=1; shift 1;; --use-xattr) HAIKU_HOST_USE_XATTR=1; shift 1;;
--use-xattr-ref) HAIKU_HOST_USE_XATTR_REF=1; shift 1;; --use-xattr-ref) HAIKU_HOST_USE_XATTR_REF=1; shift 1;;
@@ -578,45 +632,101 @@ if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then
HAIKU_YASM=$invalidCommand HAIKU_YASM=$invalidCommand
HAIKU_STRIP=$invalidCommand HAIKU_STRIP=$invalidCommand
else else
# build cross tools from sources if [ -n "$HAIKU_PACKAGING_ARCHS" ]; then
if [ -n "$buildCrossTools" ]; then targetArchs="$HAIKU_PACKAGING_ARCHS"
export HAIKU_USE_GCC_GRAPHITE fi
"$buildCrossToolsScript" $buildCrossToolsMachine "$sourceDir" \ HAIKU_PACKAGING_ARCHS=
"$buildCrossTools" "$outputDir" $buildCrossToolsJobs || exit 1
crossToolsPrefix="$outputDir/cross-tools/bin/${HAIKU_GCC_MACHINE}-" if [ -z "$targetArchs" ]; then
targetArch=x86_gcc2
targetArchs=$targetArch
set_default_value HAIKU_AR_$targetArch ar
set_default_value HAIKU_CC_$targetArch gcc
set_default_value HAIKU_LD_$targetArch ld
set_default_value HAIKU_OBJCOPY_$targetArch objcopy
set_default_value HAIKU_RANLIB_$targetArch ranlib
set_default_value HAIKU_ELFEDIT_$targetArch elfedit
set_default_value HAIKU_STRIP_$targetArch strip
fi fi
# cross tools for targetArch in $targetArchs; do
if [ -n "$crossToolsPrefix" ]; then # Note: targetArch is "unknown<n>" at this point, if a cross-tools
get_build_tool_path AR ar # prefix was specified. The standard_gcc_settings call below will get
get_build_tool_path CC gcc # the actual architecture.
get_build_tool_path LD ld
get_build_tool_path OBJCOPY objcopy
get_build_tool_path RANLIB ranlib
get_build_tool_path STRIP strip
fi
# prepare gcc settings crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch`
standard_gcc_settings
# cross tools for gcc4 builds # build cross tools from sources
if [ -n "$crossToolsPrefix" ]; then if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then
case $HAIKU_GCC_RAW_VERSION in crossToolsDir="$outputDir/cross-tools-$targetArch"
4.*) targetMachine=`get_variable buildCrossToolsMachine_$targetArch`
get_build_tool_path ELFEDIT elfedit script="$buildCrossToolsScript"
;; if [ $targetArch != x86_gcc2 ]; then
script="${script}_gcc4 $targetMachine"
fi
HAIKU_USE_GCC_GRAPHITE=`get_variable \
HAIKU_USE_GCC_GRAPHITE_$targetArch` \
$script "$sourceDir" "$buildCrossTools" "$crossToolsDir" \
$buildCrossToolsJobs || exit 1
crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-"
fi
# prepare gcc settings and get the actual target architecture
gcc="${crossToolsPrefix}gcc"
if [ -z "${crossToolsPrefix}" ]; then
gcc=`get_variable HAIKU_CC_$targetArch`
fi
standard_gcc_settings "$gcc"
targetArch=$standard_gcc_settings_targetArch
# set default values for flags
set_default_value HAIKU_CPPFLAGS_$targetArch ""
set_default_value HAIKU_CCFLAGS_$targetArch ""
set_default_value HAIKU_CXXFLAGS_$targetArch ""
set_default_value HAIKU_LDFLAGS_$targetArch ""
set_default_value HAIKU_ARFLAGS_$targetArch cru
set_default_value HAIKU_UNARFLAGS_$targetArch x
# Override the cross tools variables, if the tools were built or a
# prefix was specified.
if [ -n "$crossToolsPrefix" ]; then
get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar
get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld
get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy
get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib
get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip
case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in
4.*)
get_build_tool_path ELFEDIT_$targetArch \
${crossToolsPrefix}elfedit
;;
esac
fi
# Get the libgcc objects. We couldn't do that in standard_gcc_settings,
# since we need "ar", which may be set later.
ar=`get_variable HAIKU_AR_$targetArch`
libgcc=`get_variable HAIKU_GCC_LIBGCC_$targetArch`
set_variable HAIKU_GCC_LIBGCC_OBJECTS_$targetArch \
"`$ar t $libgcc | grep -v eabi.o`"
# Note: We filter out eabi.o. It's present in gcc's libgcc for PPC
# and neither needed nor wanted.
# check whether the Haiku compiler really targets Haiku
targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch`
case "$targetMachine" in
*-*-haiku) ;;
*)
echo The compiler specified as Haiku target compiler is not a \
valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
echo compiler: $HAIKU_CC
echo compiler is configured for target: $targetMachine
exit 1 ;;
esac esac
fi
# check whether the Haiku compiler really targets Haiku HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch"
case "$HAIKU_GCC_MACHINE" in done
*-*-haiku) ;;
*) echo The compiler specified as Haiku target compiler is not a valid \
Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
echo compiler: $HAIKU_CC
echo compiler is configured for target: $HAIKU_GCC_MACHINE
exit 1 ;;
esac
fi fi
# Generate BuildConfig # Generate BuildConfig
@@ -636,48 +746,16 @@ HAIKU_INCLUDE_3RDPARTY ?= "${HAIKU_INCLUDE_3RDPARTY}" ;
HAIKU_ENABLE_MULTIUSER ?= "${HAIKU_ENABLE_MULTIUSER}" ; HAIKU_ENABLE_MULTIUSER ?= "${HAIKU_ENABLE_MULTIUSER}" ;
HAIKU_DISTRO_COMPATIBILITY ?= "${HAIKU_DISTRO_COMPATIBILITY}" ; HAIKU_DISTRO_COMPATIBILITY ?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
HAIKU_USE_GCC_PIPE ?= "${HAIKU_USE_GCC_PIPE}" ; HAIKU_USE_GCC_PIPE ?= "${HAIKU_USE_GCC_PIPE}" ;
HAIKU_USE_GCC_GRAPHITE ?= "${HAIKU_USE_GCC_GRAPHITE}" ;
HAIKU_HOST_USE_32BIT ?= "${HAIKU_HOST_USE_32BIT}" ; HAIKU_HOST_USE_32BIT ?= "${HAIKU_HOST_USE_32BIT}" ;
HAIKU_HOST_USE_XATTR ?= "${HAIKU_HOST_USE_XATTR}" ; HAIKU_HOST_USE_XATTR ?= "${HAIKU_HOST_USE_XATTR}" ;
HAIKU_HOST_USE_XATTR_REF ?= "${HAIKU_HOST_USE_XATTR_REF}" ; HAIKU_HOST_USE_XATTR_REF ?= "${HAIKU_HOST_USE_XATTR_REF}" ;
HAIKU_HOST_BUILD_ONLY ?= "${HAIKU_HOST_BUILD_ONLY}" ; HAIKU_HOST_BUILD_ONLY ?= "${HAIKU_HOST_BUILD_ONLY}" ;
HAIKU_GCC_RAW_VERSION ?= ${HAIKU_GCC_RAW_VERSION} ; HAIKU_PACKAGING_ARCHS ?= ${HAIKU_PACKAGING_ARCHS} ;
HAIKU_GCC_MACHINE ?= ${HAIKU_GCC_MACHINE} ;
HAIKU_GCC_LIB_DIR ?= ${HAIKU_GCC_LIB_DIR} ;
HAIKU_GCC_HEADERS_DIR ?= ${HAIKU_GCC_HEADERS_DIR} ;
HAIKU_GCC_LIBGCC ?= ${HAIKU_GCC_LIBGCC} ;
HAIKU_CPU ?= ${HAIKU_CPU} ;
HAIKU_PACKAGING_ARCH ?= ${HAIKU_PACKAGING_ARCH} ;
HAIKU_STATIC_LIBSTDC++ ?= ${HAIKU_STATIC_LIBSTDCXX} ;
HAIKU_SHARED_LIBSTDC++ ?= ${HAIKU_SHARED_LIBSTDCXX} ;
HAIKU_STATIC_LIBSUPC++ ?= ${HAIKU_STATIC_LIBSUPCXX} ;
HAIKU_SHARED_LIBSUPC++ ?= ${HAIKU_SHARED_LIBSUPCXX} ;
HAIKU_C++_HEADERS_DIR ?= ${HAIKU_CXX_HEADERS_DIR} ;
HAIKU_KERNEL_LIBGCC ?= ${HAIKU_KERNEL_LIBGCC} ;
HAIKU_KERNEL_LIBSUPC++ ?= ${HAIKU_KERNEL_LIBSUPCXX} ;
HAIKU_BOOT_LIBGCC ?= ${HAIKU_BOOT_LIBGCC} ;
HAIKU_BOOT_LIBSUPC++ ?= ${HAIKU_BOOT_LIBSUPCXX} ;
HAIKU_BUILD_ATTRIBUTES_DIR ?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ; HAIKU_BUILD_ATTRIBUTES_DIR ?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ;
HAIKU_AR ?= ${HAIKU_AR} ;
HAIKU_CC ?= ${HAIKU_CC} ;
HAIKU_LD ?= ${HAIKU_LD} ;
HAIKU_OBJCOPY ?= ${HAIKU_OBJCOPY} ;
HAIKU_RANLIB ?= ${HAIKU_RANLIB} ;
HAIKU_ELFEDIT ?= ${HAIKU_ELFEDIT} ;
HAIKU_YASM ?= ${HAIKU_YASM} ; HAIKU_YASM ?= ${HAIKU_YASM} ;
HAIKU_STRIP ?= ${HAIKU_STRIP} ;
HAIKU_CPPFLAGS ?= ${HAIKU_CPPFLAGS} ;
HAIKU_CCFLAGS ?= ${HAIKU_CCFLAGS} ;
HAIKU_C++FLAGS ?= ${HAIKU_CXXFLAGS} ;
HAIKU_LDFLAGS ?= ${HAIKU_LDFLAGS} ;
HAIKU_ARFLAGS ?= ${HAIKU_ARFLAGS} ;
HAIKU_UNARFLAGS ?= ${HAIKU_UNARFLAGS} ;
HOST_GCC_RAW_VERSION ?= ${HOST_GCC_RAW_VERSION} ; HOST_GCC_RAW_VERSION ?= ${HOST_GCC_RAW_VERSION} ;
HOST_GCC_MACHINE ?= ${HOST_GCC_MACHINE} ; HOST_GCC_MACHINE ?= ${HOST_GCC_MACHINE} ;
@@ -692,14 +770,60 @@ HAIKU_PORTS_CROSS ?= ${HAIKU_PORTS_CROSS} ;
EOF EOF
# Libgcc.a objects for targetArch in $HAIKU_PACKAGING_ARCHS; do
variables="
HAIKU_GCC_RAW_VERSION HAIKU_GCC_RAW_VERSION
HAIKU_GCC_MACHINE HAIKU_GCC_MACHINE
HAIKU_GCC_LIB_DIR HAIKU_GCC_LIB_DIR
HAIKU_GCC_LIBGCC HAIKU_GCC_LIBGCC
HAIKU_CPU HAIKU_CPU
HAIKU_STATIC_LIBSTDC++ HAIKU_STATIC_LIBSTDCXX
HAIKU_SHARED_LIBSTDC++ HAIKU_SHARED_LIBSTDCXX
HAIKU_STATIC_LIBSUPC++ HAIKU_STATIC_LIBSUPCXX
HAIKU_SHARED_LIBSUPC++ HAIKU_SHARED_LIBSUPCXX
HAIKU_KERNEL_LIBGCC HAIKU_KERNEL_LIBGCC
HAIKU_KERNEL_LIBSUPC++ HAIKU_KERNEL_LIBSUPCXX
HAIKU_BOOT_LIBGCC HAIKU_BOOT_LIBGCC
HAIKU_BOOT_LIBSUPC++ HAIKU_BOOT_LIBSUPCXX
HAIKU_AR HAIKU_AR
HAIKU_CC HAIKU_CC
HAIKU_LD HAIKU_LD
HAIKU_OBJCOPY HAIKU_OBJCOPY
HAIKU_RANLIB HAIKU_RANLIB
HAIKU_ELFEDIT HAIKU_ELFEDIT
HAIKU_STRIP HAIKU_STRIP
HAIKU_CPPFLAGS HAIKU_CPPFLAGS
HAIKU_CCFLAGS HAIKU_CCFLAGS
HAIKU_C++FLAGS HAIKU_CXXFLAGS
HAIKU_LDFLAGS HAIKU_LDFLAGS
HAIKU_ARFLAGS HAIKU_ARFLAGS
HAIKU_UNARFLAGS HAIKU_UNARFLAGS
HAIKU_USE_GCC_GRAPHITE HAIKU_USE_GCC_GRAPHITE
"
set -- $variables
while [ $# -ge 2 ]; do
value=`get_variable ${2}_$targetArch`
echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile"
shift 2
done
cat << EOF > "$buildOutputDir/libgccObjects" # For variables that may have long values, distribute them over multiple
# libgcc.a objects to be linked against libroot.so # lines so that jam doesn't hit the maximum line length.
# Note: This file has been automatically generated by configure. variables="
HAIKU_GCC_HEADERS_DIR HAIKU_GCC_HEADERS_DIR
HAIKU_C++_HEADERS_DIR HAIKU_CXX_HEADERS_DIR
HAIKU_GCC_LIBGCC_OBJECTS HAIKU_GCC_LIBGCC_OBJECTS
"
set -- $variables
while [ $# -ge 2 ]; do
echo "${1}_${targetArch} ?= " >> "$buildConfigFile"
get_variable ${2}_$targetArch | xargs -n 1 echo " " \
>> "$buildConfigFile"
echo " ;" >> "$buildConfigFile"
shift 2
done
done
HAIKU_GCC_LIBGCC_OBJECTS ?= ${HAIKU_GCC_LIBGCC_OBJECTS} ;
EOF
# Generate a boot strap Jamfile in the output directory. # Generate a boot strap Jamfile in the output directory.