[haiku-commits] BRANCH HaikuPM-github.package-management [c0e8cc1] build/scripts
- From: HaikuPM-github.package-management <community@xxxxxxxxxxxx>
- To: haiku-commits@xxxxxxxxxxxxx
- Date: Fri, 26 Jul 2013 00:00:34 +0200 (CEST)
added 2 changesets to branch 'refs/remotes/HaikuPM-github/package-management'
old head: e2732c07a833f2fd3bfe38a285202f4f0d501abd
new head: c0e8cc1a1368c6cc99ddf1c76f8826cd5a598fd2
overview: https://github.com/haiku/HaikuPM/compare/e2732c0...c0e8cc1
----------------------------------------------------------------------------
ef57df3: configure: remove BeOS support
Likely doesn't work anymore anyway.
c0e8cc1: configure: prepare for hybrid support
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.
[ Ingo Weinhold <ingo_weinhold@xxxxxx> ]
----------------------------------------------------------------------------
5 files changed, 389 insertions(+), 256 deletions(-)
Jamrules | 37 ++
build/jam/BuildSetup | 17 -
build/scripts/build_cross_tools | 16 +-
build/scripts/build_cross_tools_gcc4 | 16 +-
configure | 559 +++++++++++++++++++------------
############################################################################
Commit: ef57df3d81efabe336b76734d2897418c3ad8098
Author: Ingo Weinhold <ingo_weinhold@xxxxxx>
Date: Wed Jul 24 22:31:25 2013 UTC
configure: remove BeOS support
Likely doesn't work anymore anyway.
----------------------------------------------------------------------------
diff --git a/configure b/configure
index 3ecb896..02fd33d 100755
--- a/configure
+++ b/configure
@@ -527,16 +527,6 @@ done
# detect the build platform
case "${platform}" in
- BeOS) revision=`uname -r`
- case "$revision" in
- 6.*) HOST_PLATFORM=dano ;;
- 5.1) HOST_PLATFORM=dano ;;
- 5.0.4) HOST_PLATFORM=bone ;;
- 5.0*) HOST_PLATFORM=r5 ;;
- *) echo Unknown BeOS version:
$revision
- exit 1 ;;
- esac
- ;;
Darwin) HOST_PLATFORM=darwin ;;
FreeBSD) HOST_PLATFORM=freebsd
SFDISK_BINARY=sfdisk-linux
@@ -618,10 +608,9 @@ else
esac
fi
- # check whether the Haiku compiler really targets Haiku or BeOS
+ # check whether the Haiku compiler really targets Haiku
case "$HAIKU_GCC_MACHINE" in
*-*-haiku) ;;
- *-*-beos) ;;
*) 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
############################################################################
Commit: c0e8cc1a1368c6cc99ddf1c76f8826cd5a598fd2
Author: Ingo Weinhold <ingo_weinhold@xxxxxx>
Date: Thu Jul 25 21:52:11 2013 UTC
configure: prepare for hybrid support
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.
----------------------------------------------------------------------------
diff --git a/Jamrules b/Jamrules
index 80189fa..accfe49 100644
--- a/Jamrules
+++ b/Jamrules
@@ -29,6 +29,43 @@ if ! $(buildConfig) {
LOCATE on BuildConfig = $(HAIKU_BUILD_OUTPUT_DIR) ;
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
# 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).
diff --git a/build/jam/BuildSetup b/build/jam/BuildSetup
index a824d7a..3ba10a1 100644
--- a/build/jam/BuildSetup
+++ b/build/jam/BuildSetup
@@ -83,23 +83,6 @@ HAIKU_DEFAULT_ANYBOOT_LABEL ?= Haiku ;
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
HAIKU_DEBUG_LEVELS = 0 1 2 3 4 5 ;
diff --git a/build/scripts/build_cross_tools b/build/scripts/build_cross_tools
index a000264..74b8405 100755
--- a/build/scripts/build_cross_tools
+++ b/build/scripts/build_cross_tools
@@ -1,19 +1,19 @@
#!/bin/sh
-# Parameters <haiku sourcedir> <buildtools dir> <haiku output dir>
+# Parameters <haiku sourcedir> <buildtools dir> <install dir>
# Influential environmental variable:
# * haikuRequiredLegacyGCCVersion: The required version of the gcc. Will be
# checked against the version in the buildtools directory.
# get and check the parameters
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
fi
haikuSourceDir=$1
buildToolsDir=$2/legacy
-haikuOutputDir=$3
+installDir=$3
shift 3
additionalMakeArgs=$*
# 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
-mkdir -p $haikuOutputDir || exit 1
+mkdir -p $installDir || exit 1
# get absolute paths
@@ -76,13 +76,13 @@ cd $buildToolsDir
buildToolsDir=`pwd`
cd $currentDir
-cd $haikuOutputDir
-haikuOutputDir=`pwd`
+cd $installDir
+installDir=`pwd`
+cd $currentDir
# create the object and installation directories for the cross compilation
tools
-installDir=$haikuOutputDir/cross-tools
-objDir=$haikuOutputDir/cross-tools-build
+objDir=${installDir}-build
binutilsObjDir=$objDir/binutils
gccObjDir=$objDir/gcc
tmpIncludeDir=$objDir/sysincludes
diff --git a/build/scripts/build_cross_tools_gcc4
b/build/scripts/build_cross_tools_gcc4
index e22ef70..0a0a695 100755
--- a/build/scripts/build_cross_tools_gcc4
+++ b/build/scripts/build_cross_tools_gcc4
@@ -1,18 +1,18 @@
#!/bin/sh
#
-# parameters <machine> <haiku sourcedir> <buildtools dir> <haiku output dir>
+# parameters <machine> <haiku sourcedir> <buildtools dir> <isntall dir>
# get and check the parameters
if [ $# -lt 4 ]; then
echo Usage: $0 '<machine> <haiku sourcedir> <buildtools dir>' \
- '<haiku output dir>' >&2
+ '<install dir>' >&2
exit 1
fi
haikuMachine=$1
haikuSourceDir=$2
buildToolsDir=$3
-haikuOutputDir=$4
+installDir=$4
shift 4
additionalMakeArgs=$*
@@ -68,7 +68,7 @@ fi
# create the output dir
-mkdir -p $haikuOutputDir || exit 1
+mkdir -p $installDir || exit 1
# get absolute paths
@@ -82,8 +82,9 @@ cd $buildToolsDir
buildToolsDir=$(pwd)
cd $currentDir
-cd $haikuOutputDir
-haikuOutputDir=$(pwd)
+cd $installDir
+installDir=$(pwd)
+cd $currentDir
binutilsSourceDir=$buildToolsDir/binutils
gccSourceDir=$buildToolsDir/gcc
@@ -104,8 +105,7 @@ fi
find $binutilsSourceDir $gccSourceDir -name \*.info -print0 | xargs -0 touch
# create the object and installation directories for the cross compilation
tools
-installDir=$haikuOutputDir/cross-tools
-objDir=$haikuOutputDir/cross-tools-build
+objDir=${installDir}-build
binutilsObjDir=$objDir/binutils
gccObjDir=$objDir/gcc
stdcxxObjDir=$objDir/stdcxx
diff --git a/configure b/configure
index 02fd33d..a416149 100755
--- a/configure
+++ b/configure
@@ -22,19 +22,22 @@ options:
out HaikuPorts cross-compilation repository.
<HaikuPorts repo> is the path to a checked out
HaikuPorts repository.
- --build-cross-tools <build tools dir>
+ --build-cross-tools <arch> [ <build tools dir> ]
Assume cross compilation. <build tools dir>
defines the location of the build tools sources.
They will be compiled and placed in the output
directory under "cross-tools". The HAIKU_* tools
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
- "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>
Assume cross compilation. <prefix> should be a
path to the directory where the cross
@@ -90,23 +93,32 @@ options:
less likely).
environment variables:
- HAIKU_AR The static library archiver. Defaults to "ar".
- HAIKU_CC The compiler. Defaults to "gcc".
- HAIKU_LD The linker. Defaults to "ld".
- HAIKU_OBJCOPY The objcopy to be used. Defaults to "objcopy".
- HAIKU_RANLIB The static library indexer. Defaults to "ranlib".
+ HAIKU_AR_x86_gcc2 The static library archiver for x86_gcc2.
+ Defaults to "ar".
+ HAIKU_CC_x86_gcc2 The x86_gcc2 compiler. Defaults to "gcc".
+ HAIKU_LD_x86_gcc2 The x86_gcc2 linker. Defaults to "ld".
+ 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_STRIP The strip command. Defaults to "strip".
- HAIKU_CPPFLAGS The preprocessor flags. Defaults to "".
- HAIKU_CCFLAGS The C flags. Defaults to "".
- HAIKU_CXXFLAGS The C++ flags. Defaults to "".
- HAIKU_LDFLAGS The linker flags. Defaults to "".
- HAIKU_ARFLAGS The flags passed to HAIKU_AR for archiving.
- Defaults to "cru".
- HAIKU_UNARFLAGS The flags passed to HAIKU_AR for unarchiving.
- Defaults to "x".
-
-Non-standard output directories:
+ HAIKU_CPPFLAGS_<arch> The preprocessor flags for target architecture
+ <arch>. Defaults to "".
+ HAIKU_CCFLAGS_<arch> The C flags for target architecture <arch>.
+ Defaults to "".
+ HAIKU_CXXFLAGS_<arch> The C++ flags for target architecture <arch>.
+ Defaults to "".
+ HAIKU_LDFLAGS_<arch> The linker flags for target architecture <arch>.
+ Defaults to "".
+ 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-default output directories:
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
location, run "../../relative/path/to/haiku_source/configure <options>" from
@@ -173,6 +185,8 @@ real_path()
#
standard_gcc_settings()
{
+ local gcc=$1
+
if which greadlink > /dev/null 2>&1; then
readlink="greadlink -e"
elif which realpath > /dev/null 2>&1; then
@@ -184,77 +198,67 @@ standard_gcc_settings()
fi
# PLATFORM_LINKLIBS
- gcclib=`$HAIKU_CC -print-libgcc-file-name`
- gccdir=`dirname ${gcclib}`
+ local gcclib=`$gcc -print-libgcc-file-name`
+ local gccdir=`dirname ${gcclib}`
- HAIKU_GCC_RAW_VERSION=`$HAIKU_CC -dumpversion`
- HAIKU_GCC_MACHINE=`$HAIKU_CC -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
+ local gccRawVersion=`$gcc -dumpversion`
+ local gccMachine=`$gcc -dumpmachine`
- HAIKU_GCC_LIB_DIR=${gccdir}
- 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.
+ local libgcc=${gccdir}/libgcc.a
# determine architecture from machine triple
- case $HAIKU_GCC_MACHINE in
- arm-*) HAIKU_CPU=arm;;
- i?86-*) HAIKU_CPU=x86;;
- m68k-*) HAIKU_CPU=m68k;;
- mipsel-*) HAIKU_CPU=mipsel;;
- powerpc-*) HAIKU_CPU=ppc;;
- x86_64-*) HAIKU_CPU=x86_64;;
+ case $gccMachine in
+ arm-*) targetCpu=arm;;
+ i?86-*) targetCpu=x86;;
+ m68k-*) targetCpu=m68k;;
+ mipsel-*) targetCpu=mipsel;;
+ powerpc-*) targetCpu=ppc;;
+ x86_64-*) targetCpu=x86_64;;
*)
- echo "Unsupported gcc target machine:
$HAIKU_GCC_MACHINE" >&2
+ echo "Unsupported gcc target machine: $gccMachine" >&2
exit 1
;;
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.*)
# for gcc 4 we use the libstdc++ and libsupc++ that
come with the
# compiler
- HAIKU_STATIC_LIBSTDCXX=`$HAIKU_CC
-print-file-name=libstdc++.a`
- HAIKU_SHARED_LIBSTDCXX=`$HAIKU_CC
-print-file-name=libstdc++.so`
- HAIKU_STATIC_LIBSUPCXX=`$HAIKU_CC
-print-file-name=libsupc++.a`
- HAIKU_SHARED_LIBSUPCXX=`$HAIKU_CC
-print-file-name=libsupc++.so`
+ staticLibStdCxx=`$gcc -print-file-name=libstdc++.a`
+ sharedLibStdCxx=`$gcc -print-file-name=libstdc++.so`
+ staticLibSupCxx=`$gcc -print-file-name=libsupc++.a`
+ sharedLibSupCxx=`$gcc -print-file-name=libsupc++.so`
# If the architecture has separate runtime libraries
for the
# kernel, use them.
- HAIKU_KERNEL_LIBGCC=`$HAIKU_CC
-print-file-name=libgcc-kernel.a`
- if [ $HAIKU_KERNEL_LIBGCC = libgcc-kernel.a ]; then
- HAIKU_KERNEL_LIBGCC=$HAIKU_GCC_LIBGCC
+ kernelLibgcc=`$gcc -print-file-name=libgcc-kernel.a`
+ if [ $kernelLibgcc = libgcc-kernel.a ]; then
+ kernelLibgcc=$libgcc
fi
- HAIKU_KERNEL_LIBSUPCXX=`$HAIKU_CC
-print-file-name=libsupc++-kernel.a`
- if [ $HAIKU_KERNEL_LIBSUPCXX = libsupc++-kernel.a ];
then
- HAIKU_KERNEL_LIBSUPCXX=$HAIKU_STATIC_LIBSUPCXX
+ kernelLibSupCxx=`$gcc
-print-file-name=libsupc++-kernel.a`
+ if [ $kernelLibSupCxx = libsupc++-kernel.a ]; then
+ kernelLibSupCxx=$staticLibSupCxx
fi
- local headers
- if [ -d
$gccdir/../../../../$HAIKU_GCC_MACHINE/include/c++/$HAIKU_GCC_RAW_VERSION ];
then
-
headers=$gccdir/../../../../$HAIKU_GCC_MACHINE/include/c++/$HAIKU_GCC_RAW_VERSION
- else
-
headers=$gccdir/../../../../include/c++/$HAIKU_GCC_RAW_VERSION
+ local headersBase=$gccdir/../../../..
+ local
headers=$headersBase/$gccMachine/include/c++/$gccRawVersion
+ if [ ! -d $headers ]; then
+ headers=$headersBase/include/c++/$gccRawVersion
fi
- HAIKU_CXX_HEADERS_DIR=$headers
- for d in $HAIKU_GCC_MACHINE backward ext; do
+ cxxHeaders=$headers
+ for d in $gccMachine backward ext; do
# Note: We need the line break, otherwise the
line might become
# too long for jam (512 bytes max).
- HAIKU_CXX_HEADERS_DIR="$HAIKU_CXX_HEADERS_DIR
- $headers/$d"
+ cxxHeaders="$cxxHeaders $headers/$d"
done
# 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
# image.
- if [ $HAIKU_STATIC_LIBSTDCXX = libstdc++.a ]; then
- HAIKU_STATIC_LIBSTDCXX=
+ if [ $staticLibStdCxx = libstdc++.a ]; then
+ staticLibStdCxx=
else
- HAIKU_STATIC_LIBSTDCXX=`$readlink
$HAIKU_STATIC_LIBSTDCXX`
+ staticLibStdCxx=`$readlink $staticLibStdCxx`
fi
- if [ $HAIKU_SHARED_LIBSTDCXX = libstdc++.so ]; then
- HAIKU_SHARED_LIBSTDCXX=
+ if [ $sharedLibStdCxx = libstdc++.so ]; then
+ sharedLibStdCxx=
else
- HAIKU_SHARED_LIBSTDCXX=`$readlink
$HAIKU_SHARED_LIBSTDCXX`
+ sharedLibStdCxx=`$readlink $sharedLibStdCxx`
fi
- if [ $HAIKU_STATIC_LIBSUPCXX = libsupc++.a ]; then
- HAIKU_STATIC_LIBSUPCXX=
+ if [ $staticLibSupCxx = libsupc++.a ]; then
+ staticLibSupCxx=
else
- HAIKU_STATIC_LIBSUPCXX=`$readlink
$HAIKU_STATIC_LIBSUPCXX`
+ staticLibSupCxx=`$readlink $staticLibSupCxx`
fi
- if [ $HAIKU_SHARED_LIBSUPCXX = libsupc++.so ]; then
- HAIKU_SHARED_LIBSUPCXX=
+ if [ $sharedLibSupCxx = libsupc++.so ]; then
+ sharedLibSupCxx=
else
- HAIKU_SHARED_LIBSUPCXX=`$readlink
$HAIKU_SHARED_LIBSUPCXX`
+ sharedLibSupCxx=`$readlink $sharedLibSupCxx`
fi
;;
2.9*)
# check for correct (most up-to-date) legacy compiler
and complain
# if an older one is installed
- if [ $HAIKU_GCC_RAW_VERSION !=
$haikuRequiredLegacyGCCVersion ]; then
+ if [ $gccRawVersion != $haikuRequiredLegacyGCCVersion
]; then
echo "GCC version
$haikuRequiredLegacyGCCVersion is required!";
echo "Please download it from
www.haiku-os.org...";
exit 1;
fi
- HAIKU_KERNEL_LIBGCC=$HAIKU_GCC_LIBGCC
- HAIKU_KERNEL_LIBSUPCXX=
- HAIKU_PACKAGING_ARCH=x86_gcc2
+ kernelLibgcc=$libgcc
+ kernelLibSupCxx=
+ targetArch=x86_gcc2
;;
esac
- case $HAIKU_GCC_MACHINE in
+ local bootLibgcc
+ local bootLibSupCxx
+ case $gccMachine in
x86_64-*)
# Boot loader is 32-bit, need the 32-bit libs.
- HAIKU_BOOT_LIBGCC=`$HAIKU_CC -m32
-print-libgcc-file-name`
- HAIKU_BOOT_LIBSUPCXX=`$HAIKU_CC -m32
-print-file-name=libsupc++.a`
+ bootLibgcc=`$gcc -m32 -print-libgcc-file-name`
+ bootLibSupCxx=`$gcc -m32 -print-file-name=libsupc++.a`
;;
*)
- HAIKU_BOOT_LIBGCC=$HAIKU_GCC_LIBGCC
- HAIKU_BOOT_LIBSUPCXX=$HAIKU_STATIC_LIBSUPCXX
+ bootLibgcc=$libgcc
+ bootLibSupCxx=$staticLibSupCxx
;;
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
@@ -330,8 +391,7 @@ set_default_value()
get_build_tool_path()
{
local var="HAIKU_$1"
- local tool=$2
- local path="${crossToolsPrefix}$tool"
+ local path=$2
if [ -f "$path" ]; then
# get absolute path
@@ -362,23 +422,15 @@ configureArgs="$@"
#
platform=`uname`
platformMachine=`uname -m`
-crossToolsPrefix=
+targetArchs=
buildCrossTools=
buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
-buildCrossToolsMachine=
buildCrossToolsJobs=
+useGccGraphiteDefault=0
+unknownArchIndex=1
# 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_MACHINE=`gcc -dumpmachine`
HAIKU_INCLUDE_GPL_ADDONS=0
@@ -389,7 +441,6 @@ HAIKU_ENABLE_MULTIUSER=0
HAIKU_DISTRO_COMPATIBILITY=default
TARGET_PLATFORM=haiku
HAIKU_USE_GCC_PIPE=0
-HAIKU_USE_GCC_GRAPHITE=0
HAIKU_HOST_USE_32BIT=0
HAIKU_HOST_USE_XATTR=0
HAIKU_HOST_USE_XATTR_REF=0
@@ -403,6 +454,10 @@ HOST_HAIKU_PORTER=
HAIKU_PORTS=
HAIKU_PORTS_CROSS=
+HAIKU_PACKAGING_ARCHS=
+
+set_default_value HAIKU_YASM yasm
+
if sha256sum < /dev/null > /dev/null 2>&1; then
HOST_SHA256=sha256sum
elif sha256 < /dev/null > /dev/null 2>&1; then
@@ -416,21 +471,6 @@ haikuRequiredLegacyGCCVersion="2.95.3-haiku-2013_07_15"
export haikuRequiredLegacyGCCVersion
# 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
if [ "$currentDir" = "$sourceDir" ]; then
outputDir=$currentDir/generated
@@ -471,27 +511,41 @@ while [ $# -gt 0 ] ; do
HAIKU_PORTS="`absolute_path $4`"
shift 4
;;
- --build-cross-tools) assertparam "$1" $#; buildCrossTools=$2;
shift 2;;
- --build-cross-tools-gcc4)
- assertparams "$1" 2 $#
- buildCrossTools=$3
- buildCrossToolsScript="${buildCrossToolsScript}_gcc4"
- case "$2" in
- x86) HAIKU_GCC_MACHINE=i586-pc-haiku;;
- x86_64) HAIKU_GCC_MACHINE=x86_64-unknown-haiku;;
- ppc) HAIKU_GCC_MACHINE=powerpc-apple-haiku;;
- m68k) HAIKU_GCC_MACHINE=m68k-unknown-haiku;;
- arm) HAIKU_GCC_MACHINE=arm-unknown-haiku;;
- mipsel) HAIKU_GCC_MACHINE=mipsel-unknown-haiku;;
- *) echo "Unsupported target
architecture: $2"
- exit 1;;
+ --build-cross-tools)
+ if [ -z "$buildCrossTools" ]; then
+ assertparams "$1" 2 $#
+ targetArch=$2
+ buildCrossTools=$3
+ shift 3
+ else
+ assertparam "$1" $#
+ targetArch=$2
+ shift 2
+ fi
+ case "$targetArch" in
+ x86_gcc2) targetMachine=i586-pc-haiku;;
+ 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
- buildCrossToolsMachine=$HAIKU_GCC_MACHINE
- shift 3
+ set_variable buildCrossToolsMachine_$targetArch
$targetMachine
+ targetArchs="$targetArchs $targetArch"
+ HAIKU_PACKAGING_ARCHS=
;;
--cross-tools-prefix)
assertparam "$1" $#
- crossToolsPrefix=$2
+ targetArch=unknown${unknownArchIndex}
+ set_variable crossToolsPrefix_$targetArch "$2"
+ targetArchs="$targetArchs $targetArch"
+ HAIKU_PACKAGING_ARCHS=
+ unknownArchIndex=$[$unknownArchIndex + 1]
shift 2
;;
--distro-compatibility)
@@ -517,7 +571,7 @@ while [ $# -gt 0 ] ; do
-j*) buildCrossToolsJobs="$1"; shift 1;;
--target=*) TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`;
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-xattr) HAIKU_HOST_USE_XATTR=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_STRIP=$invalidCommand
else
- # build cross tools from sources
- if [ -n "$buildCrossTools" ]; then
- export HAIKU_USE_GCC_GRAPHITE
- "$buildCrossToolsScript" $buildCrossToolsMachine "$sourceDir" \
- "$buildCrossTools" "$outputDir" $buildCrossToolsJobs ||
exit 1
-
crossToolsPrefix="$outputDir/cross-tools/bin/${HAIKU_GCC_MACHINE}-"
+ if [ -n "$HAIKU_PACKAGING_ARCHS" ]; then
+ targetArchs="$HAIKU_PACKAGING_ARCHS"
fi
-
- # cross tools
- if [ -n "$crossToolsPrefix" ]; then
- get_build_tool_path AR ar
- get_build_tool_path CC gcc
- get_build_tool_path LD ld
- get_build_tool_path OBJCOPY objcopy
- get_build_tool_path RANLIB ranlib
- get_build_tool_path STRIP strip
+ HAIKU_PACKAGING_ARCHS=
+
+ 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
- # prepare gcc settings
- standard_gcc_settings
+ for targetArch in $targetArchs; do
+ # Note: targetArch is "unknown<n>" at this point, if a
cross-tools
+ # prefix was specified. The standard_gcc_settings call below
will get
+ # the actual architecture.
- # cross tools for gcc4 builds
- if [ -n "$crossToolsPrefix" ]; then
- case $HAIKU_GCC_RAW_VERSION in
- 4.*)
- get_build_tool_path ELFEDIT elfedit
- ;;
+ crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch`
+
+ # build cross tools from sources
+ if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then
+ crossToolsDir="$outputDir/cross-tools-$targetArch"
+ targetMachine=`get_variable
buildCrossToolsMachine_$targetArch`
+ 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
- fi
- # check whether the Haiku compiler really targets Haiku
- case "$HAIKU_GCC_MACHINE" 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: $HAIKU_GCC_MACHINE
- exit 1 ;;
- esac
+ HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch"
+ done
fi
# Generate BuildConfig
@@ -636,48 +746,16 @@ HAIKU_INCLUDE_3RDPARTY ?=
"${HAIKU_INCLUDE_3RDPARTY}" ;
HAIKU_ENABLE_MULTIUSER ?= "${HAIKU_ENABLE_MULTIUSER}" ;
HAIKU_DISTRO_COMPATIBILITY ?=
"${HAIKU_DISTRO_COMPATIBILITY}" ;
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_XATTR ?= "${HAIKU_HOST_USE_XATTR}" ;
HAIKU_HOST_USE_XATTR_REF ?=
"${HAIKU_HOST_USE_XATTR_REF}" ;
HAIKU_HOST_BUILD_ONLY ?= "${HAIKU_HOST_BUILD_ONLY}" ;
-HAIKU_GCC_RAW_VERSION ?= ${HAIKU_GCC_RAW_VERSION} ;
-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_PACKAGING_ARCHS ?= ${HAIKU_PACKAGING_ARCHS} ;
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_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_MACHINE ?= ${HOST_GCC_MACHINE} ;
@@ -692,14 +770,60 @@ HAIKU_PORTS_CROSS ?= ${HAIKU_PORTS_CROSS}
;
EOF
-# Libgcc.a objects
-
-cat << EOF > "$buildOutputDir/libgccObjects"
-# libgcc.a objects to be linked against libroot.so
-# Note: This file has been automatically generated by configure.
+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
+
+ # For variables that may have long values, distribute them over multiple
+ # lines so that jam doesn't hit the maximum line length.
+ 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.
Other related posts:
- » [haiku-commits] BRANCH HaikuPM-github.package-management [c0e8cc1] build/scripts - HaikuPM-github . package-management
