2009-10-03 23:10:11 +02:00
|
|
|
/* Wrapper to call lto. Used by collect2 and the linker plugin.
|
2010-01-03 18:03:38 +01:00
|
|
|
Copyright (C) 2009, 2010 Free Software Foundation, Inc.
|
2009-10-03 23:10:11 +02:00
|
|
|
|
|
|
|
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
|
|
|
|
|
2010-11-11 23:54:53 +01:00
|
|
|
If WHOPR is used instead, more than one file might be produced
|
2009-10-03 23:10:11 +02:00
|
|
|
./ccXj2DTk.lto.ltrans.o
|
|
|
|
./ccCJuXGv.lto.ltrans.o
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "system.h"
|
Makefile.in (READ_MD_H): New variable.
gcc/
* Makefile.in (READ_MD_H): New variable.
(BUILD_RTL): Add build/read-md.o.
(lto-wrapper.o): Depend on coretypes.h instead of defaults.h.
(build/gensupport.o, build/read-rtl.o, build/genattr.o)
(build/genattrtab.o, build/genconditions.o build/genemit.o)
(build/genextract.o, build/genflags.o, build/genoutput.o)
(build/genpreds.o, build/genrecog.o): Depend on $(READ_MD_H).
(build/read-md.o): New rule.
* defaults.h (obstack_chunk_alloc, obstack_chunk_free)
(OBSTACK_CHUNK_SIZE, gcc_obstack_init): Move to...
* coretypes.h: ...here.
* lto-wrapper.c: Include coretypes.h instead of defaults.h.
* pretty-print.c (obstack_chunk_alloc, obstack_chunk_free): Delete.
* genattr.c: Include read-md.h.
* genattrtab.c: Likewise.
* genconditions.c: Likewise.
* genemit.c: Likewise.
* genextract.c: Likewise.
* genflags.c: Likewise.
* genoutput.c: Likewise.
* genpreds.c: Likewise.
* genrecog.c: Likewise.
* rtl.h (read_skip_spaces, copy_rtx_ptr_loc, print_rtx_ptr_loc)
(join_c_conditions, print_c_condition, read_rtx_filename)
(read_rtx_lineno): Move to read-md.h.
* read-rtl.c: Include read-md.h.
(ptr_loc, string_obstack, ptr_locs, ptr_loc_obstack)
(joined_conditions, joined_conditions_obstack, read_rtx_lineno)
(read_rtx_filename, fatal_with_file_and_line, fatal_expected_char)
(leading_ptr_hash, leading_ptr_eq_p, set_rtx_ptr_loc, get_rtx_ptr_loc)
(copy_rtx_ptr_loc, print_rtx_ptr_loc, join_c_conditions)
(print_c_condition, read_skip_spaces, read_escape, read_quoted_string)
(read_braced_string, read_string): Move to read-md.c.
(read_rtx): Move some initialization to init_md_reader and call
init_md_reader here.
* gensupport.h (message_with_line, n_comma_elts, scan_comma_elt):
Move to read-md.h.
* gensupport.c: Include read-md.h.
(message_with_line, n_comma_elts, scan_comma_elt): Move to
read-md.c.
* read-md.h, read-md.c: New files.
From-SVN: r160570
2010-06-10 22:21:23 +02:00
|
|
|
#include "coretypes.h"
|
2009-10-03 23:10:11 +02:00
|
|
|
#include "intl.h"
|
Makefile.in (LIBDEPS): Add libcommon.a.
* Makefile.in (LIBDEPS): Add libcommon.a.
(LIBS): Likewise.
(GCC_OBJS): Remove diagnostic.o, pretty-print.o and input.o.
(OBJS-common): Remove diagnostic.o, input.o, intl.o,
pretty-print.o and version.o.
(OBJS-libcommon): New.
(ALL_HOST_BACKEND_OBJS): Add $(OBJS-libcommon).
(BACKEND): Add libcommon.a.
(MOSTLYCLEANFILES): Likewise.
(libcommon.a): New.
(xgcc$(exeext)): Don't explicitly use version.o and intl.o.
(cpp$(exeext)): Likewise.
(COLLECT2_OBJS): Remove intl.o, version.o, diagnostic.o,
pretty-print.o and input.o.
(lto-wrapper$(exeext)): Don't explicitly use intl.o.
(lto-wrapper.o): Depend on $(DIAGNOSTIC_H).
(errors.o): Remove.
(mips-tfile): Don't explicitly use version.o.
(mips-tdump): Likewise.
(gcov.o): Depend on $(DIAGNOSTIC_H).
(gcov-dump.o): Depend on intl.h and $(DIAGNOSTIC_H).
(GCOV_OBJS): Remove intl.o, version.o and errors.o.
(GCOV_DUMP_OBJS): Remove version.o and errors.o.
* gcov-dump.c: Include intl.h and diagnostic.h.
(main): Initialize diagnostics.
* gcov.c: Include diagnostic.h.
(fnotice): Remove.
(main): Initialize diagnostics.
* lto-wrapper.c: Include diagnostic.h.
(main): Initialize diagnostics.
ada:
* gcc-interface/Make-lang.in (EXTRA_GNATBIND_OBJS): Remove
version.o.
* gcc-interface/Makefile.in (EXTRA_GNATTOOLS_OBJS): Use
libcommon.a instead of version.o.
cp:
* Make-lang.in (GXX_OBJS): Remove intl.o and version.o.
fortran:
* Make-lang.in (GFORTRAN_D_OBJS): Remove version.o and intl.o.
go:
* Make-lang.in (GCCGO_OBJS): Remove intl.o and version.o.
java:
* Make-lang.in ($(XGCJ)$(exeext)): Don't explicitly use intl.o and
version.o.
(JCFDUMP_OBJS): Remove errors.o, version.o and intl.o.
(JVGENMAIN_OBJS): Remove errors.o and intl.o.
(java/jcf-dump.o, java/jvgenmain.o): Depend in $(DIAGNOSTIC_H).
* jcf-dump.c: Include diagnostic.h.
(main): Initialize diagnostics.
* jvgenmain.c: Include diagnostic.h.
(main): Initialize diagnostics.
From-SVN: r173958
2011-05-20 17:19:05 +02:00
|
|
|
#include "diagnostic.h"
|
2010-05-07 17:52:01 +02:00
|
|
|
#include "obstack.h"
|
2011-10-26 11:30:29 +02:00
|
|
|
#include "opts.h"
|
|
|
|
#include "options.h"
|
2011-11-03 15:46:26 +01:00
|
|
|
#include "simple-object.h"
|
|
|
|
|
|
|
|
/* From lto-streamer.h which we cannot include with -fkeep-inline-functions.
|
|
|
|
??? Split out a lto-streamer-core.h. */
|
|
|
|
|
|
|
|
#define LTO_SECTION_NAME_PREFIX ".gnu.lto_"
|
|
|
|
|
|
|
|
/* End of lto-streamer.h copy. */
|
2009-10-03 23:10:11 +02:00
|
|
|
|
2010-05-18 17:11:01 +02:00
|
|
|
int debug; /* true if -save-temps. */
|
|
|
|
int verbose; /* true if -v. */
|
2009-10-03 23:10:11 +02:00
|
|
|
|
|
|
|
enum lto_mode_d {
|
2010-05-18 17:11:01 +02:00
|
|
|
LTO_MODE_NONE, /* Not doing LTO. */
|
|
|
|
LTO_MODE_LTO, /* Normal LTO. */
|
|
|
|
LTO_MODE_WHOPR /* WHOPR. */
|
2009-10-03 23:10:11 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Current LTO mode. */
|
|
|
|
static enum lto_mode_d lto_mode = LTO_MODE_NONE;
|
|
|
|
|
2009-10-09 15:24:59 +02:00
|
|
|
static char *ltrans_output_file;
|
|
|
|
static char *flto_out;
|
|
|
|
static char *args_name;
|
2010-05-25 17:47:28 +02:00
|
|
|
static unsigned int nr;
|
|
|
|
static char **input_names;
|
|
|
|
static char **output_names;
|
|
|
|
static char *makefile;
|
2009-10-09 15:24:59 +02:00
|
|
|
|
|
|
|
static void maybe_unlink_file (const char *);
|
|
|
|
|
2010-06-02 15:58:27 +02:00
|
|
|
/* Delete tempfiles. */
|
2009-10-09 15:24:59 +02:00
|
|
|
|
|
|
|
static void
|
2010-06-02 15:58:27 +02:00
|
|
|
lto_wrapper_cleanup (void)
|
2009-10-09 15:24:59 +02:00
|
|
|
{
|
2009-11-24 16:00:15 +01:00
|
|
|
static bool cleanup_done = false;
|
2010-06-02 15:58:27 +02:00
|
|
|
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)
|
2009-11-24 16:00:15 +01:00
|
|
|
{
|
2010-06-02 15:58:27 +02:00
|
|
|
maybe_unlink_file (input_names[i]);
|
|
|
|
if (output_names[i])
|
|
|
|
maybe_unlink_file (output_names[i]);
|
2009-11-24 16:00:15 +01:00
|
|
|
}
|
2010-06-02 15:58:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2009-10-09 15:24:59 +02:00
|
|
|
}
|
|
|
|
|
2009-10-03 23:10:11 +02:00
|
|
|
/* 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);
|
|
|
|
|
2010-06-02 15:58:27 +02:00
|
|
|
lto_wrapper_cleanup ();
|
|
|
|
exit (FATAL_EXIT_CODE);
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2010-06-02 15:58:27 +02:00
|
|
|
lto_wrapper_cleanup ();
|
|
|
|
exit (FATAL_EXIT_CODE);
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2010-05-18 17:11:01 +02:00
|
|
|
if (verbose)
|
2009-10-03 23:10:11 +02:00
|
|
|
{
|
|
|
|
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");
|
|
|
|
|
2010-05-19 17:43:22 +02:00
|
|
|
/* 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,
|
2009-10-03 23:10:11 +02:00
|
|
|
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)
|
|
|
|
{
|
2010-05-27 12:33:08 +02:00
|
|
|
if (unlink_if_ordinary (file)
|
|
|
|
&& errno != ENOENT)
|
2009-10-03 23:10:11 +02:00
|
|
|
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];
|
2009-10-09 15:24:59 +02:00
|
|
|
char *at_args;
|
|
|
|
FILE *args;
|
2009-10-03 23:10:11 +02:00
|
|
|
int status;
|
|
|
|
|
2009-10-09 15:24:59 +02:00
|
|
|
args_name = make_temp_file (".args");
|
|
|
|
at_args = concat ("@", args_name, NULL);
|
|
|
|
args = fopen (args_name, "w");
|
2009-10-03 23:10:11 +02:00
|
|
|
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);
|
2010-05-27 12:33:08 +02:00
|
|
|
args_name = NULL;
|
2009-10-03 23:10:11 +02:00
|
|
|
free (at_args);
|
|
|
|
}
|
|
|
|
|
2010-05-07 17:52:01 +02:00
|
|
|
/* Template of LTRANS dumpbase suffix. */
|
|
|
|
#define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
|
2009-10-03 23:10:11 +02:00
|
|
|
|
2011-10-26 11:30:29 +02:00
|
|
|
/* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
|
|
|
|
environment according to LANG_MASK. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
get_options_from_collect_gcc_options (const char *collect_gcc,
|
|
|
|
const char *collect_gcc_options,
|
|
|
|
unsigned int lang_mask,
|
|
|
|
struct cl_decoded_option **decoded_options,
|
|
|
|
unsigned int *decoded_options_count)
|
|
|
|
{
|
2011-11-03 14:13:33 +01:00
|
|
|
struct obstack argv_obstack;
|
2011-10-26 11:30:29 +02:00
|
|
|
char *argv_storage;
|
|
|
|
const char **argv;
|
2011-11-03 14:13:33 +01:00
|
|
|
int j, k, argc;
|
|
|
|
|
2011-10-26 11:30:29 +02:00
|
|
|
argv_storage = xstrdup (collect_gcc_options);
|
2011-11-03 14:13:33 +01:00
|
|
|
obstack_init (&argv_obstack);
|
|
|
|
obstack_ptr_grow (&argv_obstack, collect_gcc);
|
|
|
|
|
|
|
|
for (j = 0, k = 0; argv_storage[j] != '\0'; ++j)
|
2011-10-26 11:30:29 +02:00
|
|
|
{
|
|
|
|
if (argv_storage[j] == '\'')
|
|
|
|
{
|
2011-11-03 14:13:33 +01:00
|
|
|
obstack_ptr_grow (&argv_obstack, &argv_storage[k]);
|
|
|
|
++j;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if (argv_storage[j] == '\0')
|
|
|
|
fatal ("malformed COLLECT_GCC_OPTIONS");
|
|
|
|
else if (strncmp (&argv_storage[j], "'\\''", 4) == 0)
|
|
|
|
{
|
|
|
|
argv_storage[k++] = '\'';
|
|
|
|
j += 4;
|
|
|
|
}
|
|
|
|
else if (argv_storage[j] == '\'')
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
argv_storage[k++] = argv_storage[j++];
|
|
|
|
}
|
|
|
|
while (1);
|
|
|
|
argv_storage[k++] = '\0';
|
2011-10-26 11:30:29 +02:00
|
|
|
}
|
|
|
|
}
|
2011-11-03 14:13:33 +01:00
|
|
|
|
|
|
|
obstack_ptr_grow (&argv_obstack, NULL);
|
|
|
|
argc = obstack_object_size (&argv_obstack) / sizeof (void *) - 1;
|
|
|
|
argv = XOBFINISH (&argv_obstack, const char **);
|
2011-10-26 11:30:29 +02:00
|
|
|
|
|
|
|
decode_cmdline_options_to_array (argc, (const char **)argv,
|
|
|
|
lang_mask,
|
|
|
|
decoded_options, decoded_options_count);
|
2011-11-03 14:13:33 +01:00
|
|
|
obstack_free (&argv_obstack, NULL);
|
2011-10-26 11:30:29 +02:00
|
|
|
}
|
|
|
|
|
2011-11-03 15:46:26 +01:00
|
|
|
/* Append OPTION to the options array DECODED_OPTIONS with size
|
|
|
|
DECODED_OPTIONS_COUNT. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
append_option (struct cl_decoded_option **decoded_options,
|
|
|
|
unsigned int *decoded_options_count,
|
|
|
|
struct cl_decoded_option *option)
|
|
|
|
{
|
|
|
|
++*decoded_options_count;
|
|
|
|
*decoded_options
|
|
|
|
= (struct cl_decoded_option *)
|
|
|
|
xrealloc (*decoded_options,
|
|
|
|
(*decoded_options_count
|
|
|
|
* sizeof (struct cl_decoded_option)));
|
|
|
|
memcpy (&(*decoded_options)[*decoded_options_count - 1], option,
|
|
|
|
sizeof (struct cl_decoded_option));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try to merge and complain about options FDECODED_OPTIONS when applied
|
|
|
|
ontop of DECODED_OPTIONS. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
merge_and_complain (struct cl_decoded_option **decoded_options,
|
|
|
|
unsigned int *decoded_options_count,
|
|
|
|
struct cl_decoded_option *fdecoded_options,
|
|
|
|
unsigned int fdecoded_options_count)
|
|
|
|
{
|
|
|
|
unsigned int i, j;
|
|
|
|
|
|
|
|
/* ??? Merge options from files. Most cases can be
|
|
|
|
handled by either unioning or intersecting
|
|
|
|
(for example -fwrapv is a case for unioning,
|
|
|
|
-ffast-math is for intersection). Most complaints
|
|
|
|
about real conflicts between different options can
|
|
|
|
be deferred to the compiler proper. Options that
|
|
|
|
we can neither safely handle by intersection nor
|
|
|
|
unioning would need to be complained about here.
|
|
|
|
Ideally we'd have a flag in the opt files that
|
|
|
|
tells whether to union or intersect or reject.
|
|
|
|
In absence of that it's unclear what a good default is.
|
|
|
|
It's also difficult to get positional handling correct. */
|
|
|
|
|
|
|
|
/* The following does what the old LTO option code did,
|
|
|
|
union all target and a selected set of common options. */
|
|
|
|
for (i = 0; i < fdecoded_options_count; ++i)
|
|
|
|
{
|
|
|
|
struct cl_decoded_option *foption = &fdecoded_options[i];
|
|
|
|
switch (foption->opt_index)
|
|
|
|
{
|
|
|
|
default:
|
|
|
|
if (!(cl_options[foption->opt_index].flags & CL_TARGET))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Fallthru. */
|
|
|
|
case OPT_fPIC:
|
|
|
|
case OPT_fpic:
|
|
|
|
case OPT_fpie:
|
|
|
|
case OPT_fcommon:
|
|
|
|
case OPT_fexceptions:
|
|
|
|
/* Do what the old LTO code did - collect exactly one option
|
|
|
|
setting per OPT code, we pick the first we encounter.
|
|
|
|
??? This doesn't make too much sense, but when it doesn't
|
|
|
|
then we should complain. */
|
|
|
|
for (j = 0; j < *decoded_options_count; ++j)
|
|
|
|
if ((*decoded_options)[j].opt_index == foption->opt_index)
|
|
|
|
break;
|
|
|
|
if (j == *decoded_options_count)
|
|
|
|
append_option (decoded_options, decoded_options_count, foption);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-10-26 11:30:29 +02:00
|
|
|
|
2009-10-03 23:10:11 +02:00
|
|
|
/* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
run_gcc (unsigned argc, char *argv[])
|
|
|
|
{
|
2010-05-18 17:11:01 +02:00
|
|
|
unsigned i, j;
|
2009-10-03 23:10:11 +02:00
|
|
|
const char **new_argv;
|
|
|
|
const char **argv_ptr;
|
|
|
|
char *list_option_full = NULL;
|
2010-05-18 17:11:01 +02:00
|
|
|
const char *linker_output = NULL;
|
2011-10-26 11:30:29 +02:00
|
|
|
const char *collect_gcc, *collect_gcc_options;
|
2010-05-19 17:43:22 +02:00
|
|
|
int parallel = 0;
|
2010-08-31 18:58:46 +02:00
|
|
|
int jobserver = 0;
|
2010-11-11 23:54:53 +01:00
|
|
|
bool no_partition = false;
|
2011-11-03 15:46:26 +01:00
|
|
|
struct cl_decoded_option *fdecoded_options = NULL;
|
|
|
|
unsigned int fdecoded_options_count = 0;
|
2011-10-26 11:30:29 +02:00
|
|
|
struct cl_decoded_option *decoded_options;
|
|
|
|
unsigned int decoded_options_count;
|
2011-10-28 11:46:26 +02:00
|
|
|
struct obstack argv_obstack;
|
|
|
|
int new_head_argc;
|
2010-05-18 17:11:01 +02:00
|
|
|
|
|
|
|
/* Get the driver and options. */
|
|
|
|
collect_gcc = getenv ("COLLECT_GCC");
|
|
|
|
if (!collect_gcc)
|
|
|
|
fatal ("environment variable COLLECT_GCC must be set");
|
|
|
|
collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
|
|
|
|
if (!collect_gcc_options)
|
|
|
|
fatal ("environment variable COLLECT_GCC_OPTIONS must be set");
|
2011-10-26 11:30:29 +02:00
|
|
|
get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options,
|
|
|
|
CL_LANG_ALL,
|
|
|
|
&decoded_options,
|
|
|
|
&decoded_options_count);
|
2010-05-18 17:11:01 +02:00
|
|
|
|
2011-11-03 15:46:26 +01:00
|
|
|
/* Look at saved options in the IL files. */
|
|
|
|
for (i = 1; i < argc; ++i)
|
|
|
|
{
|
|
|
|
char *data, *p;
|
|
|
|
char *fopts;
|
|
|
|
int fd;
|
|
|
|
const char *errmsg;
|
|
|
|
int err;
|
|
|
|
off_t file_offset = 0, offset, length;
|
|
|
|
long loffset;
|
|
|
|
simple_object_read *sobj;
|
|
|
|
int consumed;
|
|
|
|
struct cl_decoded_option *f2decoded_options;
|
|
|
|
unsigned int f2decoded_options_count;
|
|
|
|
char *filename = argv[i];
|
|
|
|
if ((p = strrchr (argv[i], '@'))
|
|
|
|
&& p != argv[i]
|
|
|
|
&& sscanf (p, "@%li%n", &loffset, &consumed) >= 1
|
|
|
|
&& strlen (p) == (unsigned int) consumed)
|
|
|
|
{
|
|
|
|
filename = XNEWVEC (char, p - argv[i] + 1);
|
|
|
|
memcpy (filename, argv[i], p - argv[i]);
|
|
|
|
filename[p - argv[i]] = '\0';
|
|
|
|
file_offset = (off_t) loffset;
|
|
|
|
}
|
|
|
|
fd = open (argv[i], O_RDONLY);
|
|
|
|
if (fd == -1)
|
|
|
|
continue;
|
|
|
|
sobj = simple_object_start_read (fd, file_offset, NULL, &errmsg, &err);
|
|
|
|
if (!sobj)
|
|
|
|
{
|
|
|
|
close (fd);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!simple_object_find_section (sobj, LTO_SECTION_NAME_PREFIX "." "opts",
|
|
|
|
&offset, &length, &errmsg, &err))
|
|
|
|
{
|
|
|
|
simple_object_release_read (sobj);
|
|
|
|
close (fd);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
lseek (fd, file_offset + offset, SEEK_SET);
|
|
|
|
data = (char *)xmalloc (length);
|
|
|
|
read (fd, data, length);
|
|
|
|
fopts = data;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
get_options_from_collect_gcc_options (collect_gcc,
|
|
|
|
fopts, CL_LANG_ALL,
|
|
|
|
&f2decoded_options,
|
|
|
|
&f2decoded_options_count);
|
|
|
|
if (!fdecoded_options)
|
|
|
|
{
|
|
|
|
fdecoded_options = f2decoded_options;
|
|
|
|
fdecoded_options_count = f2decoded_options_count;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
merge_and_complain (&fdecoded_options,
|
|
|
|
&fdecoded_options_count,
|
|
|
|
f2decoded_options, f2decoded_options_count);
|
|
|
|
|
|
|
|
fopts += strlen (fopts) + 1;
|
|
|
|
}
|
|
|
|
while (fopts - data < length);
|
|
|
|
|
|
|
|
free (data);
|
|
|
|
simple_object_release_read (sobj);
|
|
|
|
close (fd);
|
|
|
|
}
|
|
|
|
|
2010-05-18 17:11:01 +02:00
|
|
|
/* Initalize the common arguments for the driver. */
|
2011-10-28 11:46:26 +02:00
|
|
|
obstack_init (&argv_obstack);
|
|
|
|
obstack_ptr_grow (&argv_obstack, collect_gcc);
|
|
|
|
obstack_ptr_grow (&argv_obstack, "-xlto");
|
|
|
|
obstack_ptr_grow (&argv_obstack, "-c");
|
2011-11-03 15:46:26 +01:00
|
|
|
|
|
|
|
/* Append compiler driver arguments as far as they were merged. */
|
|
|
|
for (j = 1; j < fdecoded_options_count; ++j)
|
|
|
|
{
|
|
|
|
struct cl_decoded_option *option = &fdecoded_options[j];
|
|
|
|
|
|
|
|
/* File options have been properly filtered by lto-opts.c. */
|
|
|
|
switch (option->opt_index)
|
|
|
|
{
|
|
|
|
/* Drop arguments that we want to take from the link line. */
|
|
|
|
case OPT_flto_:
|
|
|
|
case OPT_flto:
|
|
|
|
case OPT_flto_partition_none:
|
|
|
|
case OPT_flto_partition_1to1:
|
|
|
|
case OPT_flto_partition_balanced:
|
|
|
|
continue;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For now do what the original LTO option code was doing - pass
|
|
|
|
on any CL_TARGET flag and a few selected others. */
|
|
|
|
switch (option->opt_index)
|
|
|
|
{
|
|
|
|
case OPT_fPIC:
|
|
|
|
case OPT_fpic:
|
|
|
|
case OPT_fpie:
|
|
|
|
case OPT_fcommon:
|
|
|
|
case OPT_fexceptions:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
if (!(cl_options[option->opt_index].flags & CL_TARGET))
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Pass the option on. */
|
|
|
|
for (i = 0; i < option->canonical_option_num_elements; ++i)
|
|
|
|
obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Append linker driver arguments. Compiler options from the linker
|
|
|
|
driver arguments will override / merge with those from the compiler. */
|
2011-10-26 11:30:29 +02:00
|
|
|
for (j = 1; j < decoded_options_count; ++j)
|
|
|
|
{
|
|
|
|
struct cl_decoded_option *option = &decoded_options[j];
|
2009-10-03 23:10:11 +02:00
|
|
|
|
2011-10-28 11:46:26 +02:00
|
|
|
/* Do not pass on frontend specific flags not suitable for lto. */
|
2011-10-26 11:30:29 +02:00
|
|
|
if (!(cl_options[option->opt_index].flags
|
2011-10-28 11:46:26 +02:00
|
|
|
& (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
|
2011-10-26 11:30:29 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (option->opt_index)
|
|
|
|
{
|
|
|
|
case OPT_o:
|
|
|
|
linker_output = option->arg;
|
|
|
|
/* We generate new intermediate output, drop this arg. */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case OPT_save_temps:
|
2010-05-18 17:11:01 +02:00
|
|
|
debug = 1;
|
2011-10-26 11:30:29 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case OPT_v:
|
2010-05-18 17:11:01 +02:00
|
|
|
verbose = 1;
|
2011-10-26 11:30:29 +02:00
|
|
|
break;
|
2010-05-18 17:11:01 +02:00
|
|
|
|
2011-10-26 11:30:29 +02:00
|
|
|
case OPT_flto_partition_none:
|
2010-11-11 23:54:53 +01:00
|
|
|
no_partition = true;
|
2011-10-26 11:30:29 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case OPT_flto_:
|
|
|
|
if (strcmp (option->arg, "jobserver") == 0)
|
|
|
|
{
|
|
|
|
jobserver = 1;
|
|
|
|
parallel = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
parallel = atoi (option->arg);
|
|
|
|
if (parallel <= 1)
|
|
|
|
parallel = 0;
|
|
|
|
}
|
|
|
|
/* Fallthru. */
|
|
|
|
|
|
|
|
case OPT_flto:
|
|
|
|
lto_mode = LTO_MODE_WHOPR;
|
|
|
|
/* We've handled these LTO options, do not pass them on. */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Pass the option on. */
|
2011-10-28 11:46:26 +02:00
|
|
|
for (i = 0; i < option->canonical_option_num_elements; ++i)
|
|
|
|
obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
|
2011-10-26 11:30:29 +02:00
|
|
|
}
|
|
|
|
|
2010-11-11 23:54:53 +01:00
|
|
|
if (no_partition)
|
|
|
|
{
|
|
|
|
lto_mode = LTO_MODE_LTO;
|
|
|
|
jobserver = 0;
|
|
|
|
parallel = 0;
|
|
|
|
}
|
2010-05-18 17:11:01 +02:00
|
|
|
|
|
|
|
if (linker_output)
|
|
|
|
{
|
|
|
|
char *output_dir, *base, *name;
|
2011-02-01 15:42:08 +01:00
|
|
|
bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0;
|
2009-10-03 23:10:11 +02:00
|
|
|
|
2010-05-18 17:11:01 +02:00
|
|
|
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;
|
|
|
|
}
|
2011-02-01 15:42:08 +01:00
|
|
|
if (!bit_bucket)
|
|
|
|
{
|
2011-10-28 11:46:26 +02:00
|
|
|
obstack_ptr_grow (&argv_obstack, "-dumpdir");
|
|
|
|
obstack_ptr_grow (&argv_obstack, output_dir);
|
2011-02-01 15:42:08 +01:00
|
|
|
}
|
2010-05-18 17:11:01 +02:00
|
|
|
|
2011-10-28 11:46:26 +02:00
|
|
|
obstack_ptr_grow (&argv_obstack, "-dumpbase");
|
2010-05-18 17:11:01 +02:00
|
|
|
}
|
2011-10-28 11:46:26 +02:00
|
|
|
|
|
|
|
/* Remember at which point we can scrub args to re-use the commons. */
|
|
|
|
new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *);
|
2009-10-03 23:10:11 +02:00
|
|
|
|
|
|
|
if (lto_mode == LTO_MODE_LTO)
|
|
|
|
{
|
|
|
|
flto_out = make_temp_file (".lto.o");
|
2010-05-18 17:11:01 +02:00
|
|
|
if (linker_output)
|
2011-10-28 11:46:26 +02:00
|
|
|
obstack_ptr_grow (&argv_obstack, linker_output);
|
|
|
|
obstack_ptr_grow (&argv_obstack, "-o");
|
|
|
|
obstack_ptr_grow (&argv_obstack, flto_out);
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
2011-01-05 17:07:09 +01:00
|
|
|
else
|
2009-10-03 23:10:11 +02:00
|
|
|
{
|
|
|
|
const char *list_option = "-fltrans-output-list=";
|
|
|
|
size_t list_option_len = strlen (list_option);
|
|
|
|
char *tmp;
|
|
|
|
|
2010-05-18 17:11:01 +02:00
|
|
|
if (linker_output)
|
|
|
|
{
|
|
|
|
char *dumpbase = (char *) xmalloc (strlen (linker_output)
|
2010-05-28 14:48:54 +02:00
|
|
|
+ sizeof (".wpa") + 1);
|
2010-05-18 17:11:01 +02:00
|
|
|
strcpy (dumpbase, linker_output);
|
|
|
|
strcat (dumpbase, ".wpa");
|
2011-10-28 11:46:26 +02:00
|
|
|
obstack_ptr_grow (&argv_obstack, dumpbase);
|
2010-05-18 17:11:01 +02:00
|
|
|
}
|
|
|
|
|
2010-05-28 14:48:54 +02:00
|
|
|
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");
|
2009-10-03 23:10:11 +02:00
|
|
|
list_option_full = (char *) xmalloc (sizeof (char) *
|
|
|
|
(strlen (ltrans_output_file) + list_option_len + 1));
|
|
|
|
tmp = list_option_full;
|
|
|
|
|
2011-10-28 11:46:26 +02:00
|
|
|
obstack_ptr_grow (&argv_obstack, tmp);
|
2009-10-03 23:10:11 +02:00
|
|
|
strcpy (tmp, list_option);
|
|
|
|
tmp += list_option_len;
|
|
|
|
strcpy (tmp, ltrans_output_file);
|
|
|
|
|
2011-10-28 11:46:26 +02:00
|
|
|
obstack_ptr_grow (&argv_obstack, "-fwpa");
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
|
|
|
|
2010-05-18 17:11:01 +02:00
|
|
|
/* Append the input objects and possible preceeding arguments. */
|
|
|
|
for (i = 1; i < argc; ++i)
|
2011-10-28 11:46:26 +02:00
|
|
|
obstack_ptr_grow (&argv_obstack, argv[i]);
|
|
|
|
obstack_ptr_grow (&argv_obstack, NULL);
|
2009-10-03 23:10:11 +02:00
|
|
|
|
2011-10-28 11:46:26 +02:00
|
|
|
new_argv = XOBFINISH (&argv_obstack, const char **);
|
|
|
|
argv_ptr = &new_argv[new_head_argc];
|
2009-10-03 23:10:11 +02:00
|
|
|
fork_execute (CONST_CAST (char **, new_argv));
|
2010-05-07 17:52:01 +02:00
|
|
|
|
2009-10-03 23:10:11 +02:00
|
|
|
if (lto_mode == LTO_MODE_LTO)
|
|
|
|
{
|
|
|
|
printf("%s\n", flto_out);
|
|
|
|
free (flto_out);
|
|
|
|
flto_out = NULL;
|
|
|
|
}
|
2011-01-05 17:07:09 +01:00
|
|
|
else
|
2009-10-03 23:10:11 +02:00
|
|
|
{
|
|
|
|
FILE *stream = fopen (ltrans_output_file, "r");
|
2010-05-19 17:43:22 +02:00
|
|
|
FILE *mstream = NULL;
|
2011-10-26 13:48:09 +02:00
|
|
|
struct obstack env_obstack;
|
2009-10-03 23:10:11 +02:00
|
|
|
|
|
|
|
if (!stream)
|
|
|
|
fatal_perror ("fopen: %s", ltrans_output_file);
|
|
|
|
|
2010-05-25 17:47:28 +02:00
|
|
|
/* Parse the list of LTRANS inputs from the WPA stage. */
|
2011-10-26 13:48:09 +02:00
|
|
|
obstack_init (&env_obstack);
|
2010-05-25 17:47:28 +02:00
|
|
|
nr = 0;
|
2010-05-07 17:52:01 +02:00
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
const unsigned piece = 32;
|
2010-05-25 17:47:28 +02:00
|
|
|
char *output_name = NULL;
|
2010-05-07 17:52:01 +02:00
|
|
|
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] == '*')
|
2010-05-19 17:43:22 +02:00
|
|
|
output_name = &input_name[1];
|
2010-05-07 17:52:01 +02:00
|
|
|
|
2010-05-19 17:43:22 +02:00
|
|
|
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;
|
|
|
|
}
|
2010-05-25 17:47:28 +02:00
|
|
|
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_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),
|
2010-05-28 14:48:54 +02:00
|
|
|
"%s.ltrans%u", linker_output, i);
|
2010-05-25 17:47:28 +02:00
|
|
|
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");
|
2011-12-15 15:50:25 +01:00
|
|
|
/* If we are not preserving the ltrans input files then
|
|
|
|
truncate them as soon as we have processed it. This
|
|
|
|
reduces temporary disk-space usage. */
|
|
|
|
if (! debug)
|
|
|
|
fprintf (mstream, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
|
|
|
|
"&& mv %s.tem %s\n",
|
|
|
|
input_name, input_name, input_name, input_name);
|
2010-05-25 17:47:28 +02:00
|
|
|
}
|
|
|
|
else
|
2011-12-15 15:50:25 +01:00
|
|
|
{
|
|
|
|
fork_execute (CONST_CAST (char **, new_argv));
|
|
|
|
maybe_unlink_file (input_name);
|
|
|
|
}
|
2010-05-25 17:47:28 +02:00
|
|
|
|
|
|
|
output_names[i] = output_name;
|
|
|
|
}
|
2010-05-19 17:43:22 +02:00
|
|
|
if (parallel)
|
|
|
|
{
|
|
|
|
struct pex_obj *pex;
|
|
|
|
char jobs[32];
|
2010-08-31 18:58:46 +02:00
|
|
|
|
2010-05-19 17:43:22 +02:00
|
|
|
fprintf (mstream, "all:");
|
|
|
|
for (i = 0; i < nr; ++i)
|
|
|
|
fprintf (mstream, " \\\n\t%s", output_names[i]);
|
|
|
|
fprintf (mstream, "\n");
|
|
|
|
fclose (mstream);
|
2010-08-31 18:58:46 +02:00
|
|
|
if (!jobserver)
|
|
|
|
{
|
|
|
|
/* Avoid passing --jobserver-fd= and similar flags
|
|
|
|
unless jobserver mode is explicitly enabled. */
|
|
|
|
putenv (xstrdup ("MAKEFLAGS="));
|
|
|
|
putenv (xstrdup ("MFLAGS="));
|
|
|
|
}
|
2010-05-23 16:36:07 +02:00
|
|
|
new_argv[0] = getenv ("MAKE");
|
|
|
|
if (!new_argv[0])
|
|
|
|
new_argv[0] = "make";
|
2010-05-19 17:43:22 +02:00
|
|
|
new_argv[1] = "-f";
|
|
|
|
new_argv[2] = makefile;
|
2010-08-31 18:58:46 +02:00
|
|
|
i = 3;
|
|
|
|
if (!jobserver)
|
|
|
|
{
|
|
|
|
snprintf (jobs, 31, "-j%d", parallel);
|
|
|
|
new_argv[i++] = jobs;
|
|
|
|
}
|
|
|
|
new_argv[i++] = "all";
|
|
|
|
new_argv[i++] = NULL;
|
2010-05-19 17:43:22 +02:00
|
|
|
pex = collect_execute (CONST_CAST (char **, new_argv));
|
|
|
|
collect_wait (new_argv[0], pex);
|
|
|
|
maybe_unlink_file (makefile);
|
2010-05-25 17:47:28 +02:00
|
|
|
makefile = NULL;
|
2011-12-15 15:50:25 +01:00
|
|
|
for (i = 0; i < nr; ++i)
|
|
|
|
maybe_unlink_file (input_names[i]);
|
2010-05-19 17:43:22 +02:00
|
|
|
}
|
|
|
|
for (i = 0; i < nr; ++i)
|
|
|
|
{
|
|
|
|
fputs (output_names[i], stdout);
|
2010-05-07 17:52:01 +02:00
|
|
|
putc ('\n', stdout);
|
2010-05-19 17:43:22 +02:00
|
|
|
free (input_names[i]);
|
2010-05-07 17:52:01 +02:00
|
|
|
}
|
2010-05-25 17:47:28 +02:00
|
|
|
nr = 0;
|
2010-05-19 17:43:22 +02:00
|
|
|
free (output_names);
|
|
|
|
free (input_names);
|
2009-10-03 23:10:11 +02:00
|
|
|
free (list_option_full);
|
2011-10-26 13:48:09 +02:00
|
|
|
obstack_free (&env_obstack, NULL);
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
2011-10-28 11:46:26 +02:00
|
|
|
|
|
|
|
obstack_free (&argv_obstack, NULL);
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Entry point. */
|
|
|
|
|
|
|
|
int
|
|
|
|
main (int argc, char *argv[])
|
|
|
|
{
|
Makefile.in (LIBDEPS): Add libcommon.a.
* Makefile.in (LIBDEPS): Add libcommon.a.
(LIBS): Likewise.
(GCC_OBJS): Remove diagnostic.o, pretty-print.o and input.o.
(OBJS-common): Remove diagnostic.o, input.o, intl.o,
pretty-print.o and version.o.
(OBJS-libcommon): New.
(ALL_HOST_BACKEND_OBJS): Add $(OBJS-libcommon).
(BACKEND): Add libcommon.a.
(MOSTLYCLEANFILES): Likewise.
(libcommon.a): New.
(xgcc$(exeext)): Don't explicitly use version.o and intl.o.
(cpp$(exeext)): Likewise.
(COLLECT2_OBJS): Remove intl.o, version.o, diagnostic.o,
pretty-print.o and input.o.
(lto-wrapper$(exeext)): Don't explicitly use intl.o.
(lto-wrapper.o): Depend on $(DIAGNOSTIC_H).
(errors.o): Remove.
(mips-tfile): Don't explicitly use version.o.
(mips-tdump): Likewise.
(gcov.o): Depend on $(DIAGNOSTIC_H).
(gcov-dump.o): Depend on intl.h and $(DIAGNOSTIC_H).
(GCOV_OBJS): Remove intl.o, version.o and errors.o.
(GCOV_DUMP_OBJS): Remove version.o and errors.o.
* gcov-dump.c: Include intl.h and diagnostic.h.
(main): Initialize diagnostics.
* gcov.c: Include diagnostic.h.
(fnotice): Remove.
(main): Initialize diagnostics.
* lto-wrapper.c: Include diagnostic.h.
(main): Initialize diagnostics.
ada:
* gcc-interface/Make-lang.in (EXTRA_GNATBIND_OBJS): Remove
version.o.
* gcc-interface/Makefile.in (EXTRA_GNATTOOLS_OBJS): Use
libcommon.a instead of version.o.
cp:
* Make-lang.in (GXX_OBJS): Remove intl.o and version.o.
fortran:
* Make-lang.in (GFORTRAN_D_OBJS): Remove version.o and intl.o.
go:
* Make-lang.in (GCCGO_OBJS): Remove intl.o and version.o.
java:
* Make-lang.in ($(XGCJ)$(exeext)): Don't explicitly use intl.o and
version.o.
(JCFDUMP_OBJS): Remove errors.o, version.o and intl.o.
(JVGENMAIN_OBJS): Remove errors.o and intl.o.
(java/jcf-dump.o, java/jvgenmain.o): Depend in $(DIAGNOSTIC_H).
* jcf-dump.c: Include diagnostic.h.
(main): Initialize diagnostics.
* jvgenmain.c: Include diagnostic.h.
(main): Initialize diagnostics.
From-SVN: r173958
2011-05-20 17:19:05 +02:00
|
|
|
const char *p;
|
|
|
|
|
|
|
|
p = argv[0] + strlen (argv[0]);
|
|
|
|
while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
|
|
|
|
--p;
|
|
|
|
progname = p;
|
|
|
|
|
|
|
|
xmalloc_set_program_name (progname);
|
|
|
|
|
2009-10-03 23:10:11 +02:00
|
|
|
gcc_init_libintl ();
|
|
|
|
|
Makefile.in (LIBDEPS): Add libcommon.a.
* Makefile.in (LIBDEPS): Add libcommon.a.
(LIBS): Likewise.
(GCC_OBJS): Remove diagnostic.o, pretty-print.o and input.o.
(OBJS-common): Remove diagnostic.o, input.o, intl.o,
pretty-print.o and version.o.
(OBJS-libcommon): New.
(ALL_HOST_BACKEND_OBJS): Add $(OBJS-libcommon).
(BACKEND): Add libcommon.a.
(MOSTLYCLEANFILES): Likewise.
(libcommon.a): New.
(xgcc$(exeext)): Don't explicitly use version.o and intl.o.
(cpp$(exeext)): Likewise.
(COLLECT2_OBJS): Remove intl.o, version.o, diagnostic.o,
pretty-print.o and input.o.
(lto-wrapper$(exeext)): Don't explicitly use intl.o.
(lto-wrapper.o): Depend on $(DIAGNOSTIC_H).
(errors.o): Remove.
(mips-tfile): Don't explicitly use version.o.
(mips-tdump): Likewise.
(gcov.o): Depend on $(DIAGNOSTIC_H).
(gcov-dump.o): Depend on intl.h and $(DIAGNOSTIC_H).
(GCOV_OBJS): Remove intl.o, version.o and errors.o.
(GCOV_DUMP_OBJS): Remove version.o and errors.o.
* gcov-dump.c: Include intl.h and diagnostic.h.
(main): Initialize diagnostics.
* gcov.c: Include diagnostic.h.
(fnotice): Remove.
(main): Initialize diagnostics.
* lto-wrapper.c: Include diagnostic.h.
(main): Initialize diagnostics.
ada:
* gcc-interface/Make-lang.in (EXTRA_GNATBIND_OBJS): Remove
version.o.
* gcc-interface/Makefile.in (EXTRA_GNATTOOLS_OBJS): Use
libcommon.a instead of version.o.
cp:
* Make-lang.in (GXX_OBJS): Remove intl.o and version.o.
fortran:
* Make-lang.in (GFORTRAN_D_OBJS): Remove version.o and intl.o.
go:
* Make-lang.in (GCCGO_OBJS): Remove intl.o and version.o.
java:
* Make-lang.in ($(XGCJ)$(exeext)): Don't explicitly use intl.o and
version.o.
(JCFDUMP_OBJS): Remove errors.o, version.o and intl.o.
(JVGENMAIN_OBJS): Remove errors.o and intl.o.
(java/jcf-dump.o, java/jvgenmain.o): Depend in $(DIAGNOSTIC_H).
* jcf-dump.c: Include diagnostic.h.
(main): Initialize diagnostics.
* jvgenmain.c: Include diagnostic.h.
(main): Initialize diagnostics.
From-SVN: r173958
2011-05-20 17:19:05 +02:00
|
|
|
diagnostic_initialize (global_dc, 0);
|
|
|
|
|
2010-06-02 15:58:27 +02:00
|
|
|
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
|
|
|
|
|
2009-10-03 23:10:11 +02:00
|
|
|
/* 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);
|
2011-10-26 11:30:29 +02:00
|
|
|
|
2010-05-18 17:11:01 +02:00
|
|
|
run_gcc (argc, argv);
|
2009-10-03 23:10:11 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|