scripts/crosstool-NG.sh.in
author "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
Sun Jan 01 17:49:44 2012 +0100 (2012-01-01)
changeset 2924 0eab838768b1
parent 2838 822af73497bf
child 2931 8a72662f0815
permissions -rw-r--r--
cc/gcc: install the core compilers in the build-tools dir

There really is no good reason to install the core compilers in their
own places, one for each pass. We can install them with the other
build tools.

Also, this implies that:
- there are fewer directories to save/restore
- there are fewer symlinks to create for binutils
- the PATH is shorter

Signed-off-by: "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
     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 CT_COMPLIBS_DIR="${CT_BUILD_DIR}/static"
   161 
   162 # Compute test suite install directory
   163 CT_TEST_SUITE_DIR=${CT_INSTALL_DIR}/test-suite
   164 
   165 # We must ensure that we can restart if asked for!
   166 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}"  ]; then
   167     CT_DoLog ERROR "You asked to restart a non-restartable build"
   168     CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
   169     CT_DoLog ERROR "in the config options for the previous build, or the state"
   170     CT_DoLog ERROR "directory for the previous build was deleted."
   171     CT_Abort "I will stop here to avoid any carnage"
   172 fi
   173 
   174 # If the local tarball directory does not exist, say so, and don't try to save there!
   175 if [    "${CT_SAVE_TARBALLS}" = "y"     \
   176      -a ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
   177     CT_DoLog WARN "Directory '${CT_LOCAL_TARBALLS_DIR}' does not exist."
   178     CT_DoLog WARN "Will not save downloaded tarballs to local storage."
   179     CT_SAVE_TARBALLS=
   180 fi
   181 
   182 # Check now if we can write to the destination directory:
   183 if [ -d "${CT_INSTALL_DIR}" ]; then
   184     CT_TestAndAbort "Destination directory '${CT_INSTALL_DIR}' is not removable" ! -w $(dirname "${CT_INSTALL_DIR}")
   185 fi
   186 
   187 # Good, now grab a bit of informations on the system we're being run on,
   188 # just in case something goes awok, and it's not our fault:
   189 CT_SYS_USER=$(id -un)
   190 CT_SYS_HOSTNAME=$(hostname -f 2>/dev/null || true)
   191 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
   192 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-$(uname -n)}"
   193 CT_SYS_KERNEL=$(uname -s)
   194 CT_SYS_REVISION=$(uname -r)
   195 CT_SYS_OS=$(uname -s)
   196 CT_SYS_MACHINE=$(uname -m)
   197 CT_SYS_PROCESSOR=$(uname -p)
   198 CT_SYS_GCC=$(gcc -dumpversion)
   199 CT_SYS_TARGET=$(CT_DoConfigGuess)
   200 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
   201 
   202 CT_DoLog EXTRA "Preparing working directories"
   203 
   204 # Ah! The build directory shall be eradicated, even if we restart!
   205 # Ditto for the build tools install dir
   206 CT_DoForceRmdir "${CT_BUILD_DIR}" "${CT_BUILDTOOLS_PREFIX_DIR}"
   207 
   208 # Don't eradicate directories if we need to restart
   209 if [ -z "${CT_RESTART}" ]; then
   210     # Get rid of pre-existing installed toolchain and previous build directories.
   211     if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
   212         CT_DoForceRmdir "${CT_TARBALLS_DIR}"
   213     fi
   214     if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
   215         CT_DoForceRmdir "${CT_SRC_DIR}"
   216     fi
   217     if [ -d "${CT_INSTALL_DIR}" -a "${CT_RM_RF_PREFIX_DIR}" = "y" ]; then
   218         CT_DoForceRmdir "${CT_INSTALL_DIR}"
   219     fi
   220     # In case we start anew, get rid of the previously saved state directory
   221     if [ -d "${CT_STATE_DIR}" ]; then
   222         CT_DoForceRmdir "${CT_STATE_DIR}"
   223     fi
   224 fi
   225 
   226 # Create the directories we'll use, even if restarting: it does no harm to
   227 # create already existent directories, and CT_BUILD_DIR needs to be created
   228 # anyway
   229 CT_DoExecLog ALL mkdir -p "${CT_TARBALLS_DIR}"
   230 CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
   231 CT_DoExecLog ALL mkdir -p "${CT_BUILD_DIR}"
   232 CT_DoExecLog ALL mkdir -p "${CT_BUILDTOOLS_PREFIX_DIR}/bin"
   233 CT_DoExecLog ALL mkdir -p "${CT_CONFIG_DIR}"
   234 CT_DoExecLog ALL mkdir -p "${CT_INSTALL_DIR}"
   235 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}"
   236 CT_DoExecLog ALL mkdir -p "${CT_COMPLIBS_DIR}"
   237 
   238 # Only create the state dir if asked for a restartable build
   239 [ -n "${CT_DEBUG_CT_SAVE_STEPS}" ] && CT_DoExecLog ALL mkdir -p "${CT_STATE_DIR}"
   240 
   241 # Check install file system case-sensitiveness
   242 CT_DoExecLog DEBUG touch "${CT_PREFIX_DIR}/foo"
   243 CT_TestAndAbort "Your file system in '${CT_PREFIX_DIR}' is *not* case-sensitive!" -f "${CT_PREFIX_DIR}/FOO"
   244 CT_DoExecLog DEBUG rm -f "${CT_PREFIX_DIR}/foo"
   245 
   246 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
   247 # the previous build was successful.
   248 CT_DoExecLog ALL chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
   249 
   250 # Setting up the rest of the environment only if not restarting
   251 if [ -z "${CT_RESTART}" ]; then
   252     case "${CT_SYSROOT_NAME}" in
   253         "")     CT_SYSROOT_NAME="sysroot";;
   254         .)      CT_Abort "Sysroot name is set to '.' which is forbidden";;
   255         *' '*)  CT_Abort "Sysroot name contains forbidden space(s): '${CT_SYSROOT_NAME}'";;
   256         */*)    CT_Abort "Sysroot name contains forbidden slash(es): '${CT_SYSROOT_NAME}'";;
   257     esac
   258 
   259     # Arrange paths depending on wether we use sysroot or not.
   260     if [ "${CT_USE_SYSROOT}" = "y" ]; then
   261         CT_SYSROOT_REL_DIR="${CT_SYSROOT_DIR_PREFIX:+${CT_SYSROOT_DIR_PREFIX}/}${CT_SYSROOT_NAME}"
   262         CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_REL_DIR}"
   263         CT_DEBUGROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_DIR_PREFIX}/debug-root"
   264         CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
   265         CT_SanitiseVarDir CT_SYSROOT_REL_DIR CT_SYSROOT_DIR CT_DEBUGROOT_DIR CT_HEADERS_DIR 
   266         BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
   267         CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
   268         CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
   269         LIBC_SYSROOT_ARG=""
   270         # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
   271         # confused when $sysroot/usr/include is not present.
   272         # Note: --prefix=/usr is magic!
   273         # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
   274     else
   275         # plain old way. All libraries in prefix/target/lib
   276         CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
   277         CT_DEBUGROOT_DIR="${CT_SYSROOT_DIR}"
   278         CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
   279         CT_SanitiseVarDir CT_SYSROOT_DIR CT_DEBUGROOT_DIR CT_HEADERS_DIR 
   280         # hack!  Always use --with-sysroot for binutils.
   281         # binutils 2.14 and later obey it, older binutils ignore it.
   282         # Lets you build a working 32->64 bit cross gcc
   283         BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
   284         # Use --with-headers, else final gcc will define disable_glibc while
   285         # building libgcc, and you'll have no profiling
   286         CC_CORE_SYSROOT_ARG="--without-headers"
   287         CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
   288         LIBC_SYSROOT_ARG="prefix="
   289     fi
   290     CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}"
   291     CT_DoExecLog ALL mkdir -p "${CT_DEBUGROOT_DIR}"
   292 
   293     # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
   294     # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail
   295     # with: "ld: cannot open crti.o: No such file or directory"
   296     # Also prepare the lib directory in the install dir, else some 64 bit archs
   297     # won't build
   298     CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/lib"
   299     CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/lib"
   300     CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
   301     CT_DoExecLog ALL mkdir -p "${CT_HEADERS_DIR}"
   302 
   303     if [ "${CT_USE_SYSROOT}" = "y" ]; then
   304         # Prevent gcc from installing its libraries outside of the sysroot
   305         CT_Pushd "${CT_PREFIX_DIR}/${CT_TARGET}"
   306         CT_DoExecLog ALL ln -sf "${CT_SYSROOT_REL_DIR}/lib" "lib"
   307         CT_Popd
   308     fi
   309 
   310     # Since we're *not* multilib on the target side, we want all the
   311     # libraries to end up in "lib".  We create "lib64" (for 64-bit
   312     # build or host architectures) and "lib32" (for 32-bit emulation
   313     # on 64-bit) as symlinks to "lib".
   314     #
   315     # Not all of these symlinks are necessary, but better safe than
   316     # sorry. They are summarily removed by build/internals.sh:do_finish.
   317     for d in                            \
   318         "${CT_PREFIX_DIR}"              \
   319         "${CT_SYSROOT_DIR}"             \
   320         "${CT_SYSROOT_DIR}/usr"         \
   321         "${CT_PREFIX_DIR}/${CT_TARGET}" \
   322     ; do
   323         CT_DoExecLog ALL ln -sf "lib" "${d}/lib32"
   324         CT_DoExecLog ALL ln -sf "lib" "${d}/lib64"
   325     done
   326 
   327     # Determine build system if not set by the user
   328     if [ -z "${CT_BUILD}" ]; then
   329         CT_BUILD=$(CT_DoConfigGuess)
   330     fi
   331 
   332     # Prepare mangling patterns to later modify BUILD and HOST (see below)
   333     case "${CT_TOOLCHAIN_TYPE}" in
   334         cross)
   335             # A cross-compiler runs on the same machine it is built on
   336             CT_HOST="${CT_BUILD}"
   337             build_mangle="build_"
   338             host_mangle="build_"
   339             target_mangle=""
   340             install_build_tools_for="BUILD HOST"
   341             ;;
   342         canadian)
   343             build_mangle="build_"
   344             host_mangle="host_"
   345             target_mangle=""
   346             install_build_tools_for="BUILD HOST TARGET"
   347             ;;
   348         *)  CT_Abort "No code for '${CT_TOOLCHAIN_TYPE}' toolchain type!"
   349             ;;
   350     esac
   351 
   352     # Save the real tuples to generate shell-wrappers to the real tools
   353     CT_REAL_BUILD="${CT_BUILD}"
   354     CT_REAL_HOST="${CT_HOST}"
   355     CT_REAL_TARGET="${CT_TARGET}"
   356 
   357     # Canonicalise CT_BUILD and CT_HOST
   358     # Not only will it give us full-qualified tuples, but it will also ensure
   359     # that they are valid tuples (in case of typo with user-provided tuples)
   360     # That's way better than trying to rewrite config.sub ourselves...
   361     # CT_TARGET is already made canonical in CT_DoBuildTargetTuple
   362     CT_BUILD=$(CT_DoConfigSub "${CT_BUILD}")
   363     CT_HOST=$(CT_DoConfigSub "${CT_HOST}")
   364 
   365     # Modify BUILD and HOST so that gcc always generate a cross-compiler
   366     # even if any of the build, host or target machines are the same.
   367     # NOTE: we'll have to mangle the (BUILD|HOST)->TARGET x-compiler to
   368     #       support canadain build, later...
   369     CT_BUILD="${CT_BUILD/-/-${build_mangle}}"
   370     CT_HOST="${CT_HOST/-/-${host_mangle}}"
   371     CT_TARGET="${CT_TARGET/-/-${target_mangle}}"
   372 
   373     # Now we have mangled our BUILD and HOST tuples, we must fake the new
   374     # cross-tools for those mangled tuples.
   375     CT_DoLog DEBUG "Making build system tools available"
   376     for m in ${install_build_tools_for}; do
   377         r="CT_REAL_${m}"
   378         v="CT_${m}"
   379         p="CT_${m}_PREFIX"
   380         s="CT_${m}_SUFFIX"
   381         if [ -n "${!p}" ]; then
   382             t="${!p}"
   383         else
   384             t="${!r}-"
   385         fi
   386 
   387         for tool in ar as dlltool gcc g++ gcj gnatbind gnatmake ld nm objcopy objdump ranlib strip windres; do
   388             # First try with prefix + suffix
   389             # Then try with prefix only
   390             # Then try with suffix only, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
   391             # Finally try with neither prefix nor suffix, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
   392             # This is needed, because some tools have a prefix and
   393             # a suffix (eg. gcc), while others may have only one,
   394             # or even none (eg. binutils)
   395             where=$(CT_Which "${t}${tool}${!s}")
   396             [ -z "${where}" ] && where=$(CT_Which "${t}${tool}")
   397             if [    -z "${where}"                         \
   398                  -a \(    "${m}" = "BUILD"                \
   399                        -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
   400                 where=$(CT_Which "${tool}${!s}")
   401             fi
   402             if [ -z "${where}"                            \
   403                  -a \(    "${m}" = "BUILD"                \
   404                        -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
   405                 where=$(CT_Which "${tool}")
   406             fi
   407 
   408             # Not all tools are available for all platforms, but some are really,
   409             # bally needed
   410             if [ -n "${where}" ]; then
   411                 CT_DoLog DEBUG "  '${!v}-${tool}' -> '${where}'"
   412                 printf "#${BANG}${CT_CONFIG_SHELL}\nexec '${where}' \"\${@}\"\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}"
   413                 CT_DoExecLog ALL chmod 700 "${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}"
   414             else
   415                 case "${tool}" in
   416                     # We'll at least need some of them...
   417                     ar|as|gcc|ld|nm|objcopy|objdump|ranlib)
   418                         CT_Abort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!"
   419                         ;;
   420                     # Some are conditionnally required
   421                     # Add them in alphabetical (C locale) ordering
   422                     g++)
   423                         # g++ (needed for companion lib), only needed for HOST
   424                         CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${m}" = "HOST"
   425                         ;;
   426                     gcj)
   427                         CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_CC_LANG_JAVA}" = "y"
   428                         ;;
   429                     strip)
   430                         CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_STRIP_ALL_TOOLCHAIN_EXECUTABLES}" = "y"
   431                         ;;
   432                     # If any other is missing, only warn at low level
   433                     *)
   434                         # It does not deserve a WARN level.
   435                         CT_DoLog DEBUG "  Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : not required."
   436                         ;;
   437                 esac
   438             fi
   439         done
   440     done
   441 
   442     # Some makeinfo versions are a pain in [put your most sensible body part here].
   443     # Go ahead with those, by creating a wrapper that keeps partial files, and that
   444     # never fails:
   445     CT_DoLog DEBUG "  'makeinfo' -> '$(CT_Which makeinfo)'"
   446     printf "#${BANG}${CT_CONFIG_SHELL}\n$(CT_Which makeinfo) --force \"\${@}\"\ntrue\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/makeinfo"
   447     CT_DoExecLog ALL chmod 700 "${CT_BUILDTOOLS_PREFIX_DIR}/bin/makeinfo"
   448 
   449     # Carefully add paths in the order we want them:
   450     #  - first try in ${CT_PREFIX_DIR}/bin
   451     #  - then try the buildtools dir
   452     #  - fall back to searching user's PATH
   453     # Of course, neither cross-native nor canadian can run on BUILD,
   454     # so don't add those PATHs in this case...
   455     case "${CT_TOOLCHAIN_TYPE}" in
   456         cross)  export PATH="${CT_PREFIX_DIR}/bin:${CT_BUILDTOOLS_PREFIX_DIR}/bin:${PATH}";;
   457         canadian) export PATH="${CT_BUILDTOOLS_PREFIX_DIR}/bin:${PATH}";;
   458         *)  ;;
   459     esac
   460 
   461     # Now we know our host and where to find the host tools, we can check
   462     # if static link was requested, but only if it was requested
   463     if [ "${CT_WANTS_STATIC_LINK}" = "y" ]; then
   464         tmp="${CT_BUILD_DIR}/.static-test"
   465         if ! "${CT_HOST}-gcc" -xc - -static -o "${tmp}" >/dev/null 2>&1 <<-_EOF_
   466 				int main() { return 0; }
   467 			_EOF_
   468         then
   469             CT_Abort "Static linking impossible on the host system '${CT_HOST}'"
   470         fi
   471         rm -f "${tmp}"
   472     fi
   473 
   474     # Help gcc
   475     CT_CFLAGS_FOR_HOST=
   476     [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST+=" -pipe"
   477     CT_CFLAGS_FOR_HOST+=" ${CT_EXTRA_FLAGS_FOR_HOST}"
   478 
   479     # Set the shell to be used by ./configure scripts and by Makefiles (those
   480     # that support it!).
   481     export CONFIG_SHELL="${CT_CONFIG_SHELL}"    # for ./configure
   482     export SHELL="${CT_CONFIG_SHELL}"           # for Makefiles
   483 
   484     # And help make go faster
   485     JOBSFLAGS=
   486     # Override the configured jobs with what's been given on the command line
   487     [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
   488     # Use the number of processors+1 when automatically setting the number of
   489     # parallel jobs.  Fall back to 1 if the host doesn't use GLIBC.
   490     AUTO_JOBS=$((`getconf _NPROCESSORS_ONLN 2> /dev/null || echo 0` + 1))
   491     [ ${CT_PARALLEL_JOBS} -eq 0 ] && JOBSFLAGS="${JOBSFLAGS} -j${AUTO_JOBS}"
   492     [ ${CT_PARALLEL_JOBS} -gt 0 ] && JOBSFLAGS="${JOBSFLAGS} -j${CT_PARALLEL_JOBS}"
   493     [ ${CT_LOAD} -ne 0 ] && JOBSFLAGS="${JOBSFLAGS} -l${CT_LOAD}"
   494 
   495     # We need to save the real .config with kconfig's value,
   496     # not our mangled .config.2 with arrays.
   497     CT_DoLog EXTRA "Installing user-supplied crosstool-NG configuration"
   498     CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/bin"
   499     CT_DoExecLog DEBUG install -m 0755 "${CT_LIB_DIR}/scripts/toolchain-config.in" "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
   500     CT_DoExecLog DEBUG sed -i -e 's,@@grep@@,"'"${grep}"'",;' "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
   501     bzip2 -c -9 .config >>"${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
   502 
   503     CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
   504     CT_DoLog EXTRA "Building a toolchain for:"
   505     CT_DoLog EXTRA "  build  = ${CT_REAL_BUILD}"
   506     CT_DoLog EXTRA "  host   = ${CT_REAL_HOST}"
   507     CT_DoLog EXTRA "  target = ${CT_TARGET}"
   508     set |grep -E '^CT_.+=' |sort |CT_DoLog DEBUG
   509     CT_DoLog DEBUG "Other environment:"
   510     printenv |grep -v -E '^CT_.+=' |CT_DoLog DEBUG
   511     CT_EndStep
   512 fi
   513 
   514 if [ -z "${CT_RESTART}" ]; then
   515     CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
   516     do_companion_tools_get
   517     do_kernel_get
   518     do_gmp_get
   519     do_mpfr_get
   520     do_ppl_get
   521     do_cloog_get
   522     do_mpc_get
   523     do_libelf_get
   524     do_binutils_get
   525     do_elf2flt_get
   526     do_sstrip_get
   527     do_cc_get
   528     do_libc_get
   529     do_debug_get
   530     do_test_suite_get
   531     CT_EndStep
   532 
   533     if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
   534         if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
   535             CT_DoForceRmdir "${CT_SRC_DIR}"
   536             CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
   537         fi
   538 
   539         if [ "${CT_COMP_TOOLS}" = "y" ]; then
   540           CT_DoStep INFO "Extracting, patching and installing companion tools"
   541           do_companion_tools_extract
   542           do_companion_tools
   543           CT_EndStep
   544         fi
   545 
   546         CT_DoStep INFO "Extracting and patching toolchain components"
   547         do_kernel_extract
   548         do_gmp_extract
   549         do_mpfr_extract
   550         do_ppl_extract
   551         do_cloog_extract
   552         do_mpc_extract
   553         do_libelf_extract
   554         do_binutils_extract
   555         do_elf2flt_extract
   556         do_sstrip_extract
   557         do_cc_extract
   558         do_libc_extract
   559         do_debug_extract
   560         do_test_suite_extract
   561         CT_EndStep
   562     fi
   563 fi
   564 
   565 # Now for the job by itself. Go have a coffee!
   566 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
   567     # Because of CT_RESTART, this becomes quite complex
   568     do_stop=0
   569     prev_step=
   570     [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
   571     # Aha! CT_STEPS comes from steps.mk!
   572     for step in ${CT_STEPS}; do
   573         if [ ${do_it} -eq 0 ]; then
   574             if [ "${CT_RESTART}" = "${step}" ]; then
   575                 CT_DoLoadState "${step}"
   576                 do_it=1
   577                 do_stop=0
   578             fi
   579         else
   580             CT_DoSaveState ${step}
   581             if [ ${do_stop} -eq 1 ]; then
   582                 CT_DoLog ERROR "Stopping just after step '${prev_step}', as requested."
   583                 exit 0
   584             fi
   585         fi
   586         if [ ${do_it} -eq 1 ]; then
   587             ( do_${step} )
   588             if [ "${CT_STOP}" = "${step}" ]; then
   589                 do_stop=1
   590             fi
   591             if [ "${CT_DEBUG_PAUSE_STEPS}" = "y" ]; then
   592                 CT_DoPause "Step '${step}' finished"
   593             fi
   594         fi
   595         prev_step="${step}"
   596     done
   597 fi
   598 
   599 CT_DoEnd INFO
   600 
   601 # From now-on, it can become impossible to log any time, because
   602 # either we're compressing the log file, or it can become RO any
   603 # moment... Consign all ouptut to oblivion...
   604 CT_DoLog INFO "Finishing installation (may take a few seconds)..."
   605 exec >/dev/null 2>&1
   606 rm -f ${CT_PREFIX_DIR}/build.log.bz2
   607 if [ "${CT_LOG_TO_FILE}" = "y" ]; then
   608     cp "${tmp_log_file}" "${CT_PREFIX_DIR}/build.log"
   609     if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
   610         bzip2 -9 "${CT_PREFIX_DIR}/build.log"
   611     fi
   612 fi
   613 [ "${CT_INSTALL_DIR_RO}" = "y"  ] && chmod -R a-w "${CT_INSTALL_DIR}"
   614 [ "${CT_TEST_SUITE}" = "y" ] && chmod -R u+w "${CT_TEST_SUITE_DIR}"
   615 
   616 trap - EXIT