scripts/build/internals.sh: compile wrapper with portable options.
static linking is not possible on MacOS, and unnessecary on other systems.
The old optimization and warning flags crash the gcc on MacOS
and (imho) are a bit overdone for this software.
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 # Overide the locale early, in case we ever translate crosstool-NG messages
29 [ -z "${CT_NO_OVERIDE_LC_MESSAGES}" ] && export LC_ALL=C
31 # Some sanity checks in the environment and needed tools
32 CT_DoLog INFO "Performing some trivial sanity checks"
33 CT_TestAndAbort "Don't set LD_LIBRARY_PATH. It screws up the build." -n "${LD_LIBRARY_PATH}"
34 CT_TestAndAbort "Don't set CFLAGS. It screws up the build." -n "${CFLAGS}"
35 CT_TestAndAbort "Don't set CXXFLAGS. It screws up the build." -n "${CXXFLAGS}"
36 CT_Test "GREP_OPTIONS screws up the build. Resetting." -n "${GREP_OPTIONS}"
39 # Some sanity checks on paths content
46 eval dir="\${CT_${d}_DIR}"
49 CT_Abort "'CT_${d}_DIR'='${dir}' contains a space in it.\nDon't use spaces in paths, it breaks things."
55 CT_WORK_DIR="${CT_WORK_DIR:-${CT_TOP_DIR}/targets}"
56 CT_DoExecLog ALL mkdir -p "${CT_WORK_DIR}"
58 # Check build file system case-sensitiveness
59 CT_DoExecLog DEBUG touch "${CT_WORK_DIR}/foo"
60 CT_TestAndAbort "Your file system in '${CT_WORK_DIR}' is *not* case-sensitive!" -f "${CT_WORK_DIR}/FOO"
61 CT_DoExecLog DEBUG rm -f "${CT_WORK_DIR}/foo"
64 # Will be plain /bin/sh on most systems, except if we have /bin/ash and we
65 # _explictly_ required using it
66 case "${CT_CONFIG_SHELL}" in
67 sh) CT_SHELL="/bin/sh";;
68 ash) CT_SHELL="/bin/ash";;
69 bash) CT_SHELL="${BASH}";;
70 custom) CT_SHELL="${CT_CONFIG_SHELL_CUSTOM_PATH}";;
73 # Check the user is using an existing SHELL to be used by ./configure and Makefiles
74 CT_TestOrAbort "The CONFIG_SHELL '${CT_CONFIG_SHELL}' (${CT_SHELL}) is not valid" -f "${CT_SHELL}" -a -x "${CT_SHELL}"
76 # Create the bin-overide early
77 # Contains symlinks to the tools found by ./configure
78 # Note: CT_DoLog and CT_DoExecLog do not use any of those tool, so
79 # they can be safely used
80 CT_TOOLS_OVERIDE_DIR="${CT_WORK_DIR}/tools"
81 CT_DoLog DEBUG "Creating bin-overide for tools in '${CT_TOOLS_OVERIDE_DIR}'"
82 CT_DoExecLog DEBUG mkdir -p "${CT_TOOLS_OVERIDE_DIR}/bin"
83 cat "${CT_LIB_DIR}/paths.mk" |while read trash line; do
86 CT_DoLog DEBUG "Creating script-override for '${tool}' -> '${path}'"
87 printf "#${BANG}${CT_SHELL}\nexec '${path}' \"\${@}\"\n" >"${CT_TOOLS_OVERIDE_DIR}/bin/${tool}"
88 CT_DoExecLog ALL chmod 700 "${CT_TOOLS_OVERIDE_DIR}/bin/${tool}"
90 export PATH="${CT_TOOLS_OVERIDE_DIR}/bin:${PATH}"
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)
97 # Log real begining of build, now
98 CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
100 CT_DoStep DEBUG "Dumping user-supplied crosstool-NG configuration"
101 CT_DoExecLog DEBUG grep -E '^(# |)CT_' .config
104 CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
108 CT_DoLog INFO "Building environment variables"
110 # Include sub-scripts instead of calling them: that way, we do not have to
111 # export any variable, nor re-parse the configuration and functions files.
112 . "${CT_LIB_DIR}/scripts/build/internals.sh"
113 . "${CT_LIB_DIR}/scripts/build/arch/${CT_ARCH}.sh"
114 . "${CT_LIB_DIR}/scripts/build/companion_tools.sh"
115 . "${CT_LIB_DIR}/scripts/build/kernel/${CT_KERNEL}.sh"
116 . "${CT_LIB_DIR}/scripts/build/companion_libs/gmp.sh"
117 . "${CT_LIB_DIR}/scripts/build/companion_libs/mpfr.sh"
118 . "${CT_LIB_DIR}/scripts/build/companion_libs/ppl.sh"
119 . "${CT_LIB_DIR}/scripts/build/companion_libs/cloog.sh"
120 . "${CT_LIB_DIR}/scripts/build/companion_libs/mpc.sh"
121 . "${CT_LIB_DIR}/scripts/build/companion_libs/libelf.sh"
122 . "${CT_LIB_DIR}/scripts/build/binutils/binutils.sh"
123 . "${CT_LIB_DIR}/scripts/build/binutils/elf2flt.sh"
124 . "${CT_LIB_DIR}/scripts/build/binutils/sstrip.sh"
125 . "${CT_LIB_DIR}/scripts/build/libc/${CT_LIBC}.sh"
126 . "${CT_LIB_DIR}/scripts/build/cc/${CT_CC}.sh"
127 . "${CT_LIB_DIR}/scripts/build/debug.sh"
128 . "${CT_LIB_DIR}/scripts/build/test_suite.sh"
130 # Target tuple: CT_TARGET needs a little love:
131 CT_DoBuildTargetTuple
133 # Kludge: If any of the configured options needs CT_TARGET,
134 # then rescan the options file now:
137 # Sanity check some directories
138 CT_TestAndAbort "'CT_PREFIX_DIR' is not set: where should I install?" -z "${CT_PREFIX_DIR}"
140 # Second kludge: merge user-supplied target CFLAGS with architecture-provided
141 # target CFLAGS. Do the same for LDFLAGS in case it happens in the future.
142 # Put user-supplied flags at the end, so that they take precedence.
143 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
144 CT_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_TARGET_LDFLAGS}"
145 CT_CC_CORE_EXTRA_CONFIG="${CT_ARCH_CC_CORE_EXTRA_CONFIG} ${CT_CC_CORE_EXTRA_CONFIG}"
146 CT_CC_EXTRA_CONFIG="${CT_ARCH_CC_EXTRA_CONFIG} ${CT_CC_EXTRA_CONFIG}"
148 # Compute the working directories names
149 CT_TARBALLS_DIR="${CT_WORK_DIR}/tarballs"
150 CT_SRC_DIR="${CT_WORK_DIR}/src"
151 CT_BUILD_DIR="${CT_WORK_DIR}/${CT_TARGET}/build"
152 CT_STATE_DIR="${CT_WORK_DIR}/${CT_TARGET}/state"
153 CT_CONFIG_DIR="${CT_BUILD_DIR}/configs"
154 if [ "${CT_COMPLIBS_SHARED}" = "y" ]; then
155 CT_COMPLIBS_DIR="${CT_PREFIX_DIR}"
156 # Set LD_LIBRARY_PATH to point to prefix/lib so we can find our own
157 # libraries; add as first path, so we get hit first by the dynamic linker
158 CT_SetLibPath "${CT_COMPLIBS_DIR}/lib" first
160 CT_COMPLIBS_DIR="${CT_BUILD_DIR}/static"
163 # Compute test suite install directory
164 CT_TEST_SUITE_DIR=${CT_INSTALL_DIR}/test-suite
166 # Note: we'll always install the core compiler in its own directory, so as to
167 # not mix the two builds: core and final.
168 CT_CC_CORE_STATIC_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-static"
169 CT_CC_CORE_SHARED_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-shared"
171 # We must ensure that we can restart if asked for!
172 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}" ]; then
173 CT_DoLog ERROR "You asked to restart a non-restartable build"
174 CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
175 CT_DoLog ERROR "in the config options for the previous build, or the state"
176 CT_DoLog ERROR "directory for the previous build was deleted."
177 CT_Abort "I will stop here to avoid any carnage"
180 # If the local tarball directory does not exist, say so, and don't try to save there!
181 if [ "${CT_SAVE_TARBALLS}" = "y" \
182 -a ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
183 CT_DoLog WARN "Directory '${CT_LOCAL_TARBALLS_DIR}' does not exist."
184 CT_DoLog WARN "Will not save downloaded tarballs to local storage."
188 # Check now if we can write to the destination directory:
189 if [ -d "${CT_INSTALL_DIR}" ]; then
190 CT_TestAndAbort "Destination directory '${CT_INSTALL_DIR}' is not removable" ! -w $(dirname "${CT_INSTALL_DIR}")
193 # Good, now grab a bit of informations on the system we're being run on,
194 # just in case something goes awok, and it's not our fault:
195 CT_SYS_USER=$(id -un)
196 CT_SYS_HOSTNAME=$(hostname -f 2>/dev/null || true)
197 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
198 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-$(uname -n)}"
199 CT_SYS_KERNEL=$(uname -s)
200 CT_SYS_REVISION=$(uname -r)
201 CT_SYS_OS=$(uname -s)
202 CT_SYS_MACHINE=$(uname -m)
203 CT_SYS_PROCESSOR=$(uname -p)
204 CT_SYS_GCC=$(gcc -dumpversion)
205 CT_SYS_TARGET=$(CT_DoConfigGuess)
206 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
208 CT_DoLog EXTRA "Preparing working directories"
210 # Ah! The build directory shall be eradicated, even if we restart!
211 if [ -d "${CT_BUILD_DIR}" ]; then
212 CT_DoForceRmdir "${CT_BUILD_DIR}"
215 # Don't eradicate directories if we need to restart
216 if [ -z "${CT_RESTART}" ]; then
217 # Get rid of pre-existing installed toolchain and previous build directories.
218 # We need to do that _before_ we can safely log, because the log file will
219 # most probably be in the toolchain directory.
220 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
221 CT_DoForceRmdir "${CT_TARBALLS_DIR}"
223 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
224 CT_DoForceRmdir "${CT_SRC_DIR}"
226 if [ -d "${CT_INSTALL_DIR}" ]; then
227 CT_DoForceRmdir "${CT_INSTALL_DIR}"
229 # In case we start anew, get rid of the previously saved state directory
230 if [ -d "${CT_STATE_DIR}" ]; then
231 CT_DoForceRmdir "${CT_STATE_DIR}"
235 # Create the directories we'll use, even if restarting: it does no harm to
236 # create already existent directories, and CT_BUILD_DIR needs to be created
238 CT_DoExecLog ALL mkdir -p "${CT_TARBALLS_DIR}"
239 CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
240 CT_DoExecLog ALL mkdir -p "${CT_BUILD_DIR}"
241 CT_DoExecLog ALL mkdir -p "${CT_CONFIG_DIR}"
242 CT_DoExecLog ALL mkdir -p "${CT_INSTALL_DIR}"
243 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}"
244 CT_DoExecLog ALL mkdir -p "${CT_COMPLIBS_DIR}"
245 if [ -z "${CT_CANADIAN}" ]; then
246 CT_DoExecLog ALL mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
247 CT_DoExecLog ALL mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
250 # Only create the state dir if asked for a restartable build
251 [ -n "${CT_DEBUG_CT_SAVE_STEPS}" ] && CT_DoExecLog ALL mkdir -p "${CT_STATE_DIR}"
253 # Check install file system case-sensitiveness
254 CT_DoExecLog DEBUG touch "${CT_PREFIX_DIR}/foo"
255 CT_TestAndAbort "Your file system in '${CT_PREFIX_DIR}' is *not* case-sensitive!" -f "${CT_PREFIX_DIR}/FOO"
256 CT_DoExecLog DEBUG rm -f "${CT_PREFIX_DIR}/foo"
258 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
259 # the previous build was successful. To be able to move the logfile there,
260 # switch them back to read/write
261 CT_DoExecLog ALL chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
263 # Redirect log to the actual log file now we can
264 # It's quite understandable that the log file will be installed in the install
265 # directory, so we must first ensure it exists and is writeable (above) before
268 case "${CT_LOG_TO_FILE}" in
269 y) CT_LOG_FILE="${CT_PREFIX_DIR}/build.log"
270 cat "${tmp_log_file}" >>"${CT_LOG_FILE}"
271 rm -f "${tmp_log_file}"
272 exec >>"${CT_LOG_FILE}"
274 *) rm -f "${tmp_log_file}"
278 # Setting up the rest of the environment only if not restarting
279 if [ -z "${CT_RESTART}" ]; then
280 # Arrange paths depending on wether we use sys-root or not.
281 if [ "${CT_USE_SYSROOT}" = "y" ]; then
282 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_DIR_PREFIX}/sys-root"
283 CT_DEBUGROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_DIR_PREFIX}/debug-root"
284 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
285 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
286 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
287 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
289 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
290 # confused when $sysroot/usr/include is not present.
291 # Note: --prefix=/usr is magic!
292 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
294 # plain old way. All libraries in prefix/target/lib
295 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
296 CT_DEBUGROOT_DIR="${CT_SYSROOT_DIR}"
297 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
298 # hack! Always use --with-sysroot for binutils.
299 # binutils 2.14 and later obey it, older binutils ignore it.
300 # Lets you build a working 32->64 bit cross gcc
301 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
302 # Use --with-headers, else final gcc will define disable_glibc while
303 # building libgcc, and you'll have no profiling
304 CC_CORE_SYSROOT_ARG="--without-headers"
305 CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
306 LIBC_SYSROOT_ARG="prefix="
308 CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}"
309 CT_DoExecLog ALL mkdir -p "${CT_DEBUGROOT_DIR}"
311 # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
312 # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail
313 # with: "ld: cannot open crti.o: No such file or directory"
314 # Also prepare the lib directory in the install dir, else some 64 bit archs
316 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/lib"
317 CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/lib"
318 CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
319 CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}/usr/include"
321 if [ "${CT_USE_SYSROOT}" = "y" ]; then
322 # Prevent gcc from installing its libraries outside of the sys-root
323 CT_DoExecLog ALL ln -sf "./${CT_SYSROOT_DIR_PREFIX}/sys-root/lib" "${CT_PREFIX_DIR}/${CT_TARGET}/lib"
324 # Prevent libc from installing its headers outside of the sysroot
325 CT_DoExecLog ALL ln -sf "./${CT_SYSROOT_DIR_PREFIX}/sys-root/usr/include" "${CT_PREFIX_DIR}/${CT_TARGET}/include"
328 # Now, in case we're 64 bits, just have lib64/ be a symlink to lib/
329 # so as to have all libraries in the same directory (we can do that
330 # because we are *not* multilib).
331 if [ "${CT_ARCH_64}" = "y" ]; then
332 CT_DoExecLog ALL ln -sf "lib" "${CT_PREFIX_DIR}/lib64"
333 CT_DoExecLog ALL ln -sf "lib" "${CT_SYSROOT_DIR}/lib64"
334 CT_DoExecLog ALL ln -sf "lib" "${CT_SYSROOT_DIR}/usr/lib64"
335 CT_DoExecLog ALL ln -sf "lib" "${CT_PREFIX_DIR}/${CT_TARGET}/lib64"
338 # Determine build system if not set by the user
339 if [ -z "${CT_BUILD}" ]; then
340 CT_BUILD=$(CT_DoConfigGuess)
343 # Prepare mangling patterns to later modify BUILD and HOST (see below)
344 case "${CT_TOOLCHAIN_TYPE}" in
346 # A cross-compiler runs on the same machine it is built on
347 CT_HOST="${CT_BUILD}"
348 build_mangle="build_"
351 install_build_tools_for="BUILD HOST"
354 build_mangle="build_"
357 install_build_tools_for="BUILD HOST TARGET"
359 *) CT_Abort "No code for '${CT_TOOLCHAIN_TYPE}' toolchain type!"
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}"
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}")
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}}"
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 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/buildtools"
388 for m in ${install_build_tools_for}; do
393 if [ -n "${!p}" ]; then
399 for tool in ar as dlltool gcc g++ gcj gnatbind gnatmake ld nm objcopy objdump ranlib strip windres; do
400 # First try with prefix + suffix
401 # Then try with prefix only
402 # Then try with suffix only, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
403 # Finally try with neither prefix nor suffix, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
404 # This is needed, because some tools have a prefix and
405 # a suffix (eg. gcc), while others may have only one,
406 # or even none (eg. binutils)
407 where=$(CT_Which "${t}${tool}${!s}")
408 [ -z "${where}" ] && where=$(CT_Which "${t}${tool}")
410 -a \( "${m}" = "BUILD" \
411 -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
412 where=$(CT_Which "${tool}${!s}")
415 -a \( "${m}" = "BUILD" \
416 -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
417 where=$(CT_Which "${tool}")
420 # Not all tools are available for all platforms, but some are really,
422 if [ -n "${where}" ]; then
423 CT_DoLog DEBUG " '${!v}-${tool}' -> '${where}'"
424 printf "#${BANG}${CT_SHELL}\nexec '${where}' \"\${@}\"\n" >"${CT_PREFIX_DIR}/buildtools/${!v}-${tool}"
425 CT_DoExecLog ALL chmod 700 "${CT_PREFIX_DIR}/buildtools/${!v}-${tool}"
428 # We'll at least need some of them...
429 ar|as|gcc|ld|nm|objcopy|objdump|ranlib)
430 CT_Abort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!"
432 # Some are conditionnally required
433 # Add them in alphabetical (C locale) ordering
435 # g++ (needed for companion lib), only needed for HOST
436 CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${m}" = "HOST"
439 CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_CC_LANG_JAVA}" = "y"
441 # If any other is missing, only warn at low level
443 # It does not deserve a WARN level.
444 CT_DoLog DEBUG " Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : not required."
451 # Carefully add paths in the order we want them:
452 # - first try in ${CT_PREFIX_DIR}/bin
453 # - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
454 # - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
455 # - fall back to searching user's PATH
456 # Of course, neither cross-native nor canadian can run on BUILD,
457 # so don't add those PATHs in this case...
458 case "${CT_TOOLCHAIN_TYPE}" in
459 cross) export PATH="${CT_PREFIX_DIR}/buildtools:${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}";;
460 canadian) export PATH="${CT_PREFIX_DIR}/buildtools:${PATH}";;
464 # Some makeinfo versions are a pain in [put your most sensible body part here].
465 # Go ahead with those, by creating a wrapper that keeps partial files, and that
467 CT_DoLog DEBUG " 'makeinfo' -> '$(CT_Which makeinfo)'"
468 printf "#${BANG}${CT_SHELL}\n$(CT_Which makeinfo) --force \"\${@}\"\ntrue\n" >"${CT_PREFIX_DIR}/buildtools/makeinfo"
469 CT_DoExecLog ALL chmod 700 "${CT_PREFIX_DIR}/buildtools/makeinfo"
473 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST="${CT_CFLAGS_FOR_HOST} -pipe"
475 # Override the configured jobs with what's been given on the command line
476 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
478 # Set the shell to be used by ./configure scripts and by Makefiles (those
480 export CONFIG_SHELL="${CT_SHELL}" # for ./configure
481 export SHELL="${CT_SHELL}" # for Makefiles
483 # And help make go faster
485 [ ${CT_PARALLEL_JOBS} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -j${CT_PARALLEL_JOBS}"
486 [ ${CT_LOAD} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -l${CT_LOAD}"
487 export PARALLELMFLAGS
489 CT_DoLog EXTRA "Installing user-supplied crosstool-NG configuration"
490 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/bin"
491 CT_DoExecLog DEBUG install -m 0755 "${CT_LIB_DIR}/scripts/toolchain-config.in" "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
492 CT_DoExecLog DEBUG sed -i -e 's,@@grep@@,"'"${grep}"'",;' "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
493 bzip2 -c -9 .config >>"${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
495 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
496 CT_DoLog EXTRA "Building a toolchain for:"
497 CT_DoLog EXTRA " build = ${CT_REAL_BUILD}"
498 CT_DoLog EXTRA " host = ${CT_REAL_HOST}"
499 CT_DoLog EXTRA " target = ${CT_TARGET}"
500 set |grep -E '^CT_.+=' |sort |CT_DoLog DEBUG
501 CT_DoLog DEBUG "Other environment:"
502 printenv |grep -v -E '^CT_.+=' |CT_DoLog DEBUG
506 if [ -z "${CT_RESTART}" ]; then
507 if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
508 CT_DoLog INFO "Downloading forbidden by configuration, skipping downloads"
510 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
511 do_companion_tools_get
529 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
530 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
531 CT_DoForceRmdir "${CT_SRC_DIR}"
532 CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
535 if [ "${CT_COMP_TOOLS}" = "y" ]; then
536 CT_DoStep INFO "Extracting, patching and installing companion tools"
537 do_companion_tools_extract
542 CT_DoStep INFO "Extracting and patching toolchain components"
556 do_test_suite_extract
561 # Now for the job by itself. Go have a coffee!
562 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
563 # Because of CT_RESTART, this becomes quite complex
566 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
567 # Aha! CT_STEPS comes from steps.mk!
568 for step in ${CT_STEPS}; do
569 if [ ${do_it} -eq 0 ]; then
570 if [ "${CT_RESTART}" = "${step}" ]; then
571 CT_DoLoadState "${step}"
576 CT_DoSaveState ${step}
577 if [ ${do_stop} -eq 1 ]; then
578 CT_DoLog ERROR "Stopping just after step '${prev_step}', as requested."
582 if [ ${do_it} -eq 1 ]; then
584 if [ "${CT_STOP}" = "${step}" ]; then
587 if [ "${CT_DEBUG_PAUSE_STEPS}" = "y" ]; then
588 CT_DoPause "Step '${step}' finished"
597 # From now-on, it can become impossible to log any time, because
598 # either we're compressing the log file, or it can become RO any
599 # moment... Consign all ouptut to oblivion...
600 CT_DoLog INFO "Finishing installation (may take a few seconds)..."
603 [ "${CT_LOG_FILE_COMPRESS}" = y ] && bzip2 -9 "${CT_LOG_FILE}"
604 [ "${CT_INSTALL_DIR_RO}" = "y" ] && chmod -R a-w "${CT_INSTALL_DIR}"
605 [ "${CT_TEST_SUITE}" = "y" ] && chmod -R u+w "${CT_TEST_SUITE_DIR}"