Ioannis E. VENETIS <venetis@mail.capsl.udel.edu> pointed out that GMP and MPFR were not used by gcc.
Turned out that none could use GMP and MPFR as the config option changed its name, but the change was not propagated to all users.
/trunk/scripts/build/binutils.sh | 2 1 1 0 +-
/trunk/scripts/build/debug/300-gdb.sh | 2 1 1 0 +-
/trunk/scripts/build/cc_gcc.sh | 6 3 3 0 +++---
3 files changed, 5 insertions(+), 5 deletions(-)
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 CT_STAR_DATE=$(CT_DoDate +%s%N)
24 CT_STAR_DATE_HUMAN=$(CT_DoDate +%Y%m%d.%H%M%S)
26 # Are we configured? We'll need that later...
27 CT_TestOrAbort "Configuration file not found. Please create one." -f "${CT_TOP_DIR}/.config"
29 # Parse the configuration file
30 # It has some info about the logging facility, so include it early
31 . "${CT_TOP_DIR}/.config"
33 # Yes! We can do full logging from now on!
34 CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
37 renice ${CT_NICE} $$ |CT_DoLog DEBUG
39 CT_DoStep DEBUG "Dumping crosstool-NG configuration"
40 cat "${CT_TOP_DIR}/.config" |egrep '^(# |)CT_' |CT_DoLog DEBUG
43 # Some sanity checks in the environment and needed tools
44 CT_DoLog INFO "Checking environment sanity"
46 CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
50 # Other environment sanity checks
51 CT_TestAndAbort "Don't set LD_LIBRARY_PATH. It screws up the build." -n "${LD_LIBRARY_PATH}"
52 CT_TestAndAbort "Don't set CFLAGS. It screws up the build." -n "${CFLAGS}"
53 CT_TestAndAbort "Don't set CXXFLAGS. It screws up the build." -n "${CXXFLAGS}"
54 CT_Test "GREP_OPTIONS screws up the build. Resetting." -n "${GREP_OPTIONS}"
62 CT_DoLog INFO "Building environment variables"
64 # Parse architecture-specific functions
65 . "${CT_LIB_DIR}/arch/${CT_ARCH}/functions"
67 # Target tuple: CT_TARGET needs a little love:
70 # Kludge: If any of the configured options needs CT_TARGET,
71 # then rescan the options file now:
72 . "${CT_TOP_DIR}/.config"
74 # Second kludge: merge user-supplied target CFLAGS with architecture-provided
75 # target CFLAGS. Do the same for LDFLAGS in case it happens in the future.
76 # Put user-supplied flags at the end, so that they take precedence.
77 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
78 CT_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_TARGET_LDFLAGS}"
80 # Now, build up the variables from the user-configured options.
81 CT_KERNEL_FILE="${CT_KERNEL}-${CT_KERNEL_VERSION}"
82 CT_BINUTILS_FILE="binutils-${CT_BINUTILS_VERSION}"
83 CT_GMP_FILE="gmp-${CT_GMP_VERSION}"
84 CT_MPFR_FILE="mpfr-${CT_MPFR_VERSION}"
85 CT_CC_FILE="${CT_CC}-${CT_CC_VERSION}"
86 CT_LIBC_FILE="${CT_LIBC}-${CT_LIBC_VERSION}"
89 : "${CT_WORK_DIR:=${CT_TOP_DIR}/targets}"
90 CT_TARBALLS_DIR="${CT_WORK_DIR}/tarballs"
91 CT_SRC_DIR="${CT_WORK_DIR}/src"
92 CT_BUILD_DIR="${CT_WORK_DIR}/${CT_TARGET}/build"
93 CT_DEBUG_INSTALL_DIR="${CT_INSTALL_DIR}/${CT_TARGET}/debug-root"
94 # Note: we'll always install the core compiler in its own directory, so as to
95 # not mix the two builds: core and final.
96 CT_CC_CORE_STATIC_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-static"
97 CT_CC_CORE_SHARED_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-shared"
98 CT_STATE_DIR="${CT_WORK_DIR}/${CT_TARGET}/state"
100 # We must ensure that we can restart if asked for!
101 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}" ]; then
102 CT_DoLog ERROR "You asked to restart a non-restartable build"
103 CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
104 CT_DoLog ERROR "in the config options for the previous build, or the state"
105 CT_DoLog ERROR "directory for the previous build was deleted."
106 CT_Abort "I will stop here to avoid any carnage"
109 # Make all path absolute, it so much easier!
110 CT_LOCAL_TARBALLS_DIR=$(CT_MakeAbsolutePath "${CT_LOCAL_TARBALLS_DIR}")
112 # If the local tarball directory does not exist, say so, and don't try to save there!
113 if [ ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
114 CT_DoLog WARN "Directory '${CT_LOCAL_TARBALLS_DIR}' does not exist. Will not save downloaded tarballs to local storage."
118 # Some more sanity checks now that we have all paths set up
119 case "${CT_LOCAL_TARBALLS_DIR},${CT_TARBALLS_DIR},${CT_SRC_DIR},${CT_BUILD_DIR},${CT_PREFIX_DIR},${CT_INSTALL_DIR}" in
120 *" "*) CT_Abort "Don't use spaces in paths, it breaks things.";;
123 # Check now if we can write to the destination directory:
124 if [ -d "${CT_INSTALL_DIR}" ]; then
125 CT_TestAndAbort "Destination directory '${CT_INSTALL_DIR}' is not removable" ! -w $(dirname "${CT_INSTALL_DIR}")
128 # Good, now grab a bit of informations on the system we're being run on,
129 # just in case something goes awok, and it's not our fault:
130 CT_SYS_USER=$(id -un)
131 CT_SYS_HOSTNAME=$(hostname -f 2>/dev/null || true)
132 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
133 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-$(uname -n)}"
134 CT_SYS_KERNEL=$(uname -s)
135 CT_SYS_REVISION=$(uname -r)
136 # MacOS X lacks '-o' :
137 CT_SYS_OS=$(uname -o || echo "Unknown (maybe MacOS-X)")
138 CT_SYS_MACHINE=$(uname -m)
139 CT_SYS_PROCESSOR=$(uname -p)
140 CT_SYS_GCC=$(gcc -dumpversion)
141 CT_SYS_TARGET=$(CT_DoConfigGuess)
142 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
144 CT_DoLog EXTRA "Preparing working directories"
146 # Ah! The build directory shall be eradicated, even if we restart!
147 if [ -d "${CT_BUILD_DIR}" ]; then
148 mv "${CT_BUILD_DIR}" "${CT_BUILD_DIR}.$$"
149 chmod -R u+w "${CT_BUILD_DIR}.$$"
150 setsid nohup rm -rf "${CT_BUILD_DIR}.$$" >/dev/null 2>&1 &
153 # Don't eradicate directories if we need to restart
154 if [ -z "${CT_RESTART}" ]; then
155 # Get rid of pre-existing installed toolchain and previous build directories.
156 # We need to do that _before_ we can safely log, because the log file will
157 # most probably be in the toolchain directory.
158 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
159 mv "${CT_TARBALLS_DIR}" "${CT_TARBALLS_DIR}.$$"
160 chmod -R u+w "${CT_TARBALLS_DIR}.$$"
161 setsid nohup rm -rf "${CT_TARBALLS_DIR}.$$" >/dev/null 2>&1 &
163 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
164 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
165 chmod -R u+w "${CT_SRC_DIR}.$$"
166 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1 &
168 if [ -d "${CT_INSTALL_DIR}" ]; then
169 mv "${CT_INSTALL_DIR}" "${CT_INSTALL_DIR}.$$"
170 chmod -R u+w "${CT_INSTALL_DIR}.$$"
171 setsid nohup rm -rf "${CT_INSTALL_DIR}.$$" >/dev/null 2>&1 &
173 if [ -d "${CT_DEBUG_INSTALL_DIR}" ]; then
174 mv "${CT_DEBUG_INSTALL_DIR}" "${CT_DEBUG_INSTALL_DIR}.$$"
175 chmod -R u+w "${CT_DEBUG_INSTALL_DIR}.$$"
176 setsid nohup rm -rf "${CT_DEBUG_INSTALL_DIR}.$$" >/dev/null 2>&1 &
178 # In case we start anew, get rid of the previously saved state directory
179 if [ -d "${CT_STATE_DIR}" ]; then
180 mv "${CT_STATE_DIR}" "${CT_STATE_DIR}.$$"
181 chmod -R u+w "${CT_STATE_DIR}.$$"
182 setsid nohup rm -rf "${CT_STATE_DIR}.$$" >/dev/null 2>&1 &
186 # Create the directories we'll use, even if restarting: it does no harm to
187 # create already existent directories, and CT_BUILD_DIR needs to be created
189 mkdir -p "${CT_TARBALLS_DIR}"
190 mkdir -p "${CT_SRC_DIR}"
191 mkdir -p "${CT_BUILD_DIR}"
192 mkdir -p "${CT_INSTALL_DIR}"
193 mkdir -p "${CT_PREFIX_DIR}"
194 mkdir -p "${CT_DEBUG_INSTALL_DIR}"
195 mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
196 mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
197 mkdir -p "${CT_STATE_DIR}"
199 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
200 # the previous build was successful. To be able to move the logfile there,
201 # switch them back to read/write
202 chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
204 # Redirect log to the actual log file now we can
205 # It's quite understandable that the log file will be installed in the install
206 # directory, so we must first ensure it exists and is writeable (above) before
209 case "${CT_LOG_TO_FILE}" in
210 y) CT_LOG_FILE="${CT_PREFIX_DIR}/build.log"
211 cat "${tmp_log_file}" >>"${CT_LOG_FILE}"
212 rm -f "${tmp_log_file}"
213 exec >>"${CT_LOG_FILE}"
215 *) rm -f "${tmp_log_file}"
219 # Set environment for proxy access
220 # This has to be done even if we are restarting, as they don't get
221 # saved in the step snapshot.
222 case "${CT_PROXY_TYPE}" in
226 case "${CT_PROXY_USER}:${CT_PROXY_PASS}" in
228 :*) http_proxy="${http_proxy}:${CT_PROXY_PASS}@";;
229 *:) http_proxy="${http_proxy}${CT_PROXY_USER}@";;
230 *:*) http_proxy="${http_proxy}${CT_PROXY_USER}:${CT_PROXY_PASS}@";;
232 export http_proxy="${http_proxy}${CT_PROXY_HOST}:${CT_PROXY_PORT}/"
233 export https_proxy="${http_proxy}"
234 export ftp_proxy="${http_proxy}"
235 CT_DoLog DEBUG "http_proxy='${http_proxy}'"
239 # Force not using HTTP proxy
240 unset http_proxy ftp_proxy https_proxy
245 # Force not using HTTP proxy
246 unset http_proxy ftp_proxy https_proxy
247 # Remove any lingering config file from any previous run
248 rm -f "${CT_BUILD_DIR}/tsocks.conf"
249 # Find all interfaces and build locally accessible networks
250 server_ip=$(ping -c 1 -W 2 "${CT_PROXY_HOST}" |head -n 1 |sed -r -e 's/^[^\(]+\(([^\)]+)\).*$/\1/;' || true)
251 CT_TestOrAbort "SOCKS proxy '${CT_PROXY_HOST}' has no IP." -n "${server_ip}"
252 /sbin/ifconfig |gawk -v server_ip="${server_ip}" '
254 split( server_ip, tmp, "\\." );
255 server_ip_num = tmp[1] * 2^24 + tmp[2] * 2^16 + tmp[3] * 2^8 + tmp[4] * 2^0;
259 $0 ~ /^[[:space:]]*inet addr:/ {
260 split( $2, tmp, ":|\\." );
261 if( ( tmp[2] == 127 ) && ( tmp[3] == 0 ) && ( tmp[4] == 0 ) && ( tmp[5] == 1 ) ) {
262 /* Skip 127.0.0.1, it'\''s taken care of by tsocks itself */
265 ip_num = tmp[2] * 2^24 + tmp[3] * 2^16 + tmp[4] * 2 ^8 + tmp[5] * 2^0;
270 } while( (i!=0) && ( and( server_ip_num, mask ) == and( ip_num, mask ) ) );
271 mask = and( 0xFFFFFFFF, lshift( mask, 1 ) );
272 if( (i!=0) && (mask!=0) ) {
273 masked_ip = and( ip_num, mask );
274 for( i=0; i<pairs; i++ ) {
275 if( ( masked_ip == ips[i] ) && ( mask == masks[i] ) ) {
279 ips[pairs] = masked_ip;
282 printf( "local = %d.%d.%d.%d/%d.%d.%d.%d\n",
283 and( 0xFF, masked_ip / 2^24 ),
284 and( 0xFF, masked_ip / 2^16 ),
285 and( 0xFF, masked_ip / 2^8 ),
286 and( 0xFF, masked_ip / 2^0 ),
287 and( 0xFF, mask / 2^24 ),
288 and( 0xFF, mask / 2^16 ),
289 and( 0xFF, mask / 2^8 ),
290 and( 0xFF, mask / 2^0 ) );
293 ' >"${CT_BUILD_DIR}/tsocks.conf"
294 ( echo "server = ${server_ip}";
295 echo "server_port = ${CT_PROXY_PORT}";
296 [ -n "${CT_PROXY_USER}" ] && echo "default_user=${CT_PROXY_USER}";
297 [ -n "${CT_PROXY_PASS}" ] && echo "default_pass=${CT_PROXY_PASS}";
298 ) >>"${CT_BUILD_DIR}/tsocks.conf"
299 case "${CT_PROXY_TYPE/socks}" in
300 4|5) proxy_type="${CT_PROXY_TYPE/socks}";;
302 reply=$(inspectsocks "${server_ip}" "${CT_PROXY_PORT}" 2>&1 || true)
304 *"server is a version 4 socks server") proxy_type=4;;
305 *"server is a version 5 socks server") proxy_type=5;;
306 *) CT_Abort "Unable to determine SOCKS proxy type for '${CT_PROXY_HOST}:${CT_PROXY_PORT}'"
310 echo "server_type = ${proxy_type}" >> "${CT_BUILD_DIR}/tsocks.conf"
311 validateconf -f "${CT_BUILD_DIR}/tsocks.conf" 2>&1 |CT_DoLog DEBUG
312 export TSOCKS_CONF_FILE="${CT_BUILD_DIR}/tsocks.conf"
317 # Setting up the rest of the environment only if not restarting
318 if [ -z "${CT_RESTART}" ]; then
319 # Determine build system if not set by the user
320 CT_Test "You did not specify the build system. That's OK, I can guess..." -z "${CT_BUILD}"
321 CT_BUILD="${CT_BUILD:-$(CT_DoConfigGuess)}"
322 CT_BUILD=$(CT_DoConfigSub "${CT_BUILD}")
324 # Arrange paths depending on wether we use sys-root or not.
325 if [ "${CT_USE_SYSROOT}" = "y" ]; then
326 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/sys-root"
327 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
328 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
329 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
330 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
332 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
333 # confused when $sysroot/usr/include is not present.
334 # Note: --prefix=/usr is magic!
335 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
337 # plain old way. All libraries in prefix/target/lib
338 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
339 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
340 # hack! Always use --with-sysroot for binutils.
341 # binutils 2.14 and later obey it, older binutils ignore it.
342 # Lets you build a working 32->64 bit cross gcc
343 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
344 # Use --with-headers, else final gcc will define disable_glibc while
345 # building libgcc, and you'll have no profiling
346 CC_CORE_SYSROOT_ARG="--without-headers"
347 CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
348 LIBC_SYSROOT_ARG="prefix="
351 # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
352 # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail with
353 # "ld: cannot open crti.o: No such file or directory"
354 mkdir -p "${CT_SYSROOT_DIR}/lib"
355 mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
357 # Canadian-cross are really picky on the way they are built. Tweak the values.
358 CT_UNIQ_BUILD=$(echo "${CT_BUILD}" |sed -r -e 's/-/-build_/')
359 if [ "${CT_CANADIAN}" = "y" ]; then
360 # Arrange so that gcc never, ever think that build system == host system
361 CT_CANADIAN_OPT="--build=${CT_UNIQ_BUILD}"
362 # We shall have a compiler for this target!
365 CT_HOST="${CT_BUILD}"
366 CT_CANADIAN_OPT="--build=${CT_BUILD}"
367 # Add the target toolchain in the path so that we can build the C library
368 # Carefully add paths in the order we want them:
369 # - first try in ${CT_PREFIX_DIR}/bin
370 # - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
371 # - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
372 # - fall back to searching user's PATH
373 export PATH="${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}"
376 # Modify GCC_HOST to never be equal to $BUILD or $TARGET
377 # This strange operation causes gcc to always generate a cross-compiler
378 # even if the build machine is the same kind as the host.
379 # This is why CC has to be set when doing a canadian cross; you can't find a
380 # host compiler by appending -gcc to our whacky $GCC_HOST
381 # Kludge: it is reported that the above causes canadian crosses with cygwin
382 # hosts to fail, so avoid it just in that one case. It would be cleaner to
383 # just move this into the non-canadian case above, but I'm afraid that might
384 # cause some configure script somewhere to decide that since build==host, they
385 # could run host binaries.
386 # (Copied almost as-is from original crosstool):
387 case "${CT_KERNEL},${CT_CANADIAN}" in
389 *,y) CT_HOST=$(echo "${CT_HOST}" |sed -r -e 's/-/-host_/;');;
392 # Ah! Recent versions of binutils need some of the build and/or host system
393 # (read CT_BUILD and CT_HOST) tools to be accessible (ar is but an example).
395 CT_DoLog DEBUG "Making build system tools available"
396 mkdir -p "${CT_PREFIX_DIR}/bin"
397 for tool in ar as dlltool ${CT_CC_NATIVE:=gcc} gnatbind gnatmake ld nm ranlib strip windres objcopy objdump; do
398 tmp=$(CT_Which ${tool})
399 if [ -n "${tmp}" ]; then
400 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_BUILD}-${tool}"
401 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_UNIQ_BUILD}-${tool}"
402 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_HOST}-${tool}"
406 # Some makeinfo versions are a pain in [put your most sensible body part here].
407 # Go ahead with those, by creating a wrapper that keeps partial files, and that
409 echo -e "#!/bin/sh\n$(CT_Which makeinfo) --force \"\${@}\"\ntrue" >"${CT_PREFIX_DIR}/bin/makeinfo"
410 chmod 700 "${CT_PREFIX_DIR}/bin/makeinfo"
414 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST="${CT_CFLAGS_FOR_HOST} -pipe"
416 # Override the configured jobs with what's been given on the command line
417 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
419 # And help make go faster
421 [ ${CT_PARALLEL_JOBS} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -j${CT_PARALLEL_JOBS}"
422 [ ${CT_LOAD} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -l${CT_LOAD}"
423 export PARALLELMFLAGS
425 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
426 CT_DoLog EXTRA "Building a toolchain for:"
427 CT_DoLog EXTRA " build = ${CT_BUILD}"
428 CT_DoLog EXTRA " host = ${CT_HOST}"
429 CT_DoLog EXTRA " target = ${CT_TARGET}"
430 set |egrep '^CT_.+=' |sort |CT_DoLog DEBUG
434 # Include sub-scripts instead of calling them: that way, we do not have to
435 # export any variable, nor re-parse the configuration and functions files.
436 . "${CT_LIB_DIR}/scripts/build/kernel_${CT_KERNEL}.sh"
437 . "${CT_LIB_DIR}/scripts/build/gmp.sh"
438 . "${CT_LIB_DIR}/scripts/build/mpfr.sh"
439 . "${CT_LIB_DIR}/scripts/build/binutils.sh"
440 . "${CT_LIB_DIR}/scripts/build/libc_${CT_LIBC}.sh"
441 . "${CT_LIB_DIR}/scripts/build/cc_${CT_CC}.sh"
442 . "${CT_LIB_DIR}/scripts/build/debug.sh"
443 . "${CT_LIB_DIR}/scripts/build/tools.sh"
445 if [ -z "${CT_RESTART}" ]; then
446 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
457 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
458 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
459 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.force.$$"
460 setsid nohup rm -rf "${CT_SRC_DIR}.force.$$" >/dev/null 2>&1
461 mkdir -p "${CT_SRC_DIR}"
463 CT_DoStep INFO "Extracting and patching toolchain components"
476 # Now for the job by itself. Go have a coffee!
477 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
478 # Because of CT_RESTART, this becomes quite complex
481 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
482 # Aha! CT_STEPS comes from steps.mk!
483 for step in ${CT_STEPS}; do
484 if [ ${do_it} -eq 0 ]; then
485 if [ "${CT_RESTART}" = "${step}" ]; then
486 CT_DoLoadState "${step}"
491 CT_DoSaveState ${step}
492 if [ ${do_stop} -eq 1 ]; then
493 CT_DoLog ERROR "Stopping just after step '${prev_step}', as requested."
497 if [ ${do_it} -eq 1 ]; then
499 if [ "${CT_STOP}" = "${step}" ]; then
502 if [ "${CTDEBUG_CT_PAUSE_STEPS}" = "y" ]; then
503 CT_DoPause "Step '${step}' finished"
509 CT_DoLog DEBUG "Removing access to the build system tools"
510 find "${CT_PREFIX_DIR}/bin" -name "${CT_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
511 find "${CT_PREFIX_DIR}/bin" -name "${CT_UNIQ_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
512 find "${CT_PREFIX_DIR}/bin" -name "${CT_HOST}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
513 rm -fv "${CT_PREFIX_DIR}/bin/makeinfo" |CT_DoLog DEBUG
515 # Install the /populator/
516 CT_DoLog EXTRA "Installing the populate helper"
517 sed -r -e 's,@@CT_READELF@@,'"${CT_PREFIX_DIR}/bin/${CT_TARGET}-readelf"',g;' \
518 -e 's,@@CT_SYSROOT_DIR@@,'"${CT_SYSROOT_DIR}"',g;' \
519 "${CT_LIB_DIR}/tools/populate.in" >"${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
520 chmod 755 "${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
522 # Create the aliases to the target tools
523 CT_DoStep EXTRA "Creating toolchain aliases"
524 CT_Pushd "${CT_PREFIX_DIR}/bin"
525 for t in "${CT_TARGET}-"*; do
526 if [ -n "${CT_TARGET_ALIAS}" ]; then
527 _t=$(echo "$t" |sed -r -e 's/^'"${CT_TARGET}"'-/'"${CT_TARGET_ALIAS}"'-/;')
528 CT_DoLog DEBUG "Linking '${_t}' -> '${t}'"
529 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
531 if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
532 _t=$(echo "$t" |sed -r -e "${CT_TARGET_ALIAS_SED_EXPR}")
533 CT_DoLog DEBUG "Linking '${_t}' -> '${t}'"
534 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
540 # Remove the generated documentation files
541 if [ "${CT_REMOVE_DOCS}" = "y" ]; then
542 CT_DoLog INFO "Removing installed documentation"
543 rm -rf "${CT_PREFIX_DIR}/"{,usr/}{man,info}
544 rm -rf "${CT_SYSROOT_DIR}/"{,usr/}{man,info}
545 rm -rf "${CT_DEBUG_INSTALL_DIR}/"{,usr/}{man,info}
551 if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
552 CT_DoLog EXTRA "Compressing log file"
554 bzip2 -9 "${CT_LOG_FILE}"
557 if [ "${CT_INSTALL_DIR_RO}" = "y" ]; then
558 # OK, now we're done, set the toolchain read-only
559 # Don't log, the log file may become read-only any moment...
560 chmod -R a-w "${CT_INSTALL_DIR}" >/dev/null 2>&1