crosstool-ng: scripts/build/cc/gcc.sh@dd71df95903a

     1 # This file adds the function to build the gcc C compiler

     2 # Copyright 2007 Yann E. MORIN

     3 # Licensed under the GPL v2. See COPYING in the root of this package

     5 # Download gcc

     6 do_cc_get() {

     7     local linaro_version

     8     local linaro_series

     9     local linaro_base_url="http://launchpad.net/gcc-linaro"

    12     # Account for the Linaro versioning

    13     linaro_version="$( echo "${CT_CC_VERSION}"      \

    14                        |sed -r -e 's/^linaro-//;'   \

    15                      )"

    16     linaro_series="$( echo "${linaro_version}"      \

    17                       |sed -r -e 's/-.*//;'         \

    18                     )"

    20     # Ah! gcc folks are kind of 'different': they store the tarballs in

    21     # subdirectories of the same name! That's because gcc is such /crap/ that

    22     # it is such /big/ that it needs being splitted for distribution! Sad. :-(

    23     # Arrgghh! Some of those versions does not follow this convention:

    24     # gcc-3.3.3 lives in releases/gcc-3.3.3, while gcc-2.95.* isn't in a

    25     # subdirectory! You bastard!

    26     CT_GetFile "gcc-${CT_CC_VERSION}"                                                       \

    27                {ftp,http}://ftp.gnu.org/gnu/gcc{,{,/releases}/gcc-${CT_CC_VERSION}}         \

    28                ftp://ftp.irisa.fr/pub/mirrors/gcc.gnu.org/gcc/releases/gcc-${CT_CC_VERSION} \

    29                ftp://ftp.uvsq.fr/pub/gcc/snapshots/${CT_CC_VERSION}                         \

    30                "${linaro_base_url}/${linaro_series}/${linaro_version}/+download"

    32     # Starting with GCC 4.3, ecj is used for Java, and will only be

    33     # built if the configure script finds ecj.jar at the top of the

    34     # GCC source tree, which will not be there unless we get it and

    35     # put it there ourselves

    36     if [ "${CT_CC_LANG_JAVA_USE_ECJ}" = "y" ]; then

    37         CT_GetFile ecj-latest .jar ftp://gcc.gnu.org/pub/java   \

    38                                    ftp://sourceware.org/pub/java

    39     fi

    40 }

    42 # Extract gcc

    43 do_cc_extract() {

    44     CT_Extract "gcc-${CT_CC_VERSION}"

    45     CT_Patch "gcc" "${CT_CC_VERSION}"

    47     # Copy ecj-latest.jar to ecj.jar at the top of the GCC source tree

    48     if [ "${CT_CC_LANG_JAVA_USE_ECJ}" = "y"                     \

    49          -a ! -f "${CT_SRC_DIR}/gcc-${CT_CC_VERSION}/ecj.jar"   \

    50        ]; then

    51         CT_DoExecLog ALL cp -v "${CT_TARBALLS_DIR}/ecj-latest.jar" "${CT_SRC_DIR}/gcc-${CT_CC_VERSION}/ecj.jar"

    52     fi

    53 }

    55 #------------------------------------------------------------------------------

    56 # Core gcc pass 1

    57 do_cc_core_pass_1() {

    58     local -a core_opts

    59     local do_core

    61     # If we're building for bare metal, build the static core gcc,

    62     # with libgcc.

    63     # In case we're not bare metal and building a canadian compiler, do nothing

    64     # In case we're not bare metal, and we're NPTL, build the static core gcc.

    65     # In any other case, do nothing.

    66     case "${CT_BARE_METAL},${CT_CANADIAN},${CT_THREADS}" in

    67         y,*,*)

    68             do_core=y

    69             core_opts+=( "mode=static" )

    70             core_opts+=( "complibs=${CT_COMPLIBS_DIR}" )

    71             ;;

    72         ,y,*)

    73             ;;

    74         ,,nptl)

    75             do_core=y

    76             core_opts+=( "mode=static" )

    77             core_opts+=( "complibs=${CT_COMPLIBS_DIR}" )

    78             ;;

    79         *)

    80             ;;

    81     esac

    83     if [ "${do_core}" = "y" ]; then

    84         do_cc_core_backend "${core_opts[@]}"

    85     fi

    86 }

    88 # Core gcc pass 2

    89 do_cc_core_pass_2() {

    90     local -a core_opts

    91     local do_core

    93     # In case we're building for bare metal, do nothing, we already have

    94     # our compiler.

    95     # In case we're not bare metal and building a canadian compiler, do nothing

    96     # In case we're NPTL, build the shared core gcc and the target libgcc.

    97     # In any other case, build the static core gcc and, if using gcc-4.3+,

    98     # also build the target libgcc.

    99     case "${CT_BARE_METAL},${CT_CANADIAN},${CT_THREADS}" in

   100         y,*,*)

   101             do_core=y

   102             core_opts+=( "mode=baremetal" )

   103             core_opts+=( "build_libgcc=yes" )

   104             core_opts+=( "build_libstdcxx=yes" )

   105             core_opts+=( "complibs=${CT_COMPLIBS_DIR}" )

   106             if [ "${CT_STATIC_TOOLCHAIN}" = "y" ]; then

   107                 core_opts+=( "build_staticlinked=yes" )

   108             fi

   109             core_opts+=( "build_manuals=yes" )

   110             ;;

   111         ,y,*)   ;;

   112         ,,nptl)

   113             do_core=y

   114             core_opts+=( "mode=shared" )

   115             core_opts+=( "build_libgcc=yes" )

   116             core_opts+=( "complibs=${CT_COMPLIBS_DIR}" )

   117             ;;

   118         ,,win32)

   119             do_core=y

   120             core_opts+=( "mode=static" )

   121             core_opts+=( "build_libgcc=yes" )

   122             core_opts+=( "complibs=${CT_COMPLIBS_DIR}" )

   123             ;;

   124         *)

   125             do_core=y

   126             core_opts+=( "mode=static" )

   127             core_opts+=( "complibs=${CT_COMPLIBS_DIR}" )

   128             if [ "${CT_CC_GCC_4_3_or_later}" = "y" ]; then

   129                 core_opts+=( "build_libgcc=yes" )

   130             fi

   131             ;;

   132     esac

   134     if [ "${do_core}" = "y" ]; then

   135         do_cc_core_backend "${core_opts[@]}"

   136     fi

   137 }

   139 #------------------------------------------------------------------------------

   140 # Build core gcc

   141 # This function is used to build both the static and the shared core C compiler,

   142 # with or without the target libgcc. We need to know wether:

   143 #  - we're building static, shared or bare metal: mode=[static|shared|baremetal]

   144 #  - we need to build libgcc or not             : build_libgcc=[yes|no]       (default: no)

   145 #  - we need to build libstdc++ or not          : build_libstdcxx=[yes|no]    (default: no)

   146 #  - we need to build statically linked or not  : build_staticlinked=[yes|no] (default: no)

   147 #  - where to find the companion libs (prefix)  : complibs=<prefix_dir>       (no default value)

   148 # Usage: do_cc_core_backend mode=[static|shared|baremetal] build_libgcc=[yes|no] build_staticlinked=[yes|no]

   149 do_cc_core_backend() {

   150     local mode

   151     local build_libgcc=no

   152     local build_libstdcxx=no

   153     local build_staticlinked=no

   154     local build_manuals=no

   155     local core_prefix_dir

   156     local complibs

   157     local lang_opt

   158     local tmp

   159     local -a host_libstdcxx_flags

   160     local -a extra_config

   161     local -a core_LDFLAGS

   162     local -a core_targets

   163     local arg

   165     for arg in "$@"; do

   166         eval "${arg// /\\ }"

   167     done

   169     lang_opt=c

   170     case "${mode}" in

   171         static)

   172             core_prefix_dir="${CT_CC_CORE_STATIC_PREFIX_DIR}"

   173             extra_config+=("--with-newlib")

   174             extra_config+=("--enable-threads=no")

   175             extra_config+=("--disable-shared")

   176             copy_headers=y  # For baremetal, as there's no headers to copy,

   177                             # we copy an empty directory. So, who cares?

   178             ;;

   179         shared)

   180             core_prefix_dir="${CT_CC_CORE_SHARED_PREFIX_DIR}"

   181             extra_config+=("--enable-shared")

   182             copy_headers=y

   183             ;;

   184         baremetal)

   185             core_prefix_dir="${CT_PREFIX_DIR}"

   186             extra_config+=("--with-newlib")

   187             extra_config+=("--enable-threads=no")

   188             extra_config+=("--disable-shared")

   189             [ "${CT_CC_LANG_CXX}" = "y" ] && lang_opt="${lang_opt},c++"

   190             copy_headers=n

   191             ;;

   192         *)

   193             CT_Abort "Internal Error: 'mode' must be one of: 'static', 'shared' or 'baremetal', not '${mode:-(empty)}'"

   194             ;;

   195     esac

   197     CT_DoStep INFO "Installing ${mode} core C compiler"

   198     mkdir -p "${CT_BUILD_DIR}/build-cc-core-${mode}"

   199     cd "${CT_BUILD_DIR}/build-cc-core-${mode}"

   201     if [ "${CT_CC_GCC_HAS_PKGVERSION_BUGURL}" = "y" ]; then

   202         # Bare metal delivers the core compiler as final compiler, so add version info and bugurl

   203         extra_config+=("--with-pkgversion=${CT_PKGVERSION}")

   204         [ -n "${CT_TOOLCHAIN_BUGURL}" ] && extra_config+=("--with-bugurl=${CT_TOOLCHAIN_BUGURL}")

   205     fi

   207     if [ "${copy_headers}" = "y" ]; then

   208         CT_DoLog DEBUG "Copying headers to install area of bootstrap gcc, so it can build libgcc2"

   209         CT_DoExecLog ALL cp -a "${CT_HEADERS_DIR}" "${core_prefix_dir}/${CT_TARGET}/include"

   210     fi

   212     CT_DoLog EXTRA "Configuring ${mode} core C compiler"

   214     for tmp in ARCH ABI CPU TUNE FPU FLOAT; do

   215         eval tmp="\${CT_ARCH_WITH_${tmp}}"

   216         if [ -n "${tmp}" ]; then

   217             extra_config+=("${tmp}")

   218         fi

   219     done

   220     if [ "${CT_CC_CXA_ATEXIT}" = "y" ]; then

   221         extra_config+=("--enable-__cxa_atexit")

   222     else

   223         extra_config+=("--disable-__cxa_atexit")

   224     fi

   226     # *** WARNING ! ***

   227     # Keep this full if-else-if-elif-fi-fi block in sync

   228     # with the same block in do_cc, below.

   229     if [ "${build_staticlinked}" = "yes" ]; then

   230         core_LDFLAGS+=("-static")

   231         host_libstdcxx_flags+=("-static-libgcc")

   232         host_libstdcxx_flags+=("-Wl,-Bstatic,-lstdc++")

   233         host_libstdcxx_flags+=("-lm")

   234         # Companion libraries are build static (eg !shared), so

   235         # the libstdc++ is not pulled automatically, although it

   236         # is needed. Shoe-horn it in our LDFLAGS

   237         # Ditto libm on some Fedora boxen

   238         core_LDFLAGS+=("-lstdc++")

   239         core_LDFLAGS+=("-lm")

   240     else

   241         if [ "${CT_CC_STATIC_LIBSTDCXX}" = "y" ]; then

   242             # this is from CodeSourcery arm-2010q1-202-arm-none-linux-gnueabi.src.tar.bz2

   243             # build script

   244             # INFO: if the host gcc is gcc-4.5 then presumably we could use -static-libstdc++,

   245             #       see http://gcc.gnu.org/ml/gcc-patches/2009-06/msg01635.html

   246             host_libstdcxx_flags+=("-static-libgcc")

   247             host_libstdcxx_flags+=("-Wl,-Bstatic,-lstdc++,-Bdynamic")

   248             host_libstdcxx_flags+=("-lm")

   249         elif [ "${CT_COMPLIBS_SHARED}" != "y" ]; then

   250             # When companion libraries are build static (eg !shared),

   251             # the libstdc++ is not pulled automatically, although it

   252             # is needed. Shoe-horn it in our LDFLAGS

   253             # Ditto libm on some Fedora boxen

   254             core_LDFLAGS+=("-lstdc++")

   255             core_LDFLAGS+=("-lm")

   256         fi

   257     fi

   259     if [ "${CT_CC_GCC_USE_GMP_MPFR}" = "y" ]; then

   260         extra_config+=("--with-gmp=${complibs}")

   261         extra_config+=("--with-mpfr=${complibs}")

   262     fi

   263     if [ "${CT_CC_GCC_USE_MPC}" = "y" ]; then

   264         extra_config+=("--with-mpc=${complibs}")

   265     fi

   266     if [ "${CT_CC_GCC_USE_GRAPHITE}" = "y" ]; then

   267         extra_config+=("--with-ppl=${complibs}")

   268         # With PPL 0.11+, also pull libpwl if needed

   269         if [ "${CT_PPL_NEEDS_LIBPWL}" = "y" ]; then

   270             host_libstdcxx_flags+=("-L${complibs}/lib")

   271             host_libstdcxx_flags+=("-lpwl")

   272         fi

   273         extra_config+=("--with-cloog=${complibs}")

   274     elif [ "${CT_CC_GCC_HAS_GRAPHITE}" = "y" ]; then

   275         extra_config+=("--with-ppl=no")

   276         extra_config+=("--with-cloog=no")

   277     fi

   278     if [ "${CT_CC_GCC_USE_LTO}" = "y" ]; then

   279         extra_config+=("--with-libelf=${complibs}")

   280         extra_config+=("--enable-lto")

   281     elif [ "${CT_CC_GCC_HAS_LTO}" = "y" ]; then

   282         extra_config+=("--with-libelf=no")

   283         extra_config+=("--disable-lto")

   284     fi

   286     if [ ${#host_libstdcxx_flags[@]} -ne 0 ]; then

   287         extra_config+=("--with-host-libstdcxx=${host_libstdcxx_flags[*]}")

   288     fi

   290     if [ "${CT_CC_GCC_ENABLE_TARGET_OPTSPACE}" = "y" ]; then

   291         extra_config+=("--enable-target-optspace")

   292     fi

   294     case "${CT_CC_GCC_LDBL_128}" in

   295         y)  extra_config+=("--with-long-double-128");;

   296         m)  ;;

   297         "") extra_config+=("--without-long-double-128");;

   298     esac

   300     if [ "${CT_CC_GCC_BUILD_ID}" = "y" ]; then

   301         extra_config+=( --enable-linker-build-id )

   302     fi

   304     case "${CT_CC_GCC_LNK_HASH_STYLE}" in

   305         "") ;;

   306         *)  extra_config+=( "--with-linker-hash-style=${CT_CC_GCC_LNK_HASH_STYLE}" );;

   307     esac

   309     case "${CT_ARCH}" in

   310         mips)

   311             case "${CT_CC_GCC_mips_llsc}" in

   312                 y)  extra_config+=( --with-llsc );;

   313                 m)  ;;

   314                 *)  extra_config+=( --without-llsc );;

   315             esac

   316             case "${CT_CC_GCC_mips_synci}" in

   317                 y)  extra_config+=( --with-synci );;

   318                 m)  ;;

   319                 *)  extra_config+=( --without-synci );;

   320             esac

   321             if [ "${CT_CC_GCC_mips_plt}" ]; then

   322                 extra_config+=( --with-mips-plt )

   323             fi

   324             ;; # ARCH is mips

   325     esac

   327     extra_config+=(--disable-libgomp)

   328     extra_config+=(--disable-libmudflap)

   330     [ "${CT_TOOLCHAIN_ENABLE_NLS}" != "y" ] && extra_config+=("--disable-nls")

   332     [ "${CT_CC_GCC_DISABLE_PCH}" = "y" ] && extra_config+=("--disable-libstdcxx-pch")

   334     if [ "${CT_CC_GCC_SYSTEM_ZLIB}" = "y" ]; then

   335         extra_config+=("--with-system-zlib")

   336     fi

   338     if [ "${CT_MULTILIB}" = "y" ]; then

   339         extra_config+=("--enable-multilib")

   340     else

   341         extra_config+=("--disable-multilib")

   342     fi

   344     CT_DoLog DEBUG "Extra config passed: '${extra_config[*]}'"

   346     # Use --with-local-prefix so older gccs don't look in /usr/local (http://gcc.gnu.org/PR10532)

   347     CT_DoExecLog CFG                                \

   348     CC_FOR_BUILD="${CT_BUILD}-gcc"                  \

   349     CFLAGS="${CT_CFLAGS_FOR_HOST}"                  \

   350     LDFLAGS="${core_LDFLAGS[*]}"                    \

   351     "${CT_SRC_DIR}/gcc-${CT_CC_VERSION}/configure"  \

   352         --build=${CT_BUILD}                         \

   353         --host=${CT_HOST}                           \

   354         --target=${CT_TARGET}                       \

   355         --prefix="${core_prefix_dir}"               \

   356         --with-local-prefix="${CT_SYSROOT_DIR}"     \

   357         --disable-libmudflap                        \

   358         ${CC_CORE_SYSROOT_ARG}                      \

   359         "${extra_config[@]}"                        \

   360         --enable-languages="${lang_opt}"            \

   361         "${CT_CC_CORE_EXTRA_CONFIG_ARRAY[@]}"

   363     if [ "${build_libgcc}" = "yes" ]; then

   364         # HACK: we need to override SHLIB_LC from gcc/config/t-slibgcc-elf-ver or

   365         # gcc/config/t-libunwind so -lc is removed from the link for

   366         # libgcc_s.so, as we do not have a target -lc yet.

   367         # This is not as ugly as it appears to be ;-) All symbols get resolved

   368         # during the glibc build, and we provide a proper libgcc_s.so for the

   369         # cross toolchain during the final gcc build.

   370         #

   371         # As we cannot modify the source tree, nor override SHLIB_LC itself

   372         # during configure or make, we have to edit the resultant

   373         # gcc/libgcc.mk itself to remove -lc from the link.

   374         # This causes us to have to jump through some hoops...

   375         #

   376         # To produce libgcc.mk to edit we firstly require libiberty.a,

   377         # so we configure then build it.

   378         # Next we have to configure gcc, create libgcc.mk then edit it...

   379         # So much easier if we just edit the source tree, but hey...

   380         if [ ! -f "${CT_SRC_DIR}/gcc-${CT_CC_VERSION}/gcc/BASE-VER" ]; then

   381             CT_DoExecLog CFG make ${JOBSFLAGS} configure-libiberty

   382             CT_DoExecLog ALL make ${JOBSFLAGS} -C libiberty libiberty.a

   383             CT_DoExecLog CFG make ${JOBSFLAGS} configure-gcc configure-libcpp

   384             CT_DoExecLog ALL make ${JOBSFLAGS} all-libcpp

   385         else

   386             CT_DoExecLog CFG make ${JOBSFLAGS} configure-gcc configure-libcpp configure-build-libiberty

   387             CT_DoExecLog ALL make ${JOBSFLAGS} all-libcpp all-build-libiberty

   388         fi

   389         # HACK: gcc-4.2 uses libdecnumber to build libgcc.mk, so build it here.

   390         if [ -d "${CT_SRC_DIR}/gcc-${CT_CC_VERSION}/libdecnumber" ]; then

   391             CT_DoExecLog CFG make ${JOBSFLAGS} configure-libdecnumber

   392             CT_DoExecLog ALL make ${JOBSFLAGS} -C libdecnumber libdecnumber.a

   393         fi

   395         # Starting with GCC 4.3, libgcc.mk is no longer built,

   396         # and libgcc.mvars is used instead.

   398         if [ "${CT_CC_GCC_4_3_or_later}" = "y" ]; then

   399             libgcc_rule="libgcc.mvars"

   400             core_targets=( gcc target-libgcc )

   401         else

   402             libgcc_rule="libgcc.mk"

   403             core_targets=( gcc )

   404         fi

   406         # On bare metal and canadian build the host-compiler is used when

   407         # actually the build-system compiler is required. Choose the correct

   408         # compilers for canadian build and use the defaults on other

   409         # configurations.

   410         if [ "${CT_BARE_METAL},${CT_CANADIAN}" = "y,y" ]; then

   411             repair_cc="CC_FOR_BUILD=${CT_BUILD}-gcc \

   412                        GCC_FOR_TARGET=${CT_TARGET}-gcc"

   413         else

   414             repair_cc=""

   415         fi

   417         CT_DoExecLog ALL make ${JOBSFLAGS} -C gcc ${libgcc_rule} \

   418                               ${repair_cc}

   419         sed -r -i -e 's@-lc@@g' gcc/${libgcc_rule}

   420     else # build_libgcc

   421         core_targets=( gcc )

   422     fi   # ! build libgcc

   423     if [    "${build_libstdcxx}" = "yes"    \

   424          -a "${CT_CC_LANG_CXX}"  = "y"      \

   425        ]; then

   426         core_targets+=( target-libstdc++-v3 )

   427     fi

   429     CT_DoLog EXTRA "Building ${mode} core C compiler"

   430     CT_DoExecLog ALL make ${JOBSFLAGS} "${core_targets[@]/#/all-}"

   432     CT_DoLog EXTRA "Installing ${mode} core C compiler"

   433     CT_DoExecLog ALL make ${JOBSFLAGS} "${core_targets[@]/#/install-}"

   435     if [ "${CT_BUILD_MANUALS}" = "y" -a "${build_manuals}" = "yes" ]; then

   436         CT_DoLog EXTRA "Building the GCC manuals"

   437         CT_DoExecLog ALL make pdf html

   438         CT_DoLog EXTRA "Installing the GCC manuals"

   439         CT_DoExecLog ALL make install-{pdf,html}-gcc

   440     fi

   442     # Create a symlink ${CT_TARGET}-cc to ${CT_TARGET}-gcc to always be able

   443     # to call the C compiler with the same, somewhat canonical name.

   444     # check whether compiler has an extension

   445     file="$( ls -1 "${core_prefix_dir}/bin/${CT_TARGET}-gcc."* 2>/dev/null || true )"

   446     [ -z "${file}" ] || ext=".${file##*.}"

   447     CT_DoExecLog ALL ln -sfv "${CT_TARGET}-gcc${ext}" "${core_prefix_dir}/bin/${CT_TARGET}-cc${ext}"

   449     if [ "${CT_MULTILIB}" = "y" ]; then

   450         multilibs=( $( "${core_prefix_dir}/bin/${CT_TARGET}-gcc" -print-multi-lib   \

   451                        |tail -n +2 ) )

   452         if [ ${#multilibs[@]} -ne 0 ]; then

   453             CT_DoLog EXTRA "gcc configured with these multilibs (besides the default):"

   454             for i in "${multilibs[@]}"; do

   455                 dir="${i%%;*}"

   456                 flags="${i#*;}"

   457                 CT_DoLog EXTRA "   ${flags//@/ -}  -->  ${dir}/"

   458             done

   459         else

   460             CT_DoLog WARN "gcc configured for multilib, but none available"

   461         fi

   462     fi

   464     CT_EndStep

   465 }

   467 #------------------------------------------------------------------------------

   468 # Build final gcc

   469 do_cc() {

   470     local -a host_libstdcxx_flags

   471     local -a extra_config

   472     local -a final_LDFLAGS

   473     local tmp

   475     # If building for bare metal, nothing to be done here, the static core conpiler is enough!

   476     [ "${CT_BARE_METAL}" = "y" ] && return 0

   478     CT_DoStep INFO "Installing final compiler"

   480     mkdir -p "${CT_BUILD_DIR}/build-cc"

   481     cd "${CT_BUILD_DIR}/build-cc"

   483     CT_DoLog EXTRA "Configuring final compiler"

   485     # Enable selected languages

   486     lang_opt="c"

   487     [ "${CT_CC_LANG_CXX}" = "y"      ] && lang_opt="${lang_opt},c++"

   488     [ "${CT_CC_LANG_FORTRAN}" = "y"  ] && lang_opt="${lang_opt},fortran"

   489     [ "${CT_CC_LANG_ADA}" = "y"      ] && lang_opt="${lang_opt},ada"

   490     [ "${CT_CC_LANG_JAVA}" = "y"     ] && lang_opt="${lang_opt},java"

   491     [ "${CT_CC_LANG_OBJC}" = "y"     ] && lang_opt="${lang_opt},objc"

   492     [ "${CT_CC_LANG_OBJCXX}" = "y"   ] && lang_opt="${lang_opt},obj-c++"

   493     CT_Test "Building ADA language is not yet supported. Will try..." "${CT_CC_LANG_ADA}" = "y"

   494     CT_Test "Building Objective-C language is not yet supported. Will try..." "${CT_CC_LANG_OBJC}" = "y"

   495     CT_Test "Building Objective-C++ language is not yet supported. Will try..." "${CT_CC_LANG_OBJCXX}" = "y"

   496     CT_Test "Building ${CT_CC_LANG_OTHERS//,/ } language(s) is not yet supported. Will try..." -n "${CT_CC_LANG_OTHERS}"

   497     lang_opt=$(echo "${lang_opt},${CT_CC_LANG_OTHERS}" |sed -r -e 's/,+/,/g; s/,*$//;')

   499     extra_config+=("--enable-languages=${lang_opt}")

   500     for tmp in ARCH ABI CPU TUNE FPU FLOAT; do

   501         eval tmp="\${CT_ARCH_WITH_${tmp}}"

   502         if [ -n "${tmp}" ]; then

   503             extra_config+=("${tmp}")

   504         fi

   505     done

   507     [ "${CT_SHARED_LIBS}" = "y" ] || extra_config+=("--disable-shared")

   508     if [ "${CT_CC_GCC_HAS_PKGVERSION_BUGURL}" = "y" ]; then

   509         extra_config+=("--with-pkgversion=${CT_PKGVERSION}")

   510         [ -n "${CT_TOOLCHAIN_BUGURL}" ] && extra_config+=("--with-bugurl=${CT_TOOLCHAIN_BUGURL}")

   511     fi

   512     case "${CT_CC_GCC_SJLJ_EXCEPTIONS}" in

   513         y)  extra_config+=("--enable-sjlj-exceptions");;

   514         m)  ;;

   515         "") extra_config+=("--disable-sjlj-exceptions");;

   516     esac

   517     if [ "${CT_CC_CXA_ATEXIT}" = "y" ]; then

   518         extra_config+=("--enable-__cxa_atexit")

   519     else

   520         extra_config+=("--disable-__cxa_atexit")

   521     fi

   522     if [ -n "${CT_CC_ENABLE_CXX_FLAGS}" ]; then

   523         extra_config+=("--enable-cxx-flags=${CT_CC_ENABLE_CXX_FLAGS}")

   524     fi

   525     if [ "${CT_CC_GCC_LIBMUDFLAP}" = "y" ]; then

   526         extra_config+=(--enable-libmudflap)

   527     else

   528         extra_config+=(--disable-libmudflap)

   529     fi

   530     if [ "${CT_CC_GCC_LIBGOMP}" = "y" ]; then

   531         extra_config+=(--enable-libgomp)

   532     else

   533         extra_config+=(--disable-libgomp)

   534     fi

   535     if [ "${CT_CC_GCC_LIBSSP}" = "y" ]; then

   536         extra_config+=(--enable-libssp)

   537     else

   538         extra_config+=(--disable-libssp)

   539     fi

   541     # *** WARNING ! ***

   542     # Keep this full if-else-if-elif-fi-fi block in sync

   543     # with the same block in do_cc_core, above.

   544     if [ "${CT_STATIC_TOOLCHAIN}" = "y" ]; then

   545         final_LDFLAGS+=("-static")

   546         host_libstdcxx_flags+=("-static-libgcc")

   547         host_libstdcxx_flags+=("-Wl,-Bstatic,-lstdc++")

   548         host_libstdcxx_flags+=("-lm")

   549         # Companion libraries are build static (eg !shared), so

   550         # the libstdc++ is not pulled automatically, although it

   551         # is needed. Shoe-horn it in our LDFLAGS

   552         # Ditto libm on some Fedora boxen

   553         final_LDFLAGS+=("-lstdc++")

   554         final_LDFLAGS+=("-lm")

   555     else

   556         if [ "${CT_CC_STATIC_LIBSTDCXX}" = "y" ]; then

   557             # this is from CodeSourcery arm-2010q1-202-arm-none-linux-gnueabi.src.tar.bz2

   558             # build script

   559             # INFO: if the host gcc is gcc-4.5 then presumably we could use -static-libstdc++,

   560             #       see http://gcc.gnu.org/ml/gcc-patches/2009-06/msg01635.html

   561             host_libstdcxx_flags+=("-static-libgcc")

   562             host_libstdcxx_flags+=("-Wl,-Bstatic,-lstdc++,-Bdynamic")

   563             host_libstdcxx_flags+=("-lm")

   564         elif [ "${CT_COMPLIBS_SHARED}" != "y" ]; then

   565             # When companion libraries are build static (eg !shared),

   566             # the libstdc++ is not pulled automatically, although it

   567             # is needed. Shoe-horn it in our LDFLAGS

   568             # Ditto libm on some Fedora boxen

   569             final_LDFLAGS+=("-lstdc++")

   570             final_LDFLAGS+=("-lm")

   571         fi

   572     fi

   574     if [ "${CT_CC_GCC_USE_GMP_MPFR}" = "y" ]; then

   575         extra_config+=("--with-gmp=${CT_COMPLIBS_DIR}")

   576         extra_config+=("--with-mpfr=${CT_COMPLIBS_DIR}")

   577     fi

   578     if [ "${CT_CC_GCC_USE_MPC}" = "y" ]; then

   579         extra_config+=("--with-mpc=${CT_COMPLIBS_DIR}")

   580     fi

   581     if [ "${CT_CC_GCC_USE_GRAPHITE}" = "y" ]; then

   582         extra_config+=("--with-ppl=${CT_COMPLIBS_DIR}")

   583         # With PPL 0.11+, also pull libpwl if needed

   584         if [ "${CT_PPL_NEEDS_LIBPWL}" = "y" ]; then

   585             host_libstdcxx_flags+=("-L${CT_COMPLIBS_DIR}/lib")

   586             host_libstdcxx_flags+=("-lpwl")

   587         fi

   588         extra_config+=("--with-cloog=${CT_COMPLIBS_DIR}")

   589     elif [ "${CT_CC_GCC_HAS_GRAPHITE}" = "y" ]; then

   590         extra_config+=("--with-ppl=no")

   591         extra_config+=("--with-cloog=no")

   592     fi

   593     if [ "${CT_CC_GCC_USE_LTO}" = "y" ]; then

   594         extra_config+=("--with-libelf=${CT_COMPLIBS_DIR}")

   595     elif [ "${CT_CC_GCC_HAS_LTO}" = "y" ]; then

   596         extra_config+=("--with-libelf=no")

   597     fi

   599     if [ ${#host_libstdcxx_flags[@]} -ne 0 ]; then

   600         extra_config+=("--with-host-libstdcxx=${host_libstdcxx_flags[*]}")

   601     fi

   603     if [ "${CT_THREADS}" = "none" ]; then

   604         extra_config+=("--disable-threads")

   605         if [ "${CT_CC_GCC_4_2_or_later}" = y ]; then

   606             CT_Test "Disabling libgomp for no-thread gcc>=4.2" "${CT_CC_GCC_LIBGOMP}" = "Y"

   607             extra_config+=("--disable-libgomp")

   608         fi

   609     else

   610         if [ "${CT_THREADS}" = "win32" ]; then

   611             extra_config+=("--enable-threads=win32")

   612             extra_config+=("--disable-win32-registry")

   613         else

   614             extra_config+=("--enable-threads=posix")

   615         fi

   616     fi

   618     if [ "${CT_CC_GCC_ENABLE_TARGET_OPTSPACE}" = "y" ]; then

   619         extra_config+=("--enable-target-optspace")

   620     fi

   621     if [ "${CT_CC_GCC_DISABLE_PCH}" = "y" ]; then

   622         extra_config+=("--disable-libstdcxx-pch")

   623     fi

   625     case "${CT_CC_GCC_LDBL_128}" in

   626         y)  extra_config+=("--with-long-double-128");;

   627         m)  ;;

   628         "") extra_config+=("--without-long-double-128");;

   629     esac

   631     if [ "${CT_CC_GCC_BUILD_ID}" = "y" ]; then

   632         extra_config+=( --enable-linker-build-id )

   633     fi

   635     case "${CT_CC_GCC_LNK_HASH_STYLE}" in

   636         "") ;;

   637         *)  extra_config+=( "--with-linker-hash-style=${CT_CC_GCC_LNK_HASH_STYLE}" );;

   638     esac

   640     if [ "${CT_CC_GCC_ENABLE_PLUGINS}" = "y" ]; then

   641         extra_config+=( --enable-plugin )

   642     fi

   643     if [ "${CT_CC_GCC_GOLD}" = "y" ]; then

   644         extra_config+=( --enable-gold )

   645     fi

   647     case "${CT_ARCH}" in

   648         mips)

   649             case "${CT_CC_GCC_mips_llsc}" in

   650                 y)  extra_config+=( --with-llsc );;

   651                 m)  ;;

   652                 *)  extra_config+=( --without-llsc );;

   653             esac

   654             case "${CT_CC_GCC_mips_synci}" in

   655                 y)  extra_config+=( --with-synci );;

   656                 m)  ;;

   657                 *)  extra_config+=( --without-synci );;

   658             esac

   659             if [ "${CT_CC_GCC_mips_plt}" ]; then

   660                 extra_config+=( --with-mips-plt )

   661             fi

   662             ;; # ARCH is mips

   663     esac

   665     [ "${CT_TOOLCHAIN_ENABLE_NLS}" != "y" ] && extra_config+=("--disable-nls")

   667     if [ "${CT_CC_GCC_SYSTEM_ZLIB}" = "y" ]; then

   668         extra_config+=("--with-system-zlib")

   669     fi

   671     if [ "${CT_MULTILIB}" = "y" ]; then

   672         extra_config+=("--enable-multilib")

   673     else

   674         extra_config+=("--disable-multilib")

   675     fi

   677     CT_DoLog DEBUG "Extra config passed: '${extra_config[*]}'"

   679     CT_DoExecLog CFG                                \

   680     CC_FOR_BUILD="${CT_BUILD}-gcc"                  \

   681     CFLAGS="${CT_CFLAGS_FOR_HOST}"                  \

   682     LDFLAGS="${final_LDFLAGS[*]}"                   \

   683     CFLAGS_FOR_TARGET="${CT_TARGET_CFLAGS}"         \

   684     CXXFLAGS_FOR_TARGET="${CT_TARGET_CFLAGS}"       \

   685     LDFLAGS_FOR_TARGET="${CT_TARGET_LDFLAGS}"       \

   686     "${CT_SRC_DIR}/gcc-${CT_CC_VERSION}/configure"  \

   687         --build=${CT_BUILD}                         \

   688         --host=${CT_HOST}                           \

   689         --target=${CT_TARGET}                       \

   690         --prefix="${CT_PREFIX_DIR}"                 \

   691         ${CC_SYSROOT_ARG}                           \

   692         "${extra_config[@]}"                        \

   693         --with-local-prefix="${CT_SYSROOT_DIR}"     \

   694         --enable-c99                                \

   695         --enable-long-long                          \

   696         "${CT_CC_EXTRA_CONFIG_ARRAY[@]}"

   698     if [ "${CT_CANADIAN}" = "y" ]; then

   699         CT_DoLog EXTRA "Building libiberty"

   700         CT_DoExecLog ALL make ${JOBSFLAGS} all-build-libiberty

   701     fi

   703     CT_DoLog EXTRA "Building final compiler"

   704     CT_DoExecLog ALL make ${JOBSFLAGS} all

   706     CT_DoLog EXTRA "Installing final compiler"

   707     CT_DoExecLog ALL make ${JOBSFLAGS} install

   709     if [ "${CT_BUILD_MANUALS}" = "y" ]; then

   710         CT_DoLog EXTRA "Building the GCC manuals"

   711         CT_DoExecLog ALL make ${JOBSFLAGS} pdf html

   712         CT_DoLog EXTRA "Installing the GCC manuals"

   713         CT_DoExecLog ALL make install-{pdf,html}-gcc

   714     fi

   716     # Create a symlink ${CT_TARGET}-cc to ${CT_TARGET}-gcc to always be able

   717     # to call the C compiler with the same, somewhat canonical name.

   718     # check whether compiler has an extension

   719     file="$( ls -1 "${CT_PREFIX_DIR}/bin/${CT_TARGET}-gcc."* 2>/dev/null || true )"

   720     [ -z "${file}" ] || ext=".${file##*.}"

   721     CT_DoExecLog ALL ln -sfv "${CT_TARGET}-gcc${ext}" "${CT_PREFIX_DIR}/bin/${CT_TARGET}-cc${ext}"

   723     if [ "${CT_MULTILIB}" = "y" ]; then

   724         multilibs=( $( "${CT_PREFIX_DIR}/bin/${CT_TARGET}-gcc" -print-multi-lib \

   725                        |tail -n +2 ) )

   726         if [ ${#multilibs[@]} -ne 0 ]; then

   727             CT_DoLog EXTRA "gcc configured with these multilibs (besides the default):"

   728             for i in "${multilibs[@]}"; do

   729                 dir="${i%%;*}"

   730                 flags="${i#*;}"

   731                 CT_DoLog EXTRA "   ${flags//@/ -}  -->  ${dir}/"

   732             done

   733         else

   734             CT_DoLog WARN "gcc configured for multilib, but none available"

   735         fi

   736     fi

   738     CT_EndStep

   739 }

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Sun Jul 17 17:54:21 2011 +0200 (2011-07-17)
changeset 2888	dd71df95903a
parent 2887	6ee3b25e1097
child 2889	f3b2199620f1
permissions	-rw-r--r--