# DP: Enable both gold and ld in a single toolchain. # DP: New option -fuse-ld=ld.bfd, -fuse-ld=gold. --- a/src/gcc/doc/invoke.texi +++ b/srcgcc/doc/invoke.texi @@ -399,7 +399,7 @@ -funit-at-a-time -funroll-all-loops -funroll-loops @gol -funsafe-loop-optimizations -funsafe-math-optimizations -funswitch-loops @gol -fvariable-expansion-in-unroller -fvect-cost-model -fvpt -fweb @gol --fwhole-program -fwpa -fuse-linker-plugin @gol +-fwhole-program -fwpa -fuse-ld -fuse-linker-plugin @gol --param @var{name}=@var{value} -O -O0 -O1 -O2 -O3 -Os -Ofast} @@ -7689,6 +7689,16 @@ Enabled by default when LTO support in GCC is enabled and GCC was compiled with linker supporting plugins (GNU ld or @code{gold}). +@item -fuse-ld=gold +Use the @command{gold} linker instead of the default linker. +This option is only necessary if GCC has been configured with +@option{--enable-gold} and @option{--enable-ld=default}. + +@item -fuse-ld=bfd +Use the @command{ld.bfd} linker instead of the default linker. +This option is only necessary if GCC has been configured with +@option{--enable-gold} and @option{--enable-ld}. + @item -fcprop-registers @opindex fcprop-registers After register allocation and post-register allocation instruction splitting, --- a/src/gcc/gcc.c +++ b/srcgcc/gcc.c @@ -656,6 +656,9 @@ }"PLUGIN_COND_CLOSE" \ %{flto|flto=*:%max_errors = value; break; + case OPT_fuse_ld_: case OPT_fuse_linker_plugin: - /* No-op. Used by the driver and passed to us because it starts with f.*/ + /* No-op. Used by the driver and passed to us because it starts with f. */ break; default: --- a/src/gcc/configure.ac +++ b/srcgcc/configure.ac @@ -1937,6 +1937,17 @@ AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET) fi]) +gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold + +AS_VAR_SET_IF(gcc_cv_gold,, [ +if test -f $gcc_cv_ld_gold_srcdir/configure.ac \ + && test -f ../gold/Makefile \ + && test x$build = x$host; then + gcc_cv_gold=../gold/ld-new$build_exeext +else + gcc_cv_gold='' +fi]) + ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld PLUGIN_LD=`basename $gcc_cv_ld` AC_ARG_WITH(plugin-ld, @@ -1966,6 +1977,9 @@ *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;; esac +ORIGINAL_GOLD_FOR_TARGET=$gcc_cv_gold +AC_SUBST(ORIGINAL_GOLD_FOR_TARGET) + AC_MSG_CHECKING(what linker to use) if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext; then # Single tree build which includes ld. We want to prefer it --- a/src/gcc/exec-tool.in +++ b/srcgcc/exec-tool.in @@ -1,6 +1,6 @@ #! /bin/sh -# Copyright (C) 2007, 2008, 2010 Free Software Foundation, Inc. +# Copyright (C) 2007, 2008, 2010, 2011 Free Software Foundation, Inc. # This file is part of GCC. # GCC is free software; you can redistribute it and/or modify @@ -21,11 +21,13 @@ ORIGINAL_AS_FOR_TARGET="@ORIGINAL_AS_FOR_TARGET@" ORIGINAL_LD_FOR_TARGET="@ORIGINAL_LD_FOR_TARGET@" +ORIGINAL_GOLD_FOR_TARGET="@ORIGINAL_GOLD_FOR_TARGET@" ORIGINAL_PLUGIN_LD_FOR_TARGET="@ORIGINAL_PLUGIN_LD_FOR_TARGET@" ORIGINAL_NM_FOR_TARGET="@ORIGINAL_NM_FOR_TARGET@" exeext=@host_exeext@ fast_install=@enable_fast_install@ objdir=@objdir@ +version="1.1" invoked=`basename "$0"` id=$invoked @@ -36,15 +38,44 @@ dir=gas ;; collect-ld) - # when using a linker plugin, gcc will always pass '-plugin' as the - # first or second option to the linker. - if test x"$1" = "x-plugin" || test x"$2" = "x-plugin"; then - original=$ORIGINAL_PLUGIN_LD_FOR_TARGET - else - original=$ORIGINAL_LD_FOR_TARGET + prog=ld-new$exeext + # Look for the a command line option + # specifying the linker to be used. + case " $* " in + *\ -use-gold\ *) + original=$ORIGINAL_GOLD_FOR_TARGET + dir=gold + ;; + *\ -use-ld\ * | *\ -use-ld.bfd\ *) + original=$ORIGINAL_LD_FOR_TARGET + dir=ld + ;; + *\ -plugin\ *) + original=$ORIGINAL_PLUGIN_LD_FOR_TARGET + dir=ld + ;; + *) + original=$ORIGINAL_LD_FOR_TARGET + dir=ld + ;; + esac + + # If the selected linker has not been configured then + # try using the others, in the order PLUGIN-LD, LD, GOLD. + if test x"$original" = x; then + if test x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" != x; then + original=$ORIGINAL_PLUGIN_LD_FOR_TARGET + dir=ld + elif test x"$ORIGINAL_LD_FOR_TARGET" != x; then + original=$ORIGINAL_LD_FOR_TARGET + dir=ld + elif test x"$ORIGINAL_GOLD_FOR_TARGET" != x; then + original=$ORIGINAL_GOLD_FOR_TARGET + dir=gold + # Otherwise do nothing - the case statement below + # will issue an error message for us. + fi fi - prog=ld-new$exeext - dir=ld id=ld ;; nm) @@ -61,29 +92,58 @@ scriptdir=`cd "$tdir" && pwd` if test -x $scriptdir/../$dir/$prog; then - test "$fast_install" = yes || exec $scriptdir/../$dir/$prog ${1+"$@"} + if test "$fast_install" = yes; then + # If libtool did everything it needs to do, there's a fast path. + lt_prog=$scriptdir/../$dir/$objdir/lt-$prog - # if libtool did everything it needs to do, there's a fast path - lt_prog=$scriptdir/../$dir/$objdir/lt-$prog - test -x $lt_prog && exec $lt_prog ${1+"$@"} - - # libtool has not relinked ld-new yet, but we cannot just use the - # previous stage (because then the relinking would just never happen!). - # So we take extra care to use prev-ld/ld-new *on recursive calls*. - eval LT_RCU="\${LT_RCU_$id}" - test x"$LT_RCU" = x"1" && exec $scriptdir/../prev-$dir/$prog ${1+"$@"} - - eval LT_RCU_$id=1 - export LT_RCU_$id - $scriptdir/../$dir/$prog ${1+"$@"} - result=$? - exit $result - + if test -x $lt_prog; then + original=$lt_prog + else + # Libtool has not relinked ld-new yet, but we cannot just use the + # previous stage (because then the relinking would just never happen!). + # So we take extra care to use prev-ld/ld-new *on recursive calls*. + eval LT_RCU="\${LT_RCU_$id}" + if test x"$LT_RCU" = x"1"; then + original=$scriptdir/../prev-$dir/$prog + else + eval LT_RCU_$id=1 + export LT_RCU_$id + case " $* " in + *\ -v\ *) + echo "$invoked $version" + echo $scriptdir/../$dir/$prog $* + ;; + esac + $scriptdir/../$dir/$prog ${1+"$@"} + result=$? + exit $result + fi + fi + else + original=$scriptdir/../$dir/$prog + fi else - exec $scriptdir/../prev-$dir/$prog ${1+"$@"} + original=$scriptdir/../prev-$dir/$prog fi ;; - *) - exec $original ${1+"$@"} + "") + echo "$invoked: executable not configured" + exit 1 ;; esac + +# If -v has been used then display our version number +# and then echo the command we are about to invoke. +case " $* " in + *\ -v\ *) + echo "$invoked $version" + echo $original $* + ;; +esac + +if test -x $original; then + exec "$original" ${1+"$@"} +else + echo "$invoked: unable to locate executable: $original" + exit 1 +fi --- a/src/gcc/common.opt +++ b/srcgcc/common.opt @@ -1998,6 +1998,9 @@ Common Report Var(flag_unwind_tables) Optimization Just generate unwind tables for exception handling +fuse-ld= +Common Joined Undocumented + fuse-linker-plugin Common Undocumented --- a/src/gcc/collect2.c +++ b/srcgcc/collect2.c @@ -1075,17 +1075,19 @@ int main (int argc, char **argv) { - static const char *const ld_suffix = "ld"; - static const char *const plugin_ld_suffix = PLUGIN_LD; - static const char *const real_ld_suffix = "real-ld"; + static const char *const ld_suffix = "ld"; + static const char *const gold_suffix = "gold"; + static const char *const bfd_ld_suffix = "ld.bfd"; + static const char *const plugin_ld_suffix = PLUGIN_LD; + static const char *const real_ld_suffix = "real-ld"; static const char *const collect_ld_suffix = "collect-ld"; - static const char *const nm_suffix = "nm"; - static const char *const gnm_suffix = "gnm"; + static const char *const nm_suffix = "nm"; + static const char *const gnm_suffix = "gnm"; #ifdef LDD_SUFFIX - static const char *const ldd_suffix = LDD_SUFFIX; + static const char *const ldd_suffix = LDD_SUFFIX; #endif - static const char *const strip_suffix = "strip"; - static const char *const gstrip_suffix = "gstrip"; + static const char *const strip_suffix = "strip"; + static const char *const gstrip_suffix = "gstrip"; #ifdef CROSS_DIRECTORY_STRUCTURE /* If we look for a program in the compiler directories, we just use @@ -1095,6 +1097,10 @@ const char *const full_ld_suffix = concat(target_machine, "-", ld_suffix, NULL); + const char *const full_gold_suffix = + concat (target_machine, "-", gold_suffix, NULL); + const char *const full_bfd_ld_suffix = + concat (target_machine, "-", bfd_ld_suffix, NULL); const char *const full_plugin_ld_suffix = concat(target_machine, "-", plugin_ld_suffix, NULL); const char *const full_nm_suffix = @@ -1110,15 +1116,17 @@ const char *const full_gstrip_suffix = concat (target_machine, "-", gstrip_suffix, NULL); #else - const char *const full_ld_suffix = ld_suffix; + const char *const full_ld_suffix = ld_suffix; + const char *const full_gold_suffix = gold_suffix; + const char *const full_bfd_ld_suffix = bfd_ld_suffix; const char *const full_plugin_ld_suffix = plugin_ld_suffix; - const char *const full_nm_suffix = nm_suffix; - const char *const full_gnm_suffix = gnm_suffix; + const char *const full_nm_suffix = nm_suffix; + const char *const full_gnm_suffix = gnm_suffix; #ifdef LDD_SUFFIX - const char *const full_ldd_suffix = ldd_suffix; + const char *const full_ldd_suffix = ldd_suffix; #endif - const char *const full_strip_suffix = strip_suffix; - const char *const full_gstrip_suffix = gstrip_suffix; + const char *const full_strip_suffix = strip_suffix; + const char *const full_gstrip_suffix = gstrip_suffix; #endif /* CROSS_DIRECTORY_STRUCTURE */ const char *arg; @@ -1132,7 +1140,13 @@ const char **c_ptr; char **ld1_argv; const char **ld1; - bool use_plugin = false; + enum linker_select + { + DFLT_LINKER, + PLUGIN_LINKER, + GOLD_LINKER, + BFD_LINKER + } selected_linker = DFLT_LINKER; /* The kinds of symbols we will have to consider when scanning the outcome of a first pass link. This is ALL to start with, then might @@ -1209,15 +1223,21 @@ else if (! strcmp (argv[i], "-flto-partition=none")) no_partition = true; else if ((! strncmp (argv[i], "-flto=", 6) - || ! strcmp (argv[i], "-flto")) && ! use_plugin) + || ! strcmp (argv[i], "-flto")) + && selected_linker != PLUGIN_LINKER) lto_mode = LTO_MODE_WHOPR; else if (!strncmp (argv[i], "-fno-lto", 8)) lto_mode = LTO_MODE_NONE; else if (! strcmp (argv[i], "-plugin")) { - use_plugin = true; + selected_linker = PLUGIN_LINKER; lto_mode = LTO_MODE_NONE; } + else if (! strcmp (argv[i], "-use-gold")) + selected_linker = GOLD_LINKER; + else if (! strcmp (argv[i], "-use-ld")) + selected_linker = BFD_LINKER; + #ifdef COLLECT_EXPORT_LIST /* since -brtl, -bexport, -b64 are not position dependent also check for them here */ @@ -1299,36 +1319,109 @@ /* Try to discover a valid linker/nm/strip to use. */ /* Maybe we know the right file to use (if not cross). */ - ld_file_name = 0; + ld_file_name = NULL; #ifdef DEFAULT_LINKER if (access (DEFAULT_LINKER, X_OK) == 0) ld_file_name = DEFAULT_LINKER; - if (ld_file_name == 0) + if (ld_file_name == NULL) #endif #ifdef REAL_LD_FILE_NAME ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME); - if (ld_file_name == 0) + if (ld_file_name == NULL) #endif /* Search the (target-specific) compiler dirs for ld'. */ ld_file_name = find_a_file (&cpath, real_ld_suffix); /* Likewise for `collect-ld'. */ - if (ld_file_name == 0) + if (ld_file_name == NULL) ld_file_name = find_a_file (&cpath, collect_ld_suffix); /* Search the compiler directories for `ld'. We have protection against recursive calls in find_a_file. */ - if (ld_file_name == 0) - ld_file_name = find_a_file (&cpath, - use_plugin - ? plugin_ld_suffix - : ld_suffix); + if (ld_file_name == NULL) + switch (selected_linker) + { + default: + case DFLT_LINKER: + ld_file_name = find_a_file (&cpath, ld_suffix); + break; + case PLUGIN_LINKER: + ld_file_name = find_a_file (&cpath, plugin_ld_suffix); + break; + case GOLD_LINKER: + ld_file_name = find_a_file (&cpath, gold_suffix); + break; + case BFD_LINKER: + ld_file_name = find_a_file (&cpath, bfd_ld_suffix); + break; + } /* Search the ordinary system bin directories for `ld' (if native linking) or `TARGET-ld' (if cross). */ - if (ld_file_name == 0) - ld_file_name = find_a_file (&path, - use_plugin - ? full_plugin_ld_suffix - : full_ld_suffix); + if (ld_file_name == NULL) + switch (selected_linker) + { + default: + case DFLT_LINKER: + ld_file_name = find_a_file (&path, full_ld_suffix); + break; + case PLUGIN_LINKER: + ld_file_name = find_a_file (&path, full_plugin_ld_suffix); + break; + case GOLD_LINKER: + ld_file_name = find_a_file (&path, full_gold_suffix); + break; + case BFD_LINKER: + ld_file_name = find_a_file (&path, full_bfd_ld_suffix); + break; + } + /* If we failed to find a plugin-capable linker, try the ordinary one. */ + if (ld_file_name == NULL && selected_linker == PLUGIN_LINKER) + ld_file_name = find_a_file (&cpath, ld_suffix); + if ((vflag || debug) && ld_file_name == NULL) + { + struct prefix_list * p; + const char * s; + + notice ("collect2: warning: unable to find linker.\n"); + +#ifdef DEFAULT_LINKER + notice (" Searched for this absolute executable:\n"); + notice (" %s\n", DEFAULT_LINKER); +#endif + + notice (" Searched in these paths:\n"); + for (p = cpath.plist; p != NULL; p = p->next) + notice (" %s\n", p->prefix); + notice (" For these executables:\n"); + notice (" %s\n", real_ld_suffix); + notice (" %s\n", collect_ld_suffix); + switch (selected_linker) + { + default: + case DFLT_LINKER: s = ld_suffix; break; + case PLUGIN_LINKER: s = plugin_ld_suffix; break; + case GOLD_LINKER: s = gold_suffix; break; + case BFD_LINKER: s = bfd_ld_suffix; break; + } + notice (" %s\n", s); + + notice (" And searched in these paths:\n"); + for (p = path.plist; p != NULL; p = p->next) + notice (" %s\n", p->prefix); + notice (" For these executables:\n"); +#ifdef REAL_LD_FILE_NAME + notice (" %s\n", REAL_LD_FILE_NAME); +#endif + switch (selected_linker) + { + default: + case DFLT_LINKER: s = full_ld_suffix; break; + case PLUGIN_LINKER: s = full_plugin_ld_suffix; break; + case GOLD_LINKER: s = full_gold_suffix; break; + case BFD_LINKER: s = full_bfd_ld_suffix; break; + } + notice (" %s\n", s); + } + #ifdef REAL_NM_FILE_NAME nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME); if (nm_file_name == 0)