coreboot-kgpe-d16/util/crossgcc/buildgcc

1010 lines
30 KiB
Plaintext
Raw Normal View History

#!/bin/sh
#
# Copyright (C) 2008-2010 by coresystems GmbH
# written by Patrick Georgi <patrick.georgi@coresystems.de> and
# Stefan Reinauer <stefan.reinauer@coresystems.de>
#
# Copyright (C) 2011 by Sage Electronic Engineering
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
cd $(dirname $0)
CROSSGCC_DATE="August 31st, 2016"
CROSSGCC_VERSION="1.43"
CROSSGCC_COMMIT=$( git describe )
# default settings
PACKAGE=GCC
TARGETDIR=$(pwd)/xgcc
TARGETARCH=i386-elf
DEFAULT_LANGUAGES=c
LANGUAGES=
DESTDIR=
SAVETEMPS=0
SKIPPYTHON=1
buildgcc: Add option to bootstrap a host gcc Bootstrapping gcc is the recommended way if your host gcc's version doesn't match the gcc version you're going to build. While a build with an outdated host gcc usually succeeds, an outdated gnat seems to be a bigger issue. v3: Some library controversy: gcc likes the libraries it ships with most but we don't want to install shared libraries. So we build them static --disable-shared) and install only the minimum (libgcc, libada, libstdc++). However, as the code of these libraries might be used to build a shared library we have to compile them with `-fPIC`. v4: o Updated getopt strings. o The workaround for clang (-fbracket-depth=1024) isn't needed for bootstrapping and also breaks the build, as clang is only used for the first stage in that case and gcc doesn't know that option. So far build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Ubuntu 14.04 "Trusty Tahr" (i386) o Debian 8 "Jessie" (x86_64) (building python (-S) works too) o current Arch Linux (x86_64) o FreeBSD 10.3 (x86_64) (with gcc-aux package) and with clang host compiler, thus C only: `make BUILDGCC_OPTIONS="-b"` on o Debian 8 "Jessie" (x86_64) o FreeBSD 10.3 (x86_64) v5: Rebased after toolchain updates to GCC 5.3.0 etc. Build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Debian 8 "Jessie" (x86_64) Change-Id: Icb47d3e9dbafc55737fbc3ce62a084fb9d5f359a Signed-off-by: Nico Huber <nico.huber@secunet.com> Reviewed-on: https://review.coreboot.org/13473 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi@google.com>
2016-01-26 16:10:17 +01:00
BOOTSTRAP=0
THREADS=1
# GCC toolchain version numbers
GMP_VERSION=6.1.0
MPFR_VERSION=3.1.4
util/crossgcc/buildgcc: Upgrade MPC from 1.0.1 to 1.0.3 The following changes are included. Changes in version 1.0.3: - Fixed mpc_pow, see http://lists.gforge.inria.fr/pipermail/mpc-discuss/2014-October/001315.html - #18257: Switched to libtool 2.4.5. Changes in version 1.0.2: - Fixed mpc_atan, mpc_atanh for (+-0, +-1), see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57994#c7 - Fixed mpc_log10 for purely imaginary argument, see http://lists.gforge.inria.fr/pipermail/mpc-discuss/2012-September/001208.html Upgrading also fixes the issue, where for example running `make crossgcc-arm` ails as MPC cannot be built. Building MPC 1.0.1 ... failed As it worked for others, it turns out that I had a release archive for MPC 1.0.1 cached from October 2014, which was generated incorrectly, so that `./configure` and `Makefile` are missing. $ LANG=C ls -l util/crossgcc/tarballs/mpc-1.0.1.tar.gz -rw-r--r-- 1 joey joey 224232 Oct 19 2013 util/crossgcc/tarballs/mpc-1.0.1.tar.gz $ md5sum util/crossgcc/tarballs/mpc-1.0.1.tar.gz 22a27bee89616dca4d654fc579a816e5 util/crossgcc/tarballs/mpc-1.0.1.tar.gz $ md5sum mpc-1.0.1.tar.gz # downloaded today b32a2e1a3daa392372fbd586d1ed3679 mpc-1.0.1.tar.gz So upgrade to MPC 1.0.3 as the release archive as of today contains the needed files. $ md5sum util/crossgcc/tarballs/mpc-1.0.3.tar.gz d6a1d5f8ddea3abd2cc3e98f58352d26 util/crossgcc/tarballs/mpc-1.0.3.tar.gz Change-Id: Ibfd02a9b362b12361b210d512420b87caebb0fdf Signed-off-by: Paul Menzel <paulepanter@users.sourceforge.net> TEST:Run `make crossgcc-arm` and observe `Building MPC 1.0.3 ... ok`. Reviewed-on: http://review.coreboot.org/8521 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi@google.com> Reviewed-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
2015-02-23 10:33:59 +01:00
MPC_VERSION=1.0.3
LIBELF_VERSION=0.8.13
GCC_VERSION=5.3.0
GCC_AUTOCONF_VERSION=2.69
BINUTILS_VERSION=2.26.1
GDB_VERSION=7.11
IASL_VERSION=20160831
PYTHON_VERSION=3.5.1
EXPAT_VERSION=2.1.1
# CLANG version number
CLANG_VERSION=3.8.0
MAKE_VERSION=4.2.1
# GCC toolchain archive locations
# These are sanitized by the jenkins toolchain test builder, so if
# a completely new URL is added here, it probably needs to be added
# to the jenkins build as well, or the builder won't download it.
GMP_ARCHIVE="http://ftpmirror.gnu.org/gmp/gmp-${GMP_VERSION}.tar.xz"
MPFR_ARCHIVE="http://ftpmirror.gnu.org/mpfr/mpfr-${MPFR_VERSION}.tar.xz"
MPC_ARCHIVE="http://ftpmirror.gnu.org/mpc/mpc-${MPC_VERSION}.tar.gz"
LIBELF_ARCHIVE="http://www.mr511.de/software/libelf-${LIBELF_VERSION}.tar.gz"
GCC_ARCHIVE="http://ftpmirror.gnu.org/gcc/gcc-${GCC_VERSION}/gcc-${GCC_VERSION}.tar.bz2"
BINUTILS_ARCHIVE="http://ftpmirror.gnu.org/binutils/binutils-${BINUTILS_VERSION}.tar.bz2"
GDB_ARCHIVE="http://ftpmirror.gnu.org/gdb/gdb-${GDB_VERSION}.tar.xz"
IASL_ARCHIVE="https://acpica.org/sites/acpica/files/acpica-unix2-${IASL_VERSION}.tar.gz"
PYTHON_ARCHIVE="http://www.python.org/ftp/python/${PYTHON_VERSION}/Python-${PYTHON_VERSION}.tar.xz"
EXPAT_ARCHIVE="http://downloads.sourceforge.net/sourceforge/expat/expat-${EXPAT_VERSION}.tar.bz2"
# CLANG toolchain archive locations
LLVM_ARCHIVE="http://llvm.org/releases/${CLANG_VERSION}/llvm-${CLANG_VERSION}.src.tar.xz"
CFE_ARCHIVE="http://llvm.org/releases/${CLANG_VERSION}/cfe-${CLANG_VERSION}.src.tar.xz"
CRT_ARCHIVE="http://llvm.org/releases/${CLANG_VERSION}/compiler-rt-${CLANG_VERSION}.src.tar.xz"
CTE_ARCHIVE="http://llvm.org/releases/${CLANG_VERSION}/clang-tools-extra-${CLANG_VERSION}.src.tar.xz"
MAKE_ARCHIVE="http://ftpmirror.gnu.org/make/make-${MAKE_VERSION}.tar.bz2"
ALL_ARCHIVES="$GMP_ARCHIVE $MPFR_ARCHIVE $MPC_ARCHIVE $LIBELF_ARCHIVE \
$GCC_ARCHIVE $BINUTILS_ARCHIVE $GDB_ARCHIVE $IASL_ARCHIVE \
$PYTHON_ARCHIVE $EXPAT_ARCHIVE $LLVM_ARCHIVE $CFE_ARCHIVE \
$CRT_ARCHIVE $CTE_ARCHIVE $MAKE_ARCHIVE"
# GCC toolchain directories
GMP_DIR="gmp-${GMP_VERSION}"
MPFR_DIR="mpfr-${MPFR_VERSION}"
MPC_DIR="mpc-${MPC_VERSION}"
LIBELF_DIR="libelf-${LIBELF_VERSION}"
GCC_DIR="gcc-${GCC_VERSION}"
BINUTILS_DIR="binutils-${BINUTILS_VERSION}"
GDB_DIR="gdb-${GDB_VERSION}"
IASL_DIR="acpica-unix2-${IASL_VERSION}"
PYTHON_DIR="Python-${PYTHON_VERSION}"
EXPAT_DIR="expat-${EXPAT_VERSION}"
# CLANG toolchain directories
LLVM_DIR="llvm-${CLANG_VERSION}.src"
CFE_DIR="cfe-${CLANG_VERSION}.src"
CRT_DIR="compiler-rt-${CLANG_VERSION}.src"
CTE_DIR="clang-tools-extra-${CLANG_VERSION}.src"
MAKE_DIR="make-${MAKE_VERSION}"
unset MAKELEVEL MAKEFLAGS
red='\033[0;31m'
RED='\033[1;31m'
green='\033[0;32m'
GREEN='\033[1;32m'
blue='\033[0;34m'
BLUE='\033[1;34m'
cyan='\033[0;36m'
CYAN='\033[1;36m'
NC='\033[0m' # No Color
UNAME=$(uname | grep -iq cygwin && echo Cygwin || uname)
HALT_FOR_TOOLS=0
normalize_dirs()
{
mkdir -p $DESTDIR$TARGETDIR/lib
test -d $DESTDIR$TARGETDIR/lib32 && mv $DESTDIR$TARGETDIR/lib32/* $DESTDIR$TARGETDIR/lib
test -d $DESTDIR$TARGETDIR/lib64 && mv $DESTDIR$TARGETDIR/lib64/* $DESTDIR$TARGETDIR/lib
rmdir -p $DESTDIR$TARGETDIR/lib32 $DESTDIR$TARGETDIR/lib64
perl -pi -e "s,/lib32,/lib," $DESTDIR$TARGETDIR/lib/*.la
perl -pi -e "s,/lib64,/lib," $DESTDIR$TARGETDIR/lib/*.la
}
please_install()
{
HALT_FOR_TOOLS=1
test -r /etc/os-release && . /etc/os-release
case "$ID_LIKE" in
debian) solution="sudo apt-get install $1" ;;
suse) solution="sudo zypper install $1" ;;
*) solution="using your OS packaging system" ;;
esac
printf "${RED}ERROR:${red} Missing tool: Please install '$1'. (eg $solution)${NC}\n" >&2
if [ -n "$2" ]; then
printf "${RED}ERROR:${red} or install '$2'.${NC}\n" >&2
fi
}
searchtool()
{
# $1 short name
# $2 search string
# $3 soft fail if set
# $4 alternative package to install on failure
# result: file name of that tool on stdout
# or no output if nothing suitable was found
search=GNU
if [ -n "$2" ]; then
search="$2"
fi
for i in "$1" "g$1" "gnu$1"; do
if [ -x "$(which $i 2>/dev/null)" ]; then
if [ "$(cat /dev/null | $i --version 2>&1 | grep -c "$search")" \
-gt 0 ]; then
echo $i
return
fi
fi
done
# A workaround for OSX 10.9 and some BSDs, whose nongnu
# patch and tar also work.
if [ $UNAME = "Darwin" -o $UNAME = "FreeBSD" -o $UNAME = "NetBSD" -o $UNAME = "OpenBSD" ]; then
if [ "$1" = "patch" -o "$1" = "tar" ]; then
if [ -x "$(which $1 2>/dev/null)" ]; then
echo $1
return
fi
fi
fi
if echo $1 | grep -q "sum" ; then
algor=$(echo $1 | sed -e 's,sum,,')
if [ -x "$(which $1 2>/dev/null)" ]; then
#xxxsum [file]
echo $1
return
elif [ -x "$(which $algor 2>/dev/null)" ]; then
#xxx [file]
echo $algor
return
elif [ -x "$(which openssl 2>/dev/null)" ]; then
#openssl xxx [file]
echo openssl $algor
return
elif [ -x "$(which cksum 2>/dev/null)" ]; then
#cksum -a xxx [file]
#cksum has special options in NetBSD. Actually, NetBSD will use the second case above.
echo "buildgcc" | cksum -a $algor > /dev/null 2>/dev/null && \
echo cksum -a $algor
return
fi
fi
[ -z "$3" ] && please_install $1 $4
false
}
# Run a compile check of the specified library option to see if it's installed
check_for_library() {
local LIBRARY_FLAGS=$1
local LIBRARY_PACKAGES="$2"
local LIBTEST_FILE=.libtest
echo "int main(int argc, char **argv) { (void) argc; (void) argv; return 0; }" > "${LIBTEST_FILE}.c"
cc $CFLAGS $LIBRARY_FLAGS "${LIBTEST_FILE}.c" -o "${LIBTEST_FILE}" >/dev/null 2>&1 || \
please_install "$LIBRARY_PACKAGES"
rm -rf "${LIBTEST_FILE}.c" "${LIBTEST_FILE}"
}
buildcc_major() {
echo "${GCC_VERSION}" | cut -d. -f1
}
buildcc_minor() {
echo "${GCC_VERSION}" | cut -d. -f2
}
buildcc_version() {
echo "${GCC_VERSION}" | cut -d. -f1-2
}
hostcc_major() {
(echo __GNUC__ | ${CC} -E - 2>/dev/null || echo 0) | tail -1
}
hostcc_minor() {
(echo __GNUC_MINOR__ | ${CC} -E - 2>/dev/null || echo 0) | tail -1
}
hostcc_version() {
printf "%d.%d" "$(hostcc_major)" "$(hostcc_minor)"
}
hostcc_has_gnat1() {
[ -x "$(${CC} -print-prog-name=gnat1)" ]
}
ada_requested() {
echo "${LANGUAGES}" | grep -q '\<ada\>'
}
check_gnat() {
if hostcc_has_gnat1; then
if [ \( "$(hostcc_major)" -lt "$(buildcc_major)" -o \
\( "$(hostcc_major)" -eq "$(buildcc_major)" -a \
"$(hostcc_minor)" -lt "$(buildcc_minor)" \) \) \
-a \
"${BOOTSTRAP}" != "1" ]; \
then
printf "\n${RED}ERROR:${red} Building the Ada compiler (gnat $(buildcc_version)) "
printf "with an older host compiler\n version ($(hostcc_version)) "
printf "requires bootstrapping (-b).${NC}\n\n"
HALT_FOR_TOOLS=1
fi
else
please_install gnat
fi
}
check_cc() {
if is_package_enabled "GCC"; then
if [ "$(hostcc_major)" != "$(buildcc_major)" -a "${BOOTSTRAP}" != "1" ]; then
printf "\n${red}warning: Building GCC $(buildcc_version) with a different major "
printf "version ($(hostcc_version)).\n"
printf " Bootstrapping (-b) is recommended.${NC}\n\n"
fi
if ada_requested; then
check_gnat
fi
fi
}
check_sum() {
test -z "$CHECKSUM" || \
test "$(cat sum/$1.cksum 2>/dev/null | sed -e 's@.*\([0-9a-f]\{40,\}\).*@\1@')" = \
"$($CHECKSUM tarballs/$1 2>/dev/null | sed -e 's@.*\([0-9a-f]\{40,\}\).*@\1@')"
}
compute_sum() {
test ! -f sum/$1.cksum && test -f tarballs/$1 && \
(test -z "$CHECKSUM" || $CHECKSUM tarballs/$1 > sum/$1.cksum ) && \
printf "(checksum created. ${RED}Note. Please upload sum/$1.cksum if the corresponding archive is upgraded.)${NC}"
}
download() {
package=$1
archive="$(eval echo \$$package"_ARCHIVE")"
FILE=$(basename $archive)
printf " * $FILE "
if test -f tarballs/$FILE && check_sum $FILE ; then
echo "(cached)"
else
printf "(downloading from $archive)"
rm -f tarballs/$FILE
cd tarballs
download_showing_percentage $archive
cd ..
compute_sum $FILE
fi
if [ ! -f tarballs/$FILE ]; then
printf "${RED}Failed to download $FILE.${NC}\n"
exit 1
fi
}
unpack_and_patch() {
package=$1
archive="$(eval echo \$$package"_ARCHIVE")"
dir="$(eval echo \$$package"_DIR")"
test -d ${dir} && test -f ${dir}/.unpack_success || (
printf " * $(basename $archive)\n"
FLAGS=zxf
suffix=$(echo $archive | sed 's,.*\.,,')
if [ "$suffix" = "gz" ] && [ -n "$PIGZ" ]; then FLAGS="-I pigz -xf"
elif [ "$suffix" = "gz" ]; then FLAGS=zxf
elif [ "$suffix" = "bz2" ] && [ -n "$LBZIP2" ]; then FLAGS="-I lbzip2 -xf"
elif [ "$suffix" = "bz2" ]; then FLAGS=jxf
elif [ "$suffix" = "xz" ]; then FLAGS="--xz -xf"
elif [ "$suffix" = "lzma" ]; then FLAGS="--lzma -xf"
fi
$TAR $FLAGS tarballs/$(basename $archive)
for patch in patches/${dir}_*.patch; do
test -r $patch || continue
printf " o $(basename $patch)\n"
(cd ${dir} && $PATCH -s -N -p1 <../${patch}) || {
printf "\n${RED}Failed $patch.${NC}\n"
exit 1
}
done
touch ${dir}/.unpack_success
)
}
fn_exists()
{
type $1 >/dev/null 2>&1
}
is_package_enabled()
{
echo "$PACKAGES" |grep -q "\<$1\>"
}
package_uses_targetarch()
{
if [ "$1" = "GCC" ] || [ "$1" = "GDB" ] || [ "$1" = "BINUTILS" ]; then
true
else
false
fi
}
generic_build()
{
package=$1
host_target=$2
builddir=$3
success=$4
version=$5
fn_exists build_$package || return
mkdir -p "$builddir"
if [ -f "$success" ]; then
printf "Skipping $package v$version for $host_target as it is already built\n"
else
printf "Building $package v$version for $host_target ... "
DIR="$PWD"
cd "$builddir"
rm -f .failed
build_${package} $host_target > build.log 2>&1
cd "$DIR"
if [ ! -f "$builddir/.failed" ]; then
touch "$success";
else
printf "${RED}failed${NC}. Check $builddir/build.log.\n"
exit 1
fi
printf "${green}ok${NC}\n"
fi
}
build_for_host()
{
package="$1"
version="$(eval echo \$$package"_VERSION")"
generic_build "$package" host "build-$package" "${DESTDIR}${TARGETDIR}/.${package}.${version}.success" "$version"
}
build_for_target()
{
package="$1"
version="$(eval echo \$$package"_VERSION")"
generic_build "$package" target "build-${TARGETARCH}-$package" "${DESTDIR}${TARGETDIR}/.${TARGETARCH}-${package}.${version}.success" "$version"
}
build()
{
if package_uses_targetarch $1; then
if [ $BOOTSTRAP -eq 1 -a ! -f "${DESTDIR}${TARGETDIR}/.GCC.success" ]; then
buildgcc: Add option to bootstrap a host gcc Bootstrapping gcc is the recommended way if your host gcc's version doesn't match the gcc version you're going to build. While a build with an outdated host gcc usually succeeds, an outdated gnat seems to be a bigger issue. v3: Some library controversy: gcc likes the libraries it ships with most but we don't want to install shared libraries. So we build them static --disable-shared) and install only the minimum (libgcc, libada, libstdc++). However, as the code of these libraries might be used to build a shared library we have to compile them with `-fPIC`. v4: o Updated getopt strings. o The workaround for clang (-fbracket-depth=1024) isn't needed for bootstrapping and also breaks the build, as clang is only used for the first stage in that case and gcc doesn't know that option. So far build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Ubuntu 14.04 "Trusty Tahr" (i386) o Debian 8 "Jessie" (x86_64) (building python (-S) works too) o current Arch Linux (x86_64) o FreeBSD 10.3 (x86_64) (with gcc-aux package) and with clang host compiler, thus C only: `make BUILDGCC_OPTIONS="-b"` on o Debian 8 "Jessie" (x86_64) o FreeBSD 10.3 (x86_64) v5: Rebased after toolchain updates to GCC 5.3.0 etc. Build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Debian 8 "Jessie" (x86_64) Change-Id: Icb47d3e9dbafc55737fbc3ce62a084fb9d5f359a Signed-off-by: Nico Huber <nico.huber@secunet.com> Reviewed-on: https://review.coreboot.org/13473 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi@google.com>
2016-01-26 16:10:17 +01:00
build_for_host GCC
fi
build_for_target $1
else
build_for_host $1
fi
}
quit()
{
printf "${NC}Stop\n"
exit 1
}
cleanup()
{
if [ $SAVETEMPS -ne 0 ]; then
printf "Leaving temporary files around... ${green}ok${NC}\n"
return
fi
printf "Cleaning up temporary files... "
for package in $PACKAGES; do
rm -rf build-${TARGETARCH}-$package build-$package $(eval echo \$$package"_DIR")
done
rm -f getopt
printf "${green}ok${NC}\n"
}
myhelp()
{
printf "Usage: $0 [-V] [-c] [-p <platform>] [-d <target directory>] [-D <dest dir>] [-C] [-G] [-S]\n"
printf " $0 [-V|--version]\n"
printf " $0 [-h|--help]\n\n"
printf "Options:\n"
printf " [-V|--version] print version number and exit\n"
printf " [-h|--help] print this help and exit\n"
printf " [-c|--clean] remove temporary files before build\n"
printf " [-t|--savetemps] don't remove temporary files after build\n"
printf " [-y|--ccache] Use ccache when building cross compiler\n"
printf " [-n|--nocolor] don't print color codes in output\n"
printf " [-u|--urls] print the urls for all packages\n"
printf " [-j|--jobs <num>] run <num> jobs in parallel in make\n"
printf " [-s]--supported <tool> print supported version of a tool\n"
printf " [-d|--directory <target dir>] target directory to install cross compiler to\n"
printf " (defaults to $TARGETDIR)\n\n"
printf " [-D|--destdir <dest dir>] destination directory to install cross compiler to\n"
printf " (for RPM builds, default unset)\n"
printf " [-P|--package <package>] Build a specific package: GCC, CLANG, IASL, GDB\n"
printf " (defaults to $PACKAGE)\n"
printf "GCC specific options:\n"
buildgcc: Add option to bootstrap a host gcc Bootstrapping gcc is the recommended way if your host gcc's version doesn't match the gcc version you're going to build. While a build with an outdated host gcc usually succeeds, an outdated gnat seems to be a bigger issue. v3: Some library controversy: gcc likes the libraries it ships with most but we don't want to install shared libraries. So we build them static --disable-shared) and install only the minimum (libgcc, libada, libstdc++). However, as the code of these libraries might be used to build a shared library we have to compile them with `-fPIC`. v4: o Updated getopt strings. o The workaround for clang (-fbracket-depth=1024) isn't needed for bootstrapping and also breaks the build, as clang is only used for the first stage in that case and gcc doesn't know that option. So far build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Ubuntu 14.04 "Trusty Tahr" (i386) o Debian 8 "Jessie" (x86_64) (building python (-S) works too) o current Arch Linux (x86_64) o FreeBSD 10.3 (x86_64) (with gcc-aux package) and with clang host compiler, thus C only: `make BUILDGCC_OPTIONS="-b"` on o Debian 8 "Jessie" (x86_64) o FreeBSD 10.3 (x86_64) v5: Rebased after toolchain updates to GCC 5.3.0 etc. Build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Debian 8 "Jessie" (x86_64) Change-Id: Icb47d3e9dbafc55737fbc3ce62a084fb9d5f359a Signed-off-by: Nico Huber <nico.huber@secunet.com> Reviewed-on: https://review.coreboot.org/13473 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi@google.com>
2016-01-26 16:10:17 +01:00
printf " [-b|--bootstrap] bootstrap the host compiler before building\n"
printf " the cross compiler\n"
printf " [-p|--platform <platform>] target platform to build cross compiler for\n"
printf " (defaults to $TARGETARCH)\n"
printf " [-l|--languages <languages>] comma separated list of target languages\n"
printf " (defaults to $DEFAULT_LANGUAGES)\n"
printf "GDB specific options:\n"
printf " [-p|--platform <platform>] target platform to build cross compiler for\n"
printf " (defaults to $TARGETARCH)\n"
printf " [-S|--scripting] build scripting support for GDB\n\n"
printf "Platforms for GCC & GDB:\n"
printf " x86_64 i386-elf i386-mingw32 mipsel-elf riscv-elf arm aarch64\n"
printf " powerpc64le-linux-gnu nds32le-elf\n\n"
}
printversion() {
printf "${blue}Welcome to the ${red}coreboot${blue} cross toolchain builder v$CROSSGCC_VERSION ($CROSSGCC_DATE)${NC}\n\n"
}
myversion()
{
printversion
cat << EOF
Copyright (C) 2008-2010 by coresystems GmbH
Copyright (C) 2011 by Sage Electronic Engineering
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
EOF
}
have_hostcflags_from_gmp() {
grep -q __GMP_CFLAGS $DESTDIR$TARGETDIR/include/gmp.h >/dev/null 2>&1
}
set_hostcflags_from_gmp() {
# Now set CFLAGS to match GMP CFLAGS but strip out -pedantic
# as GCC 4.6.x fails if it's there.
export HOSTCFLAGS="$(grep __GMP_CFLAGS $DESTDIR$TARGETDIR/include/gmp.h |cut -d\" -f2 |\
sed s,-pedantic,,)"
}
build_GMP() {
# Check if GCC enables `-pie` by default (possible since GCC 6).
# We need PIC in all static libraries then.
if $CC -dumpspecs 2>/dev/null | grep -q '[{;][[:space:]]*:-pie\>'
then
OPTIONS="$OPTIONS --with-pic"
fi
CC="$CC" ../${GMP_DIR}/configure --disable-shared --enable-fat \
--prefix=$TARGETDIR $OPTIONS \
|| touch .failed
$MAKE $JOBS || touch .failed
$MAKE install DESTDIR=$DESTDIR || touch .failed
normalize_dirs
set_hostcflags_from_gmp
}
build_MPFR() {
test $UNAME = "Darwin" && CFLAGS="$CFLAGS -force_cpusubtype_ALL"
CC="$CC" ../${MPFR_DIR}/configure --disable-shared --prefix=$TARGETDIR \
--infodir=$TARGETDIR/info \
--with-gmp=$DESTDIR$TARGETDIR CFLAGS="$HOSTCFLAGS" || \
touch .failed
$MAKE $JOBS || touch .failed
$MAKE install DESTDIR=$DESTDIR || touch .failed
normalize_dirs
# work around build problem of libgmp.la
if [ "$DESTDIR" != "" ]; then
perl -pi -e "s,$DESTDIR,," $DESTDIR$TARGETDIR/libgmp.la
fi
}
build_MPC() {
CC="$CC" ../${MPC_DIR}/configure --disable-shared --prefix=$TARGETDIR \
--infodir=$TARGETDIR/info --with-mpfr=$DESTDIR$TARGETDIR \
--with-gmp=$DESTDIR$TARGETDIR CFLAGS="$HOSTCFLAGS" || \
touch .failed
$MAKE $JOBS || touch .failed
$MAKE install DESTDIR=$DESTDIR || touch .failed
normalize_dirs
}
build_LIBELF() {
CC="$CC" CFLAGS="$HOSTCFLAGS" libelf_cv_elf_h_works=no \
../${LIBELF_DIR}/configure --disable-shared --prefix=$TARGETDIR \
--infodir=$TARGETDIR/info CFLAGS="$HOSTCFLAGS" || touch .failed
$MAKE $JOBS || touch .failed
$MAKE install prefix=$DESTDIR$TARGETDIR || touch .failed
normalize_dirs
}
build_BINUTILS() {
if [ $TARGETARCH = "x86_64-elf" ]; then
ADDITIONALTARGET=",i386-elf"
fi
CC="$CC" ../binutils-${BINUTILS_VERSION}/configure --prefix=$TARGETDIR \
--target=${TARGETARCH} --enable-targets=${TARGETARCH}${ADDITIONALTARGET} \
--disable-werror --disable-nls --enable-lto --enable-gold \
--enable-interwork --enable-multilib \
--enable-plugins --enable-multilibs
CFLAGS="$HOSTCFLAGS" \
CXXFLAGS="$HOSTCFLAGS" \
|| touch .failed
$MAKE $JOBS || touch .failed
$MAKE install DESTDIR=$DESTDIR || touch .failed
}
buildgcc: Add option to bootstrap a host gcc Bootstrapping gcc is the recommended way if your host gcc's version doesn't match the gcc version you're going to build. While a build with an outdated host gcc usually succeeds, an outdated gnat seems to be a bigger issue. v3: Some library controversy: gcc likes the libraries it ships with most but we don't want to install shared libraries. So we build them static --disable-shared) and install only the minimum (libgcc, libada, libstdc++). However, as the code of these libraries might be used to build a shared library we have to compile them with `-fPIC`. v4: o Updated getopt strings. o The workaround for clang (-fbracket-depth=1024) isn't needed for bootstrapping and also breaks the build, as clang is only used for the first stage in that case and gcc doesn't know that option. So far build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Ubuntu 14.04 "Trusty Tahr" (i386) o Debian 8 "Jessie" (x86_64) (building python (-S) works too) o current Arch Linux (x86_64) o FreeBSD 10.3 (x86_64) (with gcc-aux package) and with clang host compiler, thus C only: `make BUILDGCC_OPTIONS="-b"` on o Debian 8 "Jessie" (x86_64) o FreeBSD 10.3 (x86_64) v5: Rebased after toolchain updates to GCC 5.3.0 etc. Build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Debian 8 "Jessie" (x86_64) Change-Id: Icb47d3e9dbafc55737fbc3ce62a084fb9d5f359a Signed-off-by: Nico Huber <nico.huber@secunet.com> Reviewed-on: https://review.coreboot.org/13473 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi@google.com>
2016-01-26 16:10:17 +01:00
bootstrap_GCC() {
CC="$CC" \
CFLAGS="$HOSTCFLAGS" \
CFLAGS_FOR_BUILD="$HOSTCFLAGS" \
CFLAGS_FOR_TARGET="$HOSTCFLAGS -fPIC" \
CXXFLAGS="$HOSTCFLAGS" \
CXXFLAGS_FOR_BUILD="$HOSTCFLAGS" \
CXXFLAGS_FOR_TARGET="$HOSTCFLAGS -fPIC" \
../gcc-${GCC_VERSION}/configure \
--prefix=$TARGETDIR --libexecdir=$TARGETDIR/lib \
--enable-bootstrap \
--disable-werror --disable-nls \
--disable-shared --disable-multilib \
--disable-libssp --disable-libquadmath --disable-libcc1 \
${GCC_OPTIONS} --enable-languages="${LANGUAGES}" \
--with-gmp=$DESTDIR$TARGETDIR --with-mpfr=$DESTDIR$TARGETDIR \
--with-mpc=$DESTDIR$TARGETDIR --with-libelf=$DESTDIR$TARGETDIR \
--with-pkgversion="coreboot bootstrap v$CROSSGCC_VERSION $CROSSGCC_DATE" \
&& \
$MAKE $JOBS BOOT_CFLAGS="$HOSTCFLAGS" BUILD_CONFIG="" bootstrap && \
$MAKE install-gcc \
install-target-libgcc \
maybe-install-target-libada \
maybe-install-target-libstdc++-v3 \
DESTDIR=$DESTDIR && \
ln -s gcc $DESTDIR$TARGETDIR/bin/cc || touch .failed
}
build_cross_GCC() {
# Work around crazy code generator in GCC that confuses CLANG.
$CC --version | grep clang >/dev/null 2>&1 && \
HOSTCFLAGS="$HOSTCFLAGS -fbracket-depth=1024"
# GCC does not honor HOSTCFLAGS at all. CFLAGS are used for
# both target and host object files.
# There's a work-around called CFLAGS_FOR_BUILD and CFLAGS_FOR_TARGET
# but it does not seem to work properly. At least the host library
# libiberty is not compiled with CFLAGS_FOR_BUILD.
# Also set the CXX version of the flags because GCC is now compiled
# using C++.
CC="$CC" CFLAGS_FOR_TARGET="-O2 -Dinhibit_libc" CFLAGS="$HOSTCFLAGS" \
CFLAGS_FOR_BUILD="$HOSTCFLAGS" CXXFLAGS="$HOSTCFLAGS" \
CXXFLAGS_FOR_BUILD="$HOSTCFLAGS" ../gcc-${GCC_VERSION}/configure \
--prefix=$TARGETDIR --libexecdir=$TARGETDIR/lib \
--target=${TARGETARCH} --disable-werror --disable-shared \
--enable-lto --enable-plugins --enable-gold --enable-ld=default \
--disable-libssp --disable-bootstrap --disable-nls \
--disable-libquadmath --without-headers \
--disable-threads \
--enable-interwork --enable-multilib --enable-targets=all \
--disable-libatomic --disable-libcc1 --disable-decimal-float \
${GCC_OPTIONS} --enable-languages="${LANGUAGES}" \
--with-system-zlib \
--with-gmp=$DESTDIR$TARGETDIR --with-mpfr=$DESTDIR$TARGETDIR \
--with-mpc=$DESTDIR$TARGETDIR --with-libelf=$DESTDIR$TARGETDIR \
--with-pkgversion="coreboot toolchain v$CROSSGCC_VERSION $CROSSGCC_DATE" \
|| touch .failed
$MAKE $JOBS CFLAGS_FOR_BUILD="$HOSTCFLAGS" all-gcc || touch .failed
$MAKE install-gcc DESTDIR=$DESTDIR || touch .failed
if [ "$(echo $TARGETARCH | grep -c -- -mingw32)" -eq 0 ]; then
$MAKE $JOBS CFLAGS_FOR_BUILD="$HOSTCFLAGS" all-target-libgcc || touch .failed
$MAKE install-target-libgcc DESTDIR=$DESTDIR || touch .failed
fi
}
buildgcc: Add option to bootstrap a host gcc Bootstrapping gcc is the recommended way if your host gcc's version doesn't match the gcc version you're going to build. While a build with an outdated host gcc usually succeeds, an outdated gnat seems to be a bigger issue. v3: Some library controversy: gcc likes the libraries it ships with most but we don't want to install shared libraries. So we build them static --disable-shared) and install only the minimum (libgcc, libada, libstdc++). However, as the code of these libraries might be used to build a shared library we have to compile them with `-fPIC`. v4: o Updated getopt strings. o The workaround for clang (-fbracket-depth=1024) isn't needed for bootstrapping and also breaks the build, as clang is only used for the first stage in that case and gcc doesn't know that option. So far build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Ubuntu 14.04 "Trusty Tahr" (i386) o Debian 8 "Jessie" (x86_64) (building python (-S) works too) o current Arch Linux (x86_64) o FreeBSD 10.3 (x86_64) (with gcc-aux package) and with clang host compiler, thus C only: `make BUILDGCC_OPTIONS="-b"` on o Debian 8 "Jessie" (x86_64) o FreeBSD 10.3 (x86_64) v5: Rebased after toolchain updates to GCC 5.3.0 etc. Build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Debian 8 "Jessie" (x86_64) Change-Id: Icb47d3e9dbafc55737fbc3ce62a084fb9d5f359a Signed-off-by: Nico Huber <nico.huber@secunet.com> Reviewed-on: https://review.coreboot.org/13473 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi@google.com>
2016-01-26 16:10:17 +01:00
build_GCC() {
if [ "$1" = host ]; then
bootstrap_GCC
else
build_cross_GCC
fi
}
build_EXPAT() {
CC="$CC" CFLAGS="$HOSTCFLAGS" ../${EXPAT_DIR}/configure --disable-shared \
--prefix=$TARGETDIR || touch .failed
$MAKE || touch .failed
$MAKE install DESTDIR=$DESTDIR || touch .failed
normalize_dirs
}
build_PYTHON() {
CC="$CC" CFLAGS="$HOSTCFLAGS" ../${PYTHON_DIR}/configure --prefix=$TARGETDIR \
|| touch .failed
$MAKE $JOBS || touch .failed
$MAKE install DESTDIR=$DESTDIR || touch .failed
normalize_dirs
}
build_GDB() {
export PYTHONHOME=$DESTDIR$TARGETDIR
if [ $(uname) != "FreeBSD" -a $(uname) != "NetBSD" ]; then
LIBDL="-ldl"
fi
LDFLAGS="-Wl,-rpath,\$\$ORIGIN/../lib/ -L$DESTDIR$TARGETDIR/lib \
-lpthread $LIBDL -lutil" \
CC="$CC" CFLAGS="$HOSTCFLAGS -I$DESTDIR$TARGETDIR/include" \
../${GDB_DIR}/configure --prefix=$TARGETDIR \
--target=${TARGETARCH} --disable-werror --disable-nls
$MAKE $JOBS || touch .failed
$MAKE install DESTDIR=$DESTDIR || touch .failed
}
build_IASL() {
RDIR=$PWD
cd ../$IASL_DIR/generate/unix
CFLAGS="$HOSTCFLAGS"
HOST="_LINUX"
test $UNAME = "Darwin" && HOST="_APPLE"
test $UNAME = "FreeBSD" && HOST="_FreeBSD"
test $UNAME = "Cygwin" && HOST="_CYGWIN"
HOST="$HOST" OPT_CFLAGS="-O -D_FORTIFY_SOURCE=2 -D COREBOOT_TOOLCHAIN_VERSION='\"coreboot toolchain v$CROSSGCC_VERSION $CROSSGCC_DATE\"' " CFLAGS="$CFLAGS" $MAKE CC="$CC" iasl || touch $RDIR/.failed
rm -f $DESTDIR$TARGETDIR/bin/iasl || touch $RDIR/.failed
cp bin/iasl $DESTDIR$TARGETDIR/bin || touch $RDIR/.failed
}
build_LLVM() {
cd ..
ln -sf $PWD/$CFE_DIR $LLVM_DIR/tools/clang
ln -sf $PWD/$CTE_DIR $LLVM_DIR/tools/clang/tools/extra
ln -sf $PWD/$CRT_DIR $LLVM_DIR/projects/compiler-rt
cd -
$CMAKE -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX=$DESTDIR$TARGETDIR \
-DCLANG_VENDOR="coreboot toolchain v$CROSSGCC_VERSION $CROSSGCC_DATE - " \
-DCMAKE_BUILD_TYPE=Release ../$LLVM_DIR || touch .failed
$MAKE $JOBS || touch .failed
$MAKE install || touch .failed
cp -a ../$CFE_DIR/tools/scan-build/* $DESTDIR$TARGETDIR/bin
cp -a ../$CFE_DIR/tools/scan-view/* $DESTDIR$TARGETDIR/bin
# create symlinks to work around broken --print-librt-file-name
# when used with -target.
cd $DESTDIR$TARGETDIR/lib/clang/${CLANG_VERSION}/lib
for i in */libclang_rt.builtins*.a; do
ln -s $i .
done
}
build_MAKE() {
CC="$CC" CFLAGS="$HOSTCFLAGS" ../${MAKE_DIR}/configure --prefix=$TARGETDIR \
--disable-nls || touch .failed
$MAKE $JOBS || touch .failed
$MAKE install DESTDIR=$DESTDIR || touch .failed
normalize_dirs
}
print_stable() {
case "$PRINTSTABLE" in
AUTOCONF|autoconf) printf "%s\n" "$GCC_AUTOCONF_VERSION";;
BINUTILS|binutils) printf "%s\n" "$BINUTILS_VERSION";;
CLANG|clang) printf "%s\n" "$CLANG_VERSION";;
EXPAT|expat) printf "%s\n" "$EXPAT_VERSION";;
GCC|gcc) printf "%s\n" "$GCC_VERSION";;
GDB|gdb) printf "%s\n" "$GDB_VERSION";;
GMP|gmp) printf "%s\n" "$GMP_VERSION";;
IASL|iasl) printf "%s\n" "$IASL_VERSION";;
LIBELF|libelf) printf "%s\n" "$LIBELF_VERSION";;
MPC|mpc) printf "%s\n" "$MPC_VERSION";;
MPFR|mpfr) printf "%s\n" "$MPFR_VERSION";;
PYTHON|python) printf "%s\n" "$PYTHON_VERSION";;
MAKE|make) printf "%s\n" "$MAKE_VERSION";;
*) printf "Unknown tool %s\n" "$PRINTSTABLE";;
esac
}
trap quit 1 2 3 15
# Look if we have getopt. If not, build it.
export PATH=$PATH:.
getopt - > /dev/null 2>/dev/null || gcc -o getopt getopt.c
# parse parameters.. try to find out whether we're running GNU getopt
getoptbrand="$(getopt -V | sed -e '1!d' -e 's,^\(......\).*,\1,')"
if [ "${getoptbrand}" = "getopt" ]; then
# Detected GNU getopt that supports long options.
args=$(getopt -l version,help,clean,directory:,bootstrap,platform:,languages:,package:,jobs:,destdir:,savetemps,scripting,ccache,supported:,urls,nocolor -o Vhcd:bp:l:P:j:D:tSys:un -- "$@")
getopt_ret=$?
eval set -- "$args"
else
# Detected non-GNU getopt
args=$(getopt Vhcd:bp:l:P:j:D:tSys:un $*)
getopt_ret=$?
set -- $args
fi
if [ $getopt_ret != 0 ]; then
myhelp
exit 1
fi
while true ; do
case "$1" in
-V|--version) shift; myversion; exit 0;;
-h|--help) shift; myhelp; exit 0;;
-c|--clean) shift; clean=1;;
-t|--savetemps) shift; SAVETEMPS=1;;
-d|--directory) shift; TARGETDIR="$1"; shift;;
buildgcc: Add option to bootstrap a host gcc Bootstrapping gcc is the recommended way if your host gcc's version doesn't match the gcc version you're going to build. While a build with an outdated host gcc usually succeeds, an outdated gnat seems to be a bigger issue. v3: Some library controversy: gcc likes the libraries it ships with most but we don't want to install shared libraries. So we build them static --disable-shared) and install only the minimum (libgcc, libada, libstdc++). However, as the code of these libraries might be used to build a shared library we have to compile them with `-fPIC`. v4: o Updated getopt strings. o The workaround for clang (-fbracket-depth=1024) isn't needed for bootstrapping and also breaks the build, as clang is only used for the first stage in that case and gcc doesn't know that option. So far build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Ubuntu 14.04 "Trusty Tahr" (i386) o Debian 8 "Jessie" (x86_64) (building python (-S) works too) o current Arch Linux (x86_64) o FreeBSD 10.3 (x86_64) (with gcc-aux package) and with clang host compiler, thus C only: `make BUILDGCC_OPTIONS="-b"` on o Debian 8 "Jessie" (x86_64) o FreeBSD 10.3 (x86_64) v5: Rebased after toolchain updates to GCC 5.3.0 etc. Build tested with `make BUILDGCC_OPTIONS="-b -l c,ada"` on o Debian 8 "Jessie" (x86_64) Change-Id: Icb47d3e9dbafc55737fbc3ce62a084fb9d5f359a Signed-off-by: Nico Huber <nico.huber@secunet.com> Reviewed-on: https://review.coreboot.org/13473 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi@google.com>
2016-01-26 16:10:17 +01:00
-b|--bootstrap) shift; BOOTSTRAP=1;;
-p|--platform) shift; TARGETARCH="$1"; shift;;
-l|--languages) shift; LANGUAGES="$1"; shift;;
-D|--destdir) shift; DESTDIR="$1"; shift;;
-j|--jobs) shift; THREADS="$1"; JOBS="-j $1"; shift;;
-P|--package) shift; PACKAGE="$1"; shift;;
-S|--scripting) shift; SKIPPYTHON=0;;
-y|--ccache) shift; USECCACHE=1;;
-s|--supported) shift; PRINTSTABLE="$1"; shift;;
-u|--urls) shift; printf "%s\n" "$ALL_ARCHIVES"; exit 0;;
-n|--nocolor) shift; \
unset red RED green GREEN blue BLUE cyan CYAN NC;;
--) shift; break;;
*) break;;
esac
done
if [ $# -gt 0 ]; then
printf "Excessive arguments: $*\n"
myhelp
exit 1
fi
if [ -n "$PRINTSTABLE" ]; then
print_stable
exit 0
fi
#print toolchain builder version string as the header
printversion
printf "Building toolchain using %d thread(s).\n\n" "$THREADS"
case "$TARGETARCH" in
x86_64-elf) ;;
x86_64*) TARGETARCH=x86_64-elf;;
i386-elf) ;;
i386-mingw32) ;;
mipsel-elf) ;;
riscv-elf) TARGETARCH=riscv64-elf;;
powerpc64*-linux*) ;;
i386*) TARGETARCH=i386-elf;;
arm*) TARGETARCH=arm-eabi;;
aarch64*) TARGETARCH=aarch64-elf;;
nds32le-elf) ;;
*) printf "${red}WARNING: Unsupported architecture $TARGETARCH.${NC}\n\n"; ;;
esac
# Figure out which packages to build
case "$PACKAGE" in
GCC|gcc)
echo "Target architecture is now $TARGETARCH"
NAME="${TARGETARCH} cross GCC"
PACKAGES="GMP MPFR MPC LIBELF BINUTILS GCC"
;;
GDB|gdb)
NAME="${TARGETARCH} cross GDB"
if [ $SKIPPYTHON -eq 0 ]; then
PACKAGES="EXPAT PYTHON GDB"
else
PACKAGES="EXPAT GDB"
fi
;;
CLANG|clang)
NAME=clang
PACKAGES="LLVM CFE CRT CTE"
CMAKE=$(searchtool cmake "cmake") || exit $?
;;
IASL|iasl)
NAME="IASL ACPI compiler"
PACKAGES=IASL
;;
MAKE|make)
NAME="GNU Make"
PACKAGES=MAKE
;;
*)
printf "${red}ERROR: Unsupported package $PACKAGE. (Supported packages are GCC, GDB, CLANG, IASL, MAKE)${NC}\n\n";
exit 1
;;
esac
# Find all the required tools:
TAR=$(searchtool tar) || exit $?
PATCH=$(searchtool patch) || exit $?
MAKE=$(searchtool make) || exit $?
SHA1SUM=$(searchtool sha1sum)
#SHA512SUM=$(searchtool sha512sum)
#MD5SUM=$(searchtool md5sum)
CHECKSUM=$SHA1SUM
LBZIP2=$(searchtool lbzip2 "" nofail)
PIGZ=$(searchtool pigz "" nofail)
searchtool m4 > /dev/null
searchtool bison > /dev/null
searchtool flex flex > /dev/null
searchtool g++ "Free Software Foundation" nofail > /dev/null || \
searchtool clang "clang version" nofail > /dev/null || \
searchtool clang "LLVM" "" "g++" > /dev/null
searchtool bzip2 "bzip2," > /dev/null
if searchtool wget "GNU" nofail > /dev/null; then
download_showing_percentage() {
url=$1
printf " ..${red} 0%%"
wget $url 2>&1 | while read line; do
echo $line | grep -o "[0-9]\+%" | awk '{printf("\b\b\b\b%4s", $1)}'
done
echo "${NC}"
}
elif searchtool curl "^curl " > /dev/null; then
download_showing_percentage() {
url=$1
echo
curl -#OL $url
}
fi
check_for_library "-lz" "zlib (zlib1g-dev or zlib-devel)"
CC=cc
check_cc
if [ "$HALT_FOR_TOOLS" -ne 0 ]; then
exit 1
fi
# This initial cleanup is useful when updating the toolchain script.
if [ "$clean" = "1" ]; then
cleanup
fi
# Set up host compiler and flags needed for various OSes
if is_package_enabled "GCC"; then
if [ $UNAME = "Darwin" ]; then
#GCC_OPTIONS="$GCC_OPTIONS --enable-threads=posix"
# generally the OS X compiler can create x64 binaries.
# Per default it generated i386 binaries in 10.5 and x64
# binaries in 10.6 (even if the kernel is 32bit)
# For some weird reason, 10.5 autodetects an ABI=64 though
# so we're setting the ABI explicitly here.
if [ $(sysctl -n hw.optional.x86_64 2>/dev/null) -eq 1 ] 2>/dev/null; then
OPTIONS="ABI=64"
else
OPTIONS="ABI=32"
fi
# In Xcode 4.5.2 the default compiler is clang.
# However, this compiler fails to compile gcc 4.7.x. As a
# workaround it's possible to compile gcc with llvm-gcc.
if $CC -v 2>&1 | grep -q LLVM; then
CC=llvm-gcc
fi
elif [ $UNAME = "Linux" -o $UNAME = "Cygwin" ]; then
# gmp is overeager with detecting 64bit CPUs even if they run
# a 32bit kernel and userland.
if [ "$(uname -m 2>/dev/null)" = "i686" ]; then
OPTIONS="ABI=32"
fi
elif [ $UNAME = "NetBSD" ]; then
# same for NetBSD but this one reports an i386
if [ "$(uname -m 2>/dev/null)" = "i386" ]; then
OPTIONS="ABI=32"
fi
fi
if [ -z "${LANGUAGES}" ]; then
if hostcc_has_gnat1 && \
[ "$(hostcc_version)" = "$(buildcc_version)" -o "${BOOTSTRAP}" = "1" ];
then
printf "\nFound compatible Ada compiler, enabling Ada support by default.\n\n"
LANGUAGES="ada,${DEFAULT_LANGUAGES}"
else
LANGUAGES="${DEFAULT_LANGUAGES}"
fi
fi
fi # GCC
export HOSTCFLAGS="-Os"
if have_hostcflags_from_gmp; then
set_hostcflags_from_gmp
fi
if [ "$USECCACHE" = 1 ]; then
CC="ccache $CC"
fi
# Prepare target directory for building GCC
# (dependencies must be in the PATH)
mkdir -p $DESTDIR$TARGETDIR/bin
mkdir -p $DESTDIR$TARGETDIR/share
export PATH=$DESTDIR$TARGETDIR/bin:$PATH
# Download, unpack, patch and build all packages
printf "Downloading tarballs ... \n"
mkdir -p tarballs
for P in $PACKAGES; do
download $P
done
printf "Downloaded tarballs ... ${green}ok${NC}\n"
printf "Unpacking and patching ... \n"
for P in $PACKAGES; do
unpack_and_patch $P || exit 1
done
printf "Unpacked and patched ... ${green}ok${NC}\n"
printf "Building packages ... \n"
for package in $PACKAGES; do
build $package
done
printf "Packages built ... ${green}ok${NC}\n"
# Adding git information of current tree to target directory
# for reproducibility
PROGNAME=$(basename "$0")
rm -f "$DESTDIR$TARGETDIR/share/$PROGNAME-*"
cp "$PROGNAME" "$DESTDIR$TARGETDIR/share/$PROGNAME-$CROSSGCC_VERSION-$CROSGCC_COMMIT"
cleanup
printf "\n${green}You can now run your $NAME toolchain from $TARGETDIR.${NC}\n"