Robert P. J. DAY says:
apparently, the patchset for gcc 4.2.1 applies properly to the
source for gcc 4.2.2 and gcc 4.2.3. so, if you want, you can simply
add support for those last two just by augmenting menuconfig and
adding a couple symlinks for those two directories. seems like a
cheap way to add a couple new versions.
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_CC_FILE="${CT_CC}-${CT_CC_VERSION}"
77 CT_LIBC_FILE="${CT_LIBC}-${CT_LIBC_VERSION}"
80 CT_TARBALLS_DIR="${CT_TOP_DIR}/targets/tarballs"
81 CT_SRC_DIR="${CT_TOP_DIR}/targets/src"
82 CT_BUILD_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/build"
83 CT_DEBUG_INSTALL_DIR="${CT_INSTALL_DIR}/${CT_TARGET}/debug-root"
84 # Note: we'll always install the core compiler in its own directory, so as to
85 # not mix the two builds: core and final.
86 CT_CC_CORE_STATIC_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-static"
87 CT_CC_CORE_SHARED_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-shared"
88 CT_STATE_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/state"
90 # We must ensure that we can restart if asked for!
91 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}" ]; then
92 CT_DoLog ERROR "You asked to restart a non-restartable build"
93 CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
94 CT_DoLog ERROR "in the config options for the previous build, or the state"
95 CT_DoLog ERROR "directory for the previous build was deleted."
96 CT_Abort "I will stop here to avoid any carnage"
99 # Make all path absolute, it so much easier!
100 CT_LOCAL_TARBALLS_DIR="`CT_MakeAbsolutePath \"${CT_LOCAL_TARBALLS_DIR}\"`"
102 # If the local tarball directory does not exist, say so, and don't try to save there!
103 if [ ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
104 CT_DoLog WARN "Directory \"${CT_LOCAL_TARBALLS_DIR}\" does not exist. Will not save downloaded tarballs to local storage."
108 # Some more sanity checks now that we have all paths set up
109 case "${CT_LOCAL_TARBALLS_DIR},${CT_TARBALLS_DIR},${CT_SRC_DIR},${CT_BUILD_DIR},${CT_PREFIX_DIR},${CT_INSTALL_DIR}" in
110 *" "*) CT_Abort "Don't use spaces in paths, it breaks things.";;
113 # Check now if we can write to the destination directory:
114 if [ -d "${CT_INSTALL_DIR}" ]; then
115 CT_TestAndAbort "Destination directory \"${CT_INSTALL_DIR}\" is not removable" ! -w `dirname "${CT_INSTALL_DIR}"`
118 # Good, now grab a bit of informations on the system we're being run on,
119 # just in case something goes awok, and it's not our fault:
120 CT_SYS_USER="`id -un`"
121 CT_SYS_HOSTNAME=`hostname -f 2>/dev/null || true`
122 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
123 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-`uname -n`}"
124 CT_SYS_KERNEL=`uname -s`
125 CT_SYS_REVISION=`uname -r`
126 # MacOS X lacks '-o' :
127 CT_SYS_OS=`uname -o || echo "Unknown (maybe MacOS-X)"`
128 CT_SYS_MACHINE=`uname -m`
129 CT_SYS_PROCESSOR=`uname -p`
130 CT_SYS_GCC=`gcc -dumpversion`
131 CT_SYS_TARGET=`CT_DoConfigGuess`
132 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
134 CT_DoLog EXTRA "Preparing working directories"
136 # Ah! The build directory shall be eradicated, even if we restart!
137 if [ -d "${CT_BUILD_DIR}" ]; then
138 mv "${CT_BUILD_DIR}" "${CT_BUILD_DIR}.$$"
139 chmod -R u+w "${CT_BUILD_DIR}.$$"
140 setsid nohup rm -rf "${CT_BUILD_DIR}.$$" >/dev/null 2>&1 &
143 # Don't eradicate directories if we need to restart
144 if [ -z "${CT_RESTART}" ]; then
145 # Get rid of pre-existing installed toolchain and previous build directories.
146 # We need to do that _before_ we can safely log, because the log file will
147 # most probably be in the toolchain directory.
148 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
149 mv "${CT_TARBALLS_DIR}" "${CT_TARBALLS_DIR}.$$"
150 chmod -R u+w "${CT_TARBALLS_DIR}.$$"
151 setsid nohup rm -rf "${CT_TARBALLS_DIR}.$$" >/dev/null 2>&1 &
153 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
154 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
155 chmod -R u+w "${CT_SRC_DIR}.$$"
156 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1 &
158 if [ -d "${CT_INSTALL_DIR}" ]; then
159 mv "${CT_INSTALL_DIR}" "${CT_INSTALL_DIR}.$$"
160 chmod -R u+w "${CT_INSTALL_DIR}.$$"
161 setsid nohup rm -rf "${CT_INSTALL_DIR}.$$" >/dev/null 2>&1 &
163 if [ -d "${CT_DEBUG_INSTALL_DIR}" ]; then
164 mv "${CT_DEBUG_INSTALL_DIR}" "${CT_DEBUG_INSTALL_DIR}.$$"
165 chmod -R u+w "${CT_DEBUG_INSTALL_DIR}.$$"
166 setsid nohup rm -rf "${CT_DEBUG_INSTALL_DIR}.$$" >/dev/null 2>&1 &
168 # In case we start anew, get rid of the previously saved state directory
169 if [ -d "${CT_STATE_DIR}" ]; then
170 mv "${CT_STATE_DIR}" "${CT_STATE_DIR}.$$"
171 chmod -R u+w "${CT_STATE_DIR}.$$"
172 setsid nohup rm -rf "${CT_STATE_DIR}.$$" >/dev/null 2>&1 &
176 # Create the directories we'll use, even if restarting: it does no harm to
177 # create already existent directories, and CT_BUILD_DIR needs to be created
179 mkdir -p "${CT_TARBALLS_DIR}"
180 mkdir -p "${CT_SRC_DIR}"
181 mkdir -p "${CT_BUILD_DIR}"
182 mkdir -p "${CT_INSTALL_DIR}"
183 mkdir -p "${CT_PREFIX_DIR}"
184 mkdir -p "${CT_DEBUG_INSTALL_DIR}"
185 mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
186 mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
187 mkdir -p "${CT_STATE_DIR}"
189 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
190 # the previous build was successful. To be able to move the logfile there,
191 # switch them back to read/write
192 chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
194 # Redirect log to the actual log file now we can
195 # It's quite understandable that the log file will be installed in the install
196 # directory, so we must first ensure it exists and is writeable (above) before
199 case "${CT_LOG_TO_FILE}" in
200 y) CT_LOG_FILE="${CT_PREFIX_DIR}/build.log"
201 cat "${tmp_log_file}" >>"${CT_LOG_FILE}"
202 rm -f "${tmp_log_file}"
203 exec >>"${CT_LOG_FILE}"
205 *) rm -f "${tmp_log_file}"
209 # Setting up the rest of the environment only if not restarting
210 if [ -z "${CT_RESTART}" ]; then
211 # Determine build system if not set by the user
212 CT_Test "You did not specify the build system. That's OK, I can guess..." -z "${CT_BUILD}"
213 CT_BUILD="${CT_BUILD:-`CT_DoConfigGuess`}"
214 CT_BUILD=`CT_DoConfigSub "${CT_BUILD}"`
216 # Arrange paths depending on wether we use sys-root or not.
217 if [ "${CT_USE_SYSROOT}" = "y" ]; then
218 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/sys-root"
219 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
220 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
221 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
222 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
224 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
225 # confused when $sysroot/usr/include is not present.
226 # Note: --prefix=/usr is magic!
227 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
229 # plain old way. All libraries in prefix/target/lib
230 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
231 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
232 # hack! Always use --with-sysroot for binutils.
233 # binutils 2.14 and later obey it, older binutils ignore it.
234 # Lets you build a working 32->64 bit cross gcc
235 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
236 # Use --with-headers, else final gcc will define disable_glibc while
237 # building libgcc, and you'll have no profiling
238 CC_CORE_SYSROOT_ARG="--without-headers"
239 CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
240 LIBC_SYSROOT_ARG="prefix="
243 # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
244 # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail with
245 # "ld: cannot open crti.o: No such file or directory"
246 mkdir -p "${CT_SYSROOT_DIR}/lib"
247 mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
249 # Canadian-cross are really picky on the way they are built. Tweak the values.
250 CT_UNIQ_BUILD=`echo "${CT_BUILD}" |sed -r -e 's/-/-build_/'`
251 if [ "${CT_CANADIAN}" = "y" ]; then
252 # Arrange so that gcc never, ever think that build system == host system
253 CT_CANADIAN_OPT="--build=${CT_UNIQ_BUILD}"
254 # We shall have a compiler for this target!
257 CT_HOST="${CT_BUILD}"
258 CT_CANADIAN_OPT="--build=${CT_BUILD}"
259 # Add the target toolchain in the path so that we can build the C library
260 # Carefully add paths in the order we want them:
261 # - first try in ${CT_PREFIX_DIR}/bin
262 # - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
263 # - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
264 # - fall back to searching user's PATH
265 export PATH="${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}"
268 # Modify GCC_HOST to never be equal to $BUILD or $TARGET
269 # This strange operation causes gcc to always generate a cross-compiler
270 # even if the build machine is the same kind as the host.
271 # This is why CC has to be set when doing a canadian cross; you can't find a
272 # host compiler by appending -gcc to our whacky $GCC_HOST
273 # Kludge: it is reported that the above causes canadian crosses with cygwin
274 # hosts to fail, so avoid it just in that one case. It would be cleaner to
275 # just move this into the non-canadian case above, but I'm afraid that might
276 # cause some configure script somewhere to decide that since build==host, they
277 # could run host binaries.
278 # (Copied almost as-is from original crosstool):
279 case "${CT_KERNEL},${CT_CANADIAN}" in
281 *,y) CT_HOST="`echo \"${CT_HOST}\" |sed -r -e 's/-/-host_/;'`";;
284 # Ah! Recent versions of binutils need some of the build and/or host system
285 # (read CT_BUILD and CT_HOST) tools to be accessible (ar is but an example).
287 CT_DoLog DEBUG "Making build system tools available"
288 mkdir -p "${CT_PREFIX_DIR}/bin"
289 for tool in ar as dlltool gcc g++ gnatbind gnatmake ld nm ranlib strip windres objcopy objdump; do
290 tmp=`CT_Which ${tool}`
291 if [ -n "${tmp}" ]; then
292 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_BUILD}-${tool}"
293 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_UNIQ_BUILD}-${tool}"
294 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_HOST}-${tool}"
300 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST="${CT_CFLAGS_FOR_HOST} -pipe"
302 # Override the configured jobs with what's been given on the command line
303 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
305 # And help make go faster
307 [ ${CT_PARALLEL_JOBS} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -j${CT_PARALLEL_JOBS}"
308 [ ${CT_LOAD} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -l${CT_LOAD}"
310 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
311 CT_DoLog EXTRA "Building a toolchain for:"
312 CT_DoLog EXTRA " build = ${CT_BUILD}"
313 CT_DoLog EXTRA " host = ${CT_HOST}"
314 CT_DoLog EXTRA " target = ${CT_TARGET}"
315 set |egrep '^CT_.+=' |sort |CT_DoLog DEBUG
319 # Include sub-scripts instead of calling them: that way, we do not have to
320 # export any variable, nor re-parse the configuration and functions files.
321 . "${CT_LIB_DIR}/scripts/build/kernel_${CT_KERNEL}.sh"
322 . "${CT_LIB_DIR}/scripts/build/binutils.sh"
323 . "${CT_LIB_DIR}/scripts/build/libc_${CT_LIBC}.sh"
324 . "${CT_LIB_DIR}/scripts/build/cc_${CT_CC}.sh"
325 . "${CT_LIB_DIR}/scripts/build/debug.sh"
326 . "${CT_LIB_DIR}/scripts/build/tools.sh"
328 if [ -z "${CT_RESTART}" ]; then
329 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
338 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
339 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
340 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
341 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1
343 CT_DoStep INFO "Extracting and patching toolchain components"
354 # Now for the job by itself. Go have a coffee!
355 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
356 # Because of CT_RESTART, this becomes quite complex
359 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
360 for step in libc_check_config \
361 kernel_check_config \
374 if [ ${do_it} -eq 0 ]; then
375 if [ "${CT_RESTART}" = "${step}" ]; then
376 CT_DoLoadState "${step}"
381 CT_DoSaveState ${step}
382 if [ ${do_stop} -eq 1 ]; then
383 CT_DoLog ERROR "Stopping just after step \"${prev_step}\", as requested."
387 if [ ${do_it} -eq 1 ]; then
389 if [ "${CT_STOP}" = "${step}" ]; then
392 if [ "${CTDEBUG_CT_PAUSE_STEPS}" = "y" ]; then
393 CT_DoPause "Step \"${step}\" finished"
399 CT_DoLog DEBUG "Removing access to the build system tools"
400 find "${CT_PREFIX_DIR}/bin" -name "${CT_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
401 find "${CT_PREFIX_DIR}/bin" -name "${CT_UNIQ_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
402 find "${CT_PREFIX_DIR}/bin" -name "${CT_HOST}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
404 # Install the /populator/
405 CT_DoLog EXTRA "Installing the populate helper"
406 sed -r -e 's,@@CT_READELF@@,'"${CT_PREFIX_DIR}/bin/${CT_TARGET}-readelf"',g;' \
407 -e 's,@@CT_SYSROOT_DIR@@,'"${CT_SYSROOT_DIR}"',g;' \
408 "${CT_LIB_DIR}/tools/populate.in" >"${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
409 chmod 755 "${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
411 # Create the aliases to the target tools
412 CT_DoStep EXTRA "Creating toolchain aliases"
413 CT_Pushd "${CT_PREFIX_DIR}/bin"
414 for t in "${CT_TARGET}-"*; do
415 if [ -n "${CT_TARGET_ALIAS}" ]; then
416 _t="`echo \"$t\" |sed -r -e 's/^'\"${CT_TARGET}\"'-/'\"${CT_TARGET_ALIAS}\"'-/;'`"
417 CT_DoLog DEBUG "Linking \"${_t}\" -> \"${t}\""
418 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
420 if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
421 _t="`echo \"$t\" |sed -r -e \"${CT_TARGET_ALIAS_SED_EXPR}\"`"
422 CT_DoLog DEBUG "Linking \"${_t}\" -> \"${t}\""
423 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
429 # Remove the generated documentation files
430 if [ "${CT_REMOVE_DOCS}" = "y" ]; then
431 CT_DoLog INFO "Removing installed documentation"
432 rm -rf "${CT_PREFIX_DIR}/"{,usr/}{man,info}
433 rm -rf "${CT_SYSROOT_DIR}/"{,usr/}{man,info}
434 rm -rf "${CT_DEBUG_INSTALL_DIR}/"{,usr/}{man,info}
440 if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
441 CT_DoLog EXTRA "Compressing log file"
443 bzip2 -9 "${CT_LOG_FILE}"
446 if [ "${CT_INSTALL_DIR_RO}" = "y" ]; then
447 # OK, now we're done, set the toolchain read-only
448 # Don't log, the log file may become read-only any moment...
449 chmod -R a-w "${CT_INSTALL_DIR}" >/dev/null 2>&1