Some people are reposrting that ftp does not work on their network, probably due to proxies, while http does work.
Some (most) of the sites we use toretrieve tarballs have http equivallent for the ftp service. Use http as a failover.
There's no solution for those sites that do not have such an http equivalent.
/trunk/scripts/build/binutils.sh | 5 2 3 0 ++---
/trunk/scripts/build/libc_glibc.sh | 4 2 2 0 ++--
/trunk/scripts/build/libc_uClibc.sh | 2 1 1 0 +-
/trunk/scripts/build/debug/400-ltrace.sh | 2 1 1 0 +-
/trunk/scripts/build/debug/300-gdb.sh | 8 3 5 0 +++-----
/trunk/scripts/build/kernel_linux.sh | 7 2 5 0 ++-----
/trunk/scripts/build/cc_gcc.sh | 6 2 4 0 ++----
/trunk/scripts/build/gmp.sh | 4 1 3 0 +---
8 files changed, 14 insertions(+), 24 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 . "${CT_LIB_DIR}/scripts/functions"
18 CT_STAR_DATE=`CT_DoDate +%s%N`
19 CT_STAR_DATE_HUMAN=`CT_DoDate +%Y%m%d.%H%M%S`
21 # Are we configured? We'll need that later...
22 CT_TestOrAbort "Configuration file not found. Please create one." -f "${CT_TOP_DIR}/.config"
24 # Parse the configuration file
25 # It has some info about the logging facility, so include it early
26 . "${CT_TOP_DIR}/.config"
28 # Yes! We can do full logging from now on!
29 CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
32 renice ${CT_NICE} $$ |CT_DoLog DEBUG
34 CT_DoStep DEBUG "Dumping crosstool-NG configuration"
35 cat "${CT_TOP_DIR}/.config" |egrep '^(# |)CT_' |CT_DoLog DEBUG
38 # Some sanity checks in the environment and needed tools
39 CT_DoLog INFO "Checking environment sanity"
41 CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
45 # Other environment sanity checks
46 CT_TestAndAbort "Don't set LD_LIBRARY_PATH. It screws up the build." -n "${LD_LIBRARY_PATH}"
47 CT_TestAndAbort "Don't set CFLAGS. It screws up the build." -n "${CFLAGS}"
48 CT_TestAndAbort "Don't set CXXFLAGS. It screws up the build." -n "${CXXFLAGS}"
49 CT_Test "GREP_OPTIONS screws up the build. Resetting." -n "${GREP_OPTIONS}"
57 CT_DoLog INFO "Building environment variables"
59 # Parse architecture-specific functions
60 . "${CT_LIB_DIR}/arch/${CT_ARCH}/functions"
62 # Target tuple: CT_TARGET needs a little love:
65 # Kludge: If any of the configured options needs CT_TARGET,
66 # then rescan the options file now:
67 . "${CT_TOP_DIR}/.config"
69 # Second kludge: merge user-supplied target CFLAGS with architecture-provided
71 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
73 # Now, build up the variables from the user-configured options.
74 CT_KERNEL_FILE="${CT_KERNEL}-${CT_KERNEL_VERSION}"
75 CT_BINUTILS_FILE="binutils-${CT_BINUTILS_VERSION}"
76 CT_GMP_FILE="gmp-${CT_GMP_VERSION}"
77 CT_MPFR_FILE="mpfr-${CT_MPFR_VERSION}"
78 CT_CC_FILE="${CT_CC}-${CT_CC_VERSION}"
79 CT_LIBC_FILE="${CT_LIBC}-${CT_LIBC_VERSION}"
82 CT_TARBALLS_DIR="${CT_TOP_DIR}/targets/tarballs"
83 CT_SRC_DIR="${CT_TOP_DIR}/targets/src"
84 CT_BUILD_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/build"
85 CT_DEBUG_INSTALL_DIR="${CT_INSTALL_DIR}/${CT_TARGET}/debug-root"
86 # Note: we'll always install the core compiler in its own directory, so as to
87 # not mix the two builds: core and final.
88 CT_CC_CORE_STATIC_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-static"
89 CT_CC_CORE_SHARED_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-shared"
90 CT_STATE_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/state"
92 # We must ensure that we can restart if asked for!
93 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}" ]; then
94 CT_DoLog ERROR "You asked to restart a non-restartable build"
95 CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
96 CT_DoLog ERROR "in the config options for the previous build, or the state"
97 CT_DoLog ERROR "directory for the previous build was deleted."
98 CT_Abort "I will stop here to avoid any carnage"
101 # Make all path absolute, it so much easier!
102 CT_LOCAL_TARBALLS_DIR="`CT_MakeAbsolutePath \"${CT_LOCAL_TARBALLS_DIR}\"`"
104 # If the local tarball directory does not exist, say so, and don't try to save there!
105 if [ ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
106 CT_DoLog WARN "Directory \"${CT_LOCAL_TARBALLS_DIR}\" does not exist. Will not save downloaded tarballs to local storage."
110 # Some more sanity checks now that we have all paths set up
111 case "${CT_LOCAL_TARBALLS_DIR},${CT_TARBALLS_DIR},${CT_SRC_DIR},${CT_BUILD_DIR},${CT_PREFIX_DIR},${CT_INSTALL_DIR}" in
112 *" "*) CT_Abort "Don't use spaces in paths, it breaks things.";;
115 # Check now if we can write to the destination directory:
116 if [ -d "${CT_INSTALL_DIR}" ]; then
117 CT_TestAndAbort "Destination directory \"${CT_INSTALL_DIR}\" is not removable" ! -w `dirname "${CT_INSTALL_DIR}"`
120 # Good, now grab a bit of informations on the system we're being run on,
121 # just in case something goes awok, and it's not our fault:
122 CT_SYS_USER="`id -un`"
123 CT_SYS_HOSTNAME=`hostname -f 2>/dev/null || true`
124 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
125 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-`uname -n`}"
126 CT_SYS_KERNEL=`uname -s`
127 CT_SYS_REVISION=`uname -r`
128 # MacOS X lacks '-o' :
129 CT_SYS_OS=`uname -o || echo "Unknown (maybe MacOS-X)"`
130 CT_SYS_MACHINE=`uname -m`
131 CT_SYS_PROCESSOR=`uname -p`
132 CT_SYS_GCC=`gcc -dumpversion`
133 CT_SYS_TARGET=`CT_DoConfigGuess`
134 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
136 CT_DoLog EXTRA "Preparing working directories"
138 # Ah! The build directory shall be eradicated, even if we restart!
139 if [ -d "${CT_BUILD_DIR}" ]; then
140 mv "${CT_BUILD_DIR}" "${CT_BUILD_DIR}.$$"
141 chmod -R u+w "${CT_BUILD_DIR}.$$"
142 setsid nohup rm -rf "${CT_BUILD_DIR}.$$" >/dev/null 2>&1 &
145 # Don't eradicate directories if we need to restart
146 if [ -z "${CT_RESTART}" ]; then
147 # Get rid of pre-existing installed toolchain and previous build directories.
148 # We need to do that _before_ we can safely log, because the log file will
149 # most probably be in the toolchain directory.
150 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
151 mv "${CT_TARBALLS_DIR}" "${CT_TARBALLS_DIR}.$$"
152 chmod -R u+w "${CT_TARBALLS_DIR}.$$"
153 setsid nohup rm -rf "${CT_TARBALLS_DIR}.$$" >/dev/null 2>&1 &
155 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
156 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
157 chmod -R u+w "${CT_SRC_DIR}.$$"
158 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1 &
160 if [ -d "${CT_INSTALL_DIR}" ]; then
161 mv "${CT_INSTALL_DIR}" "${CT_INSTALL_DIR}.$$"
162 chmod -R u+w "${CT_INSTALL_DIR}.$$"
163 setsid nohup rm -rf "${CT_INSTALL_DIR}.$$" >/dev/null 2>&1 &
165 if [ -d "${CT_DEBUG_INSTALL_DIR}" ]; then
166 mv "${CT_DEBUG_INSTALL_DIR}" "${CT_DEBUG_INSTALL_DIR}.$$"
167 chmod -R u+w "${CT_DEBUG_INSTALL_DIR}.$$"
168 setsid nohup rm -rf "${CT_DEBUG_INSTALL_DIR}.$$" >/dev/null 2>&1 &
170 # In case we start anew, get rid of the previously saved state directory
171 if [ -d "${CT_STATE_DIR}" ]; then
172 mv "${CT_STATE_DIR}" "${CT_STATE_DIR}.$$"
173 chmod -R u+w "${CT_STATE_DIR}.$$"
174 setsid nohup rm -rf "${CT_STATE_DIR}.$$" >/dev/null 2>&1 &
178 # Create the directories we'll use, even if restarting: it does no harm to
179 # create already existent directories, and CT_BUILD_DIR needs to be created
181 mkdir -p "${CT_TARBALLS_DIR}"
182 mkdir -p "${CT_SRC_DIR}"
183 mkdir -p "${CT_BUILD_DIR}"
184 mkdir -p "${CT_INSTALL_DIR}"
185 mkdir -p "${CT_PREFIX_DIR}"
186 mkdir -p "${CT_DEBUG_INSTALL_DIR}"
187 mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
188 mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
189 mkdir -p "${CT_STATE_DIR}"
191 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
192 # the previous build was successful. To be able to move the logfile there,
193 # switch them back to read/write
194 chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
196 # Redirect log to the actual log file now we can
197 # It's quite understandable that the log file will be installed in the install
198 # directory, so we must first ensure it exists and is writeable (above) before
201 case "${CT_LOG_TO_FILE}" in
202 y) CT_LOG_FILE="${CT_PREFIX_DIR}/build.log"
203 cat "${tmp_log_file}" >>"${CT_LOG_FILE}"
204 rm -f "${tmp_log_file}"
205 exec >>"${CT_LOG_FILE}"
207 *) rm -f "${tmp_log_file}"
211 # Set environment for proxy access
212 # This has to be done even if we are restarting, as they don't get
213 # saved in the step snapshot.
214 case "${CT_PROXY_TYPE}" in
218 case "${CT_PROXY_USER}:${CT_PROXY_PASS}" in
220 :*) http_proxy="${http_proxy}:${CT_PROXY_PASS}@";;
221 *:) http_proxy="${http_proxy}${CT_PROXY_USER}@";;
222 *:*) http_proxy="${http_proxy}${CT_PROXY_USER}:${CT_PROXY_PASS}@";;
224 export http_proxy="${http_proxy}${CT_PROXY_HOST}:${CT_PROXY_PORT}/"
225 export https_proxy="${http_proxy}"
226 export ftp_proxy="${http_proxy}"
227 CT_DoLog DEBUG "http_proxy='${http_proxy}'"
231 # Force not using HTTP proxy
232 unset http_proxy ftp_proxy https_proxy
237 # Force not using HTTP proxy
238 unset http_proxy ftp_proxy https_proxy
239 # Remove any lingering config file from any previous run
240 rm -f "${CT_BUILD_DIR}/tsocks.conf"
241 # Find all interfaces and build locally accessible networks
242 server_ip=$(ping -c 1 -W 2 "${CT_PROXY_HOST}" |head -n 1 |sed -r -e 's/^[^\(]+\(([^\)]+)\).*$/\1/;' || true)
243 CT_TestOrAbort "SOCKS proxy '${CT_PROXY_HOST}' has no IP." -n "${server_ip}"
244 /sbin/ifconfig |gawk -v server_ip="${server_ip}" '
246 split( server_ip, tmp, "\\." );
247 server_ip_num = tmp[1] * 2^24 + tmp[2] * 2^16 + tmp[3] * 2^8 + tmp[4] * 2^0;
251 $0 ~ /^[[:space:]]*inet addr:/ {
252 split( $2, tmp, ":|\\." );
253 if( ( tmp[2] == 127 ) && ( tmp[3] == 0 ) && ( tmp[4] == 0 ) && ( tmp[5] == 1 ) ) {
254 /* Skip 127.0.0.1, it'\''s taken care of by tsocks itself */
257 ip_num = tmp[2] * 2^24 + tmp[3] * 2^16 + tmp[4] * 2 ^8 + tmp[5] * 2^0;
262 } while( (i!=0) && ( and( server_ip_num, mask ) == and( ip_num, mask ) ) );
263 mask = and( 0xFFFFFFFF, lshift( mask, 1 ) );
264 if( (i!=0) && (mask!=0) ) {
265 masked_ip = and( ip_num, mask );
266 for( i=0; i<pairs; i++ ) {
267 if( ( masked_ip == ips[i] ) && ( mask == masks[i] ) ) {
271 ips[pairs] = masked_ip;
274 printf( "local = %d.%d.%d.%d/%d.%d.%d.%d\n",
275 and( 0xFF, masked_ip / 2^24 ),
276 and( 0xFF, masked_ip / 2^16 ),
277 and( 0xFF, masked_ip / 2^8 ),
278 and( 0xFF, masked_ip / 2^0 ),
279 and( 0xFF, mask / 2^24 ),
280 and( 0xFF, mask / 2^16 ),
281 and( 0xFF, mask / 2^8 ),
282 and( 0xFF, mask / 2^0 ) );
285 ' >"${CT_BUILD_DIR}/tsocks.conf"
286 ( echo "server = ${server_ip}";
287 echo "server_port = ${CT_PROXY_PORT}";
288 [ -n "${CT_PROXY_USER}" ] && echo "default_user=${CT_PROXY_USER}";
289 [ -n "${CT_PROXY_PASS}" ] && echo "default_pass=${CT_PROXY_PASS}";
290 ) >>"${CT_BUILD_DIR}/tsocks.conf"
291 case "${CT_PROXY_TYPE/socks}" in
292 4|5) proxy_type="${CT_PROXY_TYPE/socks}";;
294 reply=$(inspectsocks "${server_ip}" "${CT_PROXY_PORT}" 2>&1 || true)
296 *"server is a version 4 socks server") proxy_type=4;;
297 *"server is a version 5 socks server") proxy_type=5;;
298 *) CT_Abort "Unable to determine SOCKS proxy type for '${CT_PROXY_HOST}:${CT_PROXY_PORT}'"
302 echo "server_type = ${proxy_type}" >> "${CT_BUILD_DIR}/tsocks.conf"
303 validateconf -f "${CT_BUILD_DIR}/tsocks.conf" 2>&1 |CT_DoLog DEBUG
304 export TSOCKS_CONF_FILE="${CT_BUILD_DIR}/tsocks.conf"
309 # Setting up the rest of the environment only if not restarting
310 if [ -z "${CT_RESTART}" ]; then
311 # Determine build system if not set by the user
312 CT_Test "You did not specify the build system. That's OK, I can guess..." -z "${CT_BUILD}"
313 CT_BUILD="${CT_BUILD:-`CT_DoConfigGuess`}"
314 CT_BUILD=`CT_DoConfigSub "${CT_BUILD}"`
316 # Arrange paths depending on wether we use sys-root or not.
317 if [ "${CT_USE_SYSROOT}" = "y" ]; then
318 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/sys-root"
319 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
320 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
321 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
322 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
324 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
325 # confused when $sysroot/usr/include is not present.
326 # Note: --prefix=/usr is magic!
327 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
329 # plain old way. All libraries in prefix/target/lib
330 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
331 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
332 # hack! Always use --with-sysroot for binutils.
333 # binutils 2.14 and later obey it, older binutils ignore it.
334 # Lets you build a working 32->64 bit cross gcc
335 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
336 # Use --with-headers, else final gcc will define disable_glibc while
337 # building libgcc, and you'll have no profiling
338 CC_CORE_SYSROOT_ARG="--without-headers"
339 CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
340 LIBC_SYSROOT_ARG="prefix="
343 # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
344 # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail with
345 # "ld: cannot open crti.o: No such file or directory"
346 mkdir -p "${CT_SYSROOT_DIR}/lib"
347 mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
349 # Canadian-cross are really picky on the way they are built. Tweak the values.
350 CT_UNIQ_BUILD=`echo "${CT_BUILD}" |sed -r -e 's/-/-build_/'`
351 if [ "${CT_CANADIAN}" = "y" ]; then
352 # Arrange so that gcc never, ever think that build system == host system
353 CT_CANADIAN_OPT="--build=${CT_UNIQ_BUILD}"
354 # We shall have a compiler for this target!
357 CT_HOST="${CT_BUILD}"
358 CT_CANADIAN_OPT="--build=${CT_BUILD}"
359 # Add the target toolchain in the path so that we can build the C library
360 # Carefully add paths in the order we want them:
361 # - first try in ${CT_PREFIX_DIR}/bin
362 # - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
363 # - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
364 # - fall back to searching user's PATH
365 export PATH="${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}"
368 # Modify GCC_HOST to never be equal to $BUILD or $TARGET
369 # This strange operation causes gcc to always generate a cross-compiler
370 # even if the build machine is the same kind as the host.
371 # This is why CC has to be set when doing a canadian cross; you can't find a
372 # host compiler by appending -gcc to our whacky $GCC_HOST
373 # Kludge: it is reported that the above causes canadian crosses with cygwin
374 # hosts to fail, so avoid it just in that one case. It would be cleaner to
375 # just move this into the non-canadian case above, but I'm afraid that might
376 # cause some configure script somewhere to decide that since build==host, they
377 # could run host binaries.
378 # (Copied almost as-is from original crosstool):
379 case "${CT_KERNEL},${CT_CANADIAN}" in
381 *,y) CT_HOST="`echo \"${CT_HOST}\" |sed -r -e 's/-/-host_/;'`";;
384 # Ah! Recent versions of binutils need some of the build and/or host system
385 # (read CT_BUILD and CT_HOST) tools to be accessible (ar is but an example).
387 CT_DoLog DEBUG "Making build system tools available"
388 mkdir -p "${CT_PREFIX_DIR}/bin"
389 for tool in ar as dlltool gcc g++ gnatbind gnatmake ld nm ranlib strip windres objcopy objdump; do
390 tmp=`CT_Which ${tool}`
391 if [ -n "${tmp}" ]; then
392 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_BUILD}-${tool}"
393 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_UNIQ_BUILD}-${tool}"
394 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_HOST}-${tool}"
400 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST="${CT_CFLAGS_FOR_HOST} -pipe"
402 # Override the configured jobs with what's been given on the command line
403 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
405 # And help make go faster
407 [ ${CT_PARALLEL_JOBS} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -j${CT_PARALLEL_JOBS}"
408 [ ${CT_LOAD} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -l${CT_LOAD}"
410 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
411 CT_DoLog EXTRA "Building a toolchain for:"
412 CT_DoLog EXTRA " build = ${CT_BUILD}"
413 CT_DoLog EXTRA " host = ${CT_HOST}"
414 CT_DoLog EXTRA " target = ${CT_TARGET}"
415 set |egrep '^CT_.+=' |sort |CT_DoLog DEBUG
419 # Include sub-scripts instead of calling them: that way, we do not have to
420 # export any variable, nor re-parse the configuration and functions files.
421 . "${CT_LIB_DIR}/scripts/build/kernel_${CT_KERNEL}.sh"
422 . "${CT_LIB_DIR}/scripts/build/gmp.sh"
423 . "${CT_LIB_DIR}/scripts/build/mpfr.sh"
424 . "${CT_LIB_DIR}/scripts/build/binutils.sh"
425 . "${CT_LIB_DIR}/scripts/build/libc_${CT_LIBC}.sh"
426 . "${CT_LIB_DIR}/scripts/build/cc_${CT_CC}.sh"
427 . "${CT_LIB_DIR}/scripts/build/debug.sh"
428 . "${CT_LIB_DIR}/scripts/build/tools.sh"
430 if [ -z "${CT_RESTART}" ]; then
431 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
442 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
443 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
444 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
445 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1
447 CT_DoStep INFO "Extracting and patching toolchain components"
460 # Now for the job by itself. Go have a coffee!
461 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
462 # Because of CT_RESTART, this becomes quite complex
465 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
466 # Aha! CT_STEPS comes from steps.mk!
467 for step in ${CT_STEPS}; do
468 if [ ${do_it} -eq 0 ]; then
469 if [ "${CT_RESTART}" = "${step}" ]; then
470 CT_DoLoadState "${step}"
475 CT_DoSaveState ${step}
476 if [ ${do_stop} -eq 1 ]; then
477 CT_DoLog ERROR "Stopping just after step \"${prev_step}\", as requested."
481 if [ ${do_it} -eq 1 ]; then
483 if [ "${CT_STOP}" = "${step}" ]; then
486 if [ "${CTDEBUG_CT_PAUSE_STEPS}" = "y" ]; then
487 CT_DoPause "Step \"${step}\" finished"
493 CT_DoLog DEBUG "Removing access to the build system tools"
494 find "${CT_PREFIX_DIR}/bin" -name "${CT_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
495 find "${CT_PREFIX_DIR}/bin" -name "${CT_UNIQ_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
496 find "${CT_PREFIX_DIR}/bin" -name "${CT_HOST}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
498 # Install the /populator/
499 CT_DoLog EXTRA "Installing the populate helper"
500 sed -r -e 's,@@CT_READELF@@,'"${CT_PREFIX_DIR}/bin/${CT_TARGET}-readelf"',g;' \
501 -e 's,@@CT_SYSROOT_DIR@@,'"${CT_SYSROOT_DIR}"',g;' \
502 "${CT_LIB_DIR}/tools/populate.in" >"${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
503 chmod 755 "${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
505 # Create the aliases to the target tools
506 CT_DoStep EXTRA "Creating toolchain aliases"
507 CT_Pushd "${CT_PREFIX_DIR}/bin"
508 for t in "${CT_TARGET}-"*; do
509 if [ -n "${CT_TARGET_ALIAS}" ]; then
510 _t="`echo \"$t\" |sed -r -e 's/^'\"${CT_TARGET}\"'-/'\"${CT_TARGET_ALIAS}\"'-/;'`"
511 CT_DoLog DEBUG "Linking \"${_t}\" -> \"${t}\""
512 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
514 if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
515 _t="`echo \"$t\" |sed -r -e \"${CT_TARGET_ALIAS_SED_EXPR}\"`"
516 CT_DoLog DEBUG "Linking \"${_t}\" -> \"${t}\""
517 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
523 # Remove the generated documentation files
524 if [ "${CT_REMOVE_DOCS}" = "y" ]; then
525 CT_DoLog INFO "Removing installed documentation"
526 rm -rf "${CT_PREFIX_DIR}/"{,usr/}{man,info}
527 rm -rf "${CT_SYSROOT_DIR}/"{,usr/}{man,info}
528 rm -rf "${CT_DEBUG_INSTALL_DIR}/"{,usr/}{man,info}
534 if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
535 CT_DoLog EXTRA "Compressing log file"
537 bzip2 -9 "${CT_LOG_FILE}"
540 if [ "${CT_INSTALL_DIR_RO}" = "y" ]; then
541 # OK, now we're done, set the toolchain read-only
542 # Don't log, the log file may become read-only any moment...
543 chmod -R a-w "${CT_INSTALL_DIR}" >/dev/null 2>&1