yann@1: #!/bin/bash
yann@1: # Copyright 2007 Yann E. MORIN
yann@1: # Licensed under the GPL v2. See COPYING in the root of this package.
yann@1: 
yann@1: # This is the main entry point to crosstool
yann@1: # This will:
yann@1: #   - download, extract and patch the toolchain components
yann@1: #   - build and install each components in turn
yann@1: #   - and eventually test the resulting toolchain
yann@1: 
yann@1: # What this file does is prepare the environment, based upon the user-choosen
yann@1: # options. It also checks the existing environment for un-friendly variables,
yann@96: # and builds the tools.
yann@1: 
yann@1: # Parse the common functions
yann@182: . "${CT_LIB_DIR}/scripts/functions"
yann@1: 
yann@1: CT_STAR_DATE=`CT_DoDate +%s%N`
yann@1: CT_STAR_DATE_HUMAN=`CT_DoDate +%Y%m%d.%H%M%S`
yann@1: 
yann@96: # Are we configured? We'll need that later...
yann@96: CT_TestOrAbort "Configuration file not found. Please create one." -f "${CT_TOP_DIR}/.config"
yann@96: 
yann@1: # Parse the configuration file
yann@96: # It has some info about the logging facility, so include it early
yann@1: . "${CT_TOP_DIR}/.config"
yann@1: 
yann@379: # Yes! We can do full logging from now on!
yann@379: CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
yann@379: 
yann@96: # renice oursleves
yann@96: renice ${CT_NICE} $$ |CT_DoLog DEBUG
yann@1: 
yann@96: CT_DoStep DEBUG "Dumping crosstool-NG configuration"
yann@182: cat "${CT_TOP_DIR}/.config" |egrep '^(# |)CT_' |CT_DoLog DEBUG
yann@96: CT_EndStep
yann@63: 
yann@1: # Some sanity checks in the environment and needed tools
yann@1: CT_DoLog INFO "Checking environment sanity"
yann@1: 
yann@290: CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
yann@290: unset MAKEFLAGS
yann@290: export MAKEFLAGS
yann@290: 
yann@1: # Other environment sanity checks
yann@1: CT_TestAndAbort "Don't set LD_LIBRARY_PATH. It screws up the build." -n "${LD_LIBRARY_PATH}"
yann@1: CT_TestAndAbort "Don't set CFLAGS. It screws up the build." -n "${CFLAGS}"
yann@1: CT_TestAndAbort "Don't set CXXFLAGS. It screws up the build." -n "${CXXFLAGS}"
yann@1: CT_Test "GREP_OPTIONS screws up the build. Resetting." -n "${GREP_OPTIONS}"
yann@1: GREP_OPTIONS=
yann@1: CT_HasOrAbort awk
yann@1: CT_HasOrAbort sed
yann@1: CT_HasOrAbort bison
yann@1: CT_HasOrAbort flex
yann@243: CT_HasOrAbort lynx
yann@1: 
yann@1: CT_DoLog INFO "Building environment variables"
yann@1: 
yann@380: # Parse architecture-specific functions
yann@394: . "${CT_LIB_DIR}/arch/${CT_ARCH}/functions"
yann@380: 
yann@335: # Target tuple: CT_TARGET needs a little love:
yann@335: CT_DoBuildTargetTuple
yann@1: 
yann@96: # Kludge: If any of the configured options needs CT_TARGET,
yann@96: # then rescan the options file now:
yann@96: . "${CT_TOP_DIR}/.config"
yann@96: 
yann@397: # Second kludge: merge user-supplied target CFLAGS with architecture-provided
yann@397: # target CFLAGS
yann@397: CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
yann@397: 
yann@1: # Now, build up the variables from the user-configured options.
yann@1: CT_KERNEL_FILE="${CT_KERNEL}-${CT_KERNEL_VERSION}"
yann@1: CT_BINUTILS_FILE="binutils-${CT_BINUTILS_VERSION}"
yann@1: CT_CC_FILE="${CT_CC}-${CT_CC_VERSION}"
yann@1: CT_LIBC_FILE="${CT_LIBC}-${CT_LIBC_VERSION}"
yann@1: 
yann@85: # Where will we work?
yann@85: CT_TARBALLS_DIR="${CT_TOP_DIR}/targets/tarballs"
yann@143: CT_SRC_DIR="${CT_TOP_DIR}/targets/src"
yann@85: CT_BUILD_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/build"
yann@96: CT_DEBUG_INSTALL_DIR="${CT_INSTALL_DIR}/${CT_TARGET}/debug-root"
yann@121: # Note: we'll always install the core compiler in its own directory, so as to
yann@331: # not mix the two builds: core and final.
yann@136: CT_CC_CORE_STATIC_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-static"
yann@136: CT_CC_CORE_SHARED_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-shared"
yann@121: CT_STATE_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/state"
yann@85: 
yann@143: # We must ensure that we can restart if asked for!
yann@143: if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}"  ]; then
yann@143:     CT_DoLog ERROR "You asked to restart a non-restartable build"
yann@143:     CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
yann@153:     CT_DoLog ERROR "in the config options for the previous build, or the state"
yann@153:     CT_DoLog ERROR "directoy for the previous build was deleted."
yann@143:     CT_Abort "I will stop here to avoid any carnage"
yann@143: fi
yann@143: 
yann@85: # Make all path absolute, it so much easier!
yann@85: CT_LOCAL_TARBALLS_DIR="`CT_MakeAbsolutePath \"${CT_LOCAL_TARBALLS_DIR}\"`"
yann@85: 
yann@403: # If the local tarball directory does not exist, say so, and don't try to save there!
yann@403: if [ ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
yann@403:     CT_DoLog WARN "Directory \"${CT_LOCAL_TARBALLS_DIR}\" does not exist. Will not save downloaded tarballs to local storage."
yann@403:     CT_SAVE_TARBALLS=""
yann@403: fi
yann@403: 
yann@1: # Some more sanity checks now that we have all paths set up
yann@403: case "${CT_LOCAL_TARBALLS_DIR},${CT_TARBALLS_DIR},${CT_SRC_DIR},${CT_BUILD_DIR},${CT_PREFIX_DIR},${CT_INSTALL_DIR}" in
yann@1:     *" "*) CT_Abort "Don't use spaces in paths, it breaks things.";;
yann@1: esac
yann@1: 
yann@85: # Check now if we can write to the destination directory:
yann@85: if [ -d "${CT_INSTALL_DIR}" ]; then
yann@85:     CT_TestAndAbort "Destination directory \"${CT_INSTALL_DIR}\" is not removable" ! -w `dirname "${CT_INSTALL_DIR}"`
yann@85: fi
yann@85: 
yann@96: # Good, now grab a bit of informations on the system we're being run on,
yann@96: # just in case something goes awok, and it's not our fault:
yann@96: CT_SYS_USER="`id -un`"
yann@96: CT_SYS_HOSTNAME=`hostname -f 2>/dev/null || true`
yann@96: # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
yann@96: CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-`uname -n`}"
yann@96: CT_SYS_KERNEL=`uname -s`
yann@96: CT_SYS_REVISION=`uname -r`
yann@96: # MacOS X lacks '-o' :
yann@96: CT_SYS_OS=`uname -o || echo "Unknown (maybe MacOS-X)"`
yann@96: CT_SYS_MACHINE=`uname -m`
yann@96: CT_SYS_PROCESSOR=`uname -p`
yann@96: CT_SYS_GCC=`gcc -dumpversion`
yann@182: CT_SYS_TARGET=`CT_DoConfigGuess`
yann@96: CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
yann@96: 
yann@96: CT_DoLog EXTRA "Preparing working directories"
yann@96: 
yann@121: # Ah! The build directory shall be eradicated, even if we restart!
yann@85: if [ -d "${CT_BUILD_DIR}" ]; then
yann@85:     mv "${CT_BUILD_DIR}" "${CT_BUILD_DIR}.$$"
yann@96:     chmod -R u+w "${CT_BUILD_DIR}.$$"
yann@320:     setsid nohup rm -rf "${CT_BUILD_DIR}.$$" >/dev/null 2>&1 &
yann@85: fi
yann@121: 
yann@121: # Don't eradicate directories if we need to restart
yann@121: if [ -z "${CT_RESTART}" ]; then
yann@121:     # Get rid of pre-existing installed toolchain and previous build directories.
yann@121:     # We need to do that _before_ we can safely log, because the log file will
yann@121:     # most probably be in the toolchain directory.
yann@121:     if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
yann@121:         mv "${CT_TARBALLS_DIR}" "${CT_TARBALLS_DIR}.$$"
yann@121:         chmod -R u+w "${CT_TARBALLS_DIR}.$$"
yann@320:         setsid nohup rm -rf "${CT_TARBALLS_DIR}.$$" >/dev/null 2>&1 &
yann@121:     fi
yann@121:     if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
yann@121:         mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
yann@121:         chmod -R u+w "${CT_SRC_DIR}.$$"
yann@320:         setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1 &
yann@121:     fi
yann@121:     if [ -d "${CT_INSTALL_DIR}" ]; then
yann@121:         mv "${CT_INSTALL_DIR}" "${CT_INSTALL_DIR}.$$"
yann@121:         chmod -R u+w "${CT_INSTALL_DIR}.$$"
yann@320:         setsid nohup rm -rf "${CT_INSTALL_DIR}.$$" >/dev/null 2>&1 &
yann@121:     fi
yann@121:     if [ -d "${CT_DEBUG_INSTALL_DIR}" ]; then
yann@121:         mv "${CT_DEBUG_INSTALL_DIR}" "${CT_DEBUG_INSTALL_DIR}.$$"
yann@121:         chmod -R u+w "${CT_DEBUG_INSTALL_DIR}.$$"
yann@320:         setsid nohup rm -rf "${CT_DEBUG_INSTALL_DIR}.$$" >/dev/null 2>&1 &
yann@121:     fi
yann@121:     # In case we start anew, get rid of the previously saved state directory
yann@121:     if [ -d "${CT_STATE_DIR}" ]; then
yann@121:         mv "${CT_STATE_DIR}" "${CT_STATE_DIR}.$$"
yann@121:         chmod -R u+w "${CT_STATE_DIR}.$$"
yann@320:         setsid nohup rm -rf "${CT_STATE_DIR}.$$" >/dev/null 2>&1 &
yann@121:     fi
yann@96: fi
yann@85: 
yann@121: # Create the directories we'll use, even if restarting: it does no harm to
yann@121: # create already existent directories, and CT_BUILD_DIR needs to be created
yann@121: # anyway
yann@85: mkdir -p "${CT_TARBALLS_DIR}"
yann@85: mkdir -p "${CT_SRC_DIR}"
yann@85: mkdir -p "${CT_BUILD_DIR}"
yann@85: mkdir -p "${CT_INSTALL_DIR}"
yann@121: mkdir -p "${CT_PREFIX_DIR}"
yann@96: mkdir -p "${CT_DEBUG_INSTALL_DIR}"
yann@136: mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
yann@136: mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
yann@121: mkdir -p "${CT_STATE_DIR}"
yann@121: 
yann@121: # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
yann@136: # the previous build was successfull. To be able to move the logfile there,
yann@121: # switch them back to read/write
yann@121: chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
yann@85: 
yann@63: # Redirect log to the actual log file now we can
yann@63: # It's quite understandable that the log file will be installed in the install
yann@63: # directory, so we must first ensure it exists and is writeable (above) before
yann@63: # we can log there
yann@112: exec >/dev/null
yann@174: case "${CT_LOG_TO_FILE}" in
yann@174:     y)  CT_LOG_FILE="${CT_PREFIX_DIR}/build.log"
yann@174:         cat "${tmp_log_file}" >>"${CT_LOG_FILE}"
yann@174:         rm -f "${tmp_log_file}"
yann@174:         exec >>"${CT_LOG_FILE}"
yann@174:         ;;
yann@174:     *)  rm -f "${tmp_log_file}"
yann@174:         ;;
yann@63: esac
yann@63: 
yann@397: # Setting up the rest of the environment only if not restarting
yann@121: if [ -z "${CT_RESTART}" ]; then
yann@121:     # Determine build system if not set by the user
yann@121:     CT_Test "You did not specify the build system. That's OK, I can guess..." -z "${CT_BUILD}"
yann@182:     CT_BUILD="${CT_BUILD:-`CT_DoConfigGuess`}"
yann@182:     CT_BUILD=`CT_DoConfigSub "${CT_BUILD}"`
yann@63: 
yann@121:     # Arrange paths depending on wether we use sys-root or not.
yann@121:     if [ "${CT_USE_SYSROOT}" = "y" ]; then
yann@121:         CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/sys-root"
yann@121:         CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
yann@121:         BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
yann@121:         CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
yann@121:         CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
yann@121:         LIBC_SYSROOT_ARG=""
yann@121:         # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
yann@121:         # confused when $sysroot/usr/include is not present.
yann@121:         # Note: --prefix=/usr is magic!
yann@121:         # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
yann@121:     else
yann@121:         # plain old way. All libraries in prefix/target/lib
yann@121:         CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
yann@121:         CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
yann@121:         # hack!  Always use --with-sysroot for binutils.
yann@121:         # binutils 2.14 and later obey it, older binutils ignore it.
yann@121:         # Lets you build a working 32->64 bit cross gcc
yann@121:         BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
yann@121:         # Use --with-headers, else final gcc will define disable_glibc while
yann@121:         # building libgcc, and you'll have no profiling
yann@121:         CC_CORE_SYSROOT_ARG="--without-headers"
yann@121:         CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
yann@121:         LIBC_SYSROOT_ARG="prefix="
yann@121:     fi
yann@121: 
yann@121:     # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
yann@121:     # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail with
yann@121:     #  "ld: cannot open crti.o: No such file or directory"
yann@121:     mkdir -p "${CT_SYSROOT_DIR}/lib"
yann@121:     mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
yann@121: 
yann@121:     # Canadian-cross are really picky on the way they are built. Tweak the values.
yann@136:     CT_UNIQ_BUILD=`echo "${CT_BUILD}" |sed -r -e 's/-/-build_/'`
yann@121:     if [ "${CT_CANADIAN}" = "y" ]; then
yann@121:         # Arrange so that gcc never, ever think that build system == host system
yann@136:         CT_CANADIAN_OPT="--build=${CT_UNIQ_BUILD}"
yann@121:         # We shall have a compiler for this target!
yann@121:         # Do test here...
yann@121:     else
yann@121:         CT_HOST="${CT_BUILD}"
yann@134:         CT_CANADIAN_OPT="--build=${CT_BUILD}"
yann@121:         # Add the target toolchain in the path so that we can build the C library
yann@136:         # Carefully add paths in the order we want them:
yann@136:         #  - first try in ${CT_PREFIX_DIR}/bin
yann@136:         #  - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
yann@136:         #  - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
yann@136:         #  - fall back to searching user's PATH
yann@136:         export PATH="${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}"
yann@121:     fi
yann@121: 
yann@121:     # Modify GCC_HOST to never be equal to $BUILD or $TARGET
yann@121:     # This strange operation causes gcc to always generate a cross-compiler
yann@121:     # even if the build machine is the same kind as the host.
yann@121:     # This is why CC has to be set when doing a canadian cross; you can't find a
yann@121:     # host compiler by appending -gcc to our whacky $GCC_HOST
yann@121:     # Kludge: it is reported that the above causes canadian crosses with cygwin
yann@121:     # hosts to fail, so avoid it just in that one case.  It would be cleaner to
yann@121:     # just move this into the non-canadian case above, but I'm afraid that might
yann@121:     # cause some configure script somewhere to decide that since build==host, they
yann@121:     # could run host binaries.
yann@121:     # (Copied almost as-is from original crosstool):
yann@121:     case "${CT_KERNEL},${CT_CANADIAN}" in
yann@121:         cygwin,y) ;;
yann@136:         *,y)      CT_HOST="`echo \"${CT_HOST}\" |sed -r -e 's/-/-host_/;'`";;
yann@121:     esac
yann@121: 
yann@121:     # Ah! Recent versions of binutils need some of the build and/or host system
yann@121:     # (read CT_BUILD and CT_HOST) tools to be accessible (ar is but an example).
yann@121:     # Do that:
yann@174:     CT_DoLog DEBUG "Making build system tools available"
yann@121:     mkdir -p "${CT_PREFIX_DIR}/bin"
yann@121:     for tool in ar as dlltool gcc g++ gnatbind gnatmake ld nm ranlib strip windres objcopy objdump; do
yann@210:         tmp=`CT_Which ${tool}`
yann@210:         if [ -n "${tmp}" ]; then
yann@210:             ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_BUILD}-${tool}"
yann@210:             ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_UNIQ_BUILD}-${tool}"
yann@210:             ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_HOST}-${tool}"
yann@123:         fi |CT_DoLog DEBUG
yann@121:     done
yann@121: 
yann@121:     # Help gcc
yann@121:     CT_CFLAGS_FOR_HOST=
yann@121:     [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST="${CT_CFLAGS_FOR_HOST} -pipe"
yann@121: 
yann@333:     # Override the configured jobs with what's been given on the command line
yann@333:     [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
yann@333: 
yann@121:     # And help make go faster
yann@121:     PARALLELMFLAGS=
yann@121:     [ ${CT_PARALLEL_JOBS} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -j${CT_PARALLEL_JOBS}"
yann@121:     [ ${CT_LOAD} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -l${CT_LOAD}"
yann@121: 
yann@121:     CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
yann@121:     CT_DoLog EXTRA "Building a toolchain for:"
yann@121:     CT_DoLog EXTRA "  build  = ${CT_BUILD}"
yann@121:     CT_DoLog EXTRA "  host   = ${CT_HOST}"
yann@121:     CT_DoLog EXTRA "  target = ${CT_TARGET}"
yann@121:     set |egrep '^CT_.+=' |sort |CT_DoLog DEBUG
yann@121:     CT_EndStep
yann@63: fi
yann@63: 
yann@1: # Include sub-scripts instead of calling them: that way, we do not have to
yann@1: # export any variable, nor re-parse the configuration and functions files.
yann@182: . "${CT_LIB_DIR}/scripts/build/kernel_${CT_KERNEL}.sh"
yann@182: . "${CT_LIB_DIR}/scripts/build/binutils.sh"
yann@182: . "${CT_LIB_DIR}/scripts/build/libc_${CT_LIBC}.sh"
yann@182: . "${CT_LIB_DIR}/scripts/build/cc_${CT_CC}.sh"
yann@182: . "${CT_LIB_DIR}/scripts/build/debug.sh"
yann@182: . "${CT_LIB_DIR}/scripts/build/tools.sh"
yann@63: 
yann@121: if [ -z "${CT_RESTART}" ]; then
yann@121:     CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
yann@121:     do_kernel_get
yann@121:     do_binutils_get
yann@331:     do_cc_get
yann@121:     do_libc_get
yann@148:     do_tools_get
yann@121:     do_debug_get
yann@63:     CT_EndStep
yann@63: 
yann@121:     if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
yann@121:         if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
yann@121:             mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
yann@320:             setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1
yann@121:         fi
yann@121:         CT_DoStep INFO "Extracting and patching toolchain components"
yann@121:         do_kernel_extract
yann@121:         do_binutils_extract
yann@331:         do_cc_extract
yann@121:         do_libc_extract
yann@148:         do_tools_extract
yann@121:         do_debug_extract
yann@121:         CT_EndStep
yann@121:     fi
yann@121: fi
yann@85: 
yann@121: # Now for the job by itself. Go have a coffee!
yann@121: if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
yann@121:     # Because of CT_RESTART, this becomes quite complex
yann@143:     do_stop=0
yann@143:     prev_step=
yann@121:     [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
yann@121:     for step in libc_check_config       \
yann@121:                 kernel_check_config     \
yann@121:                 kernel_headers          \
yann@121:                 binutils                \
yann@152:                 cc_core_pass_1          \
yann@121:                 libc_headers            \
yann@136:                 libc_start_files        \
yann@152:                 cc_core_pass_2          \
yann@121:                 libc                    \
yann@121:                 cc                      \
yann@121:                 libc_finish             \
yann@148:                 tools                   \
yann@121:                 debug                   \
yann@121:                 ; do
yann@121:         if [ ${do_it} -eq 0 ]; then
yann@121:             if [ "${CT_RESTART}" = "${step}" ]; then
yann@121:                 CT_DoLoadState "${step}"
yann@121:                 do_it=1
yann@143:                 do_stop=0
yann@121:             fi
yann@121:         else
yann@121:             CT_DoSaveState ${step}
yann@143:             if [ ${do_stop} -eq 1 ]; then
yann@143:                 CT_DoLog ERROR "Stopping just after step \"${prev_step}\", as requested."
yann@143:                 exit 0
yann@143:             fi
yann@85:         fi
yann@121:         if [ ${do_it} -eq 1 ]; then
yann@121:             do_${step}
yann@135:             if [ "${CT_STOP}" = "${step}" ]; then
yann@143:                 do_stop=1
yann@135:             fi
yann@121:             if [ "${CTDEBUG_CT_PAUSE_STEPS}" = "y" ]; then
yann@121:                 CT_DoPause "Step \"${step}\" finished"
yann@121:             fi
yann@121:         fi
yann@143:         prev_step="${step}"
yann@121:     done
yann@85: 
yann@274:     CT_DoLog DEBUG "Removing access to the build system tools"
yann@274:     find "${CT_PREFIX_DIR}/bin" -name "${CT_BUILD}-"'*' -exec rm -fv {} \+ |CT_DoLog DEBUG
yann@274:     find "${CT_PREFIX_DIR}/bin" -name "${CT_UNIQ_BUILD}-"'*' -exec rm -fv {} \+ |CT_DoLog DEBUG
yann@274:     find "${CT_PREFIX_DIR}/bin" -name "${CT_HOST}-"'*' -exec rm -fv {} \+ |CT_DoLog DEBUG
yann@274: 
yann@217:     # Install the /populator/
yann@254:     CT_DoLog EXTRA "Installing the populate helper"
yann@217:     sed -r -e 's,@@CT_READELF@@,'"${CT_PREFIX_DIR}/bin/${CT_TARGET}-readelf"',g;'   \
yann@217:            -e 's,@@CT_SYSROOT_DIR@@,'"${CT_SYSROOT_DIR}"',g;'                       \
yann@217:            "${CT_LIB_DIR}/tools/populate.in" >"${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
yann@217:     chmod 755 "${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
yann@217: 
yann@121:     # Create the aliases to the target tools
yann@321:     CT_DoStep EXTRA "Creating toolchain aliases"
yann@321:     CT_Pushd "${CT_PREFIX_DIR}/bin"
yann@321:     for t in "${CT_TARGET}-"*; do
yann@321:         if [ -n "${CT_TARGET_ALIAS}" ]; then
yann@121:             _t="`echo \"$t\" |sed -r -e 's/^'\"${CT_TARGET}\"'-/'\"${CT_TARGET_ALIAS}\"'-/;'`"
yann@121:             CT_DoLog DEBUG "Linking \"${_t}\" -> \"${t}\""
yann@321:             ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
yann@321:         fi
yann@321:         if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
yann@321:             _t="`echo \"$t\" |sed -r -e \"${CT_TARGET_ALIAS_SED_EXPR}\"`"
yann@321:             CT_DoLog DEBUG "Linking \"${_t}\" -> \"${t}\""
yann@321:             ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
yann@321:         fi
yann@321:     done
yann@321:     CT_Popd
yann@321:     CT_EndStep
yann@121: 
yann@121:     # Remove the generated documentation files
yann@121:     if [ "${CT_REMOVE_DOCS}" = "y" ]; then
yann@121:     	CT_DoLog INFO "Removing installed documentation"
yann@121:         rm -rf "${CT_PREFIX_DIR}/"{,usr/}{man,info}
yann@121:         rm -rf "${CT_SYSROOT_DIR}/"{,usr/}{man,info}
yann@121:         rm -rf "${CT_DEBUG_INSTALL_DIR}/"{,usr/}{man,info}
yann@63:     fi
yann@63: fi
yann@1: 
yann@96: CT_DoEnd INFO
yann@96: 
yann@174: if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
yann@174:     CT_DoLog EXTRA "Compressing log file"
yann@174:     exec >/dev/null
yann@174:     bzip2 -9 "${CT_LOG_FILE}"
yann@174: fi
yann@174: 
yann@174: if [ "${CT_INSTALL_DIR_RO}" = "y" ]; then
yann@174:     # OK, now we're done, set the toolchain read-only
yann@174:     # Don't log, the log file may become read-only any moment...
yann@174:     chmod -R a-w "${CT_INSTALL_DIR}" >/dev/null 2>&1
yann@174: fi
yann@1: 
yann@1: trap - EXIT