scripts/addToolsVersion: properly handle .in vs. .in.2
While most components have their version in the .in file, some
have it in the .in.2 (eg. elf2flt).
Currently, to handle this case, we indiscriminately munge both files,
but this is wrong: in the elf2flt case, if we add a binutils version,
we do not want it to be added to elf2flt, and conversely.
So, for each tool, we need to explicitly know what file to munge.
Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.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 # If we want an interactive debug-shell, we must ensure these FDs
29 # are indeed connected to a terminal (and not redirected in any way).
30 if [ "${CT_DEBUG_INTERACTIVE}" = "y" -a ! \( -t 0 -a -t 6 -a -t 2 \) ]; then
31 CT_DoLog ERROR "Can't spawn interactive debug-shell,"
32 CT_DoLog ERROR "because stdout/stderr has been redirected."
36 # Override the locale early, in case we ever translate crosstool-NG messages
37 if [ -z "${CT_NO_OVERIDE_LC_MESSAGES}" ]; then
42 # remove . from PATH since it can cause gcc build failures
45 # Some sanity checks in the environment and needed tools
46 CT_DoLog INFO "Performing some trivial sanity checks"
47 CT_TestAndAbort "Don't set LD_LIBRARY_PATH. It screws up the build." -n "${LD_LIBRARY_PATH}"
48 CT_TestAndAbort "Don't set LIBRARY_PATH. It screws up the build." -n "${LIBRARY_PATH}"
49 CT_TestAndAbort "Don't set LPATH. It screws up the build." -n "${LPATH}"
50 CT_TestAndAbort "Don't set CFLAGS. It screws up the build." -n "${CFLAGS}"
51 CT_TestAndAbort "Don't set CXXFLAGS. It screws up the build." -n "${CXXFLAGS}"
52 CT_Test "GREP_OPTIONS screws up the build. Resetting." -n "${GREP_OPTIONS}"
54 # Workaround against openSUSE 12.1 that breaks ./configure for cross-compilation:
57 # Some sanity checks on paths content
64 eval dir="\${CT_${d}_DIR}"
67 CT_Abort "'CT_${d}_DIR'='${dir}' contains a space in it.\nDon't use spaces in paths, it breaks things."
70 CT_Abort "'CT_${d}_DIR'='${dir}' contains a colon in it.\nDon't use colons in paths, it breaks things."
76 CT_WORK_DIR="${CT_WORK_DIR:-${CT_TOP_DIR}/.build}"
77 CT_DoExecLog ALL mkdir -p "${CT_WORK_DIR}"
78 CT_DoExecLog DEBUG rm -f "${CT_WORK_DIR}/backtrace"
80 # Check build file system case-sensitiveness
81 CT_DoExecLog DEBUG touch "${CT_WORK_DIR}/foo"
82 CT_TestAndAbort "Your file system in '${CT_WORK_DIR}' is *not* case-sensitive!" -f "${CT_WORK_DIR}/FOO"
83 CT_DoExecLog DEBUG rm -f "${CT_WORK_DIR}/foo"
85 # Check the user is using an existing SHELL to be used by ./configure and Makefiles
86 CT_TestOrAbort "The CONFIG_SHELL '${CT_CONFIG_SHELL}' is not valid" -f "${CT_CONFIG_SHELL}" -a -x "${CT_CONFIG_SHELL}"
88 # Create the bin-override early
89 # Contains symlinks to the tools found by ./configure
90 # Note: CT_DoLog and CT_DoExecLog do not use any of those tool, so
91 # they can be safely used
92 CT_TOOLS_OVERIDE_DIR="${CT_WORK_DIR}/tools"
93 CT_DoLog DEBUG "Creating bin-override for tools in '${CT_TOOLS_OVERIDE_DIR}'"
94 CT_DoExecLog DEBUG mkdir -p "${CT_TOOLS_OVERIDE_DIR}/bin"
95 cat "${CT_LIB_DIR}/paths.sh" |while read trash line; do
98 CT_DoLog DEBUG "Creating script-override for '${tool}' -> '${path}'"
99 # Note: we need to supress the " in the path because
100 # there can be arguments in there (thanks autostuff...)
101 printf "#${BANG}${CT_CONFIG_SHELL}\nexec ${path//\"/} \"\${@}\"\n" >"${CT_TOOLS_OVERIDE_DIR}/bin/${tool}"
102 CT_DoExecLog ALL chmod 700 "${CT_TOOLS_OVERIDE_DIR}/bin/${tool}"
104 export PATH="${CT_TOOLS_OVERIDE_DIR}/bin:${PATH}"
106 # Start date. Can't be done until we know the locale
107 # Also requires the bin-override tools
108 CT_STAR_DATE=$(CT_DoDate +%s%N)
109 CT_STAR_DATE_HUMAN=$(CT_DoDate +%Y%m%d.%H%M%S)
111 # Log real begining of build, now
112 CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
114 # We really need to extract from ,config and not .config.2, as we
115 # do want the kconfig's values, not our mangled config with arrays.
116 CT_DoStep DEBUG "Dumping user-supplied crosstool-NG configuration"
117 CT_DoExecLog DEBUG grep -E '^(# |)CT_' .config
120 CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
124 CT_DoLog INFO "Building environment variables"
126 # Include sub-scripts instead of calling them: that way, we do not have to
127 # export any variable, nor re-parse the configuration and functions files.
128 . "${CT_LIB_DIR}/scripts/build/internals.sh"
129 . "${CT_LIB_DIR}/scripts/build/arch/${CT_ARCH}.sh"
130 . "${CT_LIB_DIR}/scripts/build/companion_tools.sh"
131 . "${CT_LIB_DIR}/scripts/build/kernel/${CT_KERNEL}.sh"
132 . "${CT_LIB_DIR}/scripts/build/companion_libs.sh"
133 . "${CT_LIB_DIR}/scripts/build/binutils/${CT_BINUTILS}.sh"
134 . "${CT_LIB_DIR}/scripts/build/libc/${CT_LIBC}.sh"
135 . "${CT_LIB_DIR}/scripts/build/cc/${CT_CC}.sh"
136 . "${CT_LIB_DIR}/scripts/build/debug.sh"
137 . "${CT_LIB_DIR}/scripts/build/test_suite.sh"
139 # Target tuple: CT_TARGET needs a little love:
140 CT_DoBuildTargetTuple
142 # Kludge: If any of the configured options needs CT_TARGET,
143 # then rescan the options file now:
146 # Sanity check some directories
147 CT_TestAndAbort "'CT_PREFIX_DIR' is not set: where should I install?" -z "${CT_PREFIX_DIR}"
149 # Second kludge: merge user-supplied target CFLAGS with architecture-provided
150 # target CFLAGS. Do the same for LDFLAGS in case it happens in the future.
151 # Put user-supplied flags at the end, so that they take precedence.
152 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
153 CT_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_TARGET_LDFLAGS}"
154 CT_CC_CORE_EXTRA_CONFIG_ARRAY=( ${CT_ARCH_CC_CORE_EXTRA_CONFIG} "${CT_CC_CORE_EXTRA_CONFIG_ARRAY[@]}" )
155 CT_CC_EXTRA_CONFIG_ARRAY=( ${CT_ARCH_CC_EXTRA_CONFIG} "${CT_CC_EXTRA_CONFIG_ARRAY[@]}" )
157 # Compute the package version string
158 CT_PKGVERSION="crosstool-NG ${CT_VERSION}${CT_TOOLCHAIN_PKGVERSION:+ - ${CT_TOOLCHAIN_PKGVERSION}}"
160 # Compute the working directories names
161 CT_TARBALLS_DIR="${CT_WORK_DIR}/tarballs"
162 CT_SRC_DIR="${CT_WORK_DIR}/src"
163 CT_BUILD_DIR="${CT_WORK_DIR}/${CT_TARGET}/build"
164 CT_BUILDTOOLS_PREFIX_DIR="${CT_WORK_DIR}/${CT_TARGET}/buildtools"
165 CT_STATE_DIR="${CT_WORK_DIR}/${CT_TARGET}/state"
166 CT_CONFIG_DIR="${CT_BUILD_DIR}/configs"
167 # Note about HOST_COMPLIBS_DIR: it's always gonna be in the buildtools dir, or a
168 # sub-dir. So we won't have to save/restore it, not even create it.
169 # In case of cross or native, host-complibs are used for build-complibs;
170 # in case of canadian or cross-native, host-complibs are specific
171 case "${CT_TOOLCHAIN_TYPE}" in
173 CT_HOST_COMPLIBS_DIR="${CT_BUILDTOOLS_PREFIX_DIR}"
175 canadian|cross-native)
176 CT_HOST_COMPLIBS_DIR="${CT_BUILDTOOLS_PREFIX_DIR}/complibs-host"
180 # Compute test suite install directory
181 CT_TEST_SUITE_DIR=${CT_INSTALL_DIR}/test-suite
183 # We must ensure that we can restart if asked for!
184 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}" ]; then
185 CT_DoLog ERROR "You asked to restart a non-restartable build"
186 CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
187 CT_DoLog ERROR "in the config options for the previous build, or the state"
188 CT_DoLog ERROR "directory for the previous build was deleted."
189 CT_Abort "I will stop here to avoid any carnage"
192 # If the local tarball directory does not exist, say so, and don't try to save there!
193 if [ "${CT_SAVE_TARBALLS}" = "y" \
194 -a ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
195 CT_DoLog WARN "Directory '${CT_LOCAL_TARBALLS_DIR}' does not exist."
196 CT_DoLog WARN "Will not save downloaded tarballs to local storage."
200 # Check now if we can write to the destination directory:
201 if [ -d "${CT_INSTALL_DIR}" ]; then
202 CT_TestAndAbort "Destination directory '${CT_INSTALL_DIR}' is not removable" ! -w $(dirname "${CT_INSTALL_DIR}")
205 # Good, now grab a bit of informations on the system we're being run on,
206 # just in case something goes awok, and it's not our fault:
207 CT_SYS_USER=$(id -un)
208 CT_SYS_HOSTNAME=$(hostname -f 2>/dev/null || true)
209 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
210 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-$(uname -n)}"
211 CT_SYS_KERNEL=$(uname -s)
212 CT_SYS_REVISION=$(uname -r)
213 CT_SYS_OS=$(uname -s)
214 CT_SYS_MACHINE=$(uname -m)
215 CT_SYS_PROCESSOR=$(uname -p)
216 CT_SYS_GCC=$(gcc -dumpversion)
217 CT_SYS_TARGET=$(CT_DoConfigGuess)
218 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
220 CT_DoLog EXTRA "Preparing working directories"
222 # Ah! The build directory shall be eradicated, even if we restart!
223 # Ditto for the build tools install dir
224 CT_DoForceRmdir "${CT_BUILD_DIR}" "${CT_BUILDTOOLS_PREFIX_DIR}"
226 # Don't eradicate directories if we need to restart
227 if [ -z "${CT_RESTART}" ]; then
228 # Get rid of pre-existing installed toolchain and previous build directories.
229 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
230 CT_DoForceRmdir "${CT_TARBALLS_DIR}"
232 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
233 CT_DoForceRmdir "${CT_SRC_DIR}"
235 if [ -d "${CT_INSTALL_DIR}" -a "${CT_RM_RF_PREFIX_DIR}" = "y" ]; then
236 CT_DoForceRmdir "${CT_INSTALL_DIR}"
238 # In case we start anew, get rid of the previously saved state directory
239 if [ -d "${CT_STATE_DIR}" ]; then
240 CT_DoForceRmdir "${CT_STATE_DIR}"
244 # Create the directories we'll use, even if restarting: it does no harm to
245 # create already existent directories, and CT_BUILD_DIR needs to be created
247 CT_DoExecLog ALL mkdir -p "${CT_TARBALLS_DIR}"
248 CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
249 CT_DoExecLog ALL mkdir -p "${CT_BUILD_DIR}"
250 CT_DoExecLog ALL mkdir -p "${CT_BUILDTOOLS_PREFIX_DIR}/bin"
251 CT_DoExecLog ALL mkdir -p "${CT_CONFIG_DIR}"
252 CT_DoExecLog ALL mkdir -p "${CT_INSTALL_DIR}"
253 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}"
254 CT_DoExecLog ALL mkdir -p "${CT_HOST_COMPLIBS_DIR}"
256 # Only create the state dir if asked for a restartable build
257 [ -n "${CT_DEBUG_CT_SAVE_STEPS}" ] && CT_DoExecLog ALL mkdir -p "${CT_STATE_DIR}"
259 # Check install file system case-sensitiveness
260 CT_DoExecLog DEBUG touch "${CT_PREFIX_DIR}/foo"
261 CT_TestAndAbort "Your file system in '${CT_PREFIX_DIR}' is *not* case-sensitive!" -f "${CT_PREFIX_DIR}/FOO"
262 CT_DoExecLog DEBUG rm -f "${CT_PREFIX_DIR}/foo"
264 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
265 # the previous build was successful.
266 CT_DoExecLog ALL chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
268 # Setting up the rest of the environment only if not restarting
269 if [ -z "${CT_RESTART}" ]; then
270 case "${CT_SYSROOT_NAME}" in
271 "") CT_SYSROOT_NAME="sysroot";;
272 .) CT_Abort "Sysroot name is set to '.' which is forbidden";;
273 *' '*) CT_Abort "Sysroot name contains forbidden space(s): '${CT_SYSROOT_NAME}'";;
274 */*) CT_Abort "Sysroot name contains forbidden slash(es): '${CT_SYSROOT_NAME}'";;
277 # Arrange paths depending on wether we use sysroot or not.
278 if [ "${CT_USE_SYSROOT}" = "y" ]; then
279 CT_SYSROOT_REL_DIR="${CT_SYSROOT_DIR_PREFIX:+${CT_SYSROOT_DIR_PREFIX}/}${CT_SYSROOT_NAME}"
280 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_REL_DIR}"
281 CT_DEBUGROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/${CT_SYSROOT_DIR_PREFIX}/debug-root"
282 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
283 CT_SanitiseVarDir CT_SYSROOT_REL_DIR CT_SYSROOT_DIR CT_DEBUGROOT_DIR CT_HEADERS_DIR
284 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
285 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
286 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
288 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
289 # confused when $sysroot/usr/include is not present.
290 # Note: --prefix=/usr is magic!
291 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
293 # plain old way. All libraries in prefix/target/lib
294 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
295 CT_DEBUGROOT_DIR="${CT_SYSROOT_DIR}"
296 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
297 CT_SanitiseVarDir CT_SYSROOT_DIR CT_DEBUGROOT_DIR CT_HEADERS_DIR
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_HEADERS_DIR}"
321 if [ "${CT_USE_SYSROOT}" = "y" ]; then
322 # Prevent gcc from installing its libraries outside of the sysroot
323 CT_Pushd "${CT_PREFIX_DIR}/${CT_TARGET}"
324 CT_DoExecLog ALL ln -sf "${CT_SYSROOT_REL_DIR}/lib" "lib"
328 # Since we're *not* multilib on the target side, we want all the
329 # libraries to end up in "lib". We create "lib64" (for 64-bit
330 # build or host architectures) and "lib32" (for 32-bit emulation
331 # on 64-bit) as symlinks to "lib".
333 # Not all of these symlinks are necessary, but better safe than
334 # sorry. They are summarily removed by build/internals.sh:do_finish.
337 "${CT_SYSROOT_DIR}" \
338 "${CT_SYSROOT_DIR}/usr" \
339 "${CT_PREFIX_DIR}/${CT_TARGET}" \
341 CT_DoExecLog ALL ln -sf "lib" "${d}/lib32"
342 CT_DoExecLog ALL ln -sf "lib" "${d}/lib64"
345 # Determine build system if not set by the user
346 if [ -z "${CT_BUILD}" ]; then
347 CT_BUILD=$(CT_DoConfigGuess)
350 # Prepare mangling patterns to later modify BUILD and HOST (see below)
351 case "${CT_TOOLCHAIN_TYPE}" in
353 # A cross-compiler runs on the same machine it is built on
354 CT_HOST="${CT_BUILD}"
355 build_mangle="build_"
358 install_build_tools_for="BUILD HOST"
361 build_mangle="build_"
364 install_build_tools_for="BUILD HOST"
366 *) CT_Abort "No code for '${CT_TOOLCHAIN_TYPE}' toolchain type!"
370 # Save the real tuples to generate shell-wrappers to the real tools
371 CT_REAL_BUILD="${CT_BUILD}"
372 CT_REAL_HOST="${CT_HOST}"
373 CT_REAL_TARGET="${CT_TARGET}"
375 # Canonicalise CT_BUILD and CT_HOST
376 # Not only will it give us full-qualified tuples, but it will also ensure
377 # that they are valid tuples (in case of typo with user-provided tuples)
378 # That's way better than trying to rewrite config.sub ourselves...
379 # CT_TARGET is already made canonical in CT_DoBuildTargetTuple
380 CT_BUILD=$(CT_DoConfigSub "${CT_BUILD}")
381 CT_HOST=$(CT_DoConfigSub "${CT_HOST}")
383 # Modify BUILD and HOST so that gcc always generate a cross-compiler
384 # even if any of the build, host or target machines are the same.
385 # NOTE: we'll have to mangle the (BUILD|HOST)->TARGET x-compiler to
386 # support canadain build, later...
387 CT_BUILD="${CT_BUILD/-/-${build_mangle}}"
388 CT_HOST="${CT_HOST/-/-${host_mangle}}"
389 CT_TARGET="${CT_TARGET/-/-${target_mangle}}"
391 # Now we have mangled our BUILD and HOST tuples, we must fake the new
392 # cross-tools for those mangled tuples.
393 CT_DoLog DEBUG "Making build system tools available"
394 for m in ${install_build_tools_for}; do
399 if [ -n "${!p}" ]; then
405 for tool in ar as dlltool gcc g++ gcj gnatbind gnatmake ld nm objcopy objdump ranlib strip windres; do
406 # First try with prefix + suffix
407 # Then try with prefix only
408 # Then try with suffix only, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
409 # Finally try with neither prefix nor suffix, but only for BUILD, and HOST iff REAL_BUILD == REAL_HOST
410 # This is needed, because some tools have a prefix and
411 # a suffix (eg. gcc), while others may have only one,
412 # or even none (eg. binutils)
413 where=$(CT_Which "${t}${tool}${!s}")
414 [ -z "${where}" ] && where=$(CT_Which "${t}${tool}")
416 -a \( "${m}" = "BUILD" \
417 -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
418 where=$(CT_Which "${tool}${!s}")
421 -a \( "${m}" = "BUILD" \
422 -o "${CT_REAL_BUILD}" = "${!r}" \) ]; then
423 where=$(CT_Which "${tool}")
426 # Not all tools are available for all platforms, but some are required.
427 if [ -n "${where}" ]; then
428 CT_DoLog DEBUG " '${!v}-${tool}' -> '${where}'"
429 printf "#${BANG}${CT_CONFIG_SHELL}\nexec '${where}' \"\${@}\"\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}"
430 CT_DoExecLog ALL chmod 700 "${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}"
433 # We'll at least need some of them...
434 ar|as|gcc|ld|nm|objcopy|objdump|ranlib)
435 CT_Abort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!"
437 # Some are conditionnally required
438 # Add them in alphabetical (C locale) ordering
440 # g++ (needed for companion lib), only needed for HOST
441 CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${m}" = "HOST"
444 CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_CC_LANG_JAVA}" = "y"
447 CT_TestAndAbort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" "${CT_STRIP_ALL_TOOLCHAIN_EXECUTABLES}" = "y"
449 # If any other is missing, only warn at low level
451 # It does not deserve a WARN level.
452 CT_DoLog DEBUG " Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : not required."
459 # Some makeinfo versions are a pain in [put your most sensible body part here].
460 # Go ahead with those, by creating a wrapper that keeps partial files, and that
462 CT_DoLog DEBUG " 'makeinfo' -> '$(CT_Which makeinfo)'"
463 printf "#${BANG}${CT_CONFIG_SHELL}\n$(CT_Which makeinfo) --force \"\${@}\"\ntrue\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/makeinfo"
464 CT_DoExecLog ALL chmod 700 "${CT_BUILDTOOLS_PREFIX_DIR}/bin/makeinfo"
466 # Carefully add paths in the order we want them:
467 # - first try in ${CT_PREFIX_DIR}/bin
468 # - then try the buildtools dir
469 # - fall back to searching user's PATH
470 # Of course, neither cross-native nor canadian can run on BUILD,
471 # so don't add those PATHs in this case...
472 case "${CT_TOOLCHAIN_TYPE}" in
473 cross) export PATH="${CT_PREFIX_DIR}/bin:${CT_BUILDTOOLS_PREFIX_DIR}/bin:${PATH}";;
474 canadian) export PATH="${CT_BUILDTOOLS_PREFIX_DIR}/bin:${PATH}";;
479 # Explicitly optimise, else the lines below will overide the
480 # package's default optimisation flags
481 CT_CFLAGS_FOR_BUILD="-O2 -g"
482 CT_CFLAGS_FOR_BUILD+=" ${CT_EXTRA_CFLAGS_FOR_BUILD}"
483 CT_LDFLAGS_FOR_BUILD=
484 CT_LDFLAGS_FOR_BUILD+=" ${CT_EXTRA_LDFLAGS_FOR_BUILD}"
487 # Explicitly optimise, else the lines below will overide the
488 # package's default optimisation flags
489 CT_CFLAGS_FOR_HOST="-O2 -g"
490 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST+=" -pipe"
491 CT_CFLAGS_FOR_HOST+=" ${CT_EXTRA_CFLAGS_FOR_HOST}"
493 CT_LDFLAGS_FOR_HOST+=" ${CT_EXTRA_LDFLAGS_FOR_HOST}"
494 CT_DoLog DEBUG "CFLAGS for host compiler: '${CT_CFLAGS_FOR_HOST}'"
495 CT_DoLog DEBUG "LDFLAGS for host compiler: '${CT_LDFLAGS_FOR_HOST}'"
497 # Set the shell to be used by ./configure scripts and by Makefiles (those
499 export CONFIG_SHELL="${CT_CONFIG_SHELL}" # for ./configure
500 export SHELL="${CT_CONFIG_SHELL}" # for Makefiles
502 # And help make go faster
504 # Override the configured jobs with what's been given on the command line
505 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
506 # Use the number of processors+1 when automatically setting the number of
507 # parallel jobs. Fall back to 1 if the host doesn't use GLIBC.
508 AUTO_JOBS=$((`getconf _NPROCESSORS_ONLN 2> /dev/null || echo 0` + 1))
509 [ ${CT_PARALLEL_JOBS} -eq 0 ] && JOBSFLAGS="${JOBSFLAGS} -j${AUTO_JOBS}"
510 [ ${CT_PARALLEL_JOBS} -gt 0 ] && JOBSFLAGS="${JOBSFLAGS} -j${CT_PARALLEL_JOBS}"
511 [ ${CT_LOAD} -ne 0 ] && JOBSFLAGS="${JOBSFLAGS} -l${CT_LOAD}"
513 # Now that we've set up $PATH and $CT_CFLAGS_FOR_HOST, sanity test that gcc
514 # is runnable so that the user can troubleshoot problems if not.
515 CT_DoStep DEBUG "Checking that we can run gcc -v"
516 CT_DoExecLog DEBUG "${CT_HOST}-gcc" -v
519 # Create a simple C program for testing.
520 testc="${CT_BUILD_DIR}/test.c"
521 printf "int main() { return 0; }\n" >"${testc}"
522 gccout="${CT_BUILD_DIR}/.gccout"
524 CT_DoStep DEBUG "Checking that gcc can compile a trivial program"
525 CT_DoExecLog DEBUG "${CT_HOST}-gcc" ${CT_CFLAGS_FOR_HOST} ${CT_LDFLAGS_FOR_HOST} "${testc}" -o "${gccout}"
529 if [ "${CT_WANTS_STATIC_LINK}" = "y" ]; then
530 CT_DoStep DEBUG "Checking that gcc can compile a trivial statically linked program (CT_WANTS_STATIC_LINK)"
531 CT_DoLog DEBUG "You may need to ensure that static libraries such as libc.a are installed on your system"
532 CT_DoExecLog DEBUG "${CT_HOST}-gcc" ${CT_CFLAGS_FOR_HOST} ${CT_LDFLAGS_FOR_HOST} "${testc}" -static -o "${gccout}"
537 if [ "${CT_CC_STATIC_LIBSTDCXX}" = "y" ]; then
538 CT_DoStep DEBUG "Checking that gcc can statically link libstdc++ (CT_CC_STATIC_LIBSTDCXX)"
539 CT_DoLog DEBUG "You may need to ensure that libstdc++.a is installed on your system"
540 CT_DoExecLog DEBUG "${CT_HOST}-gcc" ${CT_CFLAGS_FOR_HOST} ${CT_LDFLAGS_FOR_HOST} "${testc}" -static -lstdc++ -o "${gccout}"
546 # We need to save the real .config with kconfig's value,
547 # not our mangled .config.2 with arrays.
548 CT_DoLog EXTRA "Installing user-supplied crosstool-NG configuration"
549 CT_DoExecLog ALL mkdir -p "${CT_PREFIX_DIR}/bin"
550 CT_DoExecLog DEBUG install -m 0755 "${CT_LIB_DIR}/scripts/toolchain-config.in" "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
551 CT_DoExecLog DEBUG sed -i -e 's,@@grep@@,"'"${grep}"'",;' "${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
552 bzip2 -c -9 .config >>"${CT_PREFIX_DIR}/bin/${CT_TARGET}-ct-ng.config"
554 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
555 CT_DoLog EXTRA "Building a toolchain for:"
556 CT_DoLog EXTRA " build = ${CT_REAL_BUILD}"
557 CT_DoLog EXTRA " host = ${CT_REAL_HOST}"
558 CT_DoLog EXTRA " target = ${CT_TARGET}"
559 set |grep -E '^CT_.+=' |sort |CT_DoLog DEBUG
560 CT_DoLog DEBUG "Other environment:"
561 printenv |grep -v -E '^CT_.+=' |CT_DoLog DEBUG
565 if [ -z "${CT_RESTART}" ]; then
566 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
567 do_companion_tools_get
569 do_companion_libs_get
577 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
578 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
579 CT_DoForceRmdir "${CT_SRC_DIR}"
580 CT_DoExecLog ALL mkdir -p "${CT_SRC_DIR}"
583 if [ "${CT_COMP_TOOLS}" = "y" ]; then
584 CT_DoStep INFO "Extracting, patching and installing companion tools"
585 do_companion_tools_extract
590 CT_DoStep INFO "Extracting and patching toolchain components"
592 do_companion_libs_extract
597 do_test_suite_extract
602 # Now for the job by itself. Go have a coffee!
603 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
604 # Because of CT_RESTART, this becomes quite complex
607 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
608 # Aha! CT_STEPS comes from steps.mk!
609 for step in ${CT_STEPS}; do
610 if [ ${do_it} -eq 0 ]; then
611 if [ "${CT_RESTART}" = "${step}" ]; then
612 CT_DoLoadState "${step}"
617 CT_DoSaveState ${step}
618 if [ ${do_stop} -eq 1 ]; then
619 CT_DoLog ERROR "Stopping just after step '${prev_step}', as requested."
623 if [ ${do_it} -eq 1 ]; then
625 # POSIX 1003.1-2008 does not say if "set -e" should catch a
626 # sub-shell ending with !0. bash-3 does not, while bash-4 does,
627 # so the following line is for bash-3; bash-4 would choke above.
629 if [ "${CT_STOP}" = "${step}" ]; then
632 if [ "${CT_DEBUG_PAUSE_STEPS}" = "y" ]; then
633 CT_DoPause "Step '${step}' finished"
642 # From now-on, it can become impossible to log any time, because
643 # either we're compressing the log file, or it can become RO any
644 # moment... Consign all ouptut to oblivion...
645 CT_DoLog INFO "Finishing installation (may take a few seconds)..."
647 rm -f ${CT_PREFIX_DIR}/build.log.bz2
648 if [ "${CT_LOG_TO_FILE}" = "y" ]; then
649 cp "${tmp_log_file}" "${CT_PREFIX_DIR}/build.log"
650 if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
651 bzip2 -9 "${CT_PREFIX_DIR}/build.log"
654 [ "${CT_INSTALL_DIR_RO}" = "y" ] && chmod -R a-w "${CT_INSTALL_DIR}"
655 [ "${CT_TEST_SUITE}" = "y" ] && chmod -R u+w "${CT_TEST_SUITE_DIR}"