Introduce target-specific LDFLAGS, the same way we have CFLAGS for the target.
It seems to be helping gcc somewhat into telling the correct endianness to ld that sticks with little endian even when the target is big (eg armeb-unknown-linux-uclibcgnueabi).
There's still work to do, especially finish the gcc part that is not in this commit.
/trunk/scripts/functions | 9 7 2 0 +++++++--
1 file changed, 7 insertions(+), 2 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
76 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
78 # Now, build up the variables from the user-configured options.
79 CT_KERNEL_FILE="${CT_KERNEL}-${CT_KERNEL_VERSION}"
80 CT_BINUTILS_FILE="binutils-${CT_BINUTILS_VERSION}"
81 CT_GMP_FILE="gmp-${CT_GMP_VERSION}"
82 CT_MPFR_FILE="mpfr-${CT_MPFR_VERSION}"
83 CT_CC_FILE="${CT_CC}-${CT_CC_VERSION}"
84 CT_LIBC_FILE="${CT_LIBC}-${CT_LIBC_VERSION}"
87 CT_TARBALLS_DIR="${CT_TOP_DIR}/targets/tarballs"
88 CT_SRC_DIR="${CT_TOP_DIR}/targets/src"
89 CT_BUILD_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/build"
90 CT_DEBUG_INSTALL_DIR="${CT_INSTALL_DIR}/${CT_TARGET}/debug-root"
91 # Note: we'll always install the core compiler in its own directory, so as to
92 # not mix the two builds: core and final.
93 CT_CC_CORE_STATIC_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-static"
94 CT_CC_CORE_SHARED_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-shared"
95 CT_STATE_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/state"
97 # We must ensure that we can restart if asked for!
98 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}" ]; then
99 CT_DoLog ERROR "You asked to restart a non-restartable build"
100 CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
101 CT_DoLog ERROR "in the config options for the previous build, or the state"
102 CT_DoLog ERROR "directory for the previous build was deleted."
103 CT_Abort "I will stop here to avoid any carnage"
106 # Make all path absolute, it so much easier!
107 CT_LOCAL_TARBALLS_DIR=$(CT_MakeAbsolutePath "${CT_LOCAL_TARBALLS_DIR}")
109 # If the local tarball directory does not exist, say so, and don't try to save there!
110 if [ ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
111 CT_DoLog WARN "Directory '${CT_LOCAL_TARBALLS_DIR}' does not exist. Will not save downloaded tarballs to local storage."
115 # Some more sanity checks now that we have all paths set up
116 case "${CT_LOCAL_TARBALLS_DIR},${CT_TARBALLS_DIR},${CT_SRC_DIR},${CT_BUILD_DIR},${CT_PREFIX_DIR},${CT_INSTALL_DIR}" in
117 *" "*) CT_Abort "Don't use spaces in paths, it breaks things.";;
120 # Check now if we can write to the destination directory:
121 if [ -d "${CT_INSTALL_DIR}" ]; then
122 CT_TestAndAbort "Destination directory '${CT_INSTALL_DIR}' is not removable" ! -w $(dirname "${CT_INSTALL_DIR}")
125 # Good, now grab a bit of informations on the system we're being run on,
126 # just in case something goes awok, and it's not our fault:
127 CT_SYS_USER=$(id -un)
128 CT_SYS_HOSTNAME=$(hostname -f 2>/dev/null || true)
129 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
130 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-$(uname -n)}"
131 CT_SYS_KERNEL=$(uname -s)
132 CT_SYS_REVISION=$(uname -r)
133 # MacOS X lacks '-o' :
134 CT_SYS_OS=$(uname -o || echo "Unknown (maybe MacOS-X)")
135 CT_SYS_MACHINE=$(uname -m)
136 CT_SYS_PROCESSOR=$(uname -p)
137 CT_SYS_GCC=$(gcc -dumpversion)
138 CT_SYS_TARGET=$(CT_DoConfigGuess)
139 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
141 CT_DoLog EXTRA "Preparing working directories"
143 # Ah! The build directory shall be eradicated, even if we restart!
144 if [ -d "${CT_BUILD_DIR}" ]; then
145 mv "${CT_BUILD_DIR}" "${CT_BUILD_DIR}.$$"
146 chmod -R u+w "${CT_BUILD_DIR}.$$"
147 setsid nohup rm -rf "${CT_BUILD_DIR}.$$" >/dev/null 2>&1 &
150 # Don't eradicate directories if we need to restart
151 if [ -z "${CT_RESTART}" ]; then
152 # Get rid of pre-existing installed toolchain and previous build directories.
153 # We need to do that _before_ we can safely log, because the log file will
154 # most probably be in the toolchain directory.
155 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
156 mv "${CT_TARBALLS_DIR}" "${CT_TARBALLS_DIR}.$$"
157 chmod -R u+w "${CT_TARBALLS_DIR}.$$"
158 setsid nohup rm -rf "${CT_TARBALLS_DIR}.$$" >/dev/null 2>&1 &
160 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
161 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
162 chmod -R u+w "${CT_SRC_DIR}.$$"
163 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1 &
165 if [ -d "${CT_INSTALL_DIR}" ]; then
166 mv "${CT_INSTALL_DIR}" "${CT_INSTALL_DIR}.$$"
167 chmod -R u+w "${CT_INSTALL_DIR}.$$"
168 setsid nohup rm -rf "${CT_INSTALL_DIR}.$$" >/dev/null 2>&1 &
170 if [ -d "${CT_DEBUG_INSTALL_DIR}" ]; then
171 mv "${CT_DEBUG_INSTALL_DIR}" "${CT_DEBUG_INSTALL_DIR}.$$"
172 chmod -R u+w "${CT_DEBUG_INSTALL_DIR}.$$"
173 setsid nohup rm -rf "${CT_DEBUG_INSTALL_DIR}.$$" >/dev/null 2>&1 &
175 # In case we start anew, get rid of the previously saved state directory
176 if [ -d "${CT_STATE_DIR}" ]; then
177 mv "${CT_STATE_DIR}" "${CT_STATE_DIR}.$$"
178 chmod -R u+w "${CT_STATE_DIR}.$$"
179 setsid nohup rm -rf "${CT_STATE_DIR}.$$" >/dev/null 2>&1 &
183 # Create the directories we'll use, even if restarting: it does no harm to
184 # create already existent directories, and CT_BUILD_DIR needs to be created
186 mkdir -p "${CT_TARBALLS_DIR}"
187 mkdir -p "${CT_SRC_DIR}"
188 mkdir -p "${CT_BUILD_DIR}"
189 mkdir -p "${CT_INSTALL_DIR}"
190 mkdir -p "${CT_PREFIX_DIR}"
191 mkdir -p "${CT_DEBUG_INSTALL_DIR}"
192 mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
193 mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
194 mkdir -p "${CT_STATE_DIR}"
196 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
197 # the previous build was successful. To be able to move the logfile there,
198 # switch them back to read/write
199 chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
201 # Redirect log to the actual log file now we can
202 # It's quite understandable that the log file will be installed in the install
203 # directory, so we must first ensure it exists and is writeable (above) before
206 case "${CT_LOG_TO_FILE}" in
207 y) CT_LOG_FILE="${CT_PREFIX_DIR}/build.log"
208 cat "${tmp_log_file}" >>"${CT_LOG_FILE}"
209 rm -f "${tmp_log_file}"
210 exec >>"${CT_LOG_FILE}"
212 *) rm -f "${tmp_log_file}"
216 # Set environment for proxy access
217 # This has to be done even if we are restarting, as they don't get
218 # saved in the step snapshot.
219 case "${CT_PROXY_TYPE}" in
223 case "${CT_PROXY_USER}:${CT_PROXY_PASS}" in
225 :*) http_proxy="${http_proxy}:${CT_PROXY_PASS}@";;
226 *:) http_proxy="${http_proxy}${CT_PROXY_USER}@";;
227 *:*) http_proxy="${http_proxy}${CT_PROXY_USER}:${CT_PROXY_PASS}@";;
229 export http_proxy="${http_proxy}${CT_PROXY_HOST}:${CT_PROXY_PORT}/"
230 export https_proxy="${http_proxy}"
231 export ftp_proxy="${http_proxy}"
232 CT_DoLog DEBUG "http_proxy='${http_proxy}'"
236 # Force not using HTTP proxy
237 unset http_proxy ftp_proxy https_proxy
242 # Force not using HTTP proxy
243 unset http_proxy ftp_proxy https_proxy
244 # Remove any lingering config file from any previous run
245 rm -f "${CT_BUILD_DIR}/tsocks.conf"
246 # Find all interfaces and build locally accessible networks
247 server_ip=$(ping -c 1 -W 2 "${CT_PROXY_HOST}" |head -n 1 |sed -r -e 's/^[^\(]+\(([^\)]+)\).*$/\1/;' || true)
248 CT_TestOrAbort "SOCKS proxy '${CT_PROXY_HOST}' has no IP." -n "${server_ip}"
249 /sbin/ifconfig |gawk -v server_ip="${server_ip}" '
251 split( server_ip, tmp, "\\." );
252 server_ip_num = tmp[1] * 2^24 + tmp[2] * 2^16 + tmp[3] * 2^8 + tmp[4] * 2^0;
256 $0 ~ /^[[:space:]]*inet addr:/ {
257 split( $2, tmp, ":|\\." );
258 if( ( tmp[2] == 127 ) && ( tmp[3] == 0 ) && ( tmp[4] == 0 ) && ( tmp[5] == 1 ) ) {
259 /* Skip 127.0.0.1, it'\''s taken care of by tsocks itself */
262 ip_num = tmp[2] * 2^24 + tmp[3] * 2^16 + tmp[4] * 2 ^8 + tmp[5] * 2^0;
267 } while( (i!=0) && ( and( server_ip_num, mask ) == and( ip_num, mask ) ) );
268 mask = and( 0xFFFFFFFF, lshift( mask, 1 ) );
269 if( (i!=0) && (mask!=0) ) {
270 masked_ip = and( ip_num, mask );
271 for( i=0; i<pairs; i++ ) {
272 if( ( masked_ip == ips[i] ) && ( mask == masks[i] ) ) {
276 ips[pairs] = masked_ip;
279 printf( "local = %d.%d.%d.%d/%d.%d.%d.%d\n",
280 and( 0xFF, masked_ip / 2^24 ),
281 and( 0xFF, masked_ip / 2^16 ),
282 and( 0xFF, masked_ip / 2^8 ),
283 and( 0xFF, masked_ip / 2^0 ),
284 and( 0xFF, mask / 2^24 ),
285 and( 0xFF, mask / 2^16 ),
286 and( 0xFF, mask / 2^8 ),
287 and( 0xFF, mask / 2^0 ) );
290 ' >"${CT_BUILD_DIR}/tsocks.conf"
291 ( echo "server = ${server_ip}";
292 echo "server_port = ${CT_PROXY_PORT}";
293 [ -n "${CT_PROXY_USER}" ] && echo "default_user=${CT_PROXY_USER}";
294 [ -n "${CT_PROXY_PASS}" ] && echo "default_pass=${CT_PROXY_PASS}";
295 ) >>"${CT_BUILD_DIR}/tsocks.conf"
296 case "${CT_PROXY_TYPE/socks}" in
297 4|5) proxy_type="${CT_PROXY_TYPE/socks}";;
299 reply=$(inspectsocks "${server_ip}" "${CT_PROXY_PORT}" 2>&1 || true)
301 *"server is a version 4 socks server") proxy_type=4;;
302 *"server is a version 5 socks server") proxy_type=5;;
303 *) CT_Abort "Unable to determine SOCKS proxy type for '${CT_PROXY_HOST}:${CT_PROXY_PORT}'"
307 echo "server_type = ${proxy_type}" >> "${CT_BUILD_DIR}/tsocks.conf"
308 validateconf -f "${CT_BUILD_DIR}/tsocks.conf" 2>&1 |CT_DoLog DEBUG
309 export TSOCKS_CONF_FILE="${CT_BUILD_DIR}/tsocks.conf"
314 # Setting up the rest of the environment only if not restarting
315 if [ -z "${CT_RESTART}" ]; then
316 # Determine build system if not set by the user
317 CT_Test "You did not specify the build system. That's OK, I can guess..." -z "${CT_BUILD}"
318 CT_BUILD="${CT_BUILD:-$(CT_DoConfigGuess)}"
319 CT_BUILD=$(CT_DoConfigSub "${CT_BUILD}")
321 # Arrange paths depending on wether we use sys-root or not.
322 if [ "${CT_USE_SYSROOT}" = "y" ]; then
323 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/sys-root"
324 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
325 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
326 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
327 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
329 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
330 # confused when $sysroot/usr/include is not present.
331 # Note: --prefix=/usr is magic!
332 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
334 # plain old way. All libraries in prefix/target/lib
335 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
336 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
337 # hack! Always use --with-sysroot for binutils.
338 # binutils 2.14 and later obey it, older binutils ignore it.
339 # Lets you build a working 32->64 bit cross gcc
340 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
341 # Use --with-headers, else final gcc will define disable_glibc while
342 # building libgcc, and you'll have no profiling
343 CC_CORE_SYSROOT_ARG="--without-headers"
344 CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
345 LIBC_SYSROOT_ARG="prefix="
348 # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
349 # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail with
350 # "ld: cannot open crti.o: No such file or directory"
351 mkdir -p "${CT_SYSROOT_DIR}/lib"
352 mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
354 # Canadian-cross are really picky on the way they are built. Tweak the values.
355 CT_UNIQ_BUILD=$(echo "${CT_BUILD}" |sed -r -e 's/-/-build_/')
356 if [ "${CT_CANADIAN}" = "y" ]; then
357 # Arrange so that gcc never, ever think that build system == host system
358 CT_CANADIAN_OPT="--build=${CT_UNIQ_BUILD}"
359 # We shall have a compiler for this target!
362 CT_HOST="${CT_BUILD}"
363 CT_CANADIAN_OPT="--build=${CT_BUILD}"
364 # Add the target toolchain in the path so that we can build the C library
365 # Carefully add paths in the order we want them:
366 # - first try in ${CT_PREFIX_DIR}/bin
367 # - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
368 # - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
369 # - fall back to searching user's PATH
370 export PATH="${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}"
373 # Modify GCC_HOST to never be equal to $BUILD or $TARGET
374 # This strange operation causes gcc to always generate a cross-compiler
375 # even if the build machine is the same kind as the host.
376 # This is why CC has to be set when doing a canadian cross; you can't find a
377 # host compiler by appending -gcc to our whacky $GCC_HOST
378 # Kludge: it is reported that the above causes canadian crosses with cygwin
379 # hosts to fail, so avoid it just in that one case. It would be cleaner to
380 # just move this into the non-canadian case above, but I'm afraid that might
381 # cause some configure script somewhere to decide that since build==host, they
382 # could run host binaries.
383 # (Copied almost as-is from original crosstool):
384 case "${CT_KERNEL},${CT_CANADIAN}" in
386 *,y) CT_HOST=$(echo "${CT_HOST}" |sed -r -e 's/-/-host_/;');;
389 # Ah! Recent versions of binutils need some of the build and/or host system
390 # (read CT_BUILD and CT_HOST) tools to be accessible (ar is but an example).
392 CT_DoLog DEBUG "Making build system tools available"
393 mkdir -p "${CT_PREFIX_DIR}/bin"
394 for tool in ar as dlltool ${CT_CC_NATIVE:=gcc} gnatbind gnatmake ld nm ranlib strip windres objcopy objdump; do
395 tmp=$(CT_Which ${tool})
396 if [ -n "${tmp}" ]; then
397 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_BUILD}-${tool}"
398 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_UNIQ_BUILD}-${tool}"
399 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_HOST}-${tool}"
405 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST="${CT_CFLAGS_FOR_HOST} -pipe"
407 # Override the configured jobs with what's been given on the command line
408 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
410 # And help make go faster
412 [ ${CT_PARALLEL_JOBS} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -j${CT_PARALLEL_JOBS}"
413 [ ${CT_LOAD} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -l${CT_LOAD}"
415 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
416 CT_DoLog EXTRA "Building a toolchain for:"
417 CT_DoLog EXTRA " build = ${CT_BUILD}"
418 CT_DoLog EXTRA " host = ${CT_HOST}"
419 CT_DoLog EXTRA " target = ${CT_TARGET}"
420 set |egrep '^CT_.+=' |sort |CT_DoLog DEBUG
424 # Include sub-scripts instead of calling them: that way, we do not have to
425 # export any variable, nor re-parse the configuration and functions files.
426 . "${CT_LIB_DIR}/scripts/build/kernel_${CT_KERNEL}.sh"
427 . "${CT_LIB_DIR}/scripts/build/gmp.sh"
428 . "${CT_LIB_DIR}/scripts/build/mpfr.sh"
429 . "${CT_LIB_DIR}/scripts/build/binutils.sh"
430 . "${CT_LIB_DIR}/scripts/build/libc_${CT_LIBC}.sh"
431 . "${CT_LIB_DIR}/scripts/build/cc_${CT_CC}.sh"
432 . "${CT_LIB_DIR}/scripts/build/debug.sh"
433 . "${CT_LIB_DIR}/scripts/build/tools.sh"
435 if [ -z "${CT_RESTART}" ]; then
436 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
447 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
448 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
449 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.force.$$"
450 setsid nohup rm -rf "${CT_SRC_DIR}.force.$$" >/dev/null 2>&1
451 mkdir -p "${CT_SRC_DIR}"
453 CT_DoStep INFO "Extracting and patching toolchain components"
466 # Now for the job by itself. Go have a coffee!
467 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
468 # Because of CT_RESTART, this becomes quite complex
471 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
472 # Aha! CT_STEPS comes from steps.mk!
473 for step in ${CT_STEPS}; do
474 if [ ${do_it} -eq 0 ]; then
475 if [ "${CT_RESTART}" = "${step}" ]; then
476 CT_DoLoadState "${step}"
481 CT_DoSaveState ${step}
482 if [ ${do_stop} -eq 1 ]; then
483 CT_DoLog ERROR "Stopping just after step '${prev_step}', as requested."
487 if [ ${do_it} -eq 1 ]; then
489 if [ "${CT_STOP}" = "${step}" ]; then
492 if [ "${CTDEBUG_CT_PAUSE_STEPS}" = "y" ]; then
493 CT_DoPause "Step '${step}' finished"
499 CT_DoLog DEBUG "Removing access to the build system tools"
500 find "${CT_PREFIX_DIR}/bin" -name "${CT_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
501 find "${CT_PREFIX_DIR}/bin" -name "${CT_UNIQ_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
502 find "${CT_PREFIX_DIR}/bin" -name "${CT_HOST}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
504 # Install the /populator/
505 CT_DoLog EXTRA "Installing the populate helper"
506 sed -r -e 's,@@CT_READELF@@,'"${CT_PREFIX_DIR}/bin/${CT_TARGET}-readelf"',g;' \
507 -e 's,@@CT_SYSROOT_DIR@@,'"${CT_SYSROOT_DIR}"',g;' \
508 "${CT_LIB_DIR}/tools/populate.in" >"${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
509 chmod 755 "${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
511 # Create the aliases to the target tools
512 CT_DoStep EXTRA "Creating toolchain aliases"
513 CT_Pushd "${CT_PREFIX_DIR}/bin"
514 for t in "${CT_TARGET}-"*; do
515 if [ -n "${CT_TARGET_ALIAS}" ]; then
516 _t=$(echo "$t" |sed -r -e 's/^'"${CT_TARGET}"'-/'"${CT_TARGET_ALIAS}"'-/;')
517 CT_DoLog DEBUG "Linking '${_t}' -> '${t}'"
518 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
520 if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
521 _t=$(echo "$t" |sed -r -e "${CT_TARGET_ALIAS_SED_EXPR}")
522 CT_DoLog DEBUG "Linking '${_t}' -> '${t}'"
523 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
529 # Remove the generated documentation files
530 if [ "${CT_REMOVE_DOCS}" = "y" ]; then
531 CT_DoLog INFO "Removing installed documentation"
532 rm -rf "${CT_PREFIX_DIR}/"{,usr/}{man,info}
533 rm -rf "${CT_SYSROOT_DIR}/"{,usr/}{man,info}
534 rm -rf "${CT_DEBUG_INSTALL_DIR}/"{,usr/}{man,info}
540 if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
541 CT_DoLog EXTRA "Compressing log file"
543 bzip2 -9 "${CT_LOG_FILE}"
546 if [ "${CT_INSTALL_DIR_RO}" = "y" ]; then
547 # OK, now we're done, set the toolchain read-only
548 # Don't log, the log file may become read-only any moment...
549 chmod -R a-w "${CT_INSTALL_DIR}" >/dev/null 2>&1