scripts/functions: Fix CT_ExtractGit function.
Change CT_ExtractGit so that it clones the repository, instead of just
symlinking it. After cloning, any given ref is checked out, or if no
ref is given, the HEAD of the repository is checked out.
This makes CT_Extract behave similar for git repositories as it does
for tarballs, so that it for example can be used for passing glibc-ports
as a git repository.
Signed-off-by: "Esben Haabendal" <esben.haabendal@prevas.dk>
[yann.morin.1998@anciens.enib.fr: fix incomplete var rename]
Signed-off-by: "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
2 # Copyright 2007 Yann E. MORIN
3 # Licensed under the GPL v2. See COPYING in the root of this package.
5 # This is the main entry point to crosstool
7 # - download, extract and patch the toolchain components
8 # - build and install each components in turn
9 # - and eventually test the resulting toolchain
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.
15 # Parse the common functions
16 # Note: some initialisation and sanitizing is done while parsing this file,
18 # - set trap handler on errors,
19 # - don't hash commands lookups,
20 # - initialise logging.
21 . "${CT_LIB_DIR}/scripts/functions"
23 # Parse the configuration file
24 # It has some info about the logging facility, so include it early
26 # Yes! We can do full logging from now on!
28 # Override the locale early, in case we ever translate crosstool-NG messages
29 if [ -z "${CT_NO_OVERIDE_LC_MESSAGES}" ]; then
34 # remove . from PATH since it can cause gcc build failures
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}"
45 # Some sanity checks on paths content
52 eval dir="\${CT_${d}_DIR}"
55 CT_Abort "'CT_${d}_DIR'='${dir}' contains a space in it.\nDon't use spaces in paths, it breaks things."
61 CT_WORK_DIR="${CT_WORK_DIR:-${CT_TOP_DIR}/targets}"
62 CT_DoExecLog ALL mkdir -p "${CT_WORK_DIR}"
64 # Check build file system case-sensitiveness
65 CT_DoExecLog DEBUG touch "${CT_WORK_DIR}/foo"
66 CT_TestAndAbort "Your file system in '${CT_WORK_DIR}' is *not* case-sensitive!" -f "${CT_WORK_DIR}/FOO"
67 CT_DoExecLog DEBUG rm -f "${CT_WORK_DIR}/foo"
69 # Check the user is using an existing SHELL to be used by ./configure and Makefiles
70 CT_TestOrAbort "The CONFIG_SHELL '${CT_CONFIG_SHELL}' is not valid" -f "${CT_CONFIG_SHELL}" -a -x "${CT_CONFIG_SHELL}"
72 # Create the bin-override early
73 # Contains symlinks to the tools found by ./configure
74 # Note: CT_DoLog and CT_DoExecLog do not use any of those tool, so
75 # they can be safely used
76 CT_TOOLS_OVERIDE_DIR="${CT_WORK_DIR}/tools"
77 CT_DoLog DEBUG "Creating bin-override for tools in '${CT_TOOLS_OVERIDE_DIR}'"
78 CT_DoExecLog DEBUG mkdir -p "${CT_TOOLS_OVERIDE_DIR}/bin"
79 cat "${CT_LIB_DIR}/paths.mk" |while read trash line; do
82 CT_DoLog DEBUG "Creating script-override for '${tool}' -> '${path}'"
83 printf "#${BANG}${CT_SHELL}\nexec '${path}' \"\${@}\"\n" >"${CT_TOOLS_OVERIDE_DIR}/bin/${tool}"
84 CT_DoExecLog ALL chmod 700 "${CT_TOOLS_OVERIDE_DIR}/bin/${tool}"
86 export PATH="${CT_TOOLS_OVERIDE_DIR}/bin:${PATH}"
88 # Start date. Can't be done until we know the locale
89 # Also requires the bin-override tools
90 CT_STAR_DATE=$(CT_DoDate +%s%N)
91 CT_STAR_DATE_HUMAN=$(CT_DoDate +%Y%m%d.%H%M%S)
93 # Log real begining of build, now
94 CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
96 # We really need to extract from ,config and not .config.2, as we
97 # do want the kconfig's values, not our mangled config with arrays.
98 CT_DoStep DEBUG "Dumping user-supplied crosstool-NG configuration"
99 CT_DoExecLog DEBUG grep -E '^(# |)CT_' .config
102 CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
106 CT_DoLog INFO "Building environment variables"
108 # Include sub-scripts instead of calling them: that way, we do not have to
109 # export any variable, nor re-parse the configuration and functions files.
110 . "${CT_LIB_DIR}/scripts/build/internals.sh"
111 . "${CT_LIB_DIR}/scripts/build/arch/${CT_ARCH}.sh"
112 . "${CT_LIB_DIR}/scripts/build/companion_tools.sh"
113 . "${CT_LIB_DIR}/scripts/build/kernel/${CT_KERNEL}.sh"
114 . "${CT_LIB_DIR}/scripts/build/companion_libs/gmp.sh"
115 . "${CT_LIB_DIR}/scripts/build/companion_libs/mpfr.sh"
116 . "${CT_LIB_DIR}/scripts/build/companion_libs/ppl.sh"
117 . "${CT_LIB_DIR}/scripts/build/companion_libs/cloog.sh"
118 . "${CT_LIB_DIR}/scripts/build/companion_libs/mpc.sh"
119 . "${CT_LIB_DIR}/scripts/build/companion_libs/libelf.sh"
120 . "${CT_LIB_DIR}/scripts/build/binutils/binutils.sh"
121 . "${CT_LIB_DIR}/scripts/build/binutils/elf2flt.sh"
122 . "${CT_LIB_DIR}/scripts/build/binutils/sstrip.sh"
123 . "${CT_LIB_DIR}/scripts/build/libc/${CT_LIBC}.sh"
124 . "${CT_LIB_DIR}/scripts/build/cc/${CT_CC}.sh"
125 . "${CT_LIB_DIR}/scripts/build/debug.sh"
126 . "${CT_LIB_DIR}/scripts/build/test_suite.sh"
128 # Target tuple: CT_TARGET needs a little love:
129 CT_DoBuildTargetTuple
131 # Kludge: If any of the configured options needs CT_TARGET,
132 # then rescan the options file now:
135 # Sanity check some directories
136 CT_TestAndAbort "'CT_PREFIX_DIR' is not set: where should I install?" -z "${CT_PREFIX_DIR}"
138 # Second kludge: merge user-supplied target CFLAGS with architecture-provided
139 # target CFLAGS. Do the same for LDFLAGS in case it happens in the future.
140 # Put user-supplied flags at the end, so that they take precedence.
141 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
142 CT_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_TARGET_LDFLAGS}"
143 CT_CC_CORE_EXTRA_CONFIG_ARRAY=( ${CT_ARCH_CC_CORE_EXTRA_CONFIG} "${CT_CC_CORE_EXTRA_CONFIG_ARRAY[@]}" )
144 CT_CC_EXTRA_CONFIG_ARRAY=( ${CT_ARCH_CC_EXTRA_CONFIG} "${CT_CC_EXTRA_CONFIG_ARRAY[@]}" )
146 # Compute the package version string
147 CT_PKGVERSION="crosstool-NG ${CT_VERSION}${CT_TOOLCHAIN_PKGVERSION:+ - ${CT_TOOLCHAIN_PKGVERSION}}"
149 # Compute the working directories names
150 CT_TARBALLS_DIR="${CT_WORK_DIR}/tarballs"
151 CT_SRC_DIR="${CT_WORK_DIR}/src"
152 CT_BUILD_DIR="${CT_WORK_DIR}/${CT_TARGET}/build"
153 CT_BUILDTOOLS_PREFIX_DIR="${CT_WORK_DIR}/${CT_TARGET}/buildtools"
154 CT_STATE_DIR="${CT_WORK_DIR}/${CT_TARGET}/state"
155 CT_CONFIG_DIR="${CT_BUILD_DIR}/configs"
156 CT_COMPLIBS_DIR="${CT_BUILD_DIR}/static"
158 # Compute test suite install directory
159 CT_TEST_SUITE_DIR=${CT_INSTALL_DIR}/test-suite
161 # Note: we'll always install the core compiler in its own directory, so as to
162 # not mix the two builds: core and final.
163 CT_CC_CORE_STATIC_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-static"
164 CT_CC_CORE_SHARED_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-shared"
166 # We must ensure that we can restart if asked for!
167 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}" ]; then
168 CT_DoLog ERROR "You asked to restart a non-restartable build"
169 CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
170 CT_DoLog ERROR "in the config options for the previous build, or the state"
171 CT_DoLog ERROR "directory for the previous build was deleted."
172 CT_Abort "I will stop here to avoid any carnage"
175 # If the local tarball directory does not exist, say so, and don't try to save there!
176 if [ "${CT_SAVE_TARBALLS}" = "y" \
177 -a ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
178 CT_DoLog WARN "Directory '${CT_LOCAL_TARBALLS_DIR}' does not exist."
179 CT_DoLog WARN "Will not save downloaded tarballs to local storage."
183 # Check now if we can write to the destination directory:
184 if [ -d "${CT_INSTALL_DIR}" ]; then
185 CT_TestAndAbort "Destination directory '${CT_INSTALL_DIR}' is not removable" ! -w $(dirname "${CT_INSTALL_DIR}")
188 # Good, now grab a bit of informations on the system we're being run on,
189 # just in case something goes awok, and it's not our fault:
190 CT_SYS_USER=$(id -un)
191 CT_SYS_HOSTNAME=$(hostname -f 2>/dev/null || true)
192 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
193 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-$(uname -n)}"
194 CT_SYS_KERNEL=$(uname -s)
195 CT_SYS_REVISION=$(uname -r)
196 CT_SYS_OS=$(uname -s)
197 CT_SYS_MACHINE=$(uname -m)
198 CT_SYS_PROCESSOR=$(uname -p)
199 CT_SYS_GCC=$(gcc -dumpversion)
200 CT_SYS_TARGET=$(CT_DoConfigGuess)
201 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
203 CT_DoLog EXTRA "Preparing working directories"
205 # Ah! The build directory shall be eradicated, even if we restart!
206 # Ditto for the build tools install dir
207 CT_DoForceRmdir "${CT_BUILD_DIR}" "${CT_BUILDTOOLS_PREFIX_DIR}"
209 # Don't eradicate directories if we need to restart
210 if [ -z "${CT_RESTART}" ]; then
211 # Get rid of pre-existing installed toolchain and previous build directories.
212 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
213 CT_DoForceRmdir "${CT_TARBALLS_DIR}"
215 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
216 CT_DoForceRmdir "${CT_SRC_DIR}"
218 if [ -d "${CT_INSTALL_DIR}" -a "${CT_RM_RF_PREFIX_DIR}" = "y" ]; then
219 CT_DoForceRmdir "${CT_INSTALL_DIR}"
221 # In case we start anew, get rid of the previously saved state directory
222 if [ -d "${CT_STATE_DIR}" ]; then
223 CT_DoForceRmdir "${CT_STATE_DIR}"
227 # Create the directories we'll use, even if restarting: it does no harm to
228 # create already existent directories, and CT_BUILD_DIR needs to be created
230 CT_DoExecLog ALL mkdir -p "${CT_TARBALLS_DIR}"
231 CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
232 CT_DoExecLog ALL mkdir -p "${CT_BUILD_DIR}"
233 CT_DoExecLog ALL mkdir -p "${CT_BUILDTOOLS_PREFIX_DIR}/bin"
234 CT_DoExecLog ALL mkdir -p "${CT_CONFIG_DIR}"
235 CT_DoExecLog ALL mkdir -p "${CT_INSTALL_DIR}"
236 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}"
237 CT_DoExecLog ALL mkdir -p "${CT_COMPLIBS_DIR}"
238 if [ -z "${CT_CANADIAN}" ]; then
239 CT_DoExecLog ALL mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
240 CT_DoExecLog ALL mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
243 # Only create the state dir if asked for a restartable build
244 [ -n "${CT_DEBUG_CT_SAVE_STEPS}" ] && CT_DoExecLog ALL mkdir -p "${CT_STATE_DIR}"
246 # Check install file system case-sensitiveness
247 CT_DoExecLog DEBUG touch "${CT_PREFIX_DIR}/foo"
248 CT_TestAndAbort "Your file system in '${CT_PREFIX_DIR}' is *not* case-sensitive!" -f "${CT_PREFIX_DIR}/FOO"
249 CT_DoExecLog DEBUG rm -f "${CT_PREFIX_DIR}/foo"
251 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
252 # the previous build was successful.
253 CT_DoExecLog ALL chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
255 # Setting up the rest of the environment only if not restarting
256 if [ -z "${CT_RESTART}" ]; then
257 case "${CT_SYSROOT_NAME}" in
258 "") CT_SYSROOT_NAME="sysroot";;
259 .) CT_Abort "Sysroot name is set to '.' which is forbidden";;
260 *' '*) CT_Abort "Sysroot name contains forbidden space(s): '${CT_SYSROOT_NAME}'";;
261 */*) CT_Abort "Sysroot name contains forbidden slash(es): '${CT_SYSROOT_NAME}'";;
264 # Arrange paths depending on wether we use sysroot or not.
265 if [ "${CT_USE_SYSROOT}" = "y" ]; then
266 CT_SYSROOT_REL_DIR="${CT_SYSROOT_DIR_PREFIX:+${CT_SYSROOT_DIR_PREFIX}/}${CT_SYSROOT_NAME}"
267 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_REL_DIR}"
268 CT_DEBUGROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_DIR_PREFIX}/debug-root"
269 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
270 CT_SanitiseVarDir CT_SYSROOT_REL_DIR CT_SYSROOT_DIR CT_DEBUGROOT_DIR CT_HEADERS_DIR
271 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
272 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
273 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
275 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
276 # confused when $sysroot/usr/include is not present.
277 # Note: --prefix=/usr is magic!
278 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
280 # plain old way. All libraries in prefix/target/lib
281 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
282 CT_DEBUGROOT_DIR="${CT_SYSROOT_DIR}"
283 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
284 CT_SanitiseVarDir CT_SYSROOT_DIR CT_DEBUGROOT_DIR CT_HEADERS_DIR
285 # hack! Always use --with-sysroot for binutils.
286 # binutils 2.14 and later obey it, older binutils ignore it.
287 # Lets you build a working 32->64 bit cross gcc
288 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
289 # Use --with-headers, else final gcc will define disable_glibc while
290 # building libgcc, and you'll have no profiling
291 CC_CORE_SYSROOT_ARG="--without-headers"
292 CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
293 LIBC_SYSROOT_ARG="prefix="
295 CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}"
296 CT_DoExecLog ALL mkdir -p "${CT_DEBUGROOT_DIR}"
298 # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
299 # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail
300 # with: "ld: cannot open crti.o: No such file or directory"
301 # Also prepare the lib directory in the install dir, else some 64 bit archs
303 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/lib"
304 CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/lib"
305 CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
306 CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/usr/include"
308 if [ "${CT_USE_SYSROOT}" = "y" ]; then
309 # Prevent gcc from installing its libraries outside of the sysroot
310 CT_Pushd "${CT_PREFIX_DIR}/${CT_TARGET}"
311 CT_DoExecLog ALL ln -sf "${CT_SYSROOT_REL_DIR}/lib" "lib"
315 # Since we're *not* multilib on the target side, we want all the
316 # libraries to end up in "lib". We create "lib64" (for 64-bit
317 # build or host architectures) and "lib32" (for 32-bit emulation
318 # on 64-bit) as symlinks to "lib".
320 # Not all of these symlinks are necessary, but better safe than
321 # sorry. They are summarily removed by build/internals.sh:do_finish.
324 "${CT_SYSROOT_DIR}" \
325 "${CT_SYSROOT_DIR}/usr" \
326 "${CT_PREFIX_DIR}/${CT_TARGET}" \
328 CT_DoExecLog ALL ln -sf "lib" "${d}/lib32"
329 CT_DoExecLog ALL ln -sf "lib" "${d}/lib64"
332 # Determine build system if not set by the user
333 if [ -z "${CT_BUILD}" ]; then
334 CT_BUILD=$(CT_DoConfigGuess)
337 # Prepare mangling patterns to later modify BUILD and HOST (see below)
338 case "${CT_TOOLCHAIN_TYPE}" in
340 # A cross-compiler runs on the same machine it is built on
341 CT_HOST="${CT_BUILD}"
342 build_mangle="build_"
345 install_build_tools_for="BUILD HOST"
348 build_mangle="build_"
351 install_build_tools_for="BUILD HOST TARGET"
353 *) CT_Abort "No code for '${CT_TOOLCHAIN_TYPE}' toolchain type!"
357 # Save the real tuples to generate shell-wrappers to the real tools
358 CT_REAL_BUILD="${CT_BUILD}"
359 CT_REAL_HOST="${CT_HOST}"
360 CT_REAL_TARGET="${CT_TARGET}"
362 # Canonicalise CT_BUILD and CT_HOST
363 # Not only will it give us full-qualified tuples, but it will also ensure
364 # that they are valid tuples (in case of typo with user-provided tuples)
365 # That's way better than trying to rewrite config.sub ourselves...
366 # CT_TARGET is already made canonical in CT_DoBuildTargetTuple
367 CT_BUILD=$(CT_DoConfigSub "${CT_BUILD}")
368 CT_HOST=$(CT_DoConfigSub "${CT_HOST}")
370 # Modify BUILD and HOST so that gcc always generate a cross-compiler
371 # even if any of the build, host or target machines are the same.
372 # NOTE: we'll have to mangle the (BUILD|HOST)->TARGET x-compiler to
373 # support canadain build, later...
374 CT_BUILD="${CT_BUILD/-/-${build_mangle}}"
375 CT_HOST="${CT_HOST/-/-${host_mangle}}"
376 CT_TARGET="${CT_TARGET/-/-${target_mangle}}"
378 # Now we have mangled our BUILD and HOST tuples, we must fake the new
379 # cross-tools for those mangled tuples.
380 CT_DoLog DEBUG "Making build system tools available"
381 for m in ${install_build_tools_for}; do
386 if [ -n "${!p}" ]; then
392 for tool in ar as dlltool gcc g++ gcj gnatbind gnatmake ld nm objcopy objdump ranlib strip windres; do
393 # First try with prefix + suffix
394 # Then try with prefix only
395 # Then try with suffix only, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
396 # Finally try with neither prefix nor suffix, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
397 # This is needed, because some tools have a prefix and
398 # a suffix (eg. gcc), while others may have only one,
399 # or even none (eg. binutils)
400 where=$(CT_Which "${t}${tool}${!s}")
401 [ -z "${where}" ] && where=$(CT_Which "${t}${tool}")
403 -a \( "${m}" = "BUILD" \
404 -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
405 where=$(CT_Which "${tool}${!s}")
408 -a \( "${m}" = "BUILD" \
409 -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
410 where=$(CT_Which "${tool}")
413 # Not all tools are available for all platforms, but some are really,
415 if [ -n "${where}" ]; then
416 CT_DoLog DEBUG " '${!v}-${tool}' -> '${where}'"
417 printf "#${BANG}${CT_SHELL}\nexec '${where}' \"\${@}\"\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}"
418 CT_DoExecLog ALL chmod 700 "${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}"
421 # We'll at least need some of them...
422 ar|as|gcc|ld|nm|objcopy|objdump|ranlib)
423 CT_Abort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!"
425 # Some are conditionnally required
426 # Add them in alphabetical (C locale) ordering
428 # g++ (needed for companion lib), only needed for HOST
429 CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${m}" = "HOST"
432 CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_CC_LANG_JAVA}" = "y"
435 CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_STRIP_ALL_TOOLCHAIN_EXECUTABLES}" = "y"
437 # If any other is missing, only warn at low level
439 # It does not deserve a WARN level.
440 CT_DoLog DEBUG " Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : not required."
447 # Some makeinfo versions are a pain in [put your most sensible body part here].
448 # Go ahead with those, by creating a wrapper that keeps partial files, and that
450 CT_DoLog DEBUG " 'makeinfo' -> '$(CT_Which makeinfo)'"
451 printf "#${BANG}${CT_SHELL}\n$(CT_Which makeinfo) --force \"\${@}\"\ntrue\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/makeinfo"
452 CT_DoExecLog ALL chmod 700 "${CT_BUILDTOOLS_PREFIX_DIR}/bin/makeinfo"
454 # Carefully add paths in the order we want them:
455 # - first try in ${CT_PREFIX_DIR}/bin
456 # - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
457 # - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
458 # - fall back to searching user's PATH
459 # Of course, neither cross-native nor canadian can run on BUILD,
460 # so don't add those PATHs in this case...
461 case "${CT_TOOLCHAIN_TYPE}" in
462 cross) export PATH="${CT_BUILDTOOLS_PREFIX_DIR}/bin:${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}";;
463 canadian) export PATH="${CT_BUILDTOOLS_PREFIX_DIR}/bin:${PATH}";;
467 # Now we know our host and where to find the host tools, we can check
468 # if static link was requested, but only if it was requested
469 if [ "${CT_WANTS_STATIC_LINK}" = "y" ]; then
470 tmp="${CT_BUILD_DIR}/.static-test"
471 if ! "${CT_HOST}-gcc" -xc - -static -o "${tmp}" >/dev/null 2>&1 <<-_EOF_
472 int main() { return 0; }
475 CT_Abort "Static linking impossible on the host system '${CT_HOST}'"
482 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST+=" -pipe"
483 CT_CFLAGS_FOR_HOST+="${CT_EXTRA_FLAGS_FOR_HOST}"
485 # Set the shell to be used by ./configure scripts and by Makefiles (those
487 export CONFIG_SHELL="${CT_CONFIG_SHELL}" # for ./configure
488 export SHELL="${CT_CONFIG_SHELL}" # for Makefiles
490 # And help make go faster
492 # Override the configured jobs with what's been given on the command line
493 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
494 # Use the number of processors+1 when automatically setting the number of
495 # parallel jobs. Fall back to 1 if the host doesn't use GLIBC.
496 AUTO_JOBS=$((`getconf _NPROCESSORS_ONLN 2> /dev/null || echo 0` + 1))
497 [ ${CT_PARALLEL_JOBS} -eq 0 ] && JOBSFLAGS="${JOBSFLAGS} -j${AUTO_JOBS}"
498 [ ${CT_PARALLEL_JOBS} -gt 0 ] && JOBSFLAGS="${JOBSFLAGS} -j${CT_PARALLEL_JOBS}"
499 [ ${CT_LOAD} -ne 0 ] && JOBSFLAGS="${JOBSFLAGS} -l${CT_LOAD}"
501 # We need to save the real .config with kconfig's value,
502 # not our mangled .config.2 with arrays.
503 CT_DoLog EXTRA "Installing user-supplied crosstool-NG configuration"
504 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/bin"
505 CT_DoExecLog DEBUG install -m 0755 "${CT_LIB_DIR}/scripts/toolchain-config.in" "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
506 CT_DoExecLog DEBUG sed -i -e 's,@@grep@@,"'"${grep}"'",;' "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
507 bzip2 -c -9 .config >>"${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
509 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
510 CT_DoLog EXTRA "Building a toolchain for:"
511 CT_DoLog EXTRA " build = ${CT_REAL_BUILD}"
512 CT_DoLog EXTRA " host = ${CT_REAL_HOST}"
513 CT_DoLog EXTRA " target = ${CT_TARGET}"
514 set |grep -E '^CT_.+=' |sort |CT_DoLog DEBUG
515 CT_DoLog DEBUG "Other environment:"
516 printenv |grep -v -E '^CT_.+=' |CT_DoLog DEBUG
520 if [ -z "${CT_RESTART}" ]; then
521 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
522 do_companion_tools_get
539 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
540 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
541 CT_DoForceRmdir "${CT_SRC_DIR}"
542 CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
545 if [ "${CT_COMP_TOOLS}" = "y" ]; then
546 CT_DoStep INFO "Extracting, patching and installing companion tools"
547 do_companion_tools_extract
552 CT_DoStep INFO "Extracting and patching toolchain components"
566 do_test_suite_extract
571 # Now for the job by itself. Go have a coffee!
572 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
573 # Because of CT_RESTART, this becomes quite complex
576 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
577 # Aha! CT_STEPS comes from steps.mk!
578 for step in ${CT_STEPS}; do
579 if [ ${do_it} -eq 0 ]; then
580 if [ "${CT_RESTART}" = "${step}" ]; then
581 CT_DoLoadState "${step}"
586 CT_DoSaveState ${step}
587 if [ ${do_stop} -eq 1 ]; then
588 CT_DoLog ERROR "Stopping just after step '${prev_step}', as requested."
592 if [ ${do_it} -eq 1 ]; then
594 if [ "${CT_STOP}" = "${step}" ]; then
597 if [ "${CT_DEBUG_PAUSE_STEPS}" = "y" ]; then
598 CT_DoPause "Step '${step}' finished"
607 # From now-on, it can become impossible to log any time, because
608 # either we're compressing the log file, or it can become RO any
609 # moment... Consign all ouptut to oblivion...
610 CT_DoLog INFO "Finishing installation (may take a few seconds)..."
612 rm -f ${CT_PREFIX_DIR}/build.log.bz2
613 if [ "${CT_LOG_TO_FILE}" = "y" ]; then
614 cp "${tmp_log_file}" "${CT_PREFIX_DIR}/build.log"
615 if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
616 bzip2 -9 "${CT_PREFIX_DIR}/build.log"
619 [ "${CT_INSTALL_DIR_RO}" = "y" ] && chmod -R a-w "${CT_INSTALL_DIR}"
620 [ "${CT_TEST_SUITE}" = "y" ] && chmod -R u+w "${CT_TEST_SUITE_DIR}"