/* Collect static initialization info into data structures that can be
traversed by C++ initialization and finalization routines.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Contributed by Chris Smith (csmith@convex.com).
Heavily modified by Michael Meissner (meissner@cygnus.com),
#include "system.h"
#include "coretypes.h"
#include "tm.h"
-#include <signal.h>
-#if ! defined( SIGCHLD ) && defined( SIGCLD )
-# define SIGCHLD SIGCLD
-#endif
+#include "filenames.h"
+
+/* TARGET_64BIT may be defined to use driver specific functionality. */
+#undef TARGET_64BIT
+#define TARGET_64BIT TARGET_64BIT_DEFAULT
#ifndef LIBRARY_PATH_ENV
#define LIBRARY_PATH_ENV "LIBRARY_PATH"
#include "collect2.h"
#include "collect2-aix.h"
+#include "diagnostic.h"
#include "demangle.h"
#include "obstack.h"
#include "intl.h"
int number;
};
-int vflag; /* true if -v */
+bool vflag; /* true if -v or --version */
static int rflag; /* true if -r */
static int strip_flag; /* true if -s */
-static const char *demangle_flag;
#ifdef COLLECT_EXPORT_LIST
static int export_flag; /* true if -bE */
static int aix64_flag; /* true if -b64 */
/* Current LTO mode. */
static enum lto_mode_d lto_mode = LTO_MODE_NONE;
-int debug; /* true if -debug */
+bool debug; /* true if -debug */
+bool helpflag; /* true if --help */
static int shared_obj; /* true if -shared */
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 ... */
va_end (ap);
}
-/* Die when sys call fails. */
-
-void
-fatal_perror (const char * cmsgid, ...)
-{
- int e = errno;
- va_list ap;
-
- va_start (ap, cmsgid);
- fprintf (stderr, "collect2: ");
- vfprintf (stderr, _(cmsgid), ap);
- fprintf (stderr, ": %s\n", xstrerror (e));
- va_end (ap);
-
- collect_exit (FATAL_EXIT_CODE);
-}
-
-/* Just die. */
-
+/* Notify user of a non-error, without translating the format string. */
void
-fatal (const char * cmsgid, ...)
+notice_translated (const char *cmsgid, ...)
{
va_list ap;
va_start (ap, cmsgid);
- fprintf (stderr, "collect2: ");
- vfprintf (stderr, _(cmsgid), ap);
- fprintf (stderr, "\n");
+ vfprintf (stderr, cmsgid, ap);
va_end (ap);
-
- collect_exit (FATAL_EXIT_CODE);
-}
-
-/* Write error message. */
-
-void
-error (const char * gmsgid, ...)
-{
- va_list ap;
-
- va_start (ap, gmsgid);
- fprintf (stderr, "collect2: ");
- vfprintf (stderr, _(gmsgid), ap);
- fprintf (stderr, "\n");
- va_end(ap);
-}
-
-/* In case obstack is linked in, and abort is defined to fancy_abort,
- provide a default entry. */
-
-void
-fancy_abort (const char *file, int line, const char *func)
-{
- fatal ("internal gcc abort in %s, at %s:%d", func, file, line);
}
\f
static void
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");
+ fatal_error ("COLLECT_LTO_WRAPPER must be set");
- /* Increment the argument count by the number of inherited options.
- Some arguments may be filtered out later. Again, an upper bound
- suffices. */
+ num_lto_c_args++;
- cp = opts;
-
- 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)
*lto_c_ptr = NULL;
- /* Save intermediate WPA files in lto1 if debug. */
- if (debug)
- putenv (xstrdup ("WPA_SAVE_LTRANS=1"));
-
/* Run the LTO back end. */
pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH);
{
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
const char **ld2;
char **object_lst;
const char **object;
+#ifdef TARGET_AIX_VERSION
+ int object_nbr = argc;
+#endif
int first_file;
int num_c_args;
char **old_argv;
+ p = argv[0] + strlen (argv[0]);
+ while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
+ --p;
+ progname = p;
+
+ xmalloc_set_program_name (progname);
+
old_argv = argv;
expandargv (&argc, &argv);
if (argv != old_argv)
at_file_supplied = 1;
+ process_args (&argc, argv);
+
num_c_args = argc + 9;
+#ifndef HAVE_LD_DEMANGLE
no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
/* Suppress demangling by the real linker, which may be broken. */
- putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
+ putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
+#endif
#if defined (COLLECT2_HOST_INITIALIZATION)
/* Perform system dependent initialization, if necessary. */
gcc_init_libintl ();
+ diagnostic_initialize (global_dc, 0);
+
/* Do not invoke xcalloc before this point, since locale needs to be
set first, in case a diagnostic is issued. */
/* 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 = 1;
- else if (! strcmp (argv[i], "-flto") && ! use_plugin)
- lto_mode = LTO_MODE_LTO;
- else if (! strcmp (argv[i], "-fwhopr") && ! use_plugin)
- lto_mode = LTO_MODE_WHOPR;
+ debug = true;
+ 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;
#endif
}
vflag = debug;
+ if (no_partition && lto_mode == LTO_MODE_WHOPR)
+ lto_mode = LTO_MODE_LTO;
}
#ifndef DEFAULT_A_OUT_NAME
c_ptr = CONST_CAST2 (const char **, char **, c_argv);
if (argc < 2)
- fatal ("no arguments");
+ fatal_error ("no arguments");
#ifdef SIGQUIT
if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
/* After the first file, put in the c++ rt0. */
first_file = 1;
-#ifdef HAVE_LD_DEMANGLE
- if (!demangle_flag && !no_demangle)
- demangle_flag = "--demangle";
- if (demangle_flag)
- *ld1++ = *ld2++ = demangle_flag;
-#endif
while ((arg = *++argv) != (char *) 0)
{
*ld1++ = *ld2++ = arg;
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. */
"configuration");
#endif
}
+#ifdef TARGET_AIX_VERSION
+ else
+ {
+ /* File containing a list of input files to process. */
+
+ FILE *stream;
+ char buf[MAXPATHLEN + 2];
+ /* Number of additionnal object files. */
+ int add_nbr = 0;
+ /* Maximum of additionnal object files before vector
+ expansion. */
+ int add_max = 0;
+ const char *list_filename = arg + 2;
+
+ /* Accept -fFILENAME and -f FILENAME. */
+ if (*list_filename == '\0' && argv[1])
+ {
+ ++argv;
+ list_filename = *argv;
+ *ld1++ = *ld2++ = *argv;
+ }
+
+ stream = fopen (list_filename, "r");
+ if (stream == NULL)
+ fatal_error ("can't open %s: %m", list_filename);
+
+ while (fgets (buf, sizeof buf, stream) != NULL)
+ {
+ /* Remove end of line. */
+ int len = strlen (buf);
+ if (len >= 1 && buf[len - 1] =='\n')
+ buf[len - 1] = '\0';
+
+ /* Put on object vector.
+ Note: we only expanse vector here, so we must keep
+ extra space for remaining arguments. */
+ if (add_nbr >= add_max)
+ {
+ int pos =
+ object - CONST_CAST2 (const char **, char **,
+ object_lst);
+ add_max = (add_max == 0) ? 16 : add_max * 2;
+ object_lst = XRESIZEVEC (char *, object_lst,
+ object_nbr + add_max);
+ object = CONST_CAST2 (const char **, char **,
+ object_lst) + pos;
+ object_nbr += add_max;
+ }
+ *object++ = xstrdup (buf);
+ add_nbr++;
+ }
+ fclose (stream);
+ }
+#endif
break;
case 'l':
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;
case 'v':
if (arg[2] == '\0')
- vflag = 1;
+ vflag = true;
break;
case '-':
if (strcmp (arg, "--no-demangle") == 0)
{
- demangle_flag = arg;
+#ifndef HAVE_LD_DEMANGLE
no_demangle = 1;
ld1--;
ld2--;
+#endif
}
else if (strncmp (arg, "--demangle", 10) == 0)
{
- demangle_flag = arg;
- no_demangle = 0;
#ifndef HAVE_LD_DEMANGLE
+ no_demangle = 0;
if (arg[10] == '=')
{
enum demangling_styles style
else
current_demangling_style = style;
}
-#endif
ld1--;
ld2--;
+#endif
}
else if (strncmp (arg, "--sysroot=", 10) == 0)
target_system_root = arg + 10;
+ else if (strcmp (arg, "--version") == 0)
+ vflag = true;
+ else if (strcmp (arg, "--help") == 0)
+ helpflag = true;
break;
}
}
control whether we need a first pass link later on or not, and what
will remain to be scanned there. */
- scanfilter this_filter
- = shared_obj ? ld1_filter : (ld1_filter & ~SCAN_DWEH);
+ scanfilter this_filter = ld1_filter;
+#if HAVE_AS_REF
+ if (!shared_obj)
+ this_filter &= ~SCAN_DWEH;
+#endif
while (export_object_lst < object)
scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
exportf = fopen (export_file, "w");
if (exportf == (FILE *) 0)
- fatal_perror ("fopen %s", export_file);
+ fatal_error ("fopen %s: %m", export_file);
write_aix_file (exportf, exports.first);
if (fclose (exportf))
- fatal_perror ("fclose %s", export_file);
+ fatal_error ("fclose %s: %m", export_file);
}
#endif
*c_ptr = *ld1 = *object = (char *) 0;
if (vflag)
+ notice ("collect2 version %s\n", version_string);
+
+ if (helpflag)
{
- notice ("collect2 version %s", version_string);
-#ifdef TARGET_VERSION
- TARGET_VERSION;
-#endif
- fprintf (stderr, "\n");
+ 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);
if (debug)
{
- notice ("%d constructor(s) found\n", constructors.number);
- notice ("%d destructor(s) found\n", destructors.number);
- notice ("%d frame table(s) found\n", frame_tables.number);
+ notice_translated (ngettext ("%d constructor found\n",
+ "%d constructors found\n",
+ constructors.number),
+ constructors.number);
+ notice_translated (ngettext ("%d destructor found\n",
+ "%d destructors found\n",
+ destructors.number),
+ destructors.number);
+ notice_translated (ngettext("%d frame table found\n",
+ "%d frame tables found\n",
+ frame_tables.number),
+ frame_tables.number);
}
/* If the scan exposed nothing of special interest, there's no need to
#ifdef COLLECT_EXPORT_LIST
maybe_unlink (export_file);
#endif
+ post_ld_pass (false);
+
maybe_unlink (c_file);
maybe_unlink (o_file);
return 0;
maybe_unlink(output_file);
outf = fopen (c_file, "w");
if (outf == (FILE *) 0)
- fatal_perror ("fopen %s", c_file);
+ fatal_error ("fopen %s: %m", c_file);
write_c_file (outf, c_file);
if (fclose (outf))
- fatal_perror ("fclose %s", c_file);
+ fatal_error ("fclose %s: %m", c_file);
/* Tell the linker that we have initializer and finalizer functions. */
#ifdef LD_INIT_SWITCH
#endif
exportf = fopen (export_file, "w");
if (exportf == (FILE *) 0)
- fatal_perror ("fopen %s", export_file);
+ fatal_error ("fopen %s: %m", export_file);
write_aix_file (exportf, exports.first);
if (fclose (exportf))
- fatal_perror ("fclose %s", export_file);
+ fatal_error ("fclose %s: %m", export_file);
}
#endif
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. */
int status;
if (!pex_get_status (pex, 1, &status))
- fatal_perror ("can't get program status");
+ fatal_error ("can't get program status: %m");
pex_free (pex);
if (status)
f = fopen (response_file, "w");
if (f == NULL)
- fatal ("could not open response file %s", response_file);
+ fatal_error ("could not open response file %s", response_file);
status = writeargv (current_argv, f);
if (status)
- fatal ("could not write to response file %s", response_file);
+ fatal_error ("could not write to response file %s", response_file);
status = fclose (f);
if (EOF == status)
- fatal ("could not close response file %s", response_file);
+ fatal_error ("could not close response file %s", response_file);
response_arg = concat ("@", response_file, NULL);
response_argv[0] = argv0;
since we might not end up needing something that we could not find. */
if (argv[0] == 0)
- fatal ("cannot find '%s'", prog);
+ fatal_error ("cannot find '%s'", prog);
pex = pex_init (0, "collect2", NULL);
if (pex == NULL)
- fatal_perror ("pex_init failed");
+ fatal_error ("pex_init failed: %m");
errmsg = pex_run (pex, flags, argv[0], argv, outname,
errname, &err);
if (err != 0)
{
errno = err;
- fatal_perror (errmsg);
+ fatal_error ("%s: %m", _(errmsg));
}
else
- fatal (errmsg);
+ fatal_error (errmsg);
}
- if (response_arg)
- free (response_arg);
+ free (response_arg);
return pex;
}
int frames = (frame_tables.number > 0);
/* Figure out name of output_file, stripping off .so version. */
- p = strrchr (output_file, '/');
- if (p == 0)
- p = output_file;
- else
- p++;
- q = p;
+ q = p = lbasename (output_file);
+
while (q)
{
q = strchr (q,'.');
}
else
{
- if (strncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
+ if (filename_ncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
{
q += strlen (SHLIB_SUFFIX);
break;
\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 (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' };
+ 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, "r");
+ f = fopen (prog_name, "rb");
if (f == NULL)
return false;
if (fread (buf, sizeof (buf), 1, f) != 1)
buf[0] = 0;
fclose (f);
- return memcmp (buf, magic, sizeof (magic)) == 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
if (which_pass == PASS_SECOND)
return;
- /* LTO objects must be in ELF format. This check prevents
+ /* 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 (prog_name))
+ if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
return;
/* If we do not have an `nm', complain. */
if (nm_file_name == 0)
- fatal ("cannot find 'nm'");
+ fatal_error ("cannot find 'nm'");
nm_argv[argc++] = nm_file_name;
if (NM_FLAGS[0] != '\0')
pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
if (pex == NULL)
- fatal_perror ("pex_init failed");
+ fatal_error ("pex_init failed: %m");
errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
&err);
if (err != 0)
{
errno = err;
- fatal_perror (errmsg);
+ fatal_error ("%s: %m", _(errmsg));
}
else
- fatal (errmsg);
+ fatal_error (errmsg);
}
int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
inf = pex_read_output (pex, 0);
if (inf == NULL)
- fatal_perror ("can't open nm output");
+ fatal_error ("can't open nm output: %m");
if (debug)
{
/* Look for the LTO info marker symbol, and add filename to
the LTO objects list if found. */
for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
- if (ch == ' '
- && (strncmp (p + 1, "__gnu_lto_v1", 12) == 0)
- && ISSPACE (p[13]))
+ if (ch == ' ' && p[1] == '_' && p[2] == '_'
+ && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
+ && ISSPACE (p[p[3] == '_' ? 14 : 13]))
{
add_lto_object (<o_objects, prog_name);
if (! (filter & SCAN_INIT))
break;
if (which_pass != PASS_LIB)
- fatal ("init function found in object %s", prog_name);
+ fatal_error ("init function found in object %s", prog_name);
#ifndef LD_INIT_SWITCH
add_to_list (&constructors, name);
#endif
if (! (filter & SCAN_FINI))
break;
if (which_pass != PASS_LIB)
- fatal ("fini function found in object %s", prog_name);
+ fatal_error ("fini function found in object %s", prog_name);
#ifndef LD_FINI_SWITCH
add_to_list (&destructors, name);
#endif
pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
if (pex == NULL)
- fatal_perror ("pex_init failed");
+ fatal_error ("pex_init failed: %m");
errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
if (errmsg != NULL)
if (err != 0)
{
errno = err;
- fatal_perror (errmsg);
+ fatal_error ("%s: %m", _(errmsg));
}
else
- fatal (errmsg);
+ fatal_error (errmsg);
}
int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
inf = pex_read_output (pex, 0);
if (inf == NULL)
- fatal_perror ("can't open ldd output");
+ fatal_error ("can't open ldd output: %m");
if (debug)
notice ("\nldd output with constructors/destructors.\n");
name = p;
if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
- fatal ("dynamic dependency %s not found", buf);
+ fatal_error ("dynamic dependency %s not found", buf);
/* Find the end of the symbol name. */
for (end = p;
if (access (name, R_OK) == 0)
add_to_list (&libraries, name);
else
- fatal ("unable to open dynamic dependency '%s'", buf);
+ fatal_error ("unable to open dynamic dependency '%s'", buf);
if (debug)
fprintf (stderr, "\t%s\n", buf);
/* Now iterate through the library list adding their symbols to
the list. */
for (list = libraries.first; list; list = list->next)
- scan_prog_file (list->name, PASS_LIB);
+ scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
}
#endif /* LDD_SUFFIX */
if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
{
if (! MY_ISCOFF (HEADER (ldptr).f_magic))
- fatal ("%s: not a COFF file", prog_name);
+ fatal_error ("%s: not a COFF file", prog_name);
if (GCC_CHECK_HDR (ldptr))
{
}
else
{
- fatal ("%s: cannot open as COFF file", prog_name);
+ fatal_error ("%s: cannot open as COFF file", prog_name);
}
#ifdef COLLECT_EXPORT_LIST
/* On AIX loop continues while there are more members in archive. */
for (; list; list = list->next)
{
/* The following lines are needed because path_prefix list
- may contain directories both with trailing '/' and
+ may contain directories both with trailing DIR_SEPARATOR and
without it. */
const char *p = "";
- if (list->prefix[strlen(list->prefix)-1] != '/')
+ if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1]))
p = "/";
for (j = 0; j < 2; j++)
{
if (debug)
fprintf (stderr, "not found\n");
else
- fatal ("library lib%s not found", name);
+ fatal_error ("library lib%s not found", name);
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
