Bart De VOS pointed out that removing absolute paths from the libc linker scripts is plainly wrong.
It dates from dawn ages of the original crosstool code, and is not well explained. At that time, binutils might not understand the sysroot stuff, and it was necessary to remove absolute paths in that case.
/trunk/scripts/build/libc/glibc.sh | 14 2 12 0 ++------------
1 file changed, 2 insertions(+), 12 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 CT_DoExecLog DEBUG renice ${CT_NICE} $$
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}"
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
70 # target CFLAGS. Do the same for LDFLAGS in case it happens in the future.
71 # Put user-supplied flags at the end, so that they take precedence.
72 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
73 CT_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_TARGET_LDFLAGS}"
74 CT_CC_CORE_EXTRA_CONFIG="${CT_ARCH_CC_CORE_EXTRA_CONFIG} ${CT_CC_CORE_EXTRA_CONFIG}"
75 CT_CC_EXTRA_CONFIG="${CT_ARCH_CC_EXTRA_CONFIG} ${CT_CC_EXTRA_CONFIG}"
77 # Now, build up the variables from the user-configured options.
78 CT_KERNEL_FILE="${CT_KERNEL}-${CT_KERNEL_VERSION}"
79 CT_BINUTILS_FILE="binutils-${CT_BINUTILS_VERSION}"
80 CT_GMP_FILE="gmp-${CT_GMP_VERSION}"
81 CT_MPFR_FILE="mpfr-${CT_MPFR_VERSION}"
82 CT_CC_FILE="${CT_CC}-${CT_CC_VERSION}"
83 CT_LIBC_FILE="${CT_LIBC}-${CT_LIBC_VERSION}"
86 : "${CT_WORK_DIR:=${CT_TOP_DIR}/targets}"
87 CT_TARBALLS_DIR="${CT_WORK_DIR}/tarballs"
88 CT_SRC_DIR="${CT_WORK_DIR}/src"
89 CT_BUILD_DIR="${CT_WORK_DIR}/${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_WORK_DIR}/${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 if [ -n "${CT_LOCAL_TARBALLS_DIR}" ]; then
107 # Make absolute path, it so much easier!
108 CT_LOCAL_TARBALLS_DIR=$(CT_MakeAbsolutePath "${CT_LOCAL_TARBALLS_DIR}")
111 # If the local tarball directory does not exist, say so, and don't try to save there!
112 if [ ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
113 CT_DoLog WARN "Directory '${CT_LOCAL_TARBALLS_DIR}' does not exist. Will not save downloaded tarballs to local storage."
117 # Some more sanity checks now that we have all paths set up
118 case "${CT_LOCAL_TARBALLS_DIR},${CT_TARBALLS_DIR},${CT_SRC_DIR},${CT_BUILD_DIR},${CT_PREFIX_DIR},${CT_INSTALL_DIR}" in
119 *" "*) CT_Abort "Don't use spaces in paths, it breaks things.";;
122 # Check now if we can write to the destination directory:
123 if [ -d "${CT_INSTALL_DIR}" ]; then
124 CT_TestAndAbort "Destination directory '${CT_INSTALL_DIR}' is not removable" ! -w $(dirname "${CT_INSTALL_DIR}")
127 # Good, now grab a bit of informations on the system we're being run on,
128 # just in case something goes awok, and it's not our fault:
129 CT_SYS_USER=$(id -un)
130 CT_SYS_HOSTNAME=$(hostname -f 2>/dev/null || true)
131 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
132 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-$(uname -n)}"
133 CT_SYS_KERNEL=$(uname -s)
134 CT_SYS_REVISION=$(uname -r)
135 # MacOS X lacks '-o' :
136 CT_SYS_OS=$(uname -o || echo "Unknown (maybe MacOS-X)")
137 CT_SYS_MACHINE=$(uname -m)
138 CT_SYS_PROCESSOR=$(uname -p)
139 CT_SYS_GCC=$(gcc -dumpversion)
140 CT_SYS_TARGET=$(CT_DoConfigGuess)
141 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
143 CT_DoLog EXTRA "Preparing working directories"
145 # Ah! The build directory shall be eradicated, even if we restart!
146 if [ -d "${CT_BUILD_DIR}" ]; then
147 mv "${CT_BUILD_DIR}" "${CT_BUILD_DIR}.$$"
148 chmod -R u+w "${CT_BUILD_DIR}.$$"
149 setsid nohup rm -rf "${CT_BUILD_DIR}.$$" >/dev/null 2>&1 &
152 # Don't eradicate directories if we need to restart
153 if [ -z "${CT_RESTART}" ]; then
154 # Get rid of pre-existing installed toolchain and previous build directories.
155 # We need to do that _before_ we can safely log, because the log file will
156 # most probably be in the toolchain directory.
157 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
158 mv "${CT_TARBALLS_DIR}" "${CT_TARBALLS_DIR}.$$"
159 chmod -R u+w "${CT_TARBALLS_DIR}.$$"
160 setsid nohup rm -rf "${CT_TARBALLS_DIR}.$$" >/dev/null 2>&1 &
162 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
163 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
164 chmod -R u+w "${CT_SRC_DIR}.$$"
165 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1 &
167 if [ -d "${CT_INSTALL_DIR}" ]; then
168 mv "${CT_INSTALL_DIR}" "${CT_INSTALL_DIR}.$$"
169 chmod -R u+w "${CT_INSTALL_DIR}.$$"
170 setsid nohup rm -rf "${CT_INSTALL_DIR}.$$" >/dev/null 2>&1 &
172 if [ -d "${CT_DEBUG_INSTALL_DIR}" ]; then
173 mv "${CT_DEBUG_INSTALL_DIR}" "${CT_DEBUG_INSTALL_DIR}.$$"
174 chmod -R u+w "${CT_DEBUG_INSTALL_DIR}.$$"
175 setsid nohup rm -rf "${CT_DEBUG_INSTALL_DIR}.$$" >/dev/null 2>&1 &
177 # In case we start anew, get rid of the previously saved state directory
178 if [ -d "${CT_STATE_DIR}" ]; then
179 mv "${CT_STATE_DIR}" "${CT_STATE_DIR}.$$"
180 chmod -R u+w "${CT_STATE_DIR}.$$"
181 setsid nohup rm -rf "${CT_STATE_DIR}.$$" >/dev/null 2>&1 &
185 # Create the directories we'll use, even if restarting: it does no harm to
186 # create already existent directories, and CT_BUILD_DIR needs to be created
188 mkdir -p "${CT_TARBALLS_DIR}"
189 mkdir -p "${CT_SRC_DIR}"
190 mkdir -p "${CT_BUILD_DIR}"
191 mkdir -p "${CT_INSTALL_DIR}"
192 mkdir -p "${CT_PREFIX_DIR}"
193 mkdir -p "${CT_DEBUG_INSTALL_DIR}"
194 mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
195 mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
196 mkdir -p "${CT_STATE_DIR}"
198 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
199 # the previous build was successful. To be able to move the logfile there,
200 # switch them back to read/write
201 chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
203 # Redirect log to the actual log file now we can
204 # It's quite understandable that the log file will be installed in the install
205 # directory, so we must first ensure it exists and is writeable (above) before
208 case "${CT_LOG_TO_FILE}" in
209 y) CT_LOG_FILE="${CT_PREFIX_DIR}/build.log"
210 cat "${tmp_log_file}" >>"${CT_LOG_FILE}"
211 rm -f "${tmp_log_file}"
212 exec >>"${CT_LOG_FILE}"
214 *) rm -f "${tmp_log_file}"
218 # Setting up the rest of the environment only if not restarting
219 if [ -z "${CT_RESTART}" ]; then
220 # Determine build system if not set by the user
221 CT_Test "You did not specify the build system. That's OK, I can guess..." -z "${CT_BUILD}"
222 CT_BUILD="${CT_BUILD:-$(CT_DoConfigGuess)}"
223 CT_BUILD=$(CT_DoConfigSub "${CT_BUILD}")
225 # Arrange paths depending on wether we use sys-root or not.
226 if [ "${CT_USE_SYSROOT}" = "y" ]; then
227 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/sys-root"
228 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
229 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
230 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
231 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
233 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
234 # confused when $sysroot/usr/include is not present.
235 # Note: --prefix=/usr is magic!
236 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
238 # plain old way. All libraries in prefix/target/lib
239 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
240 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
241 # hack! Always use --with-sysroot for binutils.
242 # binutils 2.14 and later obey it, older binutils ignore it.
243 # Lets you build a working 32->64 bit cross gcc
244 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
245 # Use --with-headers, else final gcc will define disable_glibc while
246 # building libgcc, and you'll have no profiling
247 CC_CORE_SYSROOT_ARG="--without-headers"
248 CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
249 LIBC_SYSROOT_ARG="prefix="
252 # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
253 # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail with
254 # "ld: cannot open crti.o: No such file or directory"
255 mkdir -p "${CT_SYSROOT_DIR}/lib"
256 mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
258 # Prevent gcc from installing its libraries outside of the sys-root
259 ln -sf "sys-root/lib" "${CT_PREFIX_DIR}/${CT_TARGET}/lib"
261 # Now, in case we're 64 bits, just have lib64/ be a symlink to lib/
262 # so as to have all libraries in the same directory (we can do that
263 # because we are *not* multilib).
264 case "${CT_TARGET}" in
265 powerpc64*|ppc64*|x86_64*)
266 ln -sf "lib" "${CT_SYSROOT_DIR}/lib64"
267 ln -sf "lib" "${CT_SYSROOT_DIR}/usr/lib64"
268 ln -sf "sys-root/lib" "${CT_PREFIX_DIR}/${CT_TARGET}/lib64"
272 # Canadian-cross are really picky on the way they are built. Tweak the values.
273 CT_UNIQ_BUILD=$(echo "${CT_BUILD}" |sed -r -e 's/-/-build_/')
274 if [ "${CT_CANADIAN}" = "y" ]; then
275 # Arrange so that gcc never, ever think that build system == host system
276 CT_CANADIAN_OPT="--build=${CT_UNIQ_BUILD}"
277 # We shall have a compiler for this target!
280 CT_HOST="${CT_BUILD}"
281 CT_CANADIAN_OPT="--build=${CT_BUILD}"
282 # Add the target toolchain in the path so that we can build the C library
283 # Carefully add paths in the order we want them:
284 # - first try in ${CT_PREFIX_DIR}/bin
285 # - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
286 # - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
287 # - fall back to searching user's PATH
288 export PATH="${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}"
291 # Modify GCC_HOST to never be equal to $BUILD or $TARGET
292 # This strange operation causes gcc to always generate a cross-compiler
293 # even if the build machine is the same kind as the host.
294 # This is why CC has to be set when doing a canadian cross; you can't find a
295 # host compiler by appending -gcc to our whacky $GCC_HOST
296 # Kludge: it is reported that the above causes canadian crosses with cygwin
297 # hosts to fail, so avoid it just in that one case. It would be cleaner to
298 # just move this into the non-canadian case above, but I'm afraid that might
299 # cause some configure script somewhere to decide that since build==host, they
300 # could run host binaries.
301 # (Copied almost as-is from original crosstool):
302 case "${CT_KERNEL},${CT_CANADIAN}" in
304 *,y) CT_HOST=$(echo "${CT_HOST}" |sed -r -e 's/-/-host_/;');;
307 # Ah! Recent versions of binutils need some of the build and/or host system
308 # (read CT_BUILD and CT_HOST) tools to be accessible (ar is but an example).
310 CT_DoLog DEBUG "Making build system tools available"
311 mkdir -p "${CT_PREFIX_DIR}/bin"
312 for tool in ar as dlltool ${CT_CC_NATIVE:=gcc} gnatbind gnatmake ld nm ranlib strip windres objcopy objdump; do
313 tmp=$(CT_Which ${tool})
314 if [ -n "${tmp}" ]; then
315 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_BUILD}-${tool}"
316 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_UNIQ_BUILD}-${tool}"
317 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_HOST}-${tool}"
321 # Some makeinfo versions are a pain in [put your most sensible body part here].
322 # Go ahead with those, by creating a wrapper that keeps partial files, and that
324 echo -e "#!/bin/sh\n$(CT_Which makeinfo) --force \"\${@}\"\ntrue" >"${CT_PREFIX_DIR}/bin/makeinfo"
325 chmod 700 "${CT_PREFIX_DIR}/bin/makeinfo"
329 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST="${CT_CFLAGS_FOR_HOST} -pipe"
331 # Override the configured jobs with what's been given on the command line
332 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
334 # Help ./configure scripts go faster
335 [ "${CT_CONFIG_SHELL_ASH}" = "y" ] && export CONFIG_SHELL=/bin/ash
338 # And help make go faster
340 [ ${CT_PARALLEL_JOBS} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -j${CT_PARALLEL_JOBS}"
341 [ ${CT_LOAD} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -l${CT_LOAD}"
342 export PARALLELMFLAGS
344 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
345 CT_DoLog EXTRA "Building a toolchain for:"
346 CT_DoLog EXTRA " build = ${CT_BUILD}"
347 CT_DoLog EXTRA " host = ${CT_HOST}"
348 CT_DoLog EXTRA " target = ${CT_TARGET}"
349 set |egrep '^CT_.+=' |sort |CT_DoLog DEBUG
353 # Include sub-scripts instead of calling them: that way, we do not have to
354 # export any variable, nor re-parse the configuration and functions files.
355 . "${CT_LIB_DIR}/scripts/build/kernel/${CT_KERNEL}.sh"
356 . "${CT_LIB_DIR}/scripts/build/gmp.sh"
357 . "${CT_LIB_DIR}/scripts/build/mpfr.sh"
358 . "${CT_LIB_DIR}/scripts/build/binutils.sh"
359 . "${CT_LIB_DIR}/scripts/build/libc/${CT_LIBC}.sh"
360 . "${CT_LIB_DIR}/scripts/build/cc/${CT_CC}.sh"
361 . "${CT_LIB_DIR}/scripts/build/debug.sh"
362 . "${CT_LIB_DIR}/scripts/build/tools.sh"
364 if [ -z "${CT_RESTART}" ]; then
365 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
376 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
377 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
378 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.force.$$"
379 setsid nohup rm -rf "${CT_SRC_DIR}.force.$$" >/dev/null 2>&1
380 mkdir -p "${CT_SRC_DIR}"
382 CT_DoStep INFO "Extracting and patching toolchain components"
395 # Now for the job by itself. Go have a coffee!
396 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
397 # Because of CT_RESTART, this becomes quite complex
400 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
401 # Aha! CT_STEPS comes from steps.mk!
402 for step in ${CT_STEPS}; do
403 if [ ${do_it} -eq 0 ]; then
404 if [ "${CT_RESTART}" = "${step}" ]; then
405 CT_DoLoadState "${step}"
410 CT_DoSaveState ${step}
411 if [ ${do_stop} -eq 1 ]; then
412 CT_DoLog ERROR "Stopping just after step '${prev_step}', as requested."
416 if [ ${do_it} -eq 1 ]; then
418 if [ "${CT_STOP}" = "${step}" ]; then
421 if [ "${CT_DEBUG_PAUSE_STEPS}" = "y" ]; then
422 CT_DoPause "Step '${step}' finished"
428 CT_DoLog INFO "================================================================="
430 CT_DoLog DEBUG "Removing access to the build system tools"
431 find "${CT_PREFIX_DIR}/bin" -name "${CT_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
432 find "${CT_PREFIX_DIR}/bin" -name "${CT_UNIQ_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
433 find "${CT_PREFIX_DIR}/bin" -name "${CT_HOST}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
434 rm -fv "${CT_PREFIX_DIR}/bin/makeinfo" |CT_DoLog DEBUG
436 if [ "${CT_BARE_METAL}" != "y" ]; then
437 CT_DoLog EXTRA "Installing the populate helper"
438 sed -r -e 's|@@CT_TARGET@@|'"${CT_TARGET}"'|g;' \
439 "${CT_LIB_DIR}/tools/populate.in" \
440 >"${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
441 chmod 755 "${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
444 # Create the aliases to the target tools
445 CT_DoLog EXTRA "Creating toolchain aliases"
446 CT_Pushd "${CT_PREFIX_DIR}/bin"
447 for t in "${CT_TARGET}-"*; do
448 if [ -n "${CT_TARGET_ALIAS}" ]; then
449 _t=$(echo "$t" |sed -r -e 's/^'"${CT_TARGET}"'-/'"${CT_TARGET_ALIAS}"'-/;')
450 ln -sv "${t}" "${_t}" 2>&1
452 if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
453 _t=$(echo "$t" |sed -r -e "${CT_TARGET_ALIAS_SED_EXPR}")
454 ln -sv "${t}" "${_t}" 2>&1
459 # Remove the generated documentation files
460 if [ "${CT_REMOVE_DOCS}" = "y" ]; then
461 CT_DoLog INFO "Removing installed documentation"
462 rm -rf "${CT_PREFIX_DIR}/"{,usr/}{man,info}
463 rm -rf "${CT_SYSROOT_DIR}/"{,usr/}{man,info}
464 rm -rf "${CT_DEBUG_INSTALL_DIR}/"{,usr/}{man,info}
470 if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
471 CT_DoLog EXTRA "Compressing log file"
473 bzip2 -9 "${CT_LOG_FILE}"
476 if [ "${CT_INSTALL_DIR_RO}" = "y" ]; then
477 # OK, now we're done, set the toolchain read-only
478 # Don't log, the log file may become read-only any moment...
479 chmod -R a-w "${CT_INSTALL_DIR}" >/dev/null 2>&1