diff options
author | Jing Yu <jingyu@google.com> | 2011-12-19 16:56:54 -0800 |
---|---|---|
committer | Jing Yu <jingyu@google.com> | 2011-12-19 16:56:54 -0800 |
commit | 40d7cd0fd78fe2004e2a53c4618c148339b02733 (patch) | |
tree | 5874557a6c86a1f564a03e5f28b266e31bc3759c /gcc-4.6/gcc/lto-wrapper.c | |
parent | fe2afdf3f3701489c05d2a7509752d6f0c7616f7 (diff) | |
download | toolchain_gcc-40d7cd0fd78fe2004e2a53c4618c148339b02733.tar.gz toolchain_gcc-40d7cd0fd78fe2004e2a53c4618c148339b02733.tar.bz2 toolchain_gcc-40d7cd0fd78fe2004e2a53c4618c148339b02733.zip |
Add gcc-4.6. Synced to @180989
Change-Id: Ie3676586e1d8e3c8cd9f07d022f450d05fa08439
svn://gcc.gnu.org/svn/gcc/branches/google/gcc-4_6-mobile
Diffstat (limited to 'gcc-4.6/gcc/lto-wrapper.c')
-rw-r--r-- | gcc-4.6/gcc/lto-wrapper.c | 656 |
1 files changed, 656 insertions, 0 deletions
diff --git a/gcc-4.6/gcc/lto-wrapper.c b/gcc-4.6/gcc/lto-wrapper.c new file mode 100644 index 000000000..613c7b054 --- /dev/null +++ b/gcc-4.6/gcc/lto-wrapper.c @@ -0,0 +1,656 @@ +/* Wrapper to call lto. Used by collect2 and the linker plugin. + Copyright (C) 2009, 2010 Free Software Foundation, Inc. + + Factored out of collect2 by Rafael Espindola <espindola@google.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. */ + + +/* This program is passed a gcc, a list of gcc arguments and a list of + object files containing IL. It scans the argument list to check if + we are in whopr mode or not modifies the arguments and needed and + prints a list of output files on stdout. + + Example: + + $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto + + The above will print something like + /tmp/ccwbQ8B2.lto.o + + If WHOPR is used instead, more than one file might be produced + ./ccXj2DTk.lto.ltrans.o + ./ccCJuXGv.lto.ltrans.o +*/ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "intl.h" +#include "obstack.h" + +int debug; /* true if -save-temps. */ +int verbose; /* true if -v. */ + +enum lto_mode_d { + LTO_MODE_NONE, /* Not doing LTO. */ + LTO_MODE_LTO, /* Normal LTO. */ + LTO_MODE_WHOPR /* WHOPR. */ +}; + +/* Current LTO mode. */ +static enum lto_mode_d lto_mode = LTO_MODE_NONE; + +static char *ltrans_output_file; +static char *flto_out; +static char *args_name; +static unsigned int nr; +static char **input_names; +static char **output_names; +static char *makefile; + +static void maybe_unlink_file (const char *); + + /* Delete tempfiles. */ + +static void +lto_wrapper_cleanup (void) +{ + static bool cleanup_done = false; + unsigned int i; + + if (cleanup_done) + return; + + /* Setting cleanup_done prevents an infinite loop if one of the + calls to maybe_unlink_file fails. */ + cleanup_done = true; + + if (ltrans_output_file) + maybe_unlink_file (ltrans_output_file); + if (flto_out) + maybe_unlink_file (flto_out); + if (args_name) + maybe_unlink_file (args_name); + if (makefile) + maybe_unlink_file (makefile); + for (i = 0; i < nr; ++i) + { + maybe_unlink_file (input_names[i]); + if (output_names[i]) + maybe_unlink_file (output_names[i]); + } +} + +static void +fatal_signal (int signum) +{ + signal (signum, SIG_DFL); + lto_wrapper_cleanup (); + /* Get the same signal again, this time not handled, + so its normal effect occurs. */ + kill (getpid (), signum); +} + +/* Just die. CMSGID is the error message. */ + +static void __attribute__ ((format (printf, 1, 2))) +fatal (const char * cmsgid, ...) +{ + va_list ap; + + va_start (ap, cmsgid); + fprintf (stderr, "lto-wrapper: "); + vfprintf (stderr, _(cmsgid), ap); + fprintf (stderr, "\n"); + va_end (ap); + + lto_wrapper_cleanup (); + exit (FATAL_EXIT_CODE); +} + + +/* Die when sys call fails. CMSGID is the error message. */ + +static void __attribute__ ((format (printf, 1, 2))) +fatal_perror (const char *cmsgid, ...) +{ + int e = errno; + va_list ap; + + va_start (ap, cmsgid); + fprintf (stderr, "lto-wrapper: "); + vfprintf (stderr, _(cmsgid), ap); + fprintf (stderr, ": %s\n", xstrerror (e)); + va_end (ap); + + lto_wrapper_cleanup (); + exit (FATAL_EXIT_CODE); +} + + +/* Execute a program, and wait for the reply. ARGV are the arguments. The + last one must be NULL. */ + +static struct pex_obj * +collect_execute (char **argv) +{ + struct pex_obj *pex; + const char *errmsg; + int err; + + if (verbose) + { + char **p_argv; + const char *str; + + for (p_argv = argv; (str = *p_argv) != (char *) 0; p_argv++) + fprintf (stderr, " %s", str); + + fprintf (stderr, "\n"); + } + + fflush (stdout); + fflush (stderr); + + pex = pex_init (0, "lto-wrapper", NULL); + if (pex == NULL) + fatal_perror ("pex_init failed"); + + /* Do not use PEX_LAST here, we use our stdout for communicating with + collect2 or the linker-plugin. Any output from the sub-process + will confuse that. */ + errmsg = pex_run (pex, PEX_SEARCH, argv[0], argv, NULL, + NULL, &err); + if (errmsg != NULL) + { + if (err != 0) + { + errno = err; + fatal_perror (errmsg); + } + else + fatal (errmsg); + } + + return pex; +} + + +/* Wait for a process to finish, and exit if a nonzero status is found. + PROG is the program name. PEX is the process we should wait for. */ + +static int +collect_wait (const char *prog, struct pex_obj *pex) +{ + int status; + + if (!pex_get_status (pex, 1, &status)) + fatal_perror ("can't get program status"); + pex_free (pex); + + if (status) + { + if (WIFSIGNALED (status)) + { + int sig = WTERMSIG (status); + if (WCOREDUMP (status)) + fatal ("%s terminated with signal %d [%s], core dumped", + prog, sig, strsignal (sig)); + else + fatal ("%s terminated with signal %d [%s]", + prog, sig, strsignal (sig)); + } + + if (WIFEXITED (status)) + fatal ("%s returned %d exit status", prog, WEXITSTATUS (status)); + } + + return 0; +} + + +/* Unlink a temporary LTRANS file unless requested otherwise. */ + +static void +maybe_unlink_file (const char *file) +{ + if (! debug) + { + if (unlink_if_ordinary (file) + && errno != ENOENT) + fatal_perror ("deleting LTRANS file %s", file); + } + else + fprintf (stderr, "[Leaving LTRANS %s]\n", file); +} + + +/* Execute program ARGV[0] with arguments ARGV. Wait for it to finish. */ + +static void +fork_execute (char **argv) +{ + struct pex_obj *pex; + char *new_argv[3]; + char *at_args; + FILE *args; + int status; + + args_name = make_temp_file (".args"); + at_args = concat ("@", args_name, NULL); + args = fopen (args_name, "w"); + if (args == NULL) + fatal ("failed to open %s", args_name); + + status = writeargv (&argv[1], args); + + if (status) + fatal ("could not write to temporary file %s", args_name); + + fclose (args); + + new_argv[0] = argv[0]; + new_argv[1] = at_args; + new_argv[2] = NULL; + + pex = collect_execute (new_argv); + collect_wait (new_argv[0], pex); + + maybe_unlink_file (args_name); + args_name = NULL; + free (at_args); +} + +/* Template of LTRANS dumpbase suffix. */ +#define DUMPBASE_SUFFIX ".ltrans18446744073709551615" + +/* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */ + +static void +run_gcc (unsigned argc, char *argv[]) +{ + unsigned i, j; + const char **new_argv; + const char **argv_ptr; + char *list_option_full = NULL; + const char *linker_output = NULL; + const char *collect_gcc_options, *collect_gcc; + struct obstack env_obstack; + bool seen_o = false; + int parallel = 0; + int jobserver = 0; + bool no_partition = false; + + /* Get the driver and options. */ + collect_gcc = getenv ("COLLECT_GCC"); + if (!collect_gcc) + fatal ("environment variable COLLECT_GCC must be set"); + + /* Set the CFLAGS environment variable. */ + collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS"); + if (!collect_gcc_options) + fatal ("environment variable COLLECT_GCC_OPTIONS must be set"); + + /* Count arguments. */ + i = 0; + for (j = 0; collect_gcc_options[j] != '\0'; ++j) + if (collect_gcc_options[j] == '\'') + ++i; + + if (i % 2 != 0) + fatal ("malformed COLLECT_GCC_OPTIONS"); + + /* Initalize the common arguments for the driver. */ + new_argv = (const char **) xmalloc ((15 + i / 2 + argc) * sizeof (char *)); + argv_ptr = new_argv; + *argv_ptr++ = collect_gcc; + *argv_ptr++ = "-xlto"; + *argv_ptr++ = "-c"; + for (j = 0; collect_gcc_options[j] != '\0'; ++j) + if (collect_gcc_options[j] == '\'') + { + char *option; + + ++j; + i = j; + while (collect_gcc_options[j] != '\'') + ++j; + + obstack_init (&env_obstack); + obstack_grow (&env_obstack, &collect_gcc_options[i], j - i); + obstack_1grow (&env_obstack, 0); + option = XOBFINISH (&env_obstack, char *); + if (seen_o) + { + linker_output = option; + seen_o = false; + continue; + } + + /* If we see -o, skip it and skip and record its argument. */ + if (option[0] == '-' && option[1] == 'o') + { + if (option[2] == '\0') + seen_o = true; + else + linker_output = &option[2]; + continue; + } + + if (strcmp (option, "-save-temps") == 0) + debug = 1; + if (strcmp (option, "-v") == 0) + verbose = 1; + + if (strcmp (option, "-flto-partition=none") == 0) + no_partition = true; + /* We've handled these LTO options, do not pass them on. */ + if (strncmp (option, "-flto=", 6) == 0 + || !strcmp (option, "-flto")) + { + lto_mode = LTO_MODE_WHOPR; + if (option[5] == '=') + { + if (!strcmp (option + 6, "jobserver")) + { + jobserver = 1; + parallel = 1; + } + else + { + parallel = atoi (option + 6); + if (parallel <= 1) + parallel = 0; + } + } + } + else + *argv_ptr++ = option; + } + if (no_partition) + { + lto_mode = LTO_MODE_LTO; + jobserver = 0; + parallel = 0; + } + + if (linker_output) + { + char *output_dir, *base, *name; + bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0; + + output_dir = xstrdup (linker_output); + base = output_dir; + for (name = base; *name; name++) + if (IS_DIR_SEPARATOR (*name)) + base = name + 1; + *base = '\0'; + + linker_output = &linker_output[base - output_dir]; + if (*output_dir == '\0') + { + static char current_dir[] = { '.', DIR_SEPARATOR, '\0' }; + output_dir = current_dir; + } + if (!bit_bucket) + { + *argv_ptr++ = "-dumpdir"; + *argv_ptr++ = output_dir; + } + + *argv_ptr++ = "-dumpbase"; + } + else + argv_ptr--; + + if (lto_mode == LTO_MODE_LTO) + { + flto_out = make_temp_file (".lto.o"); + if (linker_output) + argv_ptr[0] = linker_output; + argv_ptr[1] = "-o"; + argv_ptr[2] = flto_out; + } + else + { + const char *list_option = "-fltrans-output-list="; + size_t list_option_len = strlen (list_option); + char *tmp; + + if (linker_output) + { + char *dumpbase = (char *) xmalloc (strlen (linker_output) + + sizeof (".wpa") + 1); + strcpy (dumpbase, linker_output); + strcat (dumpbase, ".wpa"); + argv_ptr[0] = dumpbase; + } + + if (linker_output && debug) + { + ltrans_output_file = (char *) xmalloc (strlen (linker_output) + + sizeof (".ltrans.out") + 1); + strcpy (ltrans_output_file, linker_output); + strcat (ltrans_output_file, ".ltrans.out"); + } + else + ltrans_output_file = make_temp_file (".ltrans.out"); + list_option_full = (char *) xmalloc (sizeof (char) * + (strlen (ltrans_output_file) + list_option_len + 1)); + tmp = list_option_full; + + argv_ptr[1] = tmp; + strcpy (tmp, list_option); + tmp += list_option_len; + strcpy (tmp, ltrans_output_file); + + argv_ptr[2] = "-fwpa"; + } + + /* Append the input objects and possible preceeding arguments. */ + for (i = 1; i < argc; ++i) + argv_ptr[2 + i] = argv[i]; + argv_ptr[2 + i] = NULL; + + fork_execute (CONST_CAST (char **, new_argv)); + + if (lto_mode == LTO_MODE_LTO) + { + printf("%s\n", flto_out); + free (flto_out); + flto_out = NULL; + } + else + { + FILE *stream = fopen (ltrans_output_file, "r"); + FILE *mstream = NULL; + + if (!stream) + fatal_perror ("fopen: %s", ltrans_output_file); + + /* Parse the list of LTRANS inputs from the WPA stage. */ + nr = 0; + for (;;) + { + const unsigned piece = 32; + char *output_name = NULL; + char *buf, *input_name = (char *)xmalloc (piece); + size_t len; + + buf = input_name; +cont: + if (!fgets (buf, piece, stream)) + break; + len = strlen (input_name); + if (input_name[len - 1] != '\n') + { + input_name = (char *)xrealloc (input_name, len + piece); + buf = input_name + len; + goto cont; + } + input_name[len - 1] = '\0'; + + if (input_name[0] == '*') + output_name = &input_name[1]; + + nr++; + input_names = (char **)xrealloc (input_names, nr * sizeof (char *)); + output_names = (char **)xrealloc (output_names, nr * sizeof (char *)); + input_names[nr-1] = input_name; + output_names[nr-1] = output_name; + } + fclose (stream); + maybe_unlink_file (ltrans_output_file); + ltrans_output_file = NULL; + + if (parallel) + { + makefile = make_temp_file (".mk"); + mstream = fopen (makefile, "w"); + } + + /* Execute the LTRANS stage for each input file (or prepare a + makefile to invoke this in parallel). */ + for (i = 0; i < nr; ++i) + { + char *output_name; + char *input_name = input_names[i]; + /* If it's a pass-through file do nothing. */ + if (output_names[i]) + continue; + + /* Replace the .o suffix with a .ltrans.o suffix and write + the resulting name to the LTRANS output list. */ + obstack_init (&env_obstack); + obstack_grow (&env_obstack, input_name, strlen (input_name) - 2); + obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o")); + output_name = XOBFINISH (&env_obstack, char *); + + /* Adjust the dumpbase if the linker output file was seen. */ + if (linker_output) + { + char *dumpbase + = (char *) xmalloc (strlen (linker_output) + + sizeof(DUMPBASE_SUFFIX) + 1); + snprintf (dumpbase, + strlen (linker_output) + sizeof(DUMPBASE_SUFFIX), + "%s.ltrans%u", linker_output, i); + argv_ptr[0] = dumpbase; + } + + argv_ptr[1] = "-fltrans"; + argv_ptr[2] = "-o"; + argv_ptr[3] = output_name; + argv_ptr[4] = input_name; + argv_ptr[5] = NULL; + if (parallel) + { + fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]); + for (j = 1; new_argv[j] != NULL; ++j) + fprintf (mstream, " '%s'", new_argv[j]); + fprintf (mstream, "\n"); + } + else + fork_execute (CONST_CAST (char **, new_argv)); + + output_names[i] = output_name; + } + if (parallel) + { + struct pex_obj *pex; + char jobs[32]; + + fprintf (mstream, "all:"); + for (i = 0; i < nr; ++i) + fprintf (mstream, " \\\n\t%s", output_names[i]); + fprintf (mstream, "\n"); + fclose (mstream); + if (!jobserver) + { + /* Avoid passing --jobserver-fd= and similar flags + unless jobserver mode is explicitly enabled. */ + putenv (xstrdup ("MAKEFLAGS=")); + putenv (xstrdup ("MFLAGS=")); + } + new_argv[0] = getenv ("MAKE"); + if (!new_argv[0]) + new_argv[0] = "make"; + new_argv[1] = "-f"; + new_argv[2] = makefile; + i = 3; + if (!jobserver) + { + snprintf (jobs, 31, "-j%d", parallel); + new_argv[i++] = jobs; + } + new_argv[i++] = "all"; + new_argv[i++] = NULL; + pex = collect_execute (CONST_CAST (char **, new_argv)); + collect_wait (new_argv[0], pex); + maybe_unlink_file (makefile); + makefile = NULL; + } + for (i = 0; i < nr; ++i) + { + fputs (output_names[i], stdout); + putc ('\n', stdout); + maybe_unlink_file (input_names[i]); + free (input_names[i]); + } + nr = 0; + free (output_names); + free (input_names); + free (list_option_full); + } + + obstack_free (&env_obstack, NULL); +} + + +/* Entry point. */ + +int +main (int argc, char *argv[]) +{ + gcc_init_libintl (); + + if (signal (SIGINT, SIG_IGN) != SIG_IGN) + signal (SIGINT, fatal_signal); +#ifdef SIGHUP + if (signal (SIGHUP, SIG_IGN) != SIG_IGN) + signal (SIGHUP, fatal_signal); +#endif + if (signal (SIGTERM, SIG_IGN) != SIG_IGN) + signal (SIGTERM, fatal_signal); +#ifdef SIGPIPE + if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) + signal (SIGPIPE, fatal_signal); +#endif +#ifdef SIGCHLD + /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will + receive the signal. A different setting is inheritable */ + signal (SIGCHLD, SIG_DFL); +#endif + + /* We may be called with all the arguments stored in some file and + passed with @file. Expand them into argv before processing. */ + expandargv (&argc, &argv); + run_gcc (argc, argv); + + return 0; +} |