#include "system.h"
#include "coretypes.h"
#include "tm.h"
-#include <signal.h>
-#if ! defined( SIGCHLD ) && defined( SIGCLD )
-# define SIGCHLD SIGCLD
-#endif
/* TARGET_64BIT may be defined to use driver specific functionality. */
#undef TARGET_64BIT
static char *resolve_lib_name (const char *);
#endif
static char *extract_string (const char **);
+static void post_ld_pass (bool);
+static void process_args (int *argcp, char **argv);
/* Enumerations describing which pass this is for scanning the
program file ... */
prefix_from_env (const char *env, struct path_prefix *pprefix)
{
const char *p;
- GET_ENVIRONMENT (p, env);
+ p = getenv (env);
if (p)
prefix_from_string (p, pprefix);
if (lto_objects.first)
{
- const char *opts;
char **lto_c_argv;
const char **lto_c_ptr;
- const char *cp;
- const char **p, **q, **r;
- const char **lto_o_ptr;
+ char **p;
+ char **lto_o_ptr;
struct lto_object *list;
char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER");
struct pex_obj *pex;
const char *prog = "lto-wrapper";
+ int lto_ld_argv_size = 0;
+ char **out_lto_ld_argv;
+ int out_lto_ld_argv_size;
+ size_t num_files;
if (!lto_wrapper)
- fatal ("COLLECT_LTO_WRAPPER must be set.");
-
- /* There is at least one object file containing LTO info,
- so we need to run the LTO back end and relink. */
-
- /* Get compiler options passed down from the parent `gcc' command.
- These must be passed to the LTO back end. */
- opts = getenv ("COLLECT_GCC_OPTIONS");
-
- /* Increment the argument count by the number of inherited options.
- Some arguments may be filtered out later. Again, an upper bound
- suffices. */
+ fatal ("COLLECT_LTO_WRAPPER must be set");
- cp = opts;
+ num_lto_c_args++;
- while (cp && *cp)
- {
- extract_string (&cp);
- num_lto_c_args++;
- }
- obstack_free (&temporary_obstack, temporary_firstobj);
-
- if (debug)
- num_lto_c_args++;
+ /* There is at least one object file containing LTO info,
+ so we need to run the LTO back end and relink.
- /* Increment the argument count by the number of initial
- arguments added below. */
- num_lto_c_args += 9;
+ To do so we build updated ld arguments with first
+ LTO object replaced by all partitions and other LTO
+ objects removed. */
lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
*lto_c_ptr++ = lto_wrapper;
- *lto_c_ptr++ = c_file_name;
-
- cp = opts;
-
- while (cp && *cp)
- {
- const char *s = extract_string (&cp);
-
- /* Pass the option or argument to the wrapper. */
- *lto_c_ptr++ = xstrdup (s);
- }
- obstack_free (&temporary_obstack, temporary_firstobj);
-
- if (debug)
- *lto_c_ptr++ = xstrdup ("-debug");
/* Add LTO objects to the wrapper command line. */
for (list = lto_objects.first; list; list = list->next)
{
int c;
FILE *stream;
- size_t i, num_files;
+ size_t i;
char *start, *end;
stream = pex_read_output (pex, 0);
do_wait (prog, pex);
pex = NULL;
+ /* Compute memory needed for new LD arguments. At most number of original arguemtns
+ plus number of partitions. */
+ for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++)
+ ;
+ out_lto_ld_argv = XCNEWVEC(char *, num_files + lto_ld_argv_size + 1);
+ out_lto_ld_argv_size = 0;
+
/* After running the LTO back end, we will relink, substituting
the LTO output for the object files that we submitted to the
LTO. Here, we modify the linker command line for the relink. */
- p = CONST_CAST2 (const char **, char **, lto_ld_argv);
- lto_o_ptr = CONST_CAST2 (const char **, char **, lto_o_files);
+ /* Copy all arguments until we find first LTO file. */
+ p = lto_ld_argv;
while (*p != NULL)
{
for (list = lto_objects.first; list; list = list->next)
- {
- if (*p == list->name) /* Note test for pointer equality! */
- {
- /* Excise argument from linker command line. */
- if (*lto_o_ptr)
- {
- /* Replace first argument with LTO output file. */
- *p++ = *lto_o_ptr++;
- }
- else
- {
- /* Move following arguments one position earlier,
- overwriting the current argument. */
- q = p;
- r = p + 1;
- while (*r != NULL)
- *q++ = *r++;
- *q = NULL;
- }
-
- /* No need to continue searching the LTO object list. */
- break;
- }
- }
-
- /* If we didn't find a match, move on to the next argument.
- Otherwise, P has been set to the correct argument position
- at which to continue. */
- if (!list) ++p;
+ if (*p == list->name) /* Note test for pointer equality! */
+ break;
+ if (list)
+ break;
+ out_lto_ld_argv[out_lto_ld_argv_size++] = *p++;
}
- /* The code above assumes we will never have more lto output files than
- input files. Otherwise, we need to resize lto_ld_argv. Check this
- assumption. */
- if (*lto_o_ptr)
- fatal ("too many lto output files");
+ /* Now insert all LTO partitions. */
+ lto_o_ptr = lto_o_files;
+ while (*lto_o_ptr)
+ out_lto_ld_argv[out_lto_ld_argv_size++] = *lto_o_ptr++;
+
+ /* ... and copy the rest. */
+ while (*p != NULL)
+ {
+ for (list = lto_objects.first; list; list = list->next)
+ if (*p == list->name) /* Note test for pointer equality! */
+ break;
+ if (!list)
+ out_lto_ld_argv[out_lto_ld_argv_size++] = *p;
+ p++;
+ }
+ out_lto_ld_argv[out_lto_ld_argv_size++] = 0;
/* Run the linker again, this time replacing the object files
optimized by the LTO with the temporary file generated by the LTO. */
- fork_execute ("ld", lto_ld_argv);
+ fork_execute ("ld", out_lto_ld_argv);
+ post_ld_pass (true);
+ free (lto_ld_argv);
maybe_unlink_list (lto_o_files);
}
{
/* Our caller is relying on us to do the link
even though there is no LTO back end work to be done. */
- fork_execute ("ld", lto_ld_argv);
+ fork_execute ("ld", lto_ld_argv);
+ post_ld_pass (false);
}
}
\f
int num_c_args;
char **old_argv;
- bool use_verbose = false;
-
old_argv = argv;
expandargv (&argc, &argv);
if (argv != old_argv)
at_file_supplied = 1;
+ process_args (&argc, argv);
+
num_c_args = argc + 9;
no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
/* Parse command line early for instances of -debug. This allows
the debug flag to be set before functions like find_a_file()
- are called. We also look for the -flto or -fwhopr flag to know
+ are called. We also look for the -flto or -flto-partition=none flag to know
what LTO mode we are in. */
{
int i;
+ bool no_partition = false;
for (i = 1; argv[i] != NULL; i ++)
{
if (! strcmp (argv[i], "-debug"))
debug = true;
- else if (! strcmp (argv[i], "-flto") && ! use_plugin)
- {
- use_verbose = true;
- lto_mode = LTO_MODE_LTO;
- }
- else if (! strcmp (argv[i], "-fwhopr") && ! use_plugin)
- {
- use_verbose = true;
- lto_mode = LTO_MODE_WHOPR;
- }
+ else if (! strcmp (argv[i], "-flto-partition=none"))
+ no_partition = true;
+ else if ((! strncmp (argv[i], "-flto=", 6)
+ || ! strcmp (argv[i], "-flto")) && ! use_plugin)
+ 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;
- use_verbose = true;
lto_mode = LTO_MODE_NONE;
}
#ifdef COLLECT_EXPORT_LIST
#endif
}
vflag = debug;
+ if (no_partition && lto_mode == LTO_MODE_WHOPR)
+ lto_mode = LTO_MODE_LTO;
}
#ifndef DEFAULT_A_OUT_NAME
*c_ptr++ = xstrdup (q);
}
}
- if (use_verbose && *q == '-' && q[1] == 'v' && q[2] == 0)
- {
- /* Turn on trace in collect2 if needed. */
- vflag = true;
- }
}
obstack_free (&temporary_obstack, temporary_firstobj);
*c_ptr++ = "-fno-profile-arcs";
break;
case 'f':
- if (strcmp (arg, "-flto") == 0 || strcmp (arg, "-fwhopr") == 0)
+ if (strncmp (arg, "-flto", 5) == 0)
{
#ifdef ENABLE_LTO
/* Do not pass LTO flag to the linker. */
case 'o':
if (arg[2] == '\0')
output_file = *ld1++ = *ld2++ = *++argv;
- else if (1
-#ifdef SWITCHES_NEED_SPACES
- && ! strchr (SWITCHES_NEED_SPACES, arg[1])
-#endif
- )
-
+ else
output_file = &arg[2];
break;
}
else if (strncmp (arg, "--sysroot=", 10) == 0)
target_system_root = arg + 10;
- else if (strncmp (arg, "--version", 9) == 0)
+ else if (strcmp (arg, "--version") == 0)
vflag = true;
- else if (strncmp (arg, "--help", 9) == 0)
+ else if (strcmp (arg, "--help") == 0)
helpflag = true;
break;
}
if (helpflag)
{
- fprintf (stderr, "Usage: collect2 [options]\n");
- fprintf (stderr, " Wrap linker and generate constructor code if needed.\n");
- fprintf (stderr, " Options:\n");
- fprintf (stderr, " -debug Enable debug output\n");
- fprintf (stderr, " --help Display this information\n");
- fprintf (stderr, " -v, --version Display this program's version number\n");
- fprintf (stderr, "Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
- fprintf (stderr, "Report bugs: %s\n", bug_report_url);
-
- collect_exit (0);
+ printf ("Usage: collect2 [options]\n");
+ printf (" Wrap linker and generate constructor code if needed.\n");
+ printf (" Options:\n");
+ printf (" -debug Enable debug output\n");
+ printf (" --help Display this information\n");
+ printf (" -v, --version Display this program's version number\n");
+ printf ("\n");
+ printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
+ printf ("Report bugs: %s\n", bug_report_url);
+ printf ("\n");
}
if (debug)
if (export_file != 0 && export_file[0])
maybe_unlink (export_file);
#endif
- if (lto_mode)
+ if (lto_mode != LTO_MODE_NONE)
maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
+ else
+ post_ld_pass (false);
maybe_unlink (c_file);
maybe_unlink (o_file);
#ifdef COLLECT_EXPORT_LIST
maybe_unlink (export_file);
#endif
+ post_ld_pass (false);
+
maybe_unlink (c_file);
maybe_unlink (o_file);
return 0;
if (lto_mode)
maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
else
- fork_execute ("ld", ld2_argv);
+ {
+ fork_execute ("ld", ld2_argv);
+ post_ld_pass (false);
+ }
/* Let scan_prog_file do any final mods (OSF/rose needs this for
constructors/destructors in shared libraries. */
\f
#ifdef OBJECT_FORMAT_NONE
-/* Check to make sure the file is an ELF file. LTO objects must
- be in ELF format. */
+/* Check to make sure the file is an LTO object file. */
static bool
-is_elf_or_coff (const char *prog_name)
+maybe_lto_object_file (const char *prog_name)
{
FILE *f;
- char buf[4];
- static char magic[4] = { 0x7f, 'E', 'L', 'F' };
- static char coffmag[2] = { 0x4c, 0x01 };
+ unsigned char buf[4];
+ int i;
+
+ static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' };
+ static unsigned char coffmagic[2] = { 0x4c, 0x01 };
+ static unsigned char coffmagic_x64[2] = { 0x64, 0x86 };
+ static unsigned char machomagic[4][4] = {
+ { 0xcf, 0xfa, 0xed, 0xfe },
+ { 0xce, 0xfa, 0xed, 0xfe },
+ { 0xfe, 0xed, 0xfa, 0xcf },
+ { 0xfe, 0xed, 0xfa, 0xce }
+ };
f = fopen (prog_name, "rb");
if (f == NULL)
if (fread (buf, sizeof (buf), 1, f) != 1)
buf[0] = 0;
fclose (f);
- return memcmp (buf, magic, sizeof (magic)) == 0
- || memcmp (buf, coffmag, sizeof (coffmag)) == 0;
+
+ if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0
+ || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0
+ || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0)
+ return true;
+ for (i = 0; i < 4; i++)
+ if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0)
+ return true;
+
+ return false;
}
/* Generic version to scan the name list of the loaded program for
/* LTO objects must be in a known format. This check prevents
us from accepting an archive containing LTO objects, which
gcc cannnot currently handle. */
- if (which_pass == PASS_LTOINFO && !is_elf_or_coff (prog_name))
+ if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
return;
/* If we do not have an `nm', complain. */
return (NULL);
}
#endif /* COLLECT_EXPORT_LIST */
+
+#ifdef COLLECT_RUN_DSYMUTIL
+static int flag_dsym = false;
+static int flag_idsym = false;
+
+static void
+process_args (int *argcp, char **argv) {
+ int i, j;
+ int argc = *argcp;
+ for (i=0; i<argc; ++i)
+ {
+ if (strcmp (argv[i], "-dsym") == 0)
+ {
+ flag_dsym = true;
+ /* Remove the flag, as we handle all processing for it. */
+ j = i;
+ do
+ argv[j] = argv[j+1];
+ while (++j < argc);
+ --i;
+ argc = --(*argcp);
+ }
+ else if (strcmp (argv[i], "-idsym") == 0)
+ {
+ flag_idsym = true;
+ /* Remove the flag, as we handle all processing for it. */
+ j = i;
+ do
+ argv[j] = argv[j+1];
+ while (++j < argc);
+ --i;
+ argc = --(*argcp);
+ }
+ }
+}
+
+static void
+do_dsymutil (const char *output_file) {
+ const char *dsymutil = DSYMUTIL + 1;
+ struct pex_obj *pex;
+ char **real_argv = XCNEWVEC (char *, 3);
+ const char ** argv = CONST_CAST2 (const char **, char **,
+ real_argv);
+
+ argv[0] = dsymutil;
+ argv[1] = output_file;
+ argv[2] = (char *) 0;
+
+ pex = collect_execute (dsymutil, real_argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
+ do_wait (dsymutil, pex);
+}
+
+static void
+post_ld_pass (bool temp_file) {
+ if (!(temp_file && flag_idsym) && !flag_dsym)
+ return;
+
+ do_dsymutil (output_file);
+}
+#else
+static void
+process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }
+static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }
+#endif
OSDN Git Service
