scripts/crosstool-NG.sh.in
author "Benoît Thébaudeau" <benoit.thebaudeau@advansee.com>
Mon Apr 16 15:25:36 2012 +0200 (2012-04-16)
changeset 2941 13e40098fffc
parent 2931 8a72662f0815
child 2964 d48c03998dc1
permissions -rw-r--r--
cc/gcc: update Linaro GCC revisions to 2012.04

Update Linaro GCC with the latest available revisions.

The 4.7 revision is also released, but the infrastructure is not yet ready for
it in CT-NG.

Signed-off-by: "Benoît Thébaudeau" <benoit.thebaudeau@advansee.com>
     1 #!@@CT_bash@@
     2 # Copyright 2007 Yann E. MORIN
     3 # Licensed under the GPL v2. See COPYING in the root of this package.
     4 
     5 # This is the main entry point to crosstool
     6 # This will:
     7 #   - download, extract and patch the toolchain components
     8 #   - build and install each components in turn
     9 #   - and eventually test the resulting toolchain
    10 
    11 # What this file does is prepare the environment, based upon the user-choosen
    12 # options. It also checks the existing environment for un-friendly variables,
    13 # and builds the tools.
    14 
    15 # Parse the common functions
    16 # Note: some initialisation and sanitizing is done while parsing this file,
    17 # most notably:
    18 #  - set trap handler on errors,
    19 #  - don't hash commands lookups,
    20 #  - initialise logging.
    21 . "${CT_LIB_DIR}/scripts/functions"
    22 
    23 # Parse the configuration file
    24 # It has some info about the logging facility, so include it early
    25 . .config.2
    26 # Yes! We can do full logging from now on!
    27 
    28 # Override the locale early, in case we ever translate crosstool-NG messages
    29 if [ -z "${CT_NO_OVERIDE_LC_MESSAGES}" ]; then
    30     export LC_ALL=C
    31     export LANG=C
    32 fi
    33 
    34 # remove . from PATH since it can cause gcc build failures
    35 CT_SanitizePath
    36 
    37 # Some sanity checks in the environment and needed tools
    38 CT_DoLog INFO "Performing some trivial sanity checks"
    39 CT_TestAndAbort "Don't set LD_LIBRARY_PATH. It screws up the build." -n "${LD_LIBRARY_PATH}"
    40 CT_TestAndAbort "Don't set CFLAGS. It screws up the build." -n "${CFLAGS}"
    41 CT_TestAndAbort "Don't set CXXFLAGS. It screws up the build." -n "${CXXFLAGS}"
    42 CT_Test "GREP_OPTIONS screws up the build. Resetting." -n "${GREP_OPTIONS}"
    43 export GREP_OPTIONS=
    44 # Workaround against openSUSE 12.1 that breaks ./configure for cross-compilation:
    45 export CONFIG_SITE=
    46 
    47 # Some sanity checks on paths content
    48 for d in            \
    49     LOCAL_TARBALLS  \
    50     WORK            \
    51     PREFIX          \
    52     INSTALL         \
    53     ; do
    54         eval dir="\${CT_${d}_DIR}"
    55         case "${dir}" in
    56             *" "*)
    57                 CT_Abort "'CT_${d}_DIR'='${dir}' contains a space in it.\nDon't use spaces in paths, it breaks things."
    58                 ;;
    59         esac
    60 done
    61 
    62 # Where will we work?
    63 CT_WORK_DIR="${CT_WORK_DIR:-${CT_TOP_DIR}/targets}"
    64 CT_DoExecLog ALL mkdir -p "${CT_WORK_DIR}"
    65 
    66 # Check build file system case-sensitiveness
    67 CT_DoExecLog DEBUG touch "${CT_WORK_DIR}/foo"
    68 CT_TestAndAbort "Your file system in '${CT_WORK_DIR}' is *not* case-sensitive!" -f "${CT_WORK_DIR}/FOO"
    69 CT_DoExecLog DEBUG rm -f "${CT_WORK_DIR}/foo"
    70 
    71 # Check the user is using an existing SHELL to be used by ./configure and Makefiles
    72 CT_TestOrAbort "The CONFIG_SHELL '${CT_CONFIG_SHELL}' is not valid" -f "${CT_CONFIG_SHELL}" -a -x "${CT_CONFIG_SHELL}"
    73 
    74 # Create the bin-override early
    75 # Contains symlinks to the tools found by ./configure
    76 # Note: CT_DoLog and CT_DoExecLog do not use any of those tool, so
    77 # they can be safely used
    78 CT_TOOLS_OVERIDE_DIR="${CT_WORK_DIR}/tools"
    79 CT_DoLog DEBUG "Creating bin-override for tools in '${CT_TOOLS_OVERIDE_DIR}'"
    80 CT_DoExecLog DEBUG mkdir -p "${CT_TOOLS_OVERIDE_DIR}/bin"
    81 cat "${CT_LIB_DIR}/paths.sh" |while read trash line; do
    82     tool="${line%%=*}"
    83     path="${line#*=}"
    84     CT_DoLog DEBUG "Creating script-override for '${tool}' -> '${path}'"
    85     # Note: we need to supress the " in the path because
    86     # there can be arguments in there (thanks autostuff...)
    87     printf "#${BANG}${CT_CONFIG_SHELL}\nexec ${path//\"/} \"\${@}\"\n" >"${CT_TOOLS_OVERIDE_DIR}/bin/${tool}"
    88     CT_DoExecLog ALL chmod 700 "${CT_TOOLS_OVERIDE_DIR}/bin/${tool}"
    89 done
    90 export PATH="${CT_TOOLS_OVERIDE_DIR}/bin:${PATH}"
    91 
    92 # Start date. Can't be done until we know the locale
    93 # Also requires the bin-override tools
    94 CT_STAR_DATE=$(CT_DoDate +%s%N)
    95 CT_STAR_DATE_HUMAN=$(CT_DoDate +%Y%m%d.%H%M%S)
    96 
    97 # Log real begining of build, now
    98 CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
    99 
   100 # We really need to extract from ,config and not .config.2, as we
   101 # do want the kconfig's values, not our mangled config with arrays.
   102 CT_DoStep DEBUG "Dumping user-supplied crosstool-NG configuration"
   103 CT_DoExecLog DEBUG grep -E '^(# |)CT_' .config
   104 CT_EndStep
   105 
   106 CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
   107 unset MAKEFLAGS
   108 export MAKEFLAGS
   109 
   110 CT_DoLog INFO "Building environment variables"
   111 
   112 # Include sub-scripts instead of calling them: that way, we do not have to
   113 # export any variable, nor re-parse the configuration and functions files.
   114 . "${CT_LIB_DIR}/scripts/build/internals.sh"
   115 . "${CT_LIB_DIR}/scripts/build/arch/${CT_ARCH}.sh"
   116 . "${CT_LIB_DIR}/scripts/build/companion_tools.sh"
   117 . "${CT_LIB_DIR}/scripts/build/kernel/${CT_KERNEL}.sh"
   118 . "${CT_LIB_DIR}/scripts/build/companion_libs/gmp.sh"
   119 . "${CT_LIB_DIR}/scripts/build/companion_libs/mpfr.sh"
   120 . "${CT_LIB_DIR}/scripts/build/companion_libs/ppl.sh"
   121 . "${CT_LIB_DIR}/scripts/build/companion_libs/cloog.sh"
   122 . "${CT_LIB_DIR}/scripts/build/companion_libs/mpc.sh"
   123 . "${CT_LIB_DIR}/scripts/build/companion_libs/libelf.sh"
   124 . "${CT_LIB_DIR}/scripts/build/binutils/binutils.sh"
   125 . "${CT_LIB_DIR}/scripts/build/binutils/elf2flt.sh"
   126 . "${CT_LIB_DIR}/scripts/build/binutils/sstrip.sh"
   127 . "${CT_LIB_DIR}/scripts/build/libc/${CT_LIBC}.sh"
   128 . "${CT_LIB_DIR}/scripts/build/cc/${CT_CC}.sh"
   129 . "${CT_LIB_DIR}/scripts/build/debug.sh"
   130 . "${CT_LIB_DIR}/scripts/build/test_suite.sh"
   131 
   132 # Target tuple: CT_TARGET needs a little love:
   133 CT_DoBuildTargetTuple
   134 
   135 # Kludge: If any of the configured options needs CT_TARGET,
   136 # then rescan the options file now:
   137 . .config.2
   138 
   139 # Sanity check some directories
   140 CT_TestAndAbort "'CT_PREFIX_DIR' is not set: where should I install?" -z "${CT_PREFIX_DIR}"
   141 
   142 # Second kludge: merge user-supplied target CFLAGS with architecture-provided
   143 # target CFLAGS. Do the same for LDFLAGS in case it happens in the future.
   144 # Put user-supplied flags at the end, so that they take precedence.
   145 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
   146 CT_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_TARGET_LDFLAGS}"
   147 CT_CC_CORE_EXTRA_CONFIG_ARRAY=( ${CT_ARCH_CC_CORE_EXTRA_CONFIG} "${CT_CC_CORE_EXTRA_CONFIG_ARRAY[@]}" )
   148 CT_CC_EXTRA_CONFIG_ARRAY=( ${CT_ARCH_CC_EXTRA_CONFIG} "${CT_CC_EXTRA_CONFIG_ARRAY[@]}" )
   149 
   150 # Compute the package version string
   151 CT_PKGVERSION="crosstool-NG ${CT_VERSION}${CT_TOOLCHAIN_PKGVERSION:+ - ${CT_TOOLCHAIN_PKGVERSION}}"
   152 
   153 # Compute the working directories names
   154 CT_TARBALLS_DIR="${CT_WORK_DIR}/tarballs"
   155 CT_SRC_DIR="${CT_WORK_DIR}/src"
   156 CT_BUILD_DIR="${CT_WORK_DIR}/${CT_TARGET}/build"
   157 CT_BUILDTOOLS_PREFIX_DIR="${CT_WORK_DIR}/${CT_TARGET}/buildtools"
   158 CT_STATE_DIR="${CT_WORK_DIR}/${CT_TARGET}/state"
   159 CT_CONFIG_DIR="${CT_BUILD_DIR}/configs"
   160 # Note about HOST_COMPLIBS_DIR: it's always gonna be in the buildtools dir, or a
   161 # sub-dir. So we won't have to save/restore it, not even create it.
   162 # In case of cross or native, host-complibs are used for build-complibs;
   163 # in case of canadian or cross-native, host-complibs are specific
   164 case "${CT_TOOLCHAIN_TYPE}" in
   165     native|cross)
   166         CT_HOST_COMPLIBS_DIR="${CT_BUILDTOOLS_PREFIX_DIR}"
   167         ;;
   168     canadian|cross-native)
   169         CT_HOST_COMPLIBS_DIR="${CT_BUILDTOOLS_PREFIX_DIR}/complibs-host"
   170         ;;
   171 esac
   172 
   173 # Compute test suite install directory
   174 CT_TEST_SUITE_DIR=${CT_INSTALL_DIR}/test-suite
   175 
   176 # We must ensure that we can restart if asked for!
   177 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}"  ]; then
   178     CT_DoLog ERROR "You asked to restart a non-restartable build"
   179     CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
   180     CT_DoLog ERROR "in the config options for the previous build, or the state"
   181     CT_DoLog ERROR "directory for the previous build was deleted."
   182     CT_Abort "I will stop here to avoid any carnage"
   183 fi
   184 
   185 # If the local tarball directory does not exist, say so, and don't try to save there!
   186 if [    "${CT_SAVE_TARBALLS}" = "y"     \
   187      -a ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
   188     CT_DoLog WARN "Directory '${CT_LOCAL_TARBALLS_DIR}' does not exist."
   189     CT_DoLog WARN "Will not save downloaded tarballs to local storage."
   190     CT_SAVE_TARBALLS=
   191 fi
   192 
   193 # Check now if we can write to the destination directory:
   194 if [ -d "${CT_INSTALL_DIR}" ]; then
   195     CT_TestAndAbort "Destination directory '${CT_INSTALL_DIR}' is not removable" ! -w $(dirname "${CT_INSTALL_DIR}")
   196 fi
   197 
   198 # Good, now grab a bit of informations on the system we're being run on,
   199 # just in case something goes awok, and it's not our fault:
   200 CT_SYS_USER=$(id -un)
   201 CT_SYS_HOSTNAME=$(hostname -f 2>/dev/null || true)
   202 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
   203 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-$(uname -n)}"
   204 CT_SYS_KERNEL=$(uname -s)
   205 CT_SYS_REVISION=$(uname -r)
   206 CT_SYS_OS=$(uname -s)
   207 CT_SYS_MACHINE=$(uname -m)
   208 CT_SYS_PROCESSOR=$(uname -p)
   209 CT_SYS_GCC=$(gcc -dumpversion)
   210 CT_SYS_TARGET=$(CT_DoConfigGuess)
   211 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
   212 
   213 CT_DoLog EXTRA "Preparing working directories"
   214 
   215 # Ah! The build directory shall be eradicated, even if we restart!
   216 # Ditto for the build tools install dir
   217 CT_DoForceRmdir "${CT_BUILD_DIR}" "${CT_BUILDTOOLS_PREFIX_DIR}"
   218 
   219 # Don't eradicate directories if we need to restart
   220 if [ -z "${CT_RESTART}" ]; then
   221     # Get rid of pre-existing installed toolchain and previous build directories.
   222     if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
   223         CT_DoForceRmdir "${CT_TARBALLS_DIR}"
   224     fi
   225     if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
   226         CT_DoForceRmdir "${CT_SRC_DIR}"
   227     fi
   228     if [ -d "${CT_INSTALL_DIR}" -a "${CT_RM_RF_PREFIX_DIR}" = "y" ]; then
   229         CT_DoForceRmdir "${CT_INSTALL_DIR}"
   230     fi
   231     # In case we start anew, get rid of the previously saved state directory
   232     if [ -d "${CT_STATE_DIR}" ]; then
   233         CT_DoForceRmdir "${CT_STATE_DIR}"
   234     fi
   235 fi
   236 
   237 # Create the directories we'll use, even if restarting: it does no harm to
   238 # create already existent directories, and CT_BUILD_DIR needs to be created
   239 # anyway
   240 CT_DoExecLog ALL mkdir -p "${CT_TARBALLS_DIR}"
   241 CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
   242 CT_DoExecLog ALL mkdir -p "${CT_BUILD_DIR}"
   243 CT_DoExecLog ALL mkdir -p "${CT_BUILDTOOLS_PREFIX_DIR}/bin"
   244 CT_DoExecLog ALL mkdir -p "${CT_CONFIG_DIR}"
   245 CT_DoExecLog ALL mkdir -p "${CT_INSTALL_DIR}"
   246 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}"
   247 CT_DoExecLog ALL mkdir -p "${CT_HOST_COMPLIBS_DIR}"
   248 
   249 # Only create the state dir if asked for a restartable build
   250 [ -n "${CT_DEBUG_CT_SAVE_STEPS}" ] && CT_DoExecLog ALL mkdir -p "${CT_STATE_DIR}"
   251 
   252 # Check install file system case-sensitiveness
   253 CT_DoExecLog DEBUG touch "${CT_PREFIX_DIR}/foo"
   254 CT_TestAndAbort "Your file system in '${CT_PREFIX_DIR}' is *not* case-sensitive!" -f "${CT_PREFIX_DIR}/FOO"
   255 CT_DoExecLog DEBUG rm -f "${CT_PREFIX_DIR}/foo"
   256 
   257 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
   258 # the previous build was successful.
   259 CT_DoExecLog ALL chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
   260 
   261 # Setting up the rest of the environment only if not restarting
   262 if [ -z "${CT_RESTART}" ]; then
   263     case "${CT_SYSROOT_NAME}" in
   264         "")     CT_SYSROOT_NAME="sysroot";;
   265         .)      CT_Abort "Sysroot name is set to '.' which is forbidden";;
   266         *' '*)  CT_Abort "Sysroot name contains forbidden space(s): '${CT_SYSROOT_NAME}'";;
   267         */*)    CT_Abort "Sysroot name contains forbidden slash(es): '${CT_SYSROOT_NAME}'";;
   268     esac
   269 
   270     # Arrange paths depending on wether we use sysroot or not.
   271     if [ "${CT_USE_SYSROOT}" = "y" ]; then
   272         CT_SYSROOT_REL_DIR="${CT_SYSROOT_DIR_PREFIX:+${CT_SYSROOT_DIR_PREFIX}/}${CT_SYSROOT_NAME}"
   273         CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_REL_DIR}"
   274         CT_DEBUGROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_DIR_PREFIX}/debug-root"
   275         CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
   276         CT_SanitiseVarDir CT_SYSROOT_REL_DIR CT_SYSROOT_DIR CT_DEBUGROOT_DIR CT_HEADERS_DIR 
   277         BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
   278         CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
   279         CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
   280         LIBC_SYSROOT_ARG=""
   281         # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
   282         # confused when $sysroot/usr/include is not present.
   283         # Note: --prefix=/usr is magic!
   284         # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
   285     else
   286         # plain old way. All libraries in prefix/target/lib
   287         CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
   288         CT_DEBUGROOT_DIR="${CT_SYSROOT_DIR}"
   289         CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
   290         CT_SanitiseVarDir CT_SYSROOT_DIR CT_DEBUGROOT_DIR CT_HEADERS_DIR 
   291         # hack!  Always use --with-sysroot for binutils.
   292         # binutils 2.14 and later obey it, older binutils ignore it.
   293         # Lets you build a working 32->64 bit cross gcc
   294         BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
   295         # Use --with-headers, else final gcc will define disable_glibc while
   296         # building libgcc, and you'll have no profiling
   297         CC_CORE_SYSROOT_ARG="--without-headers"
   298         CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
   299         LIBC_SYSROOT_ARG="prefix="
   300     fi
   301     CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}"
   302     CT_DoExecLog ALL mkdir -p "${CT_DEBUGROOT_DIR}"
   303 
   304     # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
   305     # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail
   306     # with: "ld: cannot open crti.o: No such file or directory"
   307     # Also prepare the lib directory in the install dir, else some 64 bit archs
   308     # won't build
   309     CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/lib"
   310     CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/lib"
   311     CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
   312     CT_DoExecLog ALL mkdir -p "${CT_HEADERS_DIR}"
   313 
   314     if [ "${CT_USE_SYSROOT}" = "y" ]; then
   315         # Prevent gcc from installing its libraries outside of the sysroot
   316         CT_Pushd "${CT_PREFIX_DIR}/${CT_TARGET}"
   317         CT_DoExecLog ALL ln -sf "${CT_SYSROOT_REL_DIR}/lib" "lib"
   318         CT_Popd
   319     fi
   320 
   321     # Since we're *not* multilib on the target side, we want all the
   322     # libraries to end up in "lib".  We create "lib64" (for 64-bit
   323     # build or host architectures) and "lib32" (for 32-bit emulation
   324     # on 64-bit) as symlinks to "lib".
   325     #
   326     # Not all of these symlinks are necessary, but better safe than
   327     # sorry. They are summarily removed by build/internals.sh:do_finish.
   328     for d in                            \
   329         "${CT_PREFIX_DIR}"              \
   330         "${CT_SYSROOT_DIR}"             \
   331         "${CT_SYSROOT_DIR}/usr"         \
   332         "${CT_PREFIX_DIR}/${CT_TARGET}" \
   333     ; do
   334         CT_DoExecLog ALL ln -sf "lib" "${d}/lib32"
   335         CT_DoExecLog ALL ln -sf "lib" "${d}/lib64"
   336     done
   337 
   338     # Determine build system if not set by the user
   339     if [ -z "${CT_BUILD}" ]; then
   340         CT_BUILD=$(CT_DoConfigGuess)
   341     fi
   342 
   343     # Prepare mangling patterns to later modify BUILD and HOST (see below)
   344     case "${CT_TOOLCHAIN_TYPE}" in
   345         cross)
   346             # A cross-compiler runs on the same machine it is built on
   347             CT_HOST="${CT_BUILD}"
   348             build_mangle="build_"
   349             host_mangle="build_"
   350             target_mangle=""
   351             install_build_tools_for="BUILD HOST"
   352             ;;
   353         canadian)
   354             build_mangle="build_"
   355             host_mangle="host_"
   356             target_mangle=""
   357             install_build_tools_for="BUILD HOST"
   358             ;;
   359         *)  CT_Abort "No code for '${CT_TOOLCHAIN_TYPE}' toolchain type!"
   360             ;;
   361     esac
   362 
   363     # Save the real tuples to generate shell-wrappers to the real tools
   364     CT_REAL_BUILD="${CT_BUILD}"
   365     CT_REAL_HOST="${CT_HOST}"
   366     CT_REAL_TARGET="${CT_TARGET}"
   367 
   368     # Canonicalise CT_BUILD and CT_HOST
   369     # Not only will it give us full-qualified tuples, but it will also ensure
   370     # that they are valid tuples (in case of typo with user-provided tuples)
   371     # That's way better than trying to rewrite config.sub ourselves...
   372     # CT_TARGET is already made canonical in CT_DoBuildTargetTuple
   373     CT_BUILD=$(CT_DoConfigSub "${CT_BUILD}")
   374     CT_HOST=$(CT_DoConfigSub "${CT_HOST}")
   375 
   376     # Modify BUILD and HOST so that gcc always generate a cross-compiler
   377     # even if any of the build, host or target machines are the same.
   378     # NOTE: we'll have to mangle the (BUILD|HOST)->TARGET x-compiler to
   379     #       support canadain build, later...
   380     CT_BUILD="${CT_BUILD/-/-${build_mangle}}"
   381     CT_HOST="${CT_HOST/-/-${host_mangle}}"
   382     CT_TARGET="${CT_TARGET/-/-${target_mangle}}"
   383 
   384     # Now we have mangled our BUILD and HOST tuples, we must fake the new
   385     # cross-tools for those mangled tuples.
   386     CT_DoLog DEBUG "Making build system tools available"
   387     for m in ${install_build_tools_for}; do
   388         r="CT_REAL_${m}"
   389         v="CT_${m}"
   390         p="CT_${m}_PREFIX"
   391         s="CT_${m}_SUFFIX"
   392         if [ -n "${!p}" ]; then
   393             t="${!p}"
   394         else
   395             t="${!r}-"
   396         fi
   397 
   398         for tool in ar as dlltool gcc g++ gcj gnatbind gnatmake ld nm objcopy objdump ranlib strip windres; do
   399             # First try with prefix + suffix
   400             # Then try with prefix only
   401             # Then try with suffix only, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
   402             # Finally try with neither prefix nor suffix, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
   403             # This is needed, because some tools have a prefix and
   404             # a suffix (eg. gcc), while others may have only one,
   405             # or even none (eg. binutils)
   406             where=$(CT_Which "${t}${tool}${!s}")
   407             [ -z "${where}" ] && where=$(CT_Which "${t}${tool}")
   408             if [    -z "${where}"                         \
   409                  -a \(    "${m}" = "BUILD"                \
   410                        -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
   411                 where=$(CT_Which "${tool}${!s}")
   412             fi
   413             if [ -z "${where}"                            \
   414                  -a \(    "${m}" = "BUILD"                \
   415                        -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
   416                 where=$(CT_Which "${tool}")
   417             fi
   418 
   419             # Not all tools are available for all platforms, but some are really,
   420             # bally needed
   421             if [ -n "${where}" ]; then
   422                 CT_DoLog DEBUG "  '${!v}-${tool}' -> '${where}'"
   423                 printf "#${BANG}${CT_CONFIG_SHELL}\nexec '${where}' \"\${@}\"\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}"
   424                 CT_DoExecLog ALL chmod 700 "${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}"
   425             else
   426                 case "${tool}" in
   427                     # We'll at least need some of them...
   428                     ar|as|gcc|ld|nm|objcopy|objdump|ranlib)
   429                         CT_Abort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!"
   430                         ;;
   431                     # Some are conditionnally required
   432                     # Add them in alphabetical (C locale) ordering
   433                     g++)
   434                         # g++ (needed for companion lib), only needed for HOST
   435                         CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${m}" = "HOST"
   436                         ;;
   437                     gcj)
   438                         CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_CC_LANG_JAVA}" = "y"
   439                         ;;
   440                     strip)
   441                         CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_STRIP_ALL_TOOLCHAIN_EXECUTABLES}" = "y"
   442                         ;;
   443                     # If any other is missing, only warn at low level
   444                     *)
   445                         # It does not deserve a WARN level.
   446                         CT_DoLog DEBUG "  Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : not required."
   447                         ;;
   448                 esac
   449             fi
   450         done
   451     done
   452 
   453     # Some makeinfo versions are a pain in [put your most sensible body part here].
   454     # Go ahead with those, by creating a wrapper that keeps partial files, and that
   455     # never fails:
   456     CT_DoLog DEBUG "  'makeinfo' -> '$(CT_Which makeinfo)'"
   457     printf "#${BANG}${CT_CONFIG_SHELL}\n$(CT_Which makeinfo) --force \"\${@}\"\ntrue\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/makeinfo"
   458     CT_DoExecLog ALL chmod 700 "${CT_BUILDTOOLS_PREFIX_DIR}/bin/makeinfo"
   459 
   460     # Carefully add paths in the order we want them:
   461     #  - first try in ${CT_PREFIX_DIR}/bin
   462     #  - then try the buildtools dir
   463     #  - fall back to searching user's PATH
   464     # Of course, neither cross-native nor canadian can run on BUILD,
   465     # so don't add those PATHs in this case...
   466     case "${CT_TOOLCHAIN_TYPE}" in
   467         cross)  export PATH="${CT_PREFIX_DIR}/bin:${CT_BUILDTOOLS_PREFIX_DIR}/bin:${PATH}";;
   468         canadian) export PATH="${CT_BUILDTOOLS_PREFIX_DIR}/bin:${PATH}";;
   469         *)  ;;
   470     esac
   471 
   472     # Now we know our host and where to find the host tools, we can check
   473     # if static link was requested, but only if it was requested
   474     if [ "${CT_WANTS_STATIC_LINK}" = "y" ]; then
   475         tmp="${CT_BUILD_DIR}/.static-test"
   476         if ! "${CT_HOST}-gcc" -xc - -static -o "${tmp}" >/dev/null 2>&1 <<-_EOF_
   477 				int main() { return 0; }
   478 			_EOF_
   479         then
   480             CT_Abort "Static linking impossible on the host system '${CT_HOST}'"
   481         fi
   482         rm -f "${tmp}"
   483     fi
   484 
   485     # Help gcc
   486     CT_CFLAGS_FOR_HOST=
   487     [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST+=" -pipe"
   488     CT_CFLAGS_FOR_HOST+=" ${CT_EXTRA_FLAGS_FOR_HOST}"
   489 
   490     # Set the shell to be used by ./configure scripts and by Makefiles (those
   491     # that support it!).
   492     export CONFIG_SHELL="${CT_CONFIG_SHELL}"    # for ./configure
   493     export SHELL="${CT_CONFIG_SHELL}"           # for Makefiles
   494 
   495     # And help make go faster
   496     JOBSFLAGS=
   497     # Override the configured jobs with what's been given on the command line
   498     [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
   499     # Use the number of processors+1 when automatically setting the number of
   500     # parallel jobs.  Fall back to 1 if the host doesn't use GLIBC.
   501     AUTO_JOBS=$((`getconf _NPROCESSORS_ONLN 2> /dev/null || echo 0` + 1))
   502     [ ${CT_PARALLEL_JOBS} -eq 0 ] && JOBSFLAGS="${JOBSFLAGS} -j${AUTO_JOBS}"
   503     [ ${CT_PARALLEL_JOBS} -gt 0 ] && JOBSFLAGS="${JOBSFLAGS} -j${CT_PARALLEL_JOBS}"
   504     [ ${CT_LOAD} -ne 0 ] && JOBSFLAGS="${JOBSFLAGS} -l${CT_LOAD}"
   505 
   506     # We need to save the real .config with kconfig's value,
   507     # not our mangled .config.2 with arrays.
   508     CT_DoLog EXTRA "Installing user-supplied crosstool-NG configuration"
   509     CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/bin"
   510     CT_DoExecLog DEBUG install -m 0755 "${CT_LIB_DIR}/scripts/toolchain-config.in" "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
   511     CT_DoExecLog DEBUG sed -i -e 's,@@grep@@,"'"${grep}"'",;' "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
   512     bzip2 -c -9 .config >>"${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
   513 
   514     CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
   515     CT_DoLog EXTRA "Building a toolchain for:"
   516     CT_DoLog EXTRA "  build  = ${CT_REAL_BUILD}"
   517     CT_DoLog EXTRA "  host   = ${CT_REAL_HOST}"
   518     CT_DoLog EXTRA "  target = ${CT_TARGET}"
   519     set |grep -E '^CT_.+=' |sort |CT_DoLog DEBUG
   520     CT_DoLog DEBUG "Other environment:"
   521     printenv |grep -v -E '^CT_.+=' |CT_DoLog DEBUG
   522     CT_EndStep
   523 fi
   524 
   525 if [ -z "${CT_RESTART}" ]; then
   526     CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
   527     do_companion_tools_get
   528     do_kernel_get
   529     do_gmp_get
   530     do_mpfr_get
   531     do_ppl_get
   532     do_cloog_get
   533     do_mpc_get
   534     do_libelf_get
   535     do_binutils_get
   536     do_elf2flt_get
   537     do_sstrip_get
   538     do_cc_get
   539     do_libc_get
   540     do_debug_get
   541     do_test_suite_get
   542     CT_EndStep
   543 
   544     if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
   545         if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
   546             CT_DoForceRmdir "${CT_SRC_DIR}"
   547             CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
   548         fi
   549 
   550         if [ "${CT_COMP_TOOLS}" = "y" ]; then
   551           CT_DoStep INFO "Extracting, patching and installing companion tools"
   552           do_companion_tools_extract
   553           do_companion_tools
   554           CT_EndStep
   555         fi
   556 
   557         CT_DoStep INFO "Extracting and patching toolchain components"
   558         do_kernel_extract
   559         do_gmp_extract
   560         do_mpfr_extract
   561         do_ppl_extract
   562         do_cloog_extract
   563         do_mpc_extract
   564         do_libelf_extract
   565         do_binutils_extract
   566         do_elf2flt_extract
   567         do_sstrip_extract
   568         do_cc_extract
   569         do_libc_extract
   570         do_debug_extract
   571         do_test_suite_extract
   572         CT_EndStep
   573     fi
   574 fi
   575 
   576 # Now for the job by itself. Go have a coffee!
   577 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
   578     # Because of CT_RESTART, this becomes quite complex
   579     do_stop=0
   580     prev_step=
   581     [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
   582     # Aha! CT_STEPS comes from steps.mk!
   583     for step in ${CT_STEPS}; do
   584         if [ ${do_it} -eq 0 ]; then
   585             if [ "${CT_RESTART}" = "${step}" ]; then
   586                 CT_DoLoadState "${step}"
   587                 do_it=1
   588                 do_stop=0
   589             fi
   590         else
   591             CT_DoSaveState ${step}
   592             if [ ${do_stop} -eq 1 ]; then
   593                 CT_DoLog ERROR "Stopping just after step '${prev_step}', as requested."
   594                 exit 0
   595             fi
   596         fi
   597         if [ ${do_it} -eq 1 ]; then
   598             ( do_${step} )
   599             if [ "${CT_STOP}" = "${step}" ]; then
   600                 do_stop=1
   601             fi
   602             if [ "${CT_DEBUG_PAUSE_STEPS}" = "y" ]; then
   603                 CT_DoPause "Step '${step}' finished"
   604             fi
   605         fi
   606         prev_step="${step}"
   607     done
   608 fi
   609 
   610 CT_DoEnd INFO
   611 
   612 # From now-on, it can become impossible to log any time, because
   613 # either we're compressing the log file, or it can become RO any
   614 # moment... Consign all ouptut to oblivion...
   615 CT_DoLog INFO "Finishing installation (may take a few seconds)..."
   616 exec >/dev/null 2>&1
   617 rm -f ${CT_PREFIX_DIR}/build.log.bz2
   618 if [ "${CT_LOG_TO_FILE}" = "y" ]; then
   619     cp "${tmp_log_file}" "${CT_PREFIX_DIR}/build.log"
   620     if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
   621         bzip2 -9 "${CT_PREFIX_DIR}/build.log"
   622     fi
   623 fi
   624 [ "${CT_INSTALL_DIR_RO}" = "y"  ] && chmod -R a-w "${CT_INSTALL_DIR}"
   625 [ "${CT_TEST_SUITE}" = "y" ] && chmod -R u+w "${CT_TEST_SUITE_DIR}"
   626 
   627 trap - EXIT