diff options
Diffstat (limited to 'scripts/build/cc')
| -rw-r--r-- | scripts/build/cc/gcc.sh (renamed from scripts/build/cc/100-gcc.sh) | 685 |
1 files changed, 403 insertions, 282 deletions
diff --git a/scripts/build/cc/100-gcc.sh b/scripts/build/cc/gcc.sh index 4dc7a69..0f369a4 100644 --- a/scripts/build/cc/100-gcc.sh +++ b/scripts/build/cc/gcc.sh @@ -3,53 +3,33 @@ # Licensed under the GPL v2. See COPYING in the root of this package # Download gcc -do_gcc_get() { +do_cc_get() { local linaro_version="" local linaro_series="" - if [ "${CT_CC_GCC_CUSTOM}" = "y" ]; then - CT_GetCustom "gcc" "${CT_CC_GCC_CUSTOM_VERSION}" \ - "${CT_CC_GCC_CUSTOM_LOCATION}" - else - case "${CT_CC_GCC_VERSION}" in - linaro-*) - CT_GetLinaro "gcc" "${CT_CC_GCC_VERSION}" - ;; - *) - # The official gcc hosts put gcc under a gcc/release/ directory, - # whereas the mirrors put it in the gcc/ directory. - CT_GetFile "gcc-${CT_CC_GCC_VERSION}" \ - {http,ftp,https}://ftp.gnu.org/gnu/gcc/gcc-${CT_CC_GCC_VERSION} \ - ftp://{gcc.gnu.org,sourceware.org}/pub/gcc/releases/gcc-${CT_CC_GCC_VERSION} - ;; - esac - fi # ! custom location + CT_Fetch GCC + # Starting with GCC 4.3, ecj is used for Java, and will only be # built if the configure script finds ecj.jar at the top of the # GCC source tree, which will not be there unless we get it and # put it there ourselves if [ "${CT_CC_LANG_JAVA_USE_ECJ}" = "y" ]; then - CT_GetFile ecj-latest .jar http://mirrors.kernel.org/sourceware/java/ \ - http://crosstool-ng.org/pub/java \ - ftp://gcc.gnu.org/pub/java \ - ftp://sourceware.org/pub/java + if ! CT_GetFile package=ecj basename=ecj-latest extensions=.jar dir_name=gcc \ + mirrors="$(CT_Mirrors sourceware java)"; then + # Should be a package, too - but with Java retirement in GCC, + # it may not make sense. + CT_Abort "Failed to download ecj-latest.jar" + fi fi } # Extract gcc -do_gcc_extract() { - CT_Extract "gcc-${CT_CC_GCC_VERSION}" - CT_Patch "gcc" "${CT_CC_GCC_VERSION}" +do_cc_extract() { + CT_ExtractPatch GCC # Copy ecj-latest.jar to ecj.jar at the top of the GCC source tree - if [ "${CT_CC_LANG_JAVA_USE_ECJ}" = "y" \ - -a ! -f "${CT_SRC_DIR}/gcc-${CT_CC_GCC_VERSION}/ecj.jar" \ - ]; then - CT_DoExecLog ALL cp -v "${CT_TARBALLS_DIR}/ecj-latest.jar" "${CT_SRC_DIR}/gcc-${CT_CC_GCC_VERSION}/ecj.jar" - fi - - if [ -n "${CT_ARCH_XTENSA_CUSTOM_NAME}" ]; then - CT_ConfigureXtensa "gcc" "${CT_CC_GCC_VERSION}" + if [ "${CT_CC_LANG_JAVA_USE_ECJ}" = "y" -a ! -f "${CT_SRC_DIR}/gcc/ecj.jar" ]; then + CT_DoExecLog ALL cp -v "${CT_TARBALLS_DIR}/ecj-latest.jar" "${CT_SRC_DIR}/gcc/ecj.jar" fi } @@ -73,23 +53,6 @@ cc_gcc_lang_list() { } #------------------------------------------------------------------------------ -# Return a value of a requested GCC spec -cc_gcc_get_spec() { - local spec=$1 - local cc_and_cflags=$2 - - # GCC does not provide a facility to request a value of a spec string. - # The only way to do that I found was to augment the spec file with - # some dummy suffix handler that does nothing except printing it. - touch temp-input.spec_eval - { - echo ".spec_eval:" - echo "echo %(${spec})" - } > "tmp-specs-${spec}" - ${cc_and_cflags} -specs="tmp-specs-${spec}" -E temp-input.spec_eval -} - -#------------------------------------------------------------------------------ # Report the type of a GCC option cc_gcc_classify_opt() { # Options present in multiple architectures @@ -129,33 +92,55 @@ cc_gcc_classify_opt() { echo "unknown" } +evaluate_multilib_cflags() +{ + local multi_dir multi_os_dir multi_os_dir_gcc multi_root multi_flags multi_index multi_count + local mdir mdir_os dirtop + local f + + for arg in "$@"; do + eval "${arg// /\\ }" + done + + mdir="lib/${multi_dir}" + mdir_os="lib/${multi_os_dir_gcc}" + CT_SanitizeVarDir mdir mdir_os + CT_DoLog EXTRA " '${multi_flags}' --> ${mdir} (gcc) ${mdir_os} (os)" + for f in ${multi_flags}; do + eval ml_`cc_gcc_classify_opt ${f}`=seen + done + if [ "${CT_DEMULTILIB}" = "y" -a "${CT_USE_SYSROOT}" = "y" ]; then + case "${mdir_os}" in + lib/*) + ;; + *) + dirtop="${mdir_os%%/*}" + if [ ! -e "${multi_root}/${mdir_os}" ]; then + CT_DoExecLog ALL ln -sfv lib "${multi_root}/${mdir_os}" + fi + if [ ! -e "${multi_root}/usr/${mdir_os}" ]; then + CT_DoExecLog ALL ln -sfv lib "${multi_root}/usr/${mdir_os}" + fi + ;; + esac + fi +} + #------------------------------------------------------------------------------ # This function lists the multilibs configured in the compiler (even if multilib # is disabled - so that it lists the default GCC/OS directory, which may differ # from the default 'lib'). It then performs a few multilib checks/quirks: # -# 1. On SuperH target, configuring with default CPU (e.g. by supplying the target -# name as 'sh4', which is what CT-NG does) results in the compiler being unable to -# run if that same switch is passed to the resulting gcc (e.g. 'gcc -m4'). The reason -# for this behavior is that the script that determines the sysroot suffix is not -# aware of the default multilib selection, so it generates <sysroot>/m4 as the -# suffixed sysroot. But the main driver, knowing that -m4 is the default, does not -# even attempt to fall back to the non-suffixed sysroot (as it does with non-default -# multilibs) - as a result, gcc fails to find any library if invoked with -m4. -# The right solution would be to drop the default CPU from the multilib list -# completely, or make the print-sysroot-suffix.sh script aware of the defaults -# (which is not easy, as the defaults are not in tmake_file, but rather in tm_file...) -# -# 2. On MIPS target, gcc (or rather, ld, which it invokes under the hood) chokes +# 1. On MIPS target, gcc (or rather, ld, which it invokes under the hood) chokes # if supplied with two -mabi=* options. I.e., 'gcc -mabi=n32' and 'gcc -mabi=32' both # work, but 'gcc -mabi=32 -mabi=n32' produces an internal error in ld. Thus we do -# not supply target's CFLAGS in multilib builds - and after compiling pass-1 gcc, +# not supply target's CFLAGS in multilib builds - and after compiling core gcc, # attempt to determine which CFLAGS need to be filtered out. +# +# 2. If "demultilibing" is in effect, create top-level directories for any +# multilibs not in lib/ as symlinks to lib. cc_gcc_multilib_housekeeping() { local cc host - local flags osdir dir multilibs i f - local multilib_defaults - local suffix sysroot base lnk local ml_arch ml_abi ml_cpu ml_tune ml_fpu ml_float ml_endian ml_mode ml_unknown ml local new_cflags @@ -171,76 +156,40 @@ cc_gcc_multilib_housekeeping() { cc="${CT_BUILDTOOLS_PREFIX_DIR}/bin/${CT_TARGET}-${CT_CC}" fi - # sed: prepend dashes or do nothing if default is empty string - multilib_defaults=( $( cc_gcc_get_spec multilib_defaults "${cc}" | \ - sed 's/\(^\|[[:space:]]\+\)\([^[:space:]]\)/ -\2/g' ) ) - CT_DoLog EXTRA "gcc default flags: '${multilib_defaults}'" - - multilibs=( $( "${cc}" -print-multi-lib ) ) - if [ ${#multilibs[@]} -ne 0 ]; then - CT_DoLog EXTRA "gcc configured with these multilibs (including the default):" - for i in "${multilibs[@]}"; do - dir="lib/${i%%;*}" - flags="${i#*;}" - flags=${flags//@/ -} - flags=$( echo ${flags} ) - osdir="lib/"$( "${cc}" -print-multi-os-directory ${flags} ) - CT_SanitizeVarDir dir osdir - CT_DoLog EXTRA " '${flags}' --> ${dir} (gcc) ${osdir} (os)" - for f in ${flags}; do - eval ml_`cc_gcc_classify_opt ${f}`=seen - done + CT_IterateMultilibs evaluate_multilib_cflags evaluate_cflags + + if [ -n "${CT_MULTILIB}" ]; then + # Filtering out some of the options provided in CT-NG config. Then *prepend* + # them to CT_TARGET_CFLAGS, like scripts/crosstool-NG.sh does. Zero out + # the stashed MULTILIB flags so that we don't process them again in the passes + # that follow. + CT_DoLog DEBUG "Configured target CFLAGS: '${CT_ARCH_TARGET_CFLAGS_MULTILIB}'" + ml_unknown= # Pass through anything we don't know about + for f in ${CT_ARCH_TARGET_CFLAGS_MULTILIB}; do + eval ml=\$ml_`cc_gcc_classify_opt ${f}` + if [ "${ml}" != "seen" ]; then + new_cflags="${new_cflags} ${f}" + fi done - else - CT_DoLog WARN "no multilib configuration: GCC unusable?" - fi - - # Filtering out some of the options provided in CT-NG config. Then *prepend* - # them to CT_TARGET_CFLAGS, like scripts/crosstool-NG.sh does. Zero out - # the stashed MULTILIB flags so that we don't process them again in the passes - # that follow. - CT_DoLog DEBUG "Configured target CFLAGS: '${CT_ARCH_TARGET_CFLAGS_MULTILIB}'" - ml_unknown= # Pass through anything we don't know about - for f in ${CT_ARCH_TARGET_CFLAGS_MULTILIB}; do - eval ml=\$ml_`cc_gcc_classify_opt ${f}` - if [ "${ml}" != "seen" ]; then - new_cflags="${new_cflags} ${f}" - fi - done - CT_DoLog DEBUG "Filtered target CFLAGS: '${new_cflags}'" - CT_EnvModify CT_TARGET_CFLAGS "${new_cflags} ${CT_TARGET_CFLAGS}" - CT_EnvModify CT_ARCH_TARGET_CFLAGS_MULTILIB "" - - # Currently, the only LDFLAGS are endianness-related - CT_DoLog DEBUG "Configured target LDFLAGS: '${CT_ARCH_TARGET_LDFLAGS_MULTILIB}'" - if [ "${ml_endian}" != "seen" ]; then - CT_EnvModify CT_TARGET_LDFLAGS "${CT_ARCH_TARGET_LDFLAGS_MULTILIB} ${CT_TARGET_LDFLAGS}" - CT_EnvModify CT_ARCH_TARGET_LDFLAGS_MULTILIB "" - fi - CT_DoLog DEBUG "Filtered target LDFLAGS: '${CT_ARCH_TARGET_LDFLAGS_MULTILIB}'" - - # Sysroot suffix fixup for the multilib default. - suffix=$( cc_gcc_get_spec sysroot_suffix_spec "${cc} ${multilib_defaults}" ) - if [ -n "${suffix}" ]; then - base=${suffix%/*} - sysroot=$( "${cc}" -print-sysroot ) - if [ -n "${base}" ]; then - CT_DoExecLog ALL mkdir -p "${sysroot}${base}" - lnk=$( echo "${base#/}" | sed -e 's,[^/]*,..,g' ) - else - lnk=. + CT_DoLog DEBUG "Filtered target CFLAGS: '${new_cflags}'" + CT_EnvModify CT_ALL_TARGET_CFLAGS "${new_cflags} ${CT_TARGET_CFLAGS}" + CT_EnvModify CT_ARCH_TARGET_CFLAGS_MULTILIB "" + + # Currently, the only LDFLAGS are endianness-related + CT_DoLog DEBUG "Configured target LDFLAGS: '${CT_ARCH_TARGET_LDFLAGS_MULTILIB}'" + if [ "${ml_endian}" != "seen" ]; then + CT_EnvModify CT_ALL_TARGET_LDFLAGS "${CT_ARCH_TARGET_LDFLAGS_MULTILIB} ${CT_TARGET_LDFLAGS}" + CT_EnvModify CT_ARCH_TARGET_LDFLAGS_MULTILIB "" fi - CT_DoExecLog ALL rm -f "${sysroot}${suffix}" - CT_DoExecLog ALL ln -sfv "${lnk}" "${sysroot}${suffix}" + CT_DoLog DEBUG "Filtered target LDFLAGS: '${CT_ARCH_TARGET_LDFLAGS_MULTILIB}'" fi } #------------------------------------------------------------------------------ -# Core gcc pass 1 -do_gcc_core_pass_1() { +do_cc_core() { local -a core_opts - if [ "${CT_CC_CORE_PASS_1_NEEDED}" != "y" ]; then + if [ "${CT_CC_CORE_NEEDED}" != "y" ]; then return 0 fi @@ -251,56 +200,12 @@ do_gcc_core_pass_1() { core_opts+=( "cflags=${CT_CFLAGS_FOR_BUILD}" ) core_opts+=( "ldflags=${CT_LDFLAGS_FOR_BUILD}" ) core_opts+=( "lang_list=c" ) - core_opts+=( "build_step=core1" ) - - CT_DoStep INFO "Installing pass-1 core C gcc compiler" - CT_mkdir_pushd "${CT_BUILD_DIR}/build-cc-gcc-core-pass-1" - - do_gcc_core_backend "${core_opts[@]}" - - CT_Popd - CT_EndStep -} - -# Core gcc pass 2 -do_gcc_core_pass_2() { - local -a core_opts - - if [ "${CT_CC_CORE_PASS_2_NEEDED}" != "y" ]; then - return 0 - fi - - # Common options: - core_opts+=( "host=${CT_BUILD}" ) - core_opts+=( "prefix=${CT_BUILDTOOLS_PREFIX_DIR}" ) - core_opts+=( "complibs=${CT_BUILDTOOLS_PREFIX_DIR}" ) - core_opts+=( "cflags=${CT_CFLAGS_FOR_BUILD}" ) - core_opts+=( "ldflags=${CT_LDFLAGS_FOR_BUILD}" ) - core_opts+=( "lang_list=c" ) - core_opts+=( "build_step=core2" ) - - # Different conditions are at stake here: - # - In case the threading model is NPTL, we need a shared-capable core - # gcc; in all other cases, we need a static-only core gcc. - # - In case the threading model is NPTL or win32, or gcc is 4.3 or - # later, we need to build libgcc - case "${CT_THREADS}" in - nptl) - core_opts+=( "mode=shared" ) - core_opts+=( "build_libgcc=yes" ) - ;; - win32) - core_opts+=( "mode=static" ) - core_opts+=( "build_libgcc=yes" ) - ;; - *) - core_opts+=( "mode=static" ) - core_opts+=( "build_libgcc=yes" ) - ;; - esac + core_opts+=( "build_step=core" ) + core_opts+=( "mode=static" ) + core_opts+=( "build_libgcc=yes" ) - CT_DoStep INFO "Installing pass-2 core C gcc compiler" - CT_mkdir_pushd "${CT_BUILD_DIR}/build-cc-gcc-core-pass-2" + CT_DoStep INFO "Installing core C gcc compiler" + CT_mkdir_pushd "${CT_BUILD_DIR}/build-cc-gcc-core" do_gcc_core_backend "${core_opts[@]}" @@ -325,8 +230,8 @@ do_gcc_core_pass_2() { # build_manuals : whether to build manuals or not : bool : no # cflags : cflags to use : string : (empty) # ldflags : ldflags to use : string : (empty) -# build_step : build step 'core1', 'core2', 'gcc_build' -# or 'gcc_host' : string : (none) +# build_step : build step 'core', 'gcc_build', +# 'libstdcxx' or 'gcc_host' : string : (none) # Usage: do_gcc_core_backend mode=[static|shared|baremetal] build_libgcc=[yes|no] build_staticlinked=[yes|no] do_gcc_core_backend() { local mode @@ -337,13 +242,18 @@ do_gcc_core_backend() { local build_manuals=no local host local prefix + local enable_optspace local complibs local lang_list - local cflags + local cflags cflags_for_build cxxflags_for_build cflags_for_target cxxflags_for_target + local extra_cxxflags_for_target local ldflags local build_step local log_txt local tmp + local exec_prefix + local header_dir + local libstdcxx_name local -a host_libstdcxx_flags local -a extra_config local -a core_LDFLAGS @@ -359,25 +269,44 @@ do_gcc_core_backend() { # This function gets called in case of a bare metal compiler for the final gcc, too. case "${build_step}" in - core1|core2) + core) CT_DoLog EXTRA "Configuring core C gcc compiler" log_txt="gcc" + extra_config+=( "${CT_CC_CORE_SYSROOT_ARG[@]}" ) extra_user_config=( "${CT_CC_GCC_CORE_EXTRA_CONFIG_ARRAY[@]}" ) ;; gcc_build|gcc_host) CT_DoLog EXTRA "Configuring final gcc compiler" + extra_config+=( "${CT_CC_SYSROOT_ARG[@]}" ) extra_user_config=( "${CT_CC_GCC_EXTRA_CONFIG_ARRAY[@]}" ) log_txt="final gcc compiler" - if [ "${CT_CC_GCC_TARGET_FINAL}" = "y" ]; then - # to inhibit the libiberty and libgcc tricks later on - build_libgcc=no + # to inhibit the libiberty and libgcc tricks later on + build_libgcc=no + ;; + libstdcxx) + CT_DoLog EXTRA "Configuring libstdc++ for ${libstdcxx_name}" + if [ "${header_dir}" = "" ]; then + header_dir="${CT_PREFIX_DIR}/${libstdcxx_name}/include" fi + if [ "${exec_prefix}" = "" ]; then + exec_prefix="${CT_PREFIX_DIR}/${libstdcxx_name}" + fi + extra_config+=( "${CT_CC_SYSROOT_ARG[@]}" ) + extra_config+=( "--with-headers=${header_dir}" ) + extra_user_config=( "${CT_CC_GCC_EXTRA_CONFIG_ARRAY[@]}" ) + log_txt="libstdc++ ${libstdcxx_name} library" + # to inhibit the libiberty and libgcc tricks later on + build_libgcc=no ;; *) - CT_Abort "Internal Error: 'build_step' must be one of: 'core1', 'core2', 'gcc_build' or 'gcc_host', not '${build_step:-(empty)}'" + CT_Abort "Internal Error: 'build_step' must be one of: 'core', 'gcc_build', 'gcc_host' or 'libstdcxx', not '${build_step:-(empty)}'" ;; esac + if [ "${exec_prefix}" = "" ]; then + exec_prefix="${prefix}" + fi + case "${mode}" in static) extra_config+=("--with-newlib") @@ -397,29 +326,33 @@ do_gcc_core_backend() { ;; esac - # This is only needed when building libstdc++ in a canadian environment with - # this function being used for final step (i.e., when building for bare metal). - if [ "${build_step}" = "gcc_build" ]; then - CT_DoLog DEBUG "Copying headers to install area of core C compiler" - CT_DoExecLog ALL cp -a "${CT_HEADERS_DIR}" "${prefix}/${CT_TARGET}/include" - fi - - for tmp in ARCH ABI CPU TUNE FPU FLOAT; do + for tmp in ARCH ABI CPU CPU_32 CPU_64 TUNE FPU FLOAT ENDIAN; do eval tmp="\${CT_ARCH_WITH_${tmp}}" if [ -n "${tmp}" ]; then extra_config+=("${tmp}") fi done - extra_config+=("--with-pkgversion=${CT_PKGVERSION}") + [ -n "${CT_PKGVERSION}" ] && extra_config+=("--with-pkgversion=${CT_PKGVERSION}") [ -n "${CT_TOOLCHAIN_BUGURL}" ] && extra_config+=("--with-bugurl=${CT_TOOLCHAIN_BUGURL}") + # Hint GCC we'll use a bit special version of Newlib + if [ "${CT_LIBC_NEWLIB_NANO_FORMATTED_IO}" = "y" ]; then + extra_config+=("--enable-newlib-nano-formatted-io") + fi + if [ "${CT_CC_CXA_ATEXIT}" = "y" ]; then extra_config+=("--enable-__cxa_atexit") else extra_config+=("--disable-__cxa_atexit") fi + case "${CT_CC_GCC_TM_CLONE_REGISTRY}" in + y) extra_config+=("--enable-tm-clone-registry");; + m) ;; + "") extra_config+=("--disable-tm-clone-registry");; + esac + if [ -n "${CT_CC_GCC_ENABLE_CXX_FLAGS}" \ -a "${mode}" = "baremetal" ]; then extra_config+=("--enable-cxx-flags=${CT_CC_GCC_ENABLE_CXX_FLAGS}") @@ -429,11 +362,11 @@ do_gcc_core_backend() { extra_config+=(--disable-libmudflap) extra_config+=(--disable-libmpx) - if [ "${CT_CC_GCC_LIBSSP}" = "y" ]; then - extra_config+=(--enable-libssp) - else - extra_config+=(--disable-libssp) - fi + case "${CT_CC_GCC_LIBSSP}" in + y) extra_config+=(--enable-libssp);; + m) ;; + "") extra_config+=(--disable-libssp);; + esac if [ "${CT_CC_GCC_LIBQUADMATH}" = "y" ]; then extra_config+=(--enable-libquadmath) extra_config+=(--enable-libquadmath-support) @@ -442,6 +375,15 @@ do_gcc_core_backend() { extra_config+=(--disable-libquadmath-support) fi + case "${CT_CC_GCC_LIBSTDCXX_VERBOSE}" in + y) extra_config+=("--enable-libstdcxx-verbose");; + "") extra_config+=("--disable-libstdcxx-verbose");; + esac + + if [ "${build_libstdcxx}" = "no" ]; then + extra_config+=(--disable-libstdcxx) + fi + core_LDFLAGS+=("${ldflags}") # *** WARNING ! *** @@ -449,9 +391,11 @@ do_gcc_core_backend() { # with the same block in do_gcc_backend, below. if [ "${build_staticlinked}" = "yes" ]; then core_LDFLAGS+=("-static") - host_libstdcxx_flags+=("-static-libgcc") - host_libstdcxx_flags+=("-Wl,-Bstatic,-lstdc++") - host_libstdcxx_flags+=("-lm") + if [ "${CT_GCC_older_than_6}" = "y" ]; then + host_libstdcxx_flags+=("-static-libgcc") + host_libstdcxx_flags+=("-Wl,-Bstatic,-lstdc++") + host_libstdcxx_flags+=("-lm") + fi # Companion libraries are build static (eg !shared), so # the libstdc++ is not pulled automatically, although it # is needed. Shoe-horn it in our LDFLAGS @@ -459,7 +403,7 @@ do_gcc_core_backend() { core_LDFLAGS+=("-lstdc++") core_LDFLAGS+=("-lm") else - if [ "${CT_CC_GCC_STATIC_LIBSTDCXX}" = "y" ]; then + if [ "${CT_CC_GCC_STATIC_LIBSTDCXX}" = "y" -a "${CT_GCC_older_than_6}" = "y" ]; then # this is from CodeSourcery arm-2010q1-202-arm-none-linux-gnueabi.src.tar.bz2 # build script # INFO: if the host gcc is gcc-4.5 then presumably we could use -static-libstdc++, @@ -500,13 +444,28 @@ do_gcc_core_backend() { extra_config+=("--with-host-libstdcxx=${host_libstdcxx_flags[*]}") fi - if [ "${CT_CC_GCC_ENABLE_TARGET_OPTSPACE}" = "y" ]; then + if [ "${CT_CC_GCC_ENABLE_TARGET_OPTSPACE}" = "y" ] || \ + [ "${enable_optspace}" = "yes" ]; then extra_config+=("--enable-target-optspace") fi if [ "${CT_CC_GCC_DISABLE_PCH}" = "y" ]; then extra_config+=("--disable-libstdcxx-pch") fi + if [ "${CT_LIBC_GLIBC}" = "y" ]; then + # Report GLIBC's version to GCC, it affects the defaults on other options. + # GCC expects just two numbers separated by a dot. + local glibc_version + + CT_GetPkgVersion GLIBC glibc_version + case "${glibc_version}" in + new) glibc_version=99.99;; + old) glibc_version=1.0;; + *) glibc_version=`echo "${glibc_version}" | sed 's/\([1-9][0-9]*\.[1-9][0-9]*\).*/\1/'`;; + esac + extra_config+=("--with-glibc-version=${glibc_version}") + fi + case "${CT_CC_GCC_LDBL_128}" in y) extra_config+=("--with-long-double-128");; m) ;; @@ -563,11 +522,10 @@ do_gcc_core_backend() { # Some versions of gcc have a defective --enable-multilib. # Since that's the default, only pass --disable-multilib. For multilib, - # also enable multiarch. Without explicit --enable-multiarch, pass-1 - # compiler is configured as multilib/no-multiarch and pass-2/final - # are multilib/multiarch (because gcc autodetects multiarch based on - # multiple instances of crt*.o in the install directory - which do - # not exist in pass-1). + # also enable multiarch. Without explicit --enable-multiarch, core + # compiler is configured as multilib/no-multiarch (because gcc autodetects + # multiarch based on multiple instances of crt*.o in the install directory + # which do not exist in the core pass). if [ "${CT_MULTILIB}" != "y" ]; then extra_config+=("--disable-multilib") else @@ -579,29 +537,75 @@ do_gcc_core_backend() { CT_DoLog DEBUG "Extra config passed: '${extra_config[*]}'" + # We may need to modify host/build/target CFLAGS separately below. Note + # that ${cflags} may refer either to build or host CFLAGS; they are provided + # by the caller. + cflags_for_build="${CT_CFLAGS_FOR_BUILD}" + cxxflags_for_build="${CT_CXXFLAGS_FOR_BUILD}" + cflags_for_target="${CT_TARGET_CFLAGS}" + # Clang's default bracket-depth is 256, and building GCC # requires somewhere between 257 and 512. - if ${CT_BUILD}-gcc --version 2>&1 | grep clang; then - cflags="$cflags "-fbracket-depth=512 + if [ "${host}" = "${CT_BUILD}" ]; then + if ${CT_BUILD}-gcc --version 2>&1 | grep clang; then + cflags="$cflags -fbracket-depth=512" + cflags_for_build="$cflags_for_build -fbracket-depth=512" + fi + else + # FIXME we currently don't support clang as host compiler, only as build + if ${CT_BUILD}-gcc --version 2>&1 | grep clang; then + cflags_for_build="$cflags_for_build -fbracket-depth=512" + fi + fi + + # For non-sysrooted toolchain, GCC doesn't search except at the installation + # prefix; in core stage we use a temporary installation prefix - but + # we may have installed something into the final prefix. This is less than ideal: + # in the installation prefix GCC also handles subdirectories for multilibs + # (e.g. first trying ${prefix}/include/${arch-triplet}) but + # we can only pass the top level directory, so non-sysrooted build with libc + # selection that doesn't merge the headers (i.e. musl, uClibc-ng) may not + # work. Better suggestions welcome. + if [ "${CT_USE_SYSROOT}" != "y" ]; then + cflags_for_target="${cflags_for_target} -idirafter ${CT_HEADERS_DIR}" fi - # Use --with-local-prefix so older gccs don't look in /usr/local (http://gcc.gnu.org/PR10532) + # Assume '-O2' by default for building target libraries. + cflags_for_target="-g -O2 ${cflags_for_target}" + + # Set target CXXFLAGS to CFLAGS if none is provided. + if [ -z "${cxxflags_for_target}" ]; then + cxxflags_for_target="${cflags_for_target}" + fi + + # Append extra CXXFLAGS if provided. + if [ -n "${extra_cxxflags_for_target}" ]; then + cxxflags_for_target="${cxxflags_for_target} ${extra_cxxflags_for_target}" + fi + + # Use --with-local-prefix so older gccs don't look in /usr/local (http://gcc.gnu.org/PR10532). + # Pass only user-specified CFLAGS/LDFLAGS in CFLAGS_FOR_TARGET/LDFLAGS_FOR_TARGET: during + # the build of, for example, libatomic, GCC tried to compile multiple variants for runtime + # selection and passing architecture/CPU selectors, as detemined by crosstool-NG, may + # miscompile or outright fail. CT_DoExecLog CFG \ CC_FOR_BUILD="${CT_BUILD}-gcc" \ CFLAGS="${cflags}" \ - CXXFLAGS="${cflags}" \ + CFLAGS_FOR_BUILD="${cflags_for_build}" \ + CXXFLAGS="${cflags} ${cxxflags_for_build}" \ + CXXFLAGS_FOR_BUILD="${cflags_for_build} ${cxxflags_for_build}" \ LDFLAGS="${core_LDFLAGS[*]}" \ - CFLAGS_FOR_TARGET="${CT_TARGET_CFLAGS}" \ - CXXFLAGS_FOR_TARGET="${CT_TARGET_CFLAGS}" \ + CFLAGS_FOR_TARGET="${cflags_for_target}" \ + CXXFLAGS_FOR_TARGET="${cxxflags_for_target}" \ LDFLAGS_FOR_TARGET="${CT_TARGET_LDFLAGS}" \ ${CONFIG_SHELL} \ - "${CT_SRC_DIR}/gcc-${CT_CC_GCC_VERSION}/configure" \ + "${CT_SRC_DIR}/gcc/configure" \ --build=${CT_BUILD} \ --host=${host} \ --target=${CT_TARGET} \ --prefix="${prefix}" \ + --exec_prefix="${exec_prefix}" \ --with-local-prefix="${CT_SYSROOT_DIR}" \ - ${CC_CORE_SYSROOT_ARG} \ "${extra_config[@]}" \ --enable-languages="${lang_list}" \ "${extra_user_config[@]}" @@ -623,43 +627,31 @@ do_gcc_core_backend() { # so we configure then build it. # Next we have to configure gcc, create libgcc.mk then edit it... # So much easier if we just edit the source tree, but hey... - if [ ! -f "${CT_SRC_DIR}/gcc-${CT_CC_GCC_VERSION}/gcc/BASE-VER" ]; then - CT_DoExecLog CFG make ${JOBSFLAGS} configure-libiberty - CT_DoExecLog ALL make ${JOBSFLAGS} -C libiberty libiberty.a - CT_DoExecLog CFG make ${JOBSFLAGS} configure-gcc configure-libcpp - CT_DoExecLog ALL make ${JOBSFLAGS} all-libcpp + if [ ! -f "${CT_SRC_DIR}/gcc/gcc/BASE-VER" ]; then + CT_DoExecLog CFG make ${CT_JOBSFLAGS} configure-libiberty + CT_DoExecLog ALL make ${CT_JOBSFLAGS} -C libiberty libiberty.a + CT_DoExecLog CFG make ${CT_JOBSFLAGS} configure-gcc configure-libcpp + CT_DoExecLog ALL make ${CT_JOBSFLAGS} all-libcpp else - CT_DoExecLog CFG make ${JOBSFLAGS} configure-gcc configure-libcpp configure-build-libiberty - CT_DoExecLog ALL make ${JOBSFLAGS} all-libcpp all-build-libiberty + CT_DoExecLog CFG make ${CT_JOBSFLAGS} configure-gcc configure-libcpp configure-build-libiberty + CT_DoExecLog ALL make ${CT_JOBSFLAGS} all-libcpp all-build-libiberty fi # HACK: gcc-4.2 uses libdecnumber to build libgcc.mk, so build it here. - if [ -d "${CT_SRC_DIR}/gcc-${CT_CC_GCC_VERSION}/libdecnumber" ]; then - CT_DoExecLog CFG make ${JOBSFLAGS} configure-libdecnumber - CT_DoExecLog ALL make ${JOBSFLAGS} -C libdecnumber libdecnumber.a + if [ -d "${CT_SRC_DIR}/gcc/libdecnumber" ]; then + CT_DoExecLog CFG make ${CT_JOBSFLAGS} configure-libdecnumber + CT_DoExecLog ALL make ${CT_JOBSFLAGS} -C libdecnumber libdecnumber.a fi # HACK: gcc-4.8 uses libbacktrace to make libgcc.mvars, so make it here. - if [ -d "${CT_SRC_DIR}/gcc-${CT_CC_GCC_VERSION}/libbacktrace" ]; then - CT_DoExecLog CFG make ${JOBSFLAGS} configure-libbacktrace - CT_DoExecLog ALL make ${JOBSFLAGS} -C libbacktrace + if [ -d "${CT_SRC_DIR}/gcc/libbacktrace" ]; then + CT_DoExecLog CFG make ${CT_JOBSFLAGS} configure-libbacktrace + CT_DoExecLog ALL make ${CT_JOBSFLAGS} -C libbacktrace fi libgcc_rule="libgcc.mvars" core_targets=( gcc target-libgcc ) - # On bare metal and canadian build the host-compiler is used when - # actually the build-system compiler is required. Choose the correct - # compilers for canadian build and use the defaults on other - # configurations. - if [ "${CT_BARE_METAL},${CT_CANADIAN}" = "y,y" ]; then - repair_cc="CC_FOR_BUILD=${CT_BUILD}-gcc \ - CXX_FOR_BUILD=${CT_BUILD}-g++ \ - GCC_FOR_TARGET=${CT_TARGET}-${CT_CC}" - else - repair_cc="" - fi + CT_DoExecLog ALL make ${CT_JOBSFLAGS} -C gcc ${libgcc_rule} - CT_DoExecLog ALL make ${JOBSFLAGS} -C gcc ${libgcc_rule} \ - ${repair_cc} sed -r -i -e 's@-lc@@g' gcc/${libgcc_rule} else # build_libgcc core_targets=( gcc ) @@ -681,17 +673,20 @@ do_gcc_core_backend() { case "${build_step}" in gcc_build|gcc_host) - if [ "${CT_CC_GCC_TARGET_FINAL}" = "y" ]; then - core_targets_all=all - core_targets_install=install - fi + core_targets_all=all + core_targets_install=install + ;; + libstdcxx) + core_targets=( target-libstdc++-v3 ) + core_targets_all="${core_targets[@]/#/all-}" + core_targets_install="${core_targets[@]/#/install-}" ;; esac CT_DoLog EXTRA "Building ${log_txt}" - CT_DoExecLog ALL make ${JOBSFLAGS} ${core_targets_all} + CT_DoExecLog ALL make ${CT_JOBSFLAGS} ${core_targets_all} - # Do not pass ${JOBSFLAGS} here: recent GCC builds have been failing + # Do not pass ${CT_JOBSFLAGS} here: recent GCC builds have been failing # in parallel 'make install' at random locations: libitm, libcilk, # always for the files that are installed more than once to the same # location (such as libitm.info). @@ -729,11 +724,18 @@ do_gcc_core_backend() { cc_gcc_multilib_housekeeping cc="${prefix}/bin/${CT_TARGET}-${CT_CC}" \ host="${host}" + + # If binutils want the LTO plugin, point them to it + if [ -d "${CT_PREFIX_DIR}/lib/bfd-plugins" -a "${build_step}" = "gcc_host" ]; then + local gcc_version=$(cat "${CT_SRC_DIR}/gcc/gcc/BASE-VER" ) + CT_DoExecLog ALL ln -sfv "../../libexec/gcc/${CT_TARGET}/${gcc_version}/liblto_plugin.so" \ + "${CT_PREFIX_DIR}/lib/bfd-plugins/liblto_plugin.so" + fi } #------------------------------------------------------------------------------ # Build complete gcc to run on build -do_gcc_for_build() { +do_cc_for_build() { local -a build_final_opts local build_final_backend @@ -755,7 +757,9 @@ do_gcc_for_build() { # lack of such a compiler, but better safe than sorry... build_final_opts+=( "mode=baremetal" ) build_final_opts+=( "build_libgcc=yes" ) - build_final_opts+=( "build_libstdcxx=yes" ) + if [ "${CT_LIBC_NONE}" != "y" ]; then + build_final_opts+=( "build_libstdcxx=yes" ) + fi build_final_opts+=( "build_libgfortran=yes" ) if [ "${CT_STATIC_TOOLCHAIN}" = "y" ]; then build_final_opts+=( "build_staticlinked=yes" ) @@ -774,14 +778,24 @@ do_gcc_for_build() { CT_EndStep } -gcc_movelibs() { - local multi_flags multi_dir multi_os_dir multi_root multi_index multi_count - local gcc_dir +gcc_movelibs() +{ + local multi_flags multi_dir multi_os_dir multi_os_dir_gcc multi_root multi_index multi_count + local gcc_dir dst_dir canon_root canon_prefix + local rel for arg in "$@"; do eval "${arg// /\\ }" done + # GCC prints the sysroot in canonicalized form, which may be different if there + # is a symlink in the path. Since we need textual match to obtain a relative + # subdirectory path, canonicalize the prefix directory. Since GCC's behavior + # is not documented and hence may change at any time, canonicalize it too just + # for the good measure. + canon_root=$( cd "${multi_root}" && pwd -P ) + canon_prefix=$( cd "${CT_PREFIX_DIR}" && pwd -P ) + # Move only files, directories are for other multilibs. We're looking inside # GCC's directory structure, thus use unmangled multi_os_dir that GCC reports. gcc_dir="${CT_PREFIX_DIR}/${CT_TARGET}/lib/${multi_os_dir_gcc}" @@ -789,6 +803,16 @@ gcc_movelibs() { # GCC didn't install anything outside of sysroot return fi + # Depending on the selected libc, we may or may not have the ${multi_os_dir_gcc} + # created by libc installation. If we do, use it. If we don't, use ${multi_os_dir} + # to avoid creating an otherwise empty directory. + dst_dir="${canon_root}/lib/${multi_os_dir_gcc}" + if [ ! -d "${dst_dir}" ]; then + dst_dir="${canon_root}/lib/${multi_os_dir}" + fi + CT_SanitizeVarDir dst_dir gcc_dir + rel=$( echo "${gcc_dir#${CT_PREFIX_DIR}/}" | sed 's#[^/]\{1,\}#..#g' ) + ls "${gcc_dir}" | while read f; do case "${f}" in *.ld) @@ -798,15 +822,16 @@ gcc_movelibs() { ;; esac if [ -f "${gcc_dir}/${f}" ]; then - CT_DoExecLog ALL mkdir -p "${multi_root}/lib/${multi_os_dir}" - CT_DoExecLog ALL mv "${gcc_dir}/${f}" "${multi_root}/lib/${multi_os_dir}/${f}" + CT_DoExecLog ALL mkdir -p "${dst_dir}" + CT_DoExecLog ALL mv "${gcc_dir}/${f}" "${dst_dir}/${f}" + CT_DoExecLog ALL ln -sf "${rel}/${dst_dir#${canon_prefix}/}/${f}" "${gcc_dir}/${f}" fi done } #------------------------------------------------------------------------------ # Build final gcc to run on host -do_gcc_for_host() { +do_cc_for_host() { local -a final_opts local final_backend @@ -823,7 +848,9 @@ do_gcc_for_host() { if [ "${CT_BARE_METAL}" = "y" ]; then final_opts+=( "mode=baremetal" ) final_opts+=( "build_libgcc=yes" ) - final_opts+=( "build_libstdcxx=yes" ) + if [ "${CT_LIBC_NONE}" != "y" ]; then + final_opts+=( "build_libstdcxx=yes" ) + fi final_opts+=( "build_libgfortran=yes" ) if [ "${CT_STATIC_TOOLCHAIN}" = "y" ]; then final_opts+=( "build_staticlinked=yes" ) @@ -856,19 +883,31 @@ do_gcc_for_host() { # Parameter : Definition : Type : Default # host : the host we run onto : tuple : (none) # prefix : the runtime prefix : dir : (none) +# exec_prefix : prefix for executables : dir : (none) # complibs : the companion libraries prefix : dir : (none) # cflags : cflags to use : string : (empty) # ldflags : ldflags to use : string : (empty) # lang_list : the list of languages to build : string : (empty) # build_manuals : whether to build manuals or not : bool : no +# build_step : build step 'gcc_build', 'gcc_host' +# or 'libstdcxx' : string : (none) do_gcc_backend() { local host local prefix + local exec_prefix local complibs local lang_list local cflags + local cflags_for_build + local cxxflags_for_build + local cflags_for_target + local cxxflags_for_target + local extra_cxxflags_for_target local ldflags local build_manuals + local exec_prefix + local header_dir + local libstdcxx_name local -a host_libstdcxx_flags local -a extra_config local -a final_LDFLAGS @@ -879,22 +918,42 @@ do_gcc_backend() { eval "${arg// /\\ }" done - CT_DoLog EXTRA "Configuring final gcc compiler" + if [ "${exec_prefix}" = "" ]; then + exec_prefix="${prefix}" + fi + + # This function gets called for final gcc and libstdcxx. + case "${build_step}" in + gcc_build|gcc_host) + log_txt="final gcc compiler" + ;; + libstdcxx) + log_txt="libstdc++ library for ${libstdcxx_name}" + ;; + *) + CT_Abort "Internal Error: 'build_step' must be one of: 'gcc_build', 'gcc_host' or 'libstdcxx', not '${build_step:-(empty)}'" + ;; + esac + + CT_DoLog EXTRA "Configuring ${log_txt}" # Enable selected languages extra_config+=("--enable-languages=${lang_list}") - for tmp in ARCH ABI CPU TUNE FPU FLOAT; do + for tmp in ARCH ARCH_32 ARCH_64 ABI CPU CPU_32 CPU_64 TUNE TUNE_32 TUNE_64 FPU FLOAT; do eval tmp="\${CT_ARCH_WITH_${tmp}}" if [ -n "${tmp}" ]; then extra_config+=("${tmp}") fi done - [ "${CT_SHARED_LIBS}" = "y" ] || extra_config+=("--disable-shared") - extra_config+=("--with-pkgversion=${CT_PKGVERSION}") + [ -n "${CT_PKGVERSION}" ] && extra_config+=("--with-pkgversion=${CT_PKGVERSION}") [ -n "${CT_TOOLCHAIN_BUGURL}" ] && extra_config+=("--with-bugurl=${CT_TOOLCHAIN_BUGURL}") + if [ "${CT_SHARED_LIBS}" != "y" ]; then + extra_config+=("--disable-shared") + fi + case "${CT_CC_GCC_SJLJ_EXCEPTIONS}" in y) extra_config+=("--enable-sjlj-exceptions");; m) ;; @@ -906,6 +965,12 @@ do_gcc_backend() { extra_config+=("--disable-__cxa_atexit") fi + case "${CT_CC_GCC_TM_CLONE_REGISTRY}" in + y) extra_config+=("--enable-tm-clone-registry");; + m) ;; + "") extra_config+=("--disable-tm-clone-registry");; + esac + if [ -n "${CT_CC_GCC_ENABLE_CXX_FLAGS}" ]; then extra_config+=("--enable-cxx-flags=${CT_CC_GCC_ENABLE_CXX_FLAGS}") fi @@ -923,11 +988,11 @@ do_gcc_backend() { else extra_config+=(--disable-libgomp) fi - if [ "${CT_CC_GCC_LIBSSP}" = "y" ]; then - extra_config+=(--enable-libssp) - else - extra_config+=(--disable-libssp) - fi + case "${CT_CC_GCC_LIBSSP}" in + y) extra_config+=(--enable-libssp);; + m) ;; + "") extra_config+=(--disable-libssp);; + esac if [ "${CT_CC_GCC_LIBQUADMATH}" = "y" ]; then extra_config+=(--enable-libquadmath) extra_config+=(--enable-libquadmath-support) @@ -950,6 +1015,15 @@ do_gcc_backend() { fi fi + case "${CT_CC_GCC_LIBSTDCXX_VERBOSE}" in + y) extra_config+=("--enable-libstdcxx-verbose");; + "") extra_config+=("--disable-libstdcxx-verbose");; + esac + + if [ "${build_libstdcxx}" = "no" ]; then + extra_config+=(--disable-libstdcxx) + fi + final_LDFLAGS+=("${ldflags}") # *** WARNING ! *** @@ -957,9 +1031,11 @@ do_gcc_backend() { # with the same block in do_gcc_core_backend, above. if [ "${CT_STATIC_TOOLCHAIN}" = "y" ]; then final_LDFLAGS+=("-static") - host_libstdcxx_flags+=("-static-libgcc") - host_libstdcxx_flags+=("-Wl,-Bstatic,-lstdc++") - host_libstdcxx_flags+=("-lm") + if [ "${CT_GCC_older_than_6}" = "y" ]; then + host_libstdcxx_flags+=("-static-libgcc") + host_libstdcxx_flags+=("-Wl,-Bstatic,-lstdc++") + host_libstdcxx_flags+=("-lm") + fi # Companion libraries are build static (eg !shared), so # the libstdc++ is not pulled automatically, although it # is needed. Shoe-horn it in our LDFLAGS @@ -967,7 +1043,7 @@ do_gcc_backend() { final_LDFLAGS+=("-lstdc++") final_LDFLAGS+=("-lm") else - if [ "${CT_CC_GCC_STATIC_LIBSTDCXX}" = "y" ]; then + if [ "${CT_CC_GCC_STATIC_LIBSTDCXX}" = "y" -a "${CT_GCC_older_than_6}" = "y" ]; then # this is from CodeSourcery arm-2010q1-202-arm-none-linux-gnueabi.src.tar.bz2 # build script # INFO: if the host gcc is gcc-4.5 then presumably we could use -static-libstdc++, @@ -1003,6 +1079,11 @@ do_gcc_backend() { else extra_config+=("--disable-lto") fi + case "${CT_CC_GCC_LTO_ZSTD}" in + y) extra_config+=("--with-zstd");; + m) ;; + *) extra_config+=("--without-zstd");; + esac if [ ${#host_libstdcxx_flags[@]} -ne 0 ]; then extra_config+=("--with-host-libstdcxx=${host_libstdcxx_flags[*]}") @@ -1019,9 +1100,11 @@ do_gcc_backend() { fi fi - if [ "${CT_CC_GCC_ENABLE_TARGET_OPTSPACE}" = "y" ]; then + if [ "${CT_CC_GCC_ENABLE_TARGET_OPTSPACE}" = "y" ] || \ + [ "${enable_optspace}" = "yes" ]; then extra_config+=("--enable-target-optspace") fi + if [ "${CT_CC_GCC_DISABLE_PCH}" = "y" ]; then extra_config+=("--disable-libstdcxx-pch") fi @@ -1102,27 +1185,58 @@ do_gcc_backend() { CT_DoLog DEBUG "Extra config passed: '${extra_config[*]}'" + # We may need to modify host/build/target CFLAGS separately below + cflags_for_build="${cflags}" + cxxflags_for_build="${CT_CXXFLAGS_FOR_BUILD}" + cflags_for_target="${CT_TARGET_CFLAGS}" + # Clang's default bracket-depth is 256, and building GCC # requires somewhere between 257 and 512. - if ${CT_BUILD}-gcc --version 2>&1 | grep clang; then - cflags="$cflags "-fbracket-depth=512 + if [ "${host}" = "${CT_BUILD}" ]; then + if ${CT_BUILD}-gcc --version 2>&1 | grep clang; then + cflags="$cflags "-fbracket-depth=512 + cflags_for_build="$cflags_for_build "-fbracket-depth=512 + fi + else + # FIXME we currently don't support clang as host compiler, only as build + if ${CT_BUILD}-gcc --version 2>&1 | grep clang; then + cflags_for_build="$cflags_for_build "-fbracket-depth=512 + fi + fi + + # Assume '-O2' by default for building target libraries. + cflags_for_target="-g -O2 ${cflags_for_target}" + + # Set target CXXFLAGS to CFLAGS if none is provided. + if [ -z "${cxxflags_for_target}" ]; then + cxxflags_for_target="${cflags_for_target}" fi + # Append extra CXXFLAGS if provided. + if [ -n "${extra_cxxflags_for_target}" ]; then + cxxflags_for_target="${cxxflags_for_target} ${extra_cxxflags_for_target}" + fi + + # NB: not using CT_ALL_TARGET_CFLAGS/CT_ALL_TARGET_LDFLAGS here! + # See do_gcc_core_backend for explanation. CT_DoExecLog CFG \ CC_FOR_BUILD="${CT_BUILD}-gcc" \ CFLAGS="${cflags}" \ - CXXFLAGS="${cflags}" \ + CFLAGS_FOR_BUILD="${cflags_for_build}" \ + CXXFLAGS="${cflags} ${cxxflags_for_build}" \ + CXXFLAGS_FOR_BUILD="${cflags_for_build} ${cxxflags_for_build}" \ LDFLAGS="${final_LDFLAGS[*]}" \ - CFLAGS_FOR_TARGET="${CT_TARGET_CFLAGS}" \ - CXXFLAGS_FOR_TARGET="${CT_TARGET_CFLAGS}" \ + CFLAGS_FOR_TARGET="${cflags_for_target}" \ + CXXFLAGS_FOR_TARGET="${cxxflags_for_target}" \ LDFLAGS_FOR_TARGET="${CT_TARGET_LDFLAGS}" \ ${CONFIG_SHELL} \ - "${CT_SRC_DIR}/gcc-${CT_CC_GCC_VERSION}/configure" \ + "${CT_SRC_DIR}/gcc/configure" \ --build=${CT_BUILD} \ --host=${host} \ --target=${CT_TARGET} \ --prefix="${prefix}" \ - ${CC_SYSROOT_ARG} \ + --exec_prefix="${exec_prefix}" \ + ${CT_CC_SYSROOT_ARG} \ "${extra_config[@]}" \ --with-local-prefix="${CT_SYSROOT_DIR}" \ --enable-long-long \ @@ -1130,11 +1244,11 @@ do_gcc_backend() { if [ "${CT_CANADIAN}" = "y" ]; then CT_DoLog EXTRA "Building libiberty" - CT_DoExecLog ALL make ${JOBSFLAGS} all-build-libiberty + CT_DoExecLog ALL make ${CT_JOBSFLAGS} all-build-libiberty fi CT_DoLog EXTRA "Building final gcc compiler" - CT_DoExecLog ALL make ${JOBSFLAGS} all + CT_DoExecLog ALL make ${CT_JOBSFLAGS} all # See the note on issues with parallel 'make install' in GCC above. CT_DoLog EXTRA "Installing final gcc compiler" @@ -1171,4 +1285,11 @@ do_gcc_backend() { cc_gcc_multilib_housekeeping cc="${prefix}/bin/${CT_TARGET}-${CT_CC}" \ host="${host}" + + # If binutils want the LTO plugin, point them to it + if [ -d "${CT_PREFIX_DIR}/lib/bfd-plugins" -a "${build_step}" = "gcc_host" ]; then + local gcc_version=$(cat "${CT_SRC_DIR}/gcc/gcc/BASE-VER" ) + CT_DoExecLog ALL ln -sfv "../../libexec/gcc/${CT_TARGET}/${gcc_version}/liblto_plugin.so" \ + "${CT_PREFIX_DIR}/lib/bfd-plugins/liblto_plugin.so" + fi } |