OSDN Git Service

Backport from mainline
[pf3gnuchains/gcc-fork.git] / gcc / collect2.c
1 /* Collect static initialization info into data structures that can be
2    traversed by C++ initialization and finalization routines.
3    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
5    Free Software Foundation, Inc.
6    Contributed by Chris Smith (csmith@convex.com).
7    Heavily modified by Michael Meissner (meissner@cygnus.com),
8    Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
9
10 This file is part of GCC.
11
12 GCC is free software; you can redistribute it and/or modify it under
13 the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 3, or (at your option) any later
15 version.
16
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
20 for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3.  If not see
24 <http://www.gnu.org/licenses/>.  */
25
26
27 /* Build tables of static constructors and destructors and run ld.  */
28
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "tm.h"
33 #include "filenames.h"
34
35 /* TARGET_64BIT may be defined to use driver specific functionality. */
36 #undef TARGET_64BIT
37 #define TARGET_64BIT TARGET_64BIT_DEFAULT
38
39 #ifndef LIBRARY_PATH_ENV
40 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
41 #endif
42
43 #define COLLECT
44
45 #include "collect2.h"
46 #include "collect2-aix.h"
47 #include "diagnostic.h"
48 #include "demangle.h"
49 #include "obstack.h"
50 #include "intl.h"
51 #include "version.h"
52 \f
53 /* On certain systems, we have code that works by scanning the object file
54    directly.  But this code uses system-specific header files and library
55    functions, so turn it off in a cross-compiler.  Likewise, the names of
56    the utilities are not correct for a cross-compiler; we have to hope that
57    cross-versions are in the proper directories.  */
58
59 #ifdef CROSS_DIRECTORY_STRUCTURE
60 #ifndef CROSS_AIX_SUPPORT
61 #undef OBJECT_FORMAT_COFF
62 #endif
63 #undef MD_EXEC_PREFIX
64 #undef REAL_LD_FILE_NAME
65 #undef REAL_NM_FILE_NAME
66 #undef REAL_STRIP_FILE_NAME
67 #endif
68
69 /* If we cannot use a special method, use the ordinary one:
70    run nm to find what symbols are present.
71    In a cross-compiler, this means you need a cross nm,
72    but that is not quite as unpleasant as special headers.  */
73
74 #if !defined (OBJECT_FORMAT_COFF)
75 #define OBJECT_FORMAT_NONE
76 #endif
77
78 #ifdef OBJECT_FORMAT_COFF
79
80 #ifndef CROSS_DIRECTORY_STRUCTURE
81 #include <a.out.h>
82 #include <ar.h>
83
84 #ifdef UMAX
85 #include <sgs.h>
86 #endif
87
88 /* Many versions of ldfcn.h define these.  */
89 #ifdef FREAD
90 #undef FREAD
91 #undef FWRITE
92 #endif
93
94 #include <ldfcn.h>
95 #endif
96
97 /* Some systems have an ISCOFF macro, but others do not.  In some cases
98    the macro may be wrong.  MY_ISCOFF is defined in tm.h files for machines
99    that either do not have an ISCOFF macro in /usr/include or for those
100    where it is wrong.  */
101
102 #ifndef MY_ISCOFF
103 #define MY_ISCOFF(X) ISCOFF (X)
104 #endif
105
106 #endif /* OBJECT_FORMAT_COFF */
107
108 #ifdef OBJECT_FORMAT_NONE
109
110 /* Default flags to pass to nm.  */
111 #ifndef NM_FLAGS
112 #define NM_FLAGS "-n"
113 #endif
114
115 #endif /* OBJECT_FORMAT_NONE */
116
117 /* Some systems use __main in a way incompatible with its use in gcc, in these
118    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
119    give the same symbol without quotes for an alternative entry point.  */
120 #ifndef NAME__MAIN
121 #define NAME__MAIN "__main"
122 #endif
123
124 /* This must match tree.h.  */
125 #define DEFAULT_INIT_PRIORITY 65535
126
127 #ifndef COLLECT_SHARED_INIT_FUNC
128 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
129   fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
130 #endif
131 #ifndef COLLECT_SHARED_FINI_FUNC
132 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
133   fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
134 #endif
135
136 #ifdef LDD_SUFFIX
137 #define SCAN_LIBRARIES
138 #endif
139
140 #ifndef SHLIB_SUFFIX
141 #define SHLIB_SUFFIX ".so"
142 #endif
143
144 #ifdef USE_COLLECT2
145 int do_collecting = 1;
146 #else
147 int do_collecting = 0;
148 #endif
149
150 /* Cook up an always defined indication of whether we proceed the
151    "EXPORT_LIST" way.  */
152
153 #ifdef COLLECT_EXPORT_LIST
154 #define DO_COLLECT_EXPORT_LIST 1
155 #else
156 #define DO_COLLECT_EXPORT_LIST 0
157 #endif
158
159 /* Nonzero if we should suppress the automatic demangling of identifiers
160    in linker error messages.  Set from COLLECT_NO_DEMANGLE.  */
161 int no_demangle;
162 \f
163 /* Linked lists of constructor and destructor names.  */
164
165 struct id
166 {
167   struct id *next;
168   int sequence;
169   char name[1];
170 };
171
172 struct head
173 {
174   struct id *first;
175   struct id *last;
176   int number;
177 };
178
179 bool vflag;                             /* true if -v or --version */ 
180 static int rflag;                       /* true if -r */
181 static int strip_flag;                  /* true if -s */
182 #ifdef COLLECT_EXPORT_LIST
183 static int export_flag;                 /* true if -bE */
184 static int aix64_flag;                  /* true if -b64 */
185 static int aixrtl_flag;                 /* true if -brtl */
186 #endif
187
188 enum lto_mode_d {
189   LTO_MODE_NONE,                        /* Not doing LTO.  */
190   LTO_MODE_LTO,                         /* Normal LTO.  */
191   LTO_MODE_WHOPR                        /* WHOPR.  */
192 };
193
194 /* Current LTO mode.  */
195 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
196
197 bool debug;                             /* true if -debug */
198 bool helpflag;                  /* true if --help */
199
200 static int shared_obj;                  /* true if -shared */
201
202 static const char *c_file;              /* <xxx>.c for constructor/destructor list.  */
203 static const char *o_file;              /* <xxx>.o for constructor/destructor list.  */
204 #ifdef COLLECT_EXPORT_LIST
205 static const char *export_file;         /* <xxx>.x for AIX export list.  */
206 #endif
207 static char **lto_o_files;              /* Output files for LTO.  */
208 const char *ldout;                      /* File for ld stdout.  */
209 const char *lderrout;                   /* File for ld stderr.  */
210 static const char *output_file;         /* Output file for ld.  */
211 static const char *nm_file_name;        /* pathname of nm */
212 #ifdef LDD_SUFFIX
213 static const char *ldd_file_name;       /* pathname of ldd (or equivalent) */
214 #endif
215 static const char *strip_file_name;             /* pathname of strip */
216 const char *c_file_name;                /* pathname of gcc */
217 static char *initname, *fininame;       /* names of init and fini funcs */
218
219 static struct head constructors;        /* list of constructors found */
220 static struct head destructors;         /* list of destructors found */
221 #ifdef COLLECT_EXPORT_LIST
222 static struct head exports;             /* list of exported symbols */
223 #endif
224 static struct head frame_tables;        /* list of frame unwind info tables */
225
226 static bool at_file_supplied;           /* Whether to use @file arguments */
227 static char *response_file;             /* Name of any current response file */
228
229 struct obstack temporary_obstack;
230 char * temporary_firstobj;
231
232 /* A string that must be prepended to a target OS path in order to find
233    it on the host system.  */
234 #ifdef TARGET_SYSTEM_ROOT
235 static const char *target_system_root = TARGET_SYSTEM_ROOT;
236 #else
237 static const char *target_system_root = "";
238 #endif
239
240 /* Structure to hold all the directories in which to search for files to
241    execute.  */
242
243 struct prefix_list
244 {
245   const char *prefix;         /* String to prepend to the path.  */
246   struct prefix_list *next;   /* Next in linked list.  */
247 };
248
249 struct path_prefix
250 {
251   struct prefix_list *plist;  /* List of prefixes to try */
252   int max_len;                /* Max length of a prefix in PLIST */
253   const char *name;           /* Name of this list (used in config stuff) */
254 };
255
256 #ifdef COLLECT_EXPORT_LIST
257 /* Lists to keep libraries to be scanned for global constructors/destructors.  */
258 static struct head libs;                    /* list of libraries */
259 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
260 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
261 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
262                                           &libpath_lib_dirs, NULL};
263 #endif
264
265 /* List of names of object files containing LTO information.
266    These are a subset of the object file names appearing on the
267    command line, and must be identical, in the sense of pointer
268    equality, with the names passed to maybe_run_lto_and_relink().  */
269
270 struct lto_object
271 {
272   const char *name;             /* Name of object file.  */
273   struct lto_object *next;      /* Next in linked list.  */
274 };
275
276 struct lto_object_list
277 {
278   struct lto_object *first;     /* First list element.  */
279   struct lto_object *last;      /* Last list element.  */
280 };
281
282 static struct lto_object_list lto_objects;
283
284 /* Special kinds of symbols that a name may denote.  */
285
286 typedef enum {
287   SYM_REGULAR = 0,  /* nothing special  */
288
289   SYM_CTOR = 1,  /* constructor */
290   SYM_DTOR = 2,  /* destructor  */
291   SYM_INIT = 3,  /* shared object routine that calls all the ctors  */
292   SYM_FINI = 4,  /* shared object routine that calls all the dtors  */
293   SYM_DWEH = 5   /* DWARF exception handling table  */
294 } symkind;
295
296 static symkind is_ctor_dtor (const char *);
297
298 static void handler (int);
299 static char *find_a_file (struct path_prefix *, const char *);
300 static void add_prefix (struct path_prefix *, const char *);
301 static void prefix_from_env (const char *, struct path_prefix *);
302 static void prefix_from_string (const char *, struct path_prefix *);
303 static void do_wait (const char *, struct pex_obj *);
304 static void fork_execute (const char *, char **);
305 static void maybe_unlink (const char *);
306 static void maybe_unlink_list (char **);
307 static void add_to_list (struct head *, const char *);
308 static int extract_init_priority (const char *);
309 static void sort_ids (struct head *);
310 static void write_list (FILE *, const char *, struct id *);
311 #ifdef COLLECT_EXPORT_LIST
312 static void dump_list (FILE *, const char *, struct id *);
313 #endif
314 #if 0
315 static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
316 #endif
317 static void write_list_with_asm (FILE *, const char *, struct id *);
318 static void write_c_file (FILE *, const char *);
319 static void write_c_file_stat (FILE *, const char *);
320 #ifndef LD_INIT_SWITCH
321 static void write_c_file_glob (FILE *, const char *);
322 #endif
323 #ifdef SCAN_LIBRARIES
324 static void scan_libraries (const char *);
325 #endif
326 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
327 static int is_in_args (const char *, const char **, const char **);
328 #endif
329 #ifdef COLLECT_EXPORT_LIST
330 #if 0
331 static int is_in_list (const char *, struct id *);
332 #endif
333 static void write_aix_file (FILE *, struct id *);
334 static char *resolve_lib_name (const char *);
335 #endif
336 static char *extract_string (const char **);
337 static void post_ld_pass (bool);
338 static void process_args (int *argcp, char **argv);
339
340 /* Enumerations describing which pass this is for scanning the
341    program file ...  */
342
343 typedef enum {
344   PASS_FIRST,                           /* without constructors */
345   PASS_OBJ,                             /* individual objects */
346   PASS_LIB,                             /* looking for shared libraries */
347   PASS_SECOND,                          /* with constructors linked in */
348   PASS_LTOINFO                          /* looking for objects with LTO info */
349 } scanpass;
350
351 /* ... and which kinds of symbols are to be considered.  */
352
353 enum scanfilter_masks {
354   SCAN_NOTHING = 0,
355
356   SCAN_CTOR = 1 << SYM_CTOR,
357   SCAN_DTOR = 1 << SYM_DTOR,
358   SCAN_INIT = 1 << SYM_INIT,
359   SCAN_FINI = 1 << SYM_FINI,
360   SCAN_DWEH = 1 << SYM_DWEH,
361   SCAN_ALL  = ~0
362 };
363
364 /* This type is used for parameters and variables which hold
365    combinations of the flags in enum scanfilter_masks.  */
366 typedef int scanfilter;
367
368 /* Scan the name list of the loaded program for the symbols g++ uses for
369    static constructors and destructors.
370
371    The SCANPASS argument tells which collect processing pass this is for and
372    the SCANFILTER argument tells which kinds of symbols to consider in this
373    pass.  Symbols of a special kind not in the filter mask are considered as
374    regular ones.
375
376    The constructor table begins at __CTOR_LIST__ and contains a count of the
377    number of pointers (or -1 if the constructors are built in a separate
378    section by the linker), followed by the pointers to the constructor
379    functions, terminated with a null pointer.  The destructor table has the
380    same format, and begins at __DTOR_LIST__.  */
381
382 static void scan_prog_file (const char *, scanpass, scanfilter);
383
384 \f
385 /* Delete tempfiles and exit function.  */
386
387 void
388 collect_exit (int status)
389 {
390   if (c_file != 0 && c_file[0])
391     maybe_unlink (c_file);
392
393   if (o_file != 0 && o_file[0])
394     maybe_unlink (o_file);
395
396 #ifdef COLLECT_EXPORT_LIST
397   if (export_file != 0 && export_file[0])
398     maybe_unlink (export_file);
399 #endif
400
401   if (lto_o_files)
402     maybe_unlink_list (lto_o_files);
403
404   if (ldout != 0 && ldout[0])
405     {
406       dump_file (ldout, stdout);
407       maybe_unlink (ldout);
408     }
409
410   if (lderrout != 0 && lderrout[0])
411     {
412       dump_file (lderrout, stderr);
413       maybe_unlink (lderrout);
414     }
415
416   if (status != 0 && output_file != 0 && output_file[0])
417     maybe_unlink (output_file);
418
419   if (response_file)
420     maybe_unlink (response_file);
421
422   exit (status);
423 }
424
425 \f
426 /* Notify user of a non-error.  */
427 void
428 notice (const char *cmsgid, ...)
429 {
430   va_list ap;
431
432   va_start (ap, cmsgid);
433   vfprintf (stderr, _(cmsgid), ap);
434   va_end (ap);
435 }
436
437 /* Notify user of a non-error, without translating the format string.  */
438 void
439 notice_translated (const char *cmsgid, ...)
440 {
441   va_list ap;
442
443   va_start (ap, cmsgid);
444   vfprintf (stderr, cmsgid, ap);
445   va_end (ap);
446 }
447 \f
448 static void
449 handler (int signo)
450 {
451   if (c_file != 0 && c_file[0])
452     maybe_unlink (c_file);
453
454   if (o_file != 0 && o_file[0])
455     maybe_unlink (o_file);
456
457   if (ldout != 0 && ldout[0])
458     maybe_unlink (ldout);
459
460   if (lderrout != 0 && lderrout[0])
461     maybe_unlink (lderrout);
462
463 #ifdef COLLECT_EXPORT_LIST
464   if (export_file != 0 && export_file[0])
465     maybe_unlink (export_file);
466 #endif
467
468   if (lto_o_files)
469     maybe_unlink_list (lto_o_files);
470
471   if (response_file)
472     maybe_unlink (response_file);
473
474   signal (signo, SIG_DFL);
475   raise (signo);
476 }
477
478 \f
479 int
480 file_exists (const char *name)
481 {
482   return access (name, R_OK) == 0;
483 }
484
485 /* Parse a reasonable subset of shell quoting syntax.  */
486
487 static char *
488 extract_string (const char **pp)
489 {
490   const char *p = *pp;
491   int backquote = 0;
492   int inside = 0;
493
494   for (;;)
495     {
496       char c = *p;
497       if (c == '\0')
498         break;
499       ++p;
500       if (backquote)
501         obstack_1grow (&temporary_obstack, c);
502       else if (! inside && c == ' ')
503         break;
504       else if (! inside && c == '\\')
505         backquote = 1;
506       else if (c == '\'')
507         inside = !inside;
508       else
509         obstack_1grow (&temporary_obstack, c);
510     }
511
512   obstack_1grow (&temporary_obstack, '\0');
513   *pp = p;
514   return XOBFINISH (&temporary_obstack, char *);
515 }
516 \f
517 void
518 dump_file (const char *name, FILE *to)
519 {
520   FILE *stream = fopen (name, "r");
521
522   if (stream == 0)
523     return;
524   while (1)
525     {
526       int c;
527       while (c = getc (stream),
528              c != EOF && (ISIDNUM (c) || c == '$' || c == '.'))
529         obstack_1grow (&temporary_obstack, c);
530       if (obstack_object_size (&temporary_obstack) > 0)
531         {
532           const char *word, *p;
533           char *result;
534           obstack_1grow (&temporary_obstack, '\0');
535           word = XOBFINISH (&temporary_obstack, const char *);
536
537           if (*word == '.')
538             ++word, putc ('.', to);
539           p = word;
540           if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
541             p += strlen (USER_LABEL_PREFIX);
542
543 #ifdef HAVE_LD_DEMANGLE
544           result = 0;
545 #else
546           if (no_demangle)
547             result = 0;
548           else
549             result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
550 #endif
551
552           if (result)
553             {
554               int diff;
555               fputs (result, to);
556
557               diff = strlen (word) - strlen (result);
558               while (diff > 0 && c == ' ')
559                 --diff, putc (' ', to);
560               if (diff < 0 && c == ' ')
561                 {
562                   while (diff < 0 && c == ' ')
563                     ++diff, c = getc (stream);
564                   if (!ISSPACE (c))
565                     {
566                       /* Make sure we output at least one space, or
567                          the demangled symbol name will run into
568                          whatever text follows.  */
569                       putc (' ', to);
570                     }
571                 }
572
573               free (result);
574             }
575           else
576             fputs (word, to);
577
578           fflush (to);
579           obstack_free (&temporary_obstack, temporary_firstobj);
580         }
581       if (c == EOF)
582         break;
583       putc (c, to);
584     }
585   fclose (stream);
586 }
587 \f
588 /* Return the kind of symbol denoted by name S.  */
589
590 static symkind
591 is_ctor_dtor (const char *s)
592 {
593   struct names { const char *const name; const int len; symkind ret;
594     const int two_underscores; };
595
596   const struct names *p;
597   int ch;
598   const char *orig_s = s;
599
600   static const struct names special[] = {
601 #ifndef NO_DOLLAR_IN_LABEL
602     { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 },
603     { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 },
604 #else
605 #ifndef NO_DOT_IN_LABEL
606     { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR, 0 },
607     { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR, 0 },
608 #endif /* NO_DOT_IN_LABEL */
609 #endif /* NO_DOLLAR_IN_LABEL */
610     { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR, 0 },
611     { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR, 0 },
612     { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH, 0 },
613     { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT, 0 },
614     { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI, 0 },
615     { NULL, 0, SYM_REGULAR, 0 }
616   };
617
618   while ((ch = *s) == '_')
619     ++s;
620
621   if (s == orig_s)
622     return SYM_REGULAR;
623
624   for (p = &special[0]; p->len > 0; p++)
625     {
626       if (ch == p->name[0]
627           && (!p->two_underscores || ((s - orig_s) >= 2))
628           && strncmp(s, p->name, p->len) == 0)
629         {
630           return p->ret;
631         }
632     }
633   return SYM_REGULAR;
634 }
635 \f
636 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
637    and one from the PATH variable.  */
638
639 static struct path_prefix cpath, path;
640
641 #ifdef CROSS_DIRECTORY_STRUCTURE
642 /* This is the name of the target machine.  We use it to form the name
643    of the files to execute.  */
644
645 static const char *const target_machine = TARGET_MACHINE;
646 #endif
647
648 /* Search for NAME using prefix list PPREFIX.  We only look for executable
649    files.
650
651    Return 0 if not found, otherwise return its name, allocated with malloc.  */
652
653 static char *
654 find_a_file (struct path_prefix *pprefix, const char *name)
655 {
656   char *temp;
657   struct prefix_list *pl;
658   int len = pprefix->max_len + strlen (name) + 1;
659
660   if (debug)
661     fprintf (stderr, "Looking for '%s'\n", name);
662
663 #ifdef HOST_EXECUTABLE_SUFFIX
664   len += strlen (HOST_EXECUTABLE_SUFFIX);
665 #endif
666
667   temp = XNEWVEC (char, len);
668
669   /* Determine the filename to execute (special case for absolute paths).  */
670
671   if (IS_ABSOLUTE_PATH (name))
672     {
673       if (access (name, X_OK) == 0)
674         {
675           strcpy (temp, name);
676
677           if (debug)
678             fprintf (stderr, "  - found: absolute path\n");
679
680           return temp;
681         }
682
683 #ifdef HOST_EXECUTABLE_SUFFIX
684         /* Some systems have a suffix for executable files.
685            So try appending that.  */
686       strcpy (temp, name);
687         strcat (temp, HOST_EXECUTABLE_SUFFIX);
688
689         if (access (temp, X_OK) == 0)
690           return temp;
691 #endif
692
693       if (debug)
694         fprintf (stderr, "  - failed to locate using absolute path\n");
695     }
696   else
697     for (pl = pprefix->plist; pl; pl = pl->next)
698       {
699         struct stat st;
700
701         strcpy (temp, pl->prefix);
702         strcat (temp, name);
703
704         if (stat (temp, &st) >= 0
705             && ! S_ISDIR (st.st_mode)
706             && access (temp, X_OK) == 0)
707           return temp;
708
709 #ifdef HOST_EXECUTABLE_SUFFIX
710         /* Some systems have a suffix for executable files.
711            So try appending that.  */
712         strcat (temp, HOST_EXECUTABLE_SUFFIX);
713
714         if (stat (temp, &st) >= 0
715             && ! S_ISDIR (st.st_mode)
716             && access (temp, X_OK) == 0)
717           return temp;
718 #endif
719       }
720
721   if (debug && pprefix->plist == NULL)
722     fprintf (stderr, "  - failed: no entries in prefix list\n");
723
724   free (temp);
725   return 0;
726 }
727
728 /* Add an entry for PREFIX to prefix list PPREFIX.  */
729
730 static void
731 add_prefix (struct path_prefix *pprefix, const char *prefix)
732 {
733   struct prefix_list *pl, **prev;
734   int len;
735
736   if (pprefix->plist)
737     {
738       for (pl = pprefix->plist; pl->next; pl = pl->next)
739         ;
740       prev = &pl->next;
741     }
742   else
743     prev = &pprefix->plist;
744
745   /* Keep track of the longest prefix.  */
746
747   len = strlen (prefix);
748   if (len > pprefix->max_len)
749     pprefix->max_len = len;
750
751   pl = XNEW (struct prefix_list);
752   pl->prefix = xstrdup (prefix);
753
754   if (*prev)
755     pl->next = *prev;
756   else
757     pl->next = (struct prefix_list *) 0;
758   *prev = pl;
759 }
760 \f
761 /* Take the value of the environment variable ENV, break it into a path, and
762    add of the entries to PPREFIX.  */
763
764 static void
765 prefix_from_env (const char *env, struct path_prefix *pprefix)
766 {
767   const char *p;
768   p = getenv (env);
769
770   if (p)
771     prefix_from_string (p, pprefix);
772 }
773
774 static void
775 prefix_from_string (const char *p, struct path_prefix *pprefix)
776 {
777   const char *startp, *endp;
778   char *nstore = XNEWVEC (char, strlen (p) + 3);
779
780   if (debug)
781     fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
782
783   startp = endp = p;
784   while (1)
785     {
786       if (*endp == PATH_SEPARATOR || *endp == 0)
787         {
788           strncpy (nstore, startp, endp-startp);
789           if (endp == startp)
790             {
791               strcpy (nstore, "./");
792             }
793           else if (! IS_DIR_SEPARATOR (endp[-1]))
794             {
795               nstore[endp-startp] = DIR_SEPARATOR;
796               nstore[endp-startp+1] = 0;
797             }
798           else
799             nstore[endp-startp] = 0;
800
801           if (debug)
802             fprintf (stderr, "  - add prefix: %s\n", nstore);
803
804           add_prefix (pprefix, nstore);
805           if (*endp == 0)
806             break;
807           endp = startp = endp + 1;
808         }
809       else
810         endp++;
811     }
812   free (nstore);
813 }
814
815 #ifdef OBJECT_FORMAT_NONE
816
817 /* Add an entry for the object file NAME to object file list LIST.
818    New entries are added at the end of the list. The original pointer
819    value of NAME is preserved, i.e., no string copy is performed.  */
820
821 static void
822 add_lto_object (struct lto_object_list *list, const char *name)
823 {
824   struct lto_object *n = XNEW (struct lto_object);
825   n->name = name;
826   n->next = NULL;
827
828   if (list->last)
829     list->last->next = n;
830   else
831     list->first = n;
832
833   list->last = n;
834 }
835 #endif /* OBJECT_FORMAT_NONE */
836
837
838 /* Perform a link-time recompilation and relink if any of the object
839    files contain LTO info.  The linker command line LTO_LD_ARGV
840    represents the linker command that would produce a final executable
841    without the use of LTO. OBJECT_LST is a vector of object file names
842    appearing in LTO_LD_ARGV that are to be considerd for link-time
843    recompilation, where OBJECT is a pointer to the last valid element.
844    (This awkward convention avoids an impedance mismatch with the
845    usage of similarly-named variables in main().)  The elements of
846    OBJECT_LST must be identical, i.e., pointer equal, to the
847    corresponding arguments in LTO_LD_ARGV.
848
849    Upon entry, at least one linker run has been performed without the
850    use of any LTO info that might be present.  Any recompilations
851    necessary for template instantiations have been performed, and
852    initializer/finalizer tables have been created if needed and
853    included in the linker command line LTO_LD_ARGV. If any of the
854    object files contain LTO info, we run the LTO back end on all such
855    files, and perform the final link with the LTO back end output
856    substituted for the LTO-optimized files.  In some cases, a final
857    link with all link-time generated code has already been performed,
858    so there is no need to relink if no LTO info is found.  In other
859    cases, our caller has not produced the final executable, and is
860    relying on us to perform the required link whether LTO info is
861    present or not.  In that case, the FORCE argument should be true.
862    Note that the linker command line argument LTO_LD_ARGV passed into
863    this function may be modified in place.  */
864
865 static void
866 maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,
867                           const char **object, bool force)
868 {
869   const char **object_file = CONST_CAST2 (const char **, char **, object_lst);
870
871   int num_lto_c_args = 1;    /* Allow space for the terminating NULL.  */
872
873   while (object_file < object)
874   {
875     /* If file contains LTO info, add it to the list of LTO objects.  */
876     scan_prog_file (*object_file++, PASS_LTOINFO, SCAN_ALL);
877
878     /* Increment the argument count by the number of object file arguments
879        we will add.  An upper bound suffices, so just count all of the
880        object files regardless of whether they contain LTO info.  */
881     num_lto_c_args++;
882   }
883
884   if (lto_objects.first)
885     {
886       char **lto_c_argv;
887       const char **lto_c_ptr;
888       char **p;
889       char **lto_o_ptr;
890       struct lto_object *list;
891       char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER");
892       struct pex_obj *pex;
893       const char *prog = "lto-wrapper";
894       int lto_ld_argv_size = 0;
895       char **out_lto_ld_argv;
896       int out_lto_ld_argv_size;
897       size_t num_files;
898
899       if (!lto_wrapper)
900         fatal_error ("COLLECT_LTO_WRAPPER must be set");
901
902       num_lto_c_args++;
903
904       /* There is at least one object file containing LTO info,
905          so we need to run the LTO back end and relink.
906
907          To do so we build updated ld arguments with first
908          LTO object replaced by all partitions and other LTO
909          objects removed.  */
910
911       lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
912       lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
913
914       *lto_c_ptr++ = lto_wrapper;
915
916       /* Add LTO objects to the wrapper command line.  */
917       for (list = lto_objects.first; list; list = list->next)
918         *lto_c_ptr++ = list->name;
919
920       *lto_c_ptr = NULL;
921
922       /* Run the LTO back end.  */
923       pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH);
924       {
925         int c;
926         FILE *stream;
927         size_t i;
928         char *start, *end;
929
930         stream = pex_read_output (pex, 0);
931         gcc_assert (stream);
932
933         num_files = 0;
934         while ((c = getc (stream)) != EOF)
935           {
936             obstack_1grow (&temporary_obstack, c);
937             if (c == '\n')
938               ++num_files;
939           }
940
941         lto_o_files = XNEWVEC (char *, num_files + 1);
942         lto_o_files[num_files] = NULL;
943         start = XOBFINISH (&temporary_obstack, char *);
944         for (i = 0; i < num_files; ++i)
945           {
946             end = start;
947             while (*end != '\n')
948               ++end;
949             *end = '\0';
950
951             lto_o_files[i] = xstrdup (start);
952
953             start = end + 1;
954           }
955
956         obstack_free (&temporary_obstack, temporary_firstobj);
957       }
958       do_wait (prog, pex);
959       pex = NULL;
960
961       /* Compute memory needed for new LD arguments.  At most number of original arguemtns
962          plus number of partitions.  */
963       for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++)
964         ;
965       out_lto_ld_argv = XCNEWVEC(char *, num_files + lto_ld_argv_size + 1);
966       out_lto_ld_argv_size = 0;
967
968       /* After running the LTO back end, we will relink, substituting
969          the LTO output for the object files that we submitted to the
970          LTO. Here, we modify the linker command line for the relink.  */
971
972       /* Copy all arguments until we find first LTO file.  */
973       p = lto_ld_argv;
974       while (*p != NULL)
975         {
976           for (list = lto_objects.first; list; list = list->next)
977             if (*p == list->name) /* Note test for pointer equality!  */
978               break;
979           if (list)
980             break;
981           out_lto_ld_argv[out_lto_ld_argv_size++] = *p++;
982         }
983
984       /* Now insert all LTO partitions.  */
985       lto_o_ptr = lto_o_files;
986       while (*lto_o_ptr)
987         out_lto_ld_argv[out_lto_ld_argv_size++] = *lto_o_ptr++;
988
989       /* ... and copy the rest.  */
990       while (*p != NULL)
991         {
992           for (list = lto_objects.first; list; list = list->next)
993             if (*p == list->name) /* Note test for pointer equality!  */
994               break;
995           if (!list)
996             out_lto_ld_argv[out_lto_ld_argv_size++] = *p;
997           p++;
998         }
999       out_lto_ld_argv[out_lto_ld_argv_size++] = 0;
1000
1001       /* Run the linker again, this time replacing the object files
1002          optimized by the LTO with the temporary file generated by the LTO.  */
1003       fork_execute ("ld", out_lto_ld_argv);
1004       post_ld_pass (true);
1005       free (lto_ld_argv);
1006
1007       maybe_unlink_list (lto_o_files);
1008     }
1009   else if (force)
1010     {
1011       /* Our caller is relying on us to do the link
1012          even though there is no LTO back end work to be done.  */
1013       fork_execute ("ld", lto_ld_argv);
1014       post_ld_pass (false);
1015     }
1016 }
1017 \f
1018 /* Main program.  */
1019
1020 int
1021 main (int argc, char **argv)
1022 {
1023   static const char *const ld_suffix    = "ld";
1024   static const char *const plugin_ld_suffix = PLUGIN_LD;
1025   static const char *const real_ld_suffix = "real-ld";
1026   static const char *const collect_ld_suffix = "collect-ld";
1027   static const char *const nm_suffix    = "nm";
1028   static const char *const gnm_suffix   = "gnm";
1029 #ifdef LDD_SUFFIX
1030   static const char *const ldd_suffix   = LDD_SUFFIX;
1031 #endif
1032   static const char *const strip_suffix = "strip";
1033   static const char *const gstrip_suffix = "gstrip";
1034
1035 #ifdef CROSS_DIRECTORY_STRUCTURE
1036   /* If we look for a program in the compiler directories, we just use
1037      the short name, since these directories are already system-specific.
1038      But it we look for a program in the system directories, we need to
1039      qualify the program name with the target machine.  */
1040
1041   const char *const full_ld_suffix =
1042     concat(target_machine, "-", ld_suffix, NULL);
1043   const char *const full_plugin_ld_suffix =
1044     concat(target_machine, "-", plugin_ld_suffix, NULL);
1045   const char *const full_nm_suffix =
1046     concat (target_machine, "-", nm_suffix, NULL);
1047   const char *const full_gnm_suffix =
1048     concat (target_machine, "-", gnm_suffix, NULL);
1049 #ifdef LDD_SUFFIX
1050   const char *const full_ldd_suffix =
1051     concat (target_machine, "-", ldd_suffix, NULL);
1052 #endif
1053   const char *const full_strip_suffix =
1054     concat (target_machine, "-", strip_suffix, NULL);
1055   const char *const full_gstrip_suffix =
1056     concat (target_machine, "-", gstrip_suffix, NULL);
1057 #else
1058   const char *const full_ld_suffix      = ld_suffix;
1059   const char *const full_plugin_ld_suffix = plugin_ld_suffix;
1060   const char *const full_nm_suffix      = nm_suffix;
1061   const char *const full_gnm_suffix     = gnm_suffix;
1062 #ifdef LDD_SUFFIX
1063   const char *const full_ldd_suffix     = ldd_suffix;
1064 #endif
1065   const char *const full_strip_suffix   = strip_suffix;
1066   const char *const full_gstrip_suffix  = gstrip_suffix;
1067 #endif /* CROSS_DIRECTORY_STRUCTURE */
1068
1069   const char *arg;
1070   FILE *outf;
1071 #ifdef COLLECT_EXPORT_LIST
1072   FILE *exportf;
1073 #endif
1074   const char *ld_file_name;
1075   const char *p;
1076   char **c_argv;
1077   const char **c_ptr;
1078   char **ld1_argv;
1079   const char **ld1;
1080   bool use_plugin = false;
1081
1082   /* The kinds of symbols we will have to consider when scanning the
1083      outcome of a first pass link.  This is ALL to start with, then might
1084      be adjusted before getting to the first pass link per se, typically on
1085      AIX where we perform an early scan of objects and libraries to fetch
1086      the list of global ctors/dtors and make sure they are not garbage
1087      collected.  */
1088   scanfilter ld1_filter = SCAN_ALL;
1089
1090   char **ld2_argv;
1091   const char **ld2;
1092   char **object_lst;
1093   const char **object;
1094 #ifdef TARGET_AIX_VERSION
1095   int object_nbr = argc;
1096 #endif
1097   int first_file;
1098   int num_c_args;
1099   char **old_argv;
1100
1101   p = argv[0] + strlen (argv[0]);
1102   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
1103     --p;
1104   progname = p;
1105
1106   xmalloc_set_program_name (progname);
1107
1108   old_argv = argv;
1109   expandargv (&argc, &argv);
1110   if (argv != old_argv)
1111     at_file_supplied = 1;
1112
1113   process_args (&argc, argv);
1114
1115   num_c_args = argc + 9;
1116
1117 #ifndef HAVE_LD_DEMANGLE
1118   no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
1119
1120   /* Suppress demangling by the real linker, which may be broken.  */
1121   putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
1122 #endif
1123
1124 #if defined (COLLECT2_HOST_INITIALIZATION)
1125   /* Perform system dependent initialization, if necessary.  */
1126   COLLECT2_HOST_INITIALIZATION;
1127 #endif
1128
1129 #ifdef SIGCHLD
1130   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1131      receive the signal.  A different setting is inheritable */
1132   signal (SIGCHLD, SIG_DFL);
1133 #endif
1134
1135   /* Unlock the stdio streams.  */
1136   unlock_std_streams ();
1137
1138   gcc_init_libintl ();
1139
1140   diagnostic_initialize (global_dc, 0);
1141
1142   /* Do not invoke xcalloc before this point, since locale needs to be
1143      set first, in case a diagnostic is issued.  */
1144
1145   ld1_argv = XCNEWVEC (char *, argc + 4);
1146   ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
1147   ld2_argv = XCNEWVEC (char *, argc + 11);
1148   ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
1149   object_lst = XCNEWVEC (char *, argc);
1150   object = CONST_CAST2 (const char **, char **, object_lst);
1151
1152 #ifdef DEBUG
1153   debug = 1;
1154 #endif
1155
1156   /* Parse command line early for instances of -debug.  This allows
1157      the debug flag to be set before functions like find_a_file()
1158      are called.  We also look for the -flto or -flto-partition=none flag to know
1159      what LTO mode we are in.  */
1160   {
1161     int i;
1162     bool no_partition = false;
1163
1164     for (i = 1; argv[i] != NULL; i ++)
1165       {
1166         if (! strcmp (argv[i], "-debug"))
1167           debug = true;
1168         else if (! strcmp (argv[i], "-flto-partition=none"))
1169           no_partition = true;
1170         else if ((! strncmp (argv[i], "-flto=", 6)
1171                   || ! strcmp (argv[i], "-flto")) && ! use_plugin)
1172           lto_mode = LTO_MODE_WHOPR;
1173         else if (!strncmp (argv[i], "-fno-lto", 8))
1174           lto_mode = LTO_MODE_NONE;
1175         else if (! strcmp (argv[i], "-plugin"))
1176           {
1177             use_plugin = true;
1178             lto_mode = LTO_MODE_NONE;
1179           }
1180 #ifdef COLLECT_EXPORT_LIST
1181         /* since -brtl, -bexport, -b64 are not position dependent
1182            also check for them here */
1183         if ((argv[i][0] == '-') && (argv[i][1] == 'b'))
1184           {
1185             arg = argv[i];
1186             /* We want to disable automatic exports on AIX when user
1187                explicitly puts an export list in command line */
1188             if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1189               export_flag = 1;
1190             else if (arg[2] == '6' && arg[3] == '4')
1191               aix64_flag = 1;
1192             else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l')
1193               aixrtl_flag = 1;
1194           }
1195 #endif
1196       }
1197     vflag = debug;
1198     if (no_partition && lto_mode == LTO_MODE_WHOPR)
1199       lto_mode = LTO_MODE_LTO;
1200   }
1201
1202 #ifndef DEFAULT_A_OUT_NAME
1203   output_file = "a.out";
1204 #else
1205   output_file = DEFAULT_A_OUT_NAME;
1206 #endif
1207
1208   obstack_begin (&temporary_obstack, 0);
1209   temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
1210
1211 #ifndef HAVE_LD_DEMANGLE
1212   current_demangling_style = auto_demangling;
1213 #endif
1214   p = getenv ("COLLECT_GCC_OPTIONS");
1215   while (p && *p)
1216     {
1217       const char *q = extract_string (&p);
1218       if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1219         num_c_args++;
1220     }
1221   obstack_free (&temporary_obstack, temporary_firstobj);
1222
1223   /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1224      -fno-exceptions -w -fno-whole-program */
1225   num_c_args += 6;
1226
1227   c_argv = XCNEWVEC (char *, num_c_args);
1228   c_ptr = CONST_CAST2 (const char **, char **, c_argv);
1229
1230   if (argc < 2)
1231     fatal_error ("no arguments");
1232
1233 #ifdef SIGQUIT
1234   if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1235     signal (SIGQUIT, handler);
1236 #endif
1237   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1238     signal (SIGINT, handler);
1239 #ifdef SIGALRM
1240   if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
1241     signal (SIGALRM, handler);
1242 #endif
1243 #ifdef SIGHUP
1244   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1245     signal (SIGHUP, handler);
1246 #endif
1247   if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1248     signal (SIGSEGV, handler);
1249 #ifdef SIGBUS
1250   if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1251     signal (SIGBUS, handler);
1252 #endif
1253
1254   /* Extract COMPILER_PATH and PATH into our prefix list.  */
1255   prefix_from_env ("COMPILER_PATH", &cpath);
1256   prefix_from_env ("PATH", &path);
1257
1258   /* Try to discover a valid linker/nm/strip to use.  */
1259
1260   /* Maybe we know the right file to use (if not cross).  */
1261   ld_file_name = 0;
1262 #ifdef DEFAULT_LINKER
1263   if (access (DEFAULT_LINKER, X_OK) == 0)
1264     ld_file_name = DEFAULT_LINKER;
1265   if (ld_file_name == 0)
1266 #endif
1267 #ifdef REAL_LD_FILE_NAME
1268   ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
1269   if (ld_file_name == 0)
1270 #endif
1271   /* Search the (target-specific) compiler dirs for ld'.  */
1272   ld_file_name = find_a_file (&cpath, real_ld_suffix);
1273   /* Likewise for `collect-ld'.  */
1274   if (ld_file_name == 0)
1275     ld_file_name = find_a_file (&cpath, collect_ld_suffix);
1276   /* Search the compiler directories for `ld'.  We have protection against
1277      recursive calls in find_a_file.  */
1278   if (ld_file_name == 0)
1279     ld_file_name = find_a_file (&cpath,
1280                                 use_plugin
1281                                 ? plugin_ld_suffix
1282                                 : ld_suffix);
1283   /* Search the ordinary system bin directories
1284      for `ld' (if native linking) or `TARGET-ld' (if cross).  */
1285   if (ld_file_name == 0)
1286     ld_file_name = find_a_file (&path,
1287                                 use_plugin
1288                                 ? full_plugin_ld_suffix
1289                                 : full_ld_suffix);
1290
1291 #ifdef REAL_NM_FILE_NAME
1292   nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
1293   if (nm_file_name == 0)
1294 #endif
1295   nm_file_name = find_a_file (&cpath, gnm_suffix);
1296   if (nm_file_name == 0)
1297     nm_file_name = find_a_file (&path, full_gnm_suffix);
1298   if (nm_file_name == 0)
1299     nm_file_name = find_a_file (&cpath, nm_suffix);
1300   if (nm_file_name == 0)
1301     nm_file_name = find_a_file (&path, full_nm_suffix);
1302
1303 #ifdef LDD_SUFFIX
1304   ldd_file_name = find_a_file (&cpath, ldd_suffix);
1305   if (ldd_file_name == 0)
1306     ldd_file_name = find_a_file (&path, full_ldd_suffix);
1307 #endif
1308
1309 #ifdef REAL_STRIP_FILE_NAME
1310   strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1311   if (strip_file_name == 0)
1312 #endif
1313   strip_file_name = find_a_file (&cpath, gstrip_suffix);
1314   if (strip_file_name == 0)
1315     strip_file_name = find_a_file (&path, full_gstrip_suffix);
1316   if (strip_file_name == 0)
1317     strip_file_name = find_a_file (&cpath, strip_suffix);
1318   if (strip_file_name == 0)
1319     strip_file_name = find_a_file (&path, full_strip_suffix);
1320
1321   /* Determine the full path name of the C compiler to use.  */
1322   c_file_name = getenv ("COLLECT_GCC");
1323   if (c_file_name == 0)
1324     {
1325 #ifdef CROSS_DIRECTORY_STRUCTURE
1326       c_file_name = concat (target_machine, "-gcc", NULL);
1327 #else
1328       c_file_name = "gcc";
1329 #endif
1330     }
1331
1332   p = find_a_file (&cpath, c_file_name);
1333
1334   /* Here it should be safe to use the system search path since we should have
1335      already qualified the name of the compiler when it is needed.  */
1336   if (p == 0)
1337     p = find_a_file (&path, c_file_name);
1338
1339   if (p)
1340     c_file_name = p;
1341
1342   *ld1++ = *ld2++ = ld_file_name;
1343
1344   /* Make temp file names.  */
1345   c_file = make_temp_file (".c");
1346   o_file = make_temp_file (".o");
1347 #ifdef COLLECT_EXPORT_LIST
1348   export_file = make_temp_file (".x");
1349 #endif
1350   ldout = make_temp_file (".ld");
1351   lderrout = make_temp_file (".le");
1352   *c_ptr++ = c_file_name;
1353   *c_ptr++ = "-x";
1354   *c_ptr++ = "c";
1355   *c_ptr++ = "-c";
1356   *c_ptr++ = "-o";
1357   *c_ptr++ = o_file;
1358
1359 #ifdef COLLECT_EXPORT_LIST
1360   /* Generate a list of directories from LIBPATH.  */
1361   prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1362   /* Add to this list also two standard directories where
1363      AIX loader always searches for libraries.  */
1364   add_prefix (&libpath_lib_dirs, "/lib");
1365   add_prefix (&libpath_lib_dirs, "/usr/lib");
1366 #endif
1367
1368   /* Get any options that the upper GCC wants to pass to the sub-GCC.
1369
1370      AIX support needs to know if -shared has been specified before
1371      parsing commandline arguments.  */
1372
1373   p = getenv ("COLLECT_GCC_OPTIONS");
1374   while (p && *p)
1375     {
1376       const char *q = extract_string (&p);
1377       if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1378         *c_ptr++ = xstrdup (q);
1379       if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1380         *c_ptr++ = xstrdup (q);
1381       if (strcmp (q, "-shared") == 0)
1382         shared_obj = 1;
1383       if (*q == '-' && q[1] == 'B')
1384         {
1385           *c_ptr++ = xstrdup (q);
1386           if (q[2] == 0)
1387             {
1388               q = extract_string (&p);
1389               *c_ptr++ = xstrdup (q);
1390             }
1391         }
1392     }
1393   obstack_free (&temporary_obstack, temporary_firstobj);
1394   *c_ptr++ = "-fno-profile-arcs";
1395   *c_ptr++ = "-fno-test-coverage";
1396   *c_ptr++ = "-fno-branch-probabilities";
1397   *c_ptr++ = "-fno-exceptions";
1398   *c_ptr++ = "-w";
1399   *c_ptr++ = "-fno-whole-program";
1400
1401   /* !!! When GCC calls collect2,
1402      it does not know whether it is calling collect2 or ld.
1403      So collect2 cannot meaningfully understand any options
1404      except those ld understands.
1405      If you propose to make GCC pass some other option,
1406      just imagine what will happen if ld is really ld!!!  */
1407
1408   /* Parse arguments.  Remember output file spec, pass the rest to ld.  */
1409   /* After the first file, put in the c++ rt0.  */
1410
1411   first_file = 1;
1412   while ((arg = *++argv) != (char *) 0)
1413     {
1414       *ld1++ = *ld2++ = arg;
1415
1416       if (arg[0] == '-')
1417         {
1418           switch (arg[1])
1419             {
1420             case 'd':
1421               if (!strcmp (arg, "-debug"))
1422                 {
1423                   /* Already parsed.  */
1424                   ld1--;
1425                   ld2--;
1426                 }
1427               if (!strcmp (arg, "-dynamic-linker") && argv[1])
1428                 {
1429                   ++argv;
1430                   *ld1++ = *ld2++ = *argv;
1431                 }
1432               break;
1433
1434             case 'f':
1435               if (strncmp (arg, "-flto", 5) == 0)
1436                 {
1437 #ifdef ENABLE_LTO
1438                   /* Do not pass LTO flag to the linker. */
1439                   ld1--;
1440                   ld2--;
1441 #else
1442                   error ("LTO support has not been enabled in this "
1443                          "configuration");
1444 #endif
1445                 }
1446 #ifdef TARGET_AIX_VERSION
1447               else
1448                 {
1449                   /* File containing a list of input files to process.  */
1450
1451                   FILE *stream;
1452                   char buf[MAXPATHLEN + 2];
1453                   /* Number of additionnal object files.  */
1454                   int add_nbr = 0;
1455                   /* Maximum of additionnal object files before vector
1456                      expansion.  */
1457                   int add_max = 0;
1458                   const char *list_filename = arg + 2;
1459
1460                   /* Accept -fFILENAME and -f FILENAME.  */
1461                   if (*list_filename == '\0' && argv[1])
1462                     {
1463                       ++argv;
1464                       list_filename = *argv;
1465                       *ld1++ = *ld2++ = *argv;
1466                     }
1467
1468                   stream = fopen (list_filename, "r");
1469                   if (stream == NULL)
1470                     fatal_error ("can't open %s: %m", list_filename);
1471
1472                   while (fgets (buf, sizeof buf, stream) != NULL)
1473                     {
1474                       /* Remove end of line.  */
1475                       int len = strlen (buf);
1476                       if (len >= 1 && buf[len - 1] =='\n')
1477                         buf[len - 1] = '\0';
1478
1479                       /* Put on object vector.
1480                          Note: we only expanse vector here, so we must keep
1481                          extra space for remaining arguments.  */
1482                       if (add_nbr >= add_max)
1483                         {
1484                           int pos =
1485                             object - CONST_CAST2 (const char **, char **,
1486                                                   object_lst);
1487                           add_max = (add_max == 0) ? 16 : add_max * 2;
1488                           object_lst = XRESIZEVEC (char *, object_lst,
1489                                                    object_nbr + add_max);
1490                           object = CONST_CAST2 (const char **, char **,
1491                                                 object_lst) + pos;
1492                           object_nbr += add_max;
1493                         }
1494                       *object++ = xstrdup (buf);
1495                       add_nbr++;
1496                     }
1497                   fclose (stream);
1498                 }
1499 #endif
1500               break;
1501
1502             case 'l':
1503               if (first_file)
1504                 {
1505                   /* place o_file BEFORE this argument! */
1506                   first_file = 0;
1507                   ld2--;
1508                   *ld2++ = o_file;
1509                   *ld2++ = arg;
1510                 }
1511 #ifdef COLLECT_EXPORT_LIST
1512               {
1513                 /* Resolving full library name.  */
1514                 const char *s = resolve_lib_name (arg+2);
1515
1516                 /* Saving a full library name.  */
1517                 add_to_list (&libs, s);
1518               }
1519 #endif
1520               break;
1521
1522 #ifdef COLLECT_EXPORT_LIST
1523             /* Saving directories where to search for libraries.  */
1524             case 'L':
1525               add_prefix (&cmdline_lib_dirs, arg+2);
1526               break;
1527 #else
1528 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1529             case 'L':
1530               if (is_in_args (arg,
1531                               CONST_CAST2 (const char **, char **, ld1_argv),
1532                               ld1 - 1))
1533                 --ld1;
1534               break;
1535 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1536 #endif
1537
1538             case 'o':
1539               if (arg[2] == '\0')
1540                 output_file = *ld1++ = *ld2++ = *++argv;
1541               else
1542                 output_file = &arg[2];
1543               break;
1544
1545             case 'r':
1546               if (arg[2] == '\0')
1547                 rflag = 1;
1548               break;
1549
1550             case 's':
1551               if (arg[2] == '\0' && do_collecting)
1552                 {
1553                   /* We must strip after the nm run, otherwise C++ linking
1554                      will not work.  Thus we strip in the second ld run, or
1555                      else with strip if there is no second ld run.  */
1556                   strip_flag = 1;
1557                   ld1--;
1558                 }
1559               break;
1560
1561             case 'v':
1562               if (arg[2] == '\0')
1563                 vflag = true;
1564               break;
1565
1566             case '-':
1567               if (strcmp (arg, "--no-demangle") == 0)
1568                 {
1569 #ifndef HAVE_LD_DEMANGLE
1570                   no_demangle = 1;
1571                   ld1--;
1572                   ld2--;
1573 #endif
1574                 }
1575               else if (strncmp (arg, "--demangle", 10) == 0)
1576                 {
1577 #ifndef HAVE_LD_DEMANGLE
1578                   no_demangle = 0;
1579                   if (arg[10] == '=')
1580                     {
1581                       enum demangling_styles style
1582                         = cplus_demangle_name_to_style (arg+11);
1583                       if (style == unknown_demangling)
1584                         error ("unknown demangling style '%s'", arg+11);
1585                       else
1586                         current_demangling_style = style;
1587                     }
1588                   ld1--;
1589                   ld2--;
1590 #endif
1591                 }
1592               else if (strncmp (arg, "--sysroot=", 10) == 0)
1593                 target_system_root = arg + 10;
1594               else if (strcmp (arg, "--version") == 0)
1595                 vflag = true;
1596               else if (strcmp (arg, "--help") == 0)
1597                 helpflag = true;
1598               break;
1599             }
1600         }
1601       else if ((p = strrchr (arg, '.')) != (char *) 0
1602                && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1603                    || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1604                    || strcmp (p, ".obj") == 0))
1605         {
1606           if (first_file)
1607             {
1608               first_file = 0;
1609               if (p[1] == 'o')
1610                 *ld2++ = o_file;
1611               else
1612                 {
1613                   /* place o_file BEFORE this argument! */
1614                   ld2--;
1615                   *ld2++ = o_file;
1616                   *ld2++ = arg;
1617                 }
1618             }
1619           if (p[1] == 'o' || p[1] == 'l')
1620             *object++ = arg;
1621 #ifdef COLLECT_EXPORT_LIST
1622           /* libraries can be specified directly, i.e. without -l flag.  */
1623           else
1624             {
1625               /* Saving a full library name.  */
1626               add_to_list (&libs, arg);
1627             }
1628 #endif
1629         }
1630     }
1631
1632 #ifdef COLLECT_EXPORT_LIST
1633   /* This is added only for debugging purposes.  */
1634   if (debug)
1635     {
1636       fprintf (stderr, "List of libraries:\n");
1637       dump_list (stderr, "\t", libs.first);
1638     }
1639
1640   /* The AIX linker will discard static constructors in object files if
1641      nothing else in the file is referenced, so look at them first.  Unless
1642      we are building a shared object, ignore the eh frame tables, as we
1643      would otherwise reference them all, hence drag all the corresponding
1644      objects even if nothing else is referenced.  */
1645   {
1646     const char **export_object_lst
1647       = CONST_CAST2 (const char **, char **, object_lst);
1648
1649     struct id *list = libs.first;
1650
1651     /* Compute the filter to use from the current one, do scan, then adjust
1652        the "current" filter to remove what we just included here.  This will
1653        control whether we need a first pass link later on or not, and what
1654        will remain to be scanned there.  */
1655
1656     scanfilter this_filter = ld1_filter;
1657 #if HAVE_AS_REF
1658     if (!shared_obj)
1659       this_filter &= ~SCAN_DWEH;
1660 #endif
1661
1662     while (export_object_lst < object)
1663       scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1664
1665     for (; list; list = list->next)
1666       scan_prog_file (list->name, PASS_FIRST, this_filter);
1667
1668     ld1_filter = ld1_filter & ~this_filter;
1669   }
1670
1671   if (exports.first)
1672     {
1673       char *buf = concat ("-bE:", export_file, NULL);
1674
1675       *ld1++ = buf;
1676       *ld2++ = buf;
1677
1678       exportf = fopen (export_file, "w");
1679       if (exportf == (FILE *) 0)
1680         fatal_error ("fopen %s: %m", export_file);
1681       write_aix_file (exportf, exports.first);
1682       if (fclose (exportf))
1683         fatal_error ("fclose %s: %m", export_file);
1684     }
1685 #endif
1686
1687   *c_ptr++ = c_file;
1688   *c_ptr = *ld1 = *object = (char *) 0;
1689
1690   if (vflag)
1691     notice ("collect2 version %s\n", version_string);
1692
1693   if (helpflag)
1694     {
1695       printf ("Usage: collect2 [options]\n");
1696       printf (" Wrap linker and generate constructor code if needed.\n");
1697       printf (" Options:\n");
1698       printf ("  -debug          Enable debug output\n");
1699       printf ("  --help          Display this information\n");
1700       printf ("  -v, --version   Display this program's version number\n");
1701       printf ("\n");
1702       printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1703       printf ("Report bugs: %s\n", bug_report_url);
1704       printf ("\n");
1705     }
1706
1707   if (debug)
1708     {
1709       const char *ptr;
1710       fprintf (stderr, "ld_file_name        = %s\n",
1711                (ld_file_name ? ld_file_name : "not found"));
1712       fprintf (stderr, "c_file_name         = %s\n",
1713                (c_file_name ? c_file_name : "not found"));
1714       fprintf (stderr, "nm_file_name        = %s\n",
1715                (nm_file_name ? nm_file_name : "not found"));
1716 #ifdef LDD_SUFFIX
1717       fprintf (stderr, "ldd_file_name       = %s\n",
1718                (ldd_file_name ? ldd_file_name : "not found"));
1719 #endif
1720       fprintf (stderr, "strip_file_name     = %s\n",
1721                (strip_file_name ? strip_file_name : "not found"));
1722       fprintf (stderr, "c_file              = %s\n",
1723                (c_file ? c_file : "not found"));
1724       fprintf (stderr, "o_file              = %s\n",
1725                (o_file ? o_file : "not found"));
1726
1727       ptr = getenv ("COLLECT_GCC_OPTIONS");
1728       if (ptr)
1729         fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1730
1731       ptr = getenv ("COLLECT_GCC");
1732       if (ptr)
1733         fprintf (stderr, "COLLECT_GCC         = %s\n", ptr);
1734
1735       ptr = getenv ("COMPILER_PATH");
1736       if (ptr)
1737         fprintf (stderr, "COMPILER_PATH       = %s\n", ptr);
1738
1739       ptr = getenv (LIBRARY_PATH_ENV);
1740       if (ptr)
1741         fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1742
1743       fprintf (stderr, "\n");
1744     }
1745
1746   /* Load the program, searching all libraries and attempting to provide
1747      undefined symbols from repository information.
1748
1749      If -r or they will be run via some other method, do not build the
1750      constructor or destructor list, just return now.  */
1751   {
1752     bool early_exit
1753       = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1754
1755     /* Perform the first pass link now, if we're about to exit or if we need
1756        to scan for things we haven't collected yet before pursuing further.
1757
1758        On AIX, the latter typically includes nothing for shared objects or
1759        frame tables for an executable, out of what the required early scan on
1760        objects and libraries has performed above.  In the !shared_obj case, we
1761        expect the relevant tables to be dragged together with their associated
1762        functions from precise cross reference insertions by the compiler.  */
1763
1764     if (early_exit || ld1_filter != SCAN_NOTHING)
1765       do_tlink (ld1_argv, object_lst);
1766
1767     if (early_exit)
1768       {
1769 #ifdef COLLECT_EXPORT_LIST
1770         /* Make sure we delete the export file we may have created.  */
1771         if (export_file != 0 && export_file[0])
1772           maybe_unlink (export_file);
1773 #endif
1774         if (lto_mode != LTO_MODE_NONE)
1775           maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1776         else
1777           post_ld_pass (false);
1778
1779         maybe_unlink (c_file);
1780         maybe_unlink (o_file);
1781         return 0;
1782       }
1783   }
1784
1785   /* Unless we have done it all already, examine the namelist and search for
1786      static constructors and destructors to call.  Write the constructor and
1787      destructor tables to a .s file and reload.  */
1788
1789   if (ld1_filter != SCAN_NOTHING)
1790     scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1791
1792 #ifdef SCAN_LIBRARIES
1793   scan_libraries (output_file);
1794 #endif
1795
1796   if (debug)
1797     {
1798       notice_translated (ngettext ("%d constructor found\n",
1799                                    "%d constructors found\n",
1800                                    constructors.number),
1801                          constructors.number);
1802       notice_translated (ngettext ("%d destructor found\n",
1803                                    "%d destructors found\n",
1804                                    destructors.number),
1805                          destructors.number);
1806       notice_translated (ngettext("%d frame table found\n",
1807                                   "%d frame tables found\n",
1808                                   frame_tables.number),
1809                          frame_tables.number);
1810     }
1811
1812   /* If the scan exposed nothing of special interest, there's no need to
1813      generate the glue code and relink so return now.  */
1814
1815   if (constructors.number == 0 && destructors.number == 0
1816       && frame_tables.number == 0
1817 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1818       /* If we will be running these functions ourselves, we want to emit
1819          stubs into the shared library so that we do not have to relink
1820          dependent programs when we add static objects.  */
1821       && ! shared_obj
1822 #endif
1823       )
1824     {
1825       /* Do tlink without additional code generation now if we didn't
1826          do it earlier for scanning purposes.  */
1827       if (ld1_filter == SCAN_NOTHING)
1828         do_tlink (ld1_argv, object_lst);
1829
1830       if (lto_mode)
1831         maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1832
1833       /* Strip now if it was requested on the command line.  */
1834       if (strip_flag)
1835         {
1836           char **real_strip_argv = XCNEWVEC (char *, 3);
1837           const char ** strip_argv = CONST_CAST2 (const char **, char **,
1838                                                   real_strip_argv);
1839
1840           strip_argv[0] = strip_file_name;
1841           strip_argv[1] = output_file;
1842           strip_argv[2] = (char *) 0;
1843           fork_execute ("strip", real_strip_argv);
1844         }
1845
1846 #ifdef COLLECT_EXPORT_LIST
1847       maybe_unlink (export_file);
1848 #endif
1849       post_ld_pass (false);
1850
1851       maybe_unlink (c_file);
1852       maybe_unlink (o_file);
1853       return 0;
1854     }
1855
1856   /* Sort ctor and dtor lists by priority.  */
1857   sort_ids (&constructors);
1858   sort_ids (&destructors);
1859
1860   maybe_unlink(output_file);
1861   outf = fopen (c_file, "w");
1862   if (outf == (FILE *) 0)
1863     fatal_error ("fopen %s: %m", c_file);
1864
1865   write_c_file (outf, c_file);
1866
1867   if (fclose (outf))
1868     fatal_error ("fclose %s: %m", c_file);
1869
1870   /* Tell the linker that we have initializer and finalizer functions.  */
1871 #ifdef LD_INIT_SWITCH
1872 #ifdef COLLECT_EXPORT_LIST
1873   *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1874 #else
1875   *ld2++ = LD_INIT_SWITCH;
1876   *ld2++ = initname;
1877   *ld2++ = LD_FINI_SWITCH;
1878   *ld2++ = fininame;
1879 #endif
1880 #endif
1881
1882 #ifdef COLLECT_EXPORT_LIST
1883   if (shared_obj)
1884     {
1885       /* If we did not add export flag to link arguments before, add it to
1886          second link phase now.  No new exports should have been added.  */
1887       if (! exports.first)
1888         *ld2++ = concat ("-bE:", export_file, NULL);
1889
1890 #ifndef LD_INIT_SWITCH
1891       add_to_list (&exports, initname);
1892       add_to_list (&exports, fininame);
1893       add_to_list (&exports, "_GLOBAL__DI");
1894       add_to_list (&exports, "_GLOBAL__DD");
1895 #endif
1896       exportf = fopen (export_file, "w");
1897       if (exportf == (FILE *) 0)
1898         fatal_error ("fopen %s: %m", export_file);
1899       write_aix_file (exportf, exports.first);
1900       if (fclose (exportf))
1901         fatal_error ("fclose %s: %m", export_file);
1902     }
1903 #endif
1904
1905   /* End of arguments to second link phase.  */
1906   *ld2 = (char*) 0;
1907
1908   if (debug)
1909     {
1910       fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1911                output_file, c_file);
1912       write_c_file (stderr, "stderr");
1913       fprintf (stderr, "========== end of c_file\n\n");
1914 #ifdef COLLECT_EXPORT_LIST
1915       fprintf (stderr, "\n========== export_file = %s\n", export_file);
1916       write_aix_file (stderr, exports.first);
1917       fprintf (stderr, "========== end of export_file\n\n");
1918 #endif
1919     }
1920
1921   /* Assemble the constructor and destructor tables.
1922      Link the tables in with the rest of the program.  */
1923
1924   fork_execute ("gcc",  c_argv);
1925 #ifdef COLLECT_EXPORT_LIST
1926   /* On AIX we must call tlink because of possible templates resolution.  */
1927   do_tlink (ld2_argv, object_lst);
1928
1929   if (lto_mode)
1930     maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1931 #else
1932   /* Otherwise, simply call ld because tlink is already done.  */
1933   if (lto_mode)
1934     maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1935   else
1936     {
1937       fork_execute ("ld", ld2_argv);
1938       post_ld_pass (false);
1939     }
1940
1941   /* Let scan_prog_file do any final mods (OSF/rose needs this for
1942      constructors/destructors in shared libraries.  */
1943   scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1944 #endif
1945
1946   maybe_unlink (c_file);
1947   maybe_unlink (o_file);
1948
1949 #ifdef COLLECT_EXPORT_LIST
1950   maybe_unlink (export_file);
1951 #endif
1952
1953   return 0;
1954 }
1955
1956 \f
1957 /* Wait for a process to finish, and exit if a nonzero status is found.  */
1958
1959 int
1960 collect_wait (const char *prog, struct pex_obj *pex)
1961 {
1962   int status;
1963
1964   if (!pex_get_status (pex, 1, &status))
1965     fatal_error ("can't get program status: %m");
1966   pex_free (pex);
1967
1968   if (status)
1969     {
1970       if (WIFSIGNALED (status))
1971         {
1972           int sig = WTERMSIG (status);
1973           error ("%s terminated with signal %d [%s]%s",
1974                  prog, sig, strsignal(sig),
1975                  WCOREDUMP(status) ? ", core dumped" : "");
1976           collect_exit (FATAL_EXIT_CODE);
1977         }
1978
1979       if (WIFEXITED (status))
1980         return WEXITSTATUS (status);
1981     }
1982   return 0;
1983 }
1984
1985 static void
1986 do_wait (const char *prog, struct pex_obj *pex)
1987 {
1988   int ret = collect_wait (prog, pex);
1989   if (ret != 0)
1990     {
1991       error ("%s returned %d exit status", prog, ret);
1992       collect_exit (ret);
1993     }
1994
1995   if (response_file)
1996     {
1997       unlink (response_file);
1998       response_file = NULL;
1999     }
2000 }
2001
2002 \f
2003 /* Execute a program, and wait for the reply.  */
2004
2005 struct pex_obj *
2006 collect_execute (const char *prog, char **argv, const char *outname,
2007                  const char *errname, int flags)
2008 {
2009   struct pex_obj *pex;
2010   const char *errmsg;
2011   int err;
2012   char *response_arg = NULL;
2013   char *response_argv[3] ATTRIBUTE_UNUSED;
2014
2015   if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
2016     {
2017       /* If using @file arguments, create a temporary file and put the
2018          contents of argv into it.  Then change argv to an array corresponding
2019          to a single argument @FILE, where FILE is the temporary filename.  */
2020
2021       char **current_argv = argv + 1;
2022       char *argv0 = argv[0];
2023       int status;
2024       FILE *f;
2025
2026       /* Note: we assume argv contains at least one element; this is
2027          checked above.  */
2028
2029       response_file = make_temp_file ("");
2030
2031       f = fopen (response_file, "w");
2032
2033       if (f == NULL)
2034         fatal_error ("could not open response file %s", response_file);
2035
2036       status = writeargv (current_argv, f);
2037
2038       if (status)
2039         fatal_error ("could not write to response file %s", response_file);
2040
2041       status = fclose (f);
2042
2043       if (EOF == status)
2044         fatal_error ("could not close response file %s", response_file);
2045
2046       response_arg = concat ("@", response_file, NULL);
2047       response_argv[0] = argv0;
2048       response_argv[1] = response_arg;
2049       response_argv[2] = NULL;
2050
2051       argv = response_argv;
2052     }
2053
2054   if (vflag || debug)
2055     {
2056       char **p_argv;
2057       const char *str;
2058
2059       if (argv[0])
2060         fprintf (stderr, "%s", argv[0]);
2061       else
2062         notice ("[cannot find %s]", prog);
2063
2064       for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
2065         fprintf (stderr, " %s", str);
2066
2067       fprintf (stderr, "\n");
2068     }
2069
2070   fflush (stdout);
2071   fflush (stderr);
2072
2073   /* If we cannot find a program we need, complain error.  Do this here
2074      since we might not end up needing something that we could not find.  */
2075
2076   if (argv[0] == 0)
2077     fatal_error ("cannot find '%s'", prog);
2078
2079   pex = pex_init (0, "collect2", NULL);
2080   if (pex == NULL)
2081     fatal_error ("pex_init failed: %m");
2082
2083   errmsg = pex_run (pex, flags, argv[0], argv, outname,
2084                     errname, &err);
2085   if (errmsg != NULL)
2086     {
2087       if (err != 0)
2088         {
2089           errno = err;
2090           fatal_error ("%s: %m", _(errmsg));
2091         }
2092       else
2093         fatal_error (errmsg);
2094     }
2095
2096   free (response_arg);
2097
2098   return pex;
2099 }
2100
2101 static void
2102 fork_execute (const char *prog, char **argv)
2103 {
2104   struct pex_obj *pex;
2105
2106   pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
2107   do_wait (prog, pex);
2108 }
2109 \f
2110 /* Unlink a file unless we are debugging.  */
2111
2112 static void
2113 maybe_unlink (const char *file)
2114 {
2115   if (!debug)
2116     unlink_if_ordinary (file);
2117   else
2118     notice ("[Leaving %s]\n", file);
2119 }
2120
2121 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST.  */
2122
2123 static void
2124 maybe_unlink_list (char **file_list)
2125 {
2126   char **tmp = file_list;
2127
2128   while (*tmp)
2129     maybe_unlink (*(tmp++));
2130 }
2131
2132 \f
2133 static long sequence_number = 0;
2134
2135 /* Add a name to a linked list.  */
2136
2137 static void
2138 add_to_list (struct head *head_ptr, const char *name)
2139 {
2140   struct id *newid
2141     = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2142   struct id *p;
2143   strcpy (newid->name, name);
2144
2145   if (head_ptr->first)
2146     head_ptr->last->next = newid;
2147   else
2148     head_ptr->first = newid;
2149
2150   /* Check for duplicate symbols.  */
2151   for (p = head_ptr->first;
2152        strcmp (name, p->name) != 0;
2153        p = p->next)
2154     ;
2155   if (p != newid)
2156     {
2157       head_ptr->last->next = 0;
2158       free (newid);
2159       return;
2160     }
2161
2162   newid->sequence = ++sequence_number;
2163   head_ptr->last = newid;
2164   head_ptr->number++;
2165 }
2166
2167 /* Grab the init priority number from an init function name that
2168    looks like "_GLOBAL_.I.12345.foo".  */
2169
2170 static int
2171 extract_init_priority (const char *name)
2172 {
2173   int pos = 0, pri;
2174
2175   while (name[pos] == '_')
2176     ++pos;
2177   pos += 10; /* strlen ("GLOBAL__X_") */
2178
2179   /* Extract init_p number from ctor/dtor name.  */
2180   pri = atoi (name + pos);
2181   return pri ? pri : DEFAULT_INIT_PRIORITY;
2182 }
2183
2184 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2185    ctors will be run from right to left, dtors from left to right.  */
2186
2187 static void
2188 sort_ids (struct head *head_ptr)
2189 {
2190   /* id holds the current element to insert.  id_next holds the next
2191      element to insert.  id_ptr iterates through the already sorted elements
2192      looking for the place to insert id.  */
2193   struct id *id, *id_next, **id_ptr;
2194
2195   id = head_ptr->first;
2196
2197   /* We don't have any sorted elements yet.  */
2198   head_ptr->first = NULL;
2199
2200   for (; id; id = id_next)
2201     {
2202       id_next = id->next;
2203       id->sequence = extract_init_priority (id->name);
2204
2205       for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2206         if (*id_ptr == NULL
2207             /* If the sequence numbers are the same, we put the id from the
2208                file later on the command line later in the list.  */
2209             || id->sequence > (*id_ptr)->sequence
2210             /* Hack: do lexical compare, too.
2211             || (id->sequence == (*id_ptr)->sequence
2212                 && strcmp (id->name, (*id_ptr)->name) > 0) */
2213             )
2214           {
2215             id->next = *id_ptr;
2216             *id_ptr = id;
2217             break;
2218           }
2219     }
2220
2221   /* Now set the sequence numbers properly so write_c_file works.  */
2222   for (id = head_ptr->first; id; id = id->next)
2223     id->sequence = ++sequence_number;
2224 }
2225
2226 /* Write: `prefix', the names on list LIST, `suffix'.  */
2227
2228 static void
2229 write_list (FILE *stream, const char *prefix, struct id *list)
2230 {
2231   while (list)
2232     {
2233       fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2234       list = list->next;
2235     }
2236 }
2237
2238 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2239 /* Given a STRING, return nonzero if it occurs in the list in range
2240    [ARGS_BEGIN,ARGS_END).  */
2241
2242 static int
2243 is_in_args (const char *string, const char **args_begin,
2244             const char **args_end)
2245 {
2246   const char **args_pointer;
2247   for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
2248     if (strcmp (string, *args_pointer) == 0)
2249       return 1;
2250   return 0;
2251 }
2252 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2253
2254 #ifdef COLLECT_EXPORT_LIST
2255 /* This function is really used only on AIX, but may be useful.  */
2256 #if 0
2257 static int
2258 is_in_list (const char *prefix, struct id *list)
2259 {
2260   while (list)
2261     {
2262       if (!strcmp (prefix, list->name)) return 1;
2263       list = list->next;
2264     }
2265     return 0;
2266 }
2267 #endif
2268 #endif /* COLLECT_EXPORT_LIST */
2269
2270 /* Added for debugging purpose.  */
2271 #ifdef COLLECT_EXPORT_LIST
2272 static void
2273 dump_list (FILE *stream, const char *prefix, struct id *list)
2274 {
2275   while (list)
2276     {
2277       fprintf (stream, "%s%s,\n", prefix, list->name);
2278       list = list->next;
2279     }
2280 }
2281 #endif
2282
2283 #if 0
2284 static void
2285 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2286 {
2287   while (list)
2288     {
2289       fprintf (stream, "%s%s,\n", prefix, list->prefix);
2290       list = list->next;
2291     }
2292 }
2293 #endif
2294
2295 static void
2296 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2297 {
2298   while (list)
2299     {
2300       fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2301                prefix, list->sequence, list->name);
2302       list = list->next;
2303     }
2304 }
2305
2306 /* Write out the constructor and destructor tables statically (for a shared
2307    object), along with the functions to execute them.  */
2308
2309 static void
2310 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2311 {
2312   const char *p, *q;
2313   char *prefix, *r;
2314   int frames = (frame_tables.number > 0);
2315
2316   /* Figure out name of output_file, stripping off .so version.  */
2317   q = p = lbasename (output_file);
2318
2319   while (q)
2320     {
2321       q = strchr (q,'.');
2322       if (q == 0)
2323         {
2324           q = p + strlen (p);
2325           break;
2326         }
2327       else
2328         {
2329           if (filename_ncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2330             {
2331               q += strlen (SHLIB_SUFFIX);
2332               break;
2333             }
2334           else
2335             q++;
2336         }
2337     }
2338   /* q points to null at end of the string (or . of the .so version) */
2339   prefix = XNEWVEC (char, q - p + 1);
2340   strncpy (prefix, p, q - p);
2341   prefix[q - p] = 0;
2342   for (r = prefix; *r; r++)
2343     if (!ISALNUM ((unsigned char)*r))
2344       *r = '_';
2345   if (debug)
2346     notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2347             output_file, prefix);
2348
2349   initname = concat ("_GLOBAL__FI_", prefix, NULL);
2350   fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2351
2352   free (prefix);
2353
2354   /* Write the tables as C code.  */
2355
2356   fprintf (stream, "static int count;\n");
2357   fprintf (stream, "typedef void entry_pt();\n");
2358   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2359
2360   if (frames)
2361     {
2362       write_list_with_asm (stream, "extern void *", frame_tables.first);
2363
2364       fprintf (stream, "\tstatic void *frame_table[] = {\n");
2365       write_list (stream, "\t\t&", frame_tables.first);
2366       fprintf (stream, "\t0\n};\n");
2367
2368       /* This must match what's in frame.h.  */
2369       fprintf (stream, "struct object {\n");
2370       fprintf (stream, "  void *pc_begin;\n");
2371       fprintf (stream, "  void *pc_end;\n");
2372       fprintf (stream, "  void *fde_begin;\n");
2373       fprintf (stream, "  void *fde_array;\n");
2374       fprintf (stream, "  __SIZE_TYPE__ count;\n");
2375       fprintf (stream, "  struct object *next;\n");
2376       fprintf (stream, "};\n");
2377
2378       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2379       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2380
2381       fprintf (stream, "static void reg_frame () {\n");
2382       fprintf (stream, "\tstatic struct object ob;\n");
2383       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2384       fprintf (stream, "\t}\n");
2385
2386       fprintf (stream, "static void dereg_frame () {\n");
2387       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2388       fprintf (stream, "\t}\n");
2389     }
2390
2391   fprintf (stream, "void %s() {\n", initname);
2392   if (constructors.number > 0 || frames)
2393     {
2394       fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2395       write_list (stream, "\t\t", constructors.first);
2396       if (frames)
2397         fprintf (stream, "\treg_frame,\n");
2398       fprintf (stream, "\t};\n");
2399       fprintf (stream, "\tentry_pt **p;\n");
2400       fprintf (stream, "\tif (count++ != 0) return;\n");
2401       fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2402       fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2403     }
2404   else
2405     fprintf (stream, "\t++count;\n");
2406   fprintf (stream, "}\n");
2407   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2408   fprintf (stream, "void %s() {\n", fininame);
2409   if (destructors.number > 0 || frames)
2410     {
2411       fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2412       write_list (stream, "\t\t", destructors.first);
2413       if (frames)
2414         fprintf (stream, "\tdereg_frame,\n");
2415       fprintf (stream, "\t};\n");
2416       fprintf (stream, "\tentry_pt **p;\n");
2417       fprintf (stream, "\tif (--count != 0) return;\n");
2418       fprintf (stream, "\tp = dtors;\n");
2419       fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2420                destructors.number + frames);
2421     }
2422   fprintf (stream, "}\n");
2423
2424   if (shared_obj)
2425     {
2426       COLLECT_SHARED_INIT_FUNC(stream, initname);
2427       COLLECT_SHARED_FINI_FUNC(stream, fininame);
2428     }
2429 }
2430
2431 /* Write the constructor/destructor tables.  */
2432
2433 #ifndef LD_INIT_SWITCH
2434 static void
2435 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2436 {
2437   /* Write the tables as C code.  */
2438
2439   int frames = (frame_tables.number > 0);
2440
2441   fprintf (stream, "typedef void entry_pt();\n\n");
2442
2443   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2444
2445   if (frames)
2446     {
2447       write_list_with_asm (stream, "extern void *", frame_tables.first);
2448
2449       fprintf (stream, "\tstatic void *frame_table[] = {\n");
2450       write_list (stream, "\t\t&", frame_tables.first);
2451       fprintf (stream, "\t0\n};\n");
2452
2453       /* This must match what's in frame.h.  */
2454       fprintf (stream, "struct object {\n");
2455       fprintf (stream, "  void *pc_begin;\n");
2456       fprintf (stream, "  void *pc_end;\n");
2457       fprintf (stream, "  void *fde_begin;\n");
2458       fprintf (stream, "  void *fde_array;\n");
2459       fprintf (stream, "  __SIZE_TYPE__ count;\n");
2460       fprintf (stream, "  struct object *next;\n");
2461       fprintf (stream, "};\n");
2462
2463       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2464       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2465
2466       fprintf (stream, "static void reg_frame () {\n");
2467       fprintf (stream, "\tstatic struct object ob;\n");
2468       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2469       fprintf (stream, "\t}\n");
2470
2471       fprintf (stream, "static void dereg_frame () {\n");
2472       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2473       fprintf (stream, "\t}\n");
2474     }
2475
2476   fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2477   fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2478   write_list (stream, "\t", constructors.first);
2479   if (frames)
2480     fprintf (stream, "\treg_frame,\n");
2481   fprintf (stream, "\t0\n};\n\n");
2482
2483   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2484
2485   fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2486   fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2487   write_list (stream, "\t", destructors.first);
2488   if (frames)
2489     fprintf (stream, "\tdereg_frame,\n");
2490   fprintf (stream, "\t0\n};\n\n");
2491
2492   fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2493   fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2494 }
2495 #endif /* ! LD_INIT_SWITCH */
2496
2497 static void
2498 write_c_file (FILE *stream, const char *name)
2499 {
2500 #ifndef LD_INIT_SWITCH
2501   if (! shared_obj)
2502     write_c_file_glob (stream, name);
2503   else
2504 #endif
2505     write_c_file_stat (stream, name);
2506 }
2507
2508 #ifdef COLLECT_EXPORT_LIST
2509 static void
2510 write_aix_file (FILE *stream, struct id *list)
2511 {
2512   for (; list; list = list->next)
2513     {
2514       fputs (list->name, stream);
2515       putc ('\n', stream);
2516     }
2517 }
2518 #endif
2519 \f
2520 #ifdef OBJECT_FORMAT_NONE
2521
2522 /* Check to make sure the file is an LTO object file.  */
2523
2524 static bool
2525 maybe_lto_object_file (const char *prog_name)
2526 {
2527   FILE *f;
2528   unsigned char buf[4];
2529   int i;
2530
2531   static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' };
2532   static unsigned char coffmagic[2] = { 0x4c, 0x01 };
2533   static unsigned char coffmagic_x64[2] = { 0x64, 0x86 };
2534   static unsigned char machomagic[4][4] = {
2535     { 0xcf, 0xfa, 0xed, 0xfe },
2536     { 0xce, 0xfa, 0xed, 0xfe },
2537     { 0xfe, 0xed, 0xfa, 0xcf },
2538     { 0xfe, 0xed, 0xfa, 0xce }
2539   };
2540
2541   f = fopen (prog_name, "rb");
2542   if (f == NULL)
2543     return false;
2544   if (fread (buf, sizeof (buf), 1, f) != 1)
2545     buf[0] = 0;
2546   fclose (f);
2547
2548   if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0
2549       || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0
2550       || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0)
2551     return true;
2552   for (i = 0; i < 4; i++)
2553     if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0)
2554       return true;
2555
2556   return false;
2557 }
2558
2559 /* Generic version to scan the name list of the loaded program for
2560    the symbols g++ uses for static constructors and destructors.  */
2561
2562 static void
2563 scan_prog_file (const char *prog_name, scanpass which_pass,
2564                 scanfilter filter)
2565 {
2566   void (*int_handler) (int);
2567 #ifdef SIGQUIT
2568   void (*quit_handler) (int);
2569 #endif
2570   char *real_nm_argv[4];
2571   const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2572   int argc = 0;
2573   struct pex_obj *pex;
2574   const char *errmsg;
2575   int err;
2576   char *p, buf[1024];
2577   FILE *inf;
2578   int found_lto = 0;
2579
2580   if (which_pass == PASS_SECOND)
2581     return;
2582
2583   /* LTO objects must be in a known format.  This check prevents
2584      us from accepting an archive containing LTO objects, which
2585      gcc cannnot currently handle.  */
2586   if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
2587     return;
2588
2589   /* If we do not have an `nm', complain.  */
2590   if (nm_file_name == 0)
2591     fatal_error ("cannot find 'nm'");
2592
2593   nm_argv[argc++] = nm_file_name;
2594   if (NM_FLAGS[0] != '\0')
2595     nm_argv[argc++] = NM_FLAGS;
2596
2597   nm_argv[argc++] = prog_name;
2598   nm_argv[argc++] = (char *) 0;
2599
2600   /* Trace if needed.  */
2601   if (vflag)
2602     {
2603       const char **p_argv;
2604       const char *str;
2605
2606       for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2607         fprintf (stderr, " %s", str);
2608
2609       fprintf (stderr, "\n");
2610     }
2611
2612   fflush (stdout);
2613   fflush (stderr);
2614
2615   pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2616   if (pex == NULL)
2617     fatal_error ("pex_init failed: %m");
2618
2619   errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2620                     &err);
2621   if (errmsg != NULL)
2622     {
2623       if (err != 0)
2624         {
2625           errno = err;
2626           fatal_error ("%s: %m", _(errmsg));
2627         }
2628       else
2629         fatal_error (errmsg);
2630     }
2631
2632   int_handler  = (void (*) (int)) signal (SIGINT,  SIG_IGN);
2633 #ifdef SIGQUIT
2634   quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2635 #endif
2636
2637   inf = pex_read_output (pex, 0);
2638   if (inf == NULL)
2639     fatal_error ("can't open nm output: %m");
2640
2641   if (debug)
2642     {
2643       if (which_pass == PASS_LTOINFO)
2644         fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2645       else
2646         fprintf (stderr, "\nnm output with constructors/destructors.\n");
2647     }
2648
2649   /* Read each line of nm output.  */
2650   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2651     {
2652       int ch, ch2;
2653       char *name, *end;
2654
2655       if (debug)
2656         fprintf (stderr, "\t%s\n", buf);
2657
2658       if (which_pass == PASS_LTOINFO)
2659         {
2660           if (found_lto)
2661             continue;
2662
2663           /* Look for the LTO info marker symbol, and add filename to
2664              the LTO objects list if found.  */
2665           for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2666             if (ch == ' '  && p[1] == '_' && p[2] == '_'
2667                 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2668                 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2669               {
2670                 add_lto_object (&lto_objects, prog_name);
2671
2672                 /* We need to read all the input, so we can't just
2673                    return here.  But we can avoid useless work.  */
2674                 found_lto = 1;
2675
2676                 break;
2677               }
2678
2679           continue;
2680         }
2681
2682       /* If it contains a constructor or destructor name, add the name
2683          to the appropriate list unless this is a kind of symbol we're
2684          not supposed to even consider.  */
2685
2686       for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2687         if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2688           break;
2689
2690       if (ch != '_')
2691         continue;
2692
2693       name = p;
2694       /* Find the end of the symbol name.
2695          Do not include `|', because Encore nm can tack that on the end.  */
2696       for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2697            end++)
2698         continue;
2699
2700
2701       *end = '\0';
2702       switch (is_ctor_dtor (name))
2703         {
2704         case SYM_CTOR:
2705           if (! (filter & SCAN_CTOR))
2706             break;
2707           if (which_pass != PASS_LIB)
2708             add_to_list (&constructors, name);
2709           break;
2710
2711         case SYM_DTOR:
2712           if (! (filter & SCAN_DTOR))
2713             break;
2714           if (which_pass != PASS_LIB)
2715             add_to_list (&destructors, name);
2716           break;
2717
2718         case SYM_INIT:
2719           if (! (filter & SCAN_INIT))
2720             break;
2721           if (which_pass != PASS_LIB)
2722             fatal_error ("init function found in object %s", prog_name);
2723 #ifndef LD_INIT_SWITCH
2724           add_to_list (&constructors, name);
2725 #endif
2726           break;
2727
2728         case SYM_FINI:
2729           if (! (filter & SCAN_FINI))
2730             break;
2731           if (which_pass != PASS_LIB)
2732             fatal_error ("fini function found in object %s", prog_name);
2733 #ifndef LD_FINI_SWITCH
2734           add_to_list (&destructors, name);
2735 #endif
2736           break;
2737
2738         case SYM_DWEH:
2739           if (! (filter & SCAN_DWEH))
2740             break;
2741           if (which_pass != PASS_LIB)
2742             add_to_list (&frame_tables, name);
2743           break;
2744
2745         default:                /* not a constructor or destructor */
2746           continue;
2747         }
2748     }
2749
2750   if (debug)
2751     fprintf (stderr, "\n");
2752
2753   do_wait (nm_file_name, pex);
2754
2755   signal (SIGINT,  int_handler);
2756 #ifdef SIGQUIT
2757   signal (SIGQUIT, quit_handler);
2758 #endif
2759 }
2760
2761 #ifdef LDD_SUFFIX
2762
2763 /* Use the List Dynamic Dependencies program to find shared libraries that
2764    the output file depends upon and their initialization/finalization
2765    routines, if any.  */
2766
2767 static void
2768 scan_libraries (const char *prog_name)
2769 {
2770   static struct head libraries;         /* list of shared libraries found */
2771   struct id *list;
2772   void (*int_handler) (int);
2773 #ifdef SIGQUIT
2774   void (*quit_handler) (int);
2775 #endif
2776   char *real_ldd_argv[4];
2777   const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2778   int argc = 0;
2779   struct pex_obj *pex;
2780   const char *errmsg;
2781   int err;
2782   char buf[1024];
2783   FILE *inf;
2784
2785   /* If we do not have an `ldd', complain.  */
2786   if (ldd_file_name == 0)
2787     {
2788       error ("cannot find 'ldd'");
2789       return;
2790     }
2791
2792   ldd_argv[argc++] = ldd_file_name;
2793   ldd_argv[argc++] = prog_name;
2794   ldd_argv[argc++] = (char *) 0;
2795
2796   /* Trace if needed.  */
2797   if (vflag)
2798     {
2799       const char **p_argv;
2800       const char *str;
2801
2802       for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2803         fprintf (stderr, " %s", str);
2804
2805       fprintf (stderr, "\n");
2806     }
2807
2808   fflush (stdout);
2809   fflush (stderr);
2810
2811   pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2812   if (pex == NULL)
2813     fatal_error ("pex_init failed: %m");
2814
2815   errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2816   if (errmsg != NULL)
2817     {
2818       if (err != 0)
2819         {
2820           errno = err;
2821           fatal_error ("%s: %m", _(errmsg));
2822         }
2823       else
2824         fatal_error (errmsg);
2825     }
2826
2827   int_handler  = (void (*) (int)) signal (SIGINT,  SIG_IGN);
2828 #ifdef SIGQUIT
2829   quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2830 #endif
2831
2832   inf = pex_read_output (pex, 0);
2833   if (inf == NULL)
2834     fatal_error ("can't open ldd output: %m");
2835
2836   if (debug)
2837     notice ("\nldd output with constructors/destructors.\n");
2838
2839   /* Read each line of ldd output.  */
2840   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2841     {
2842       int ch2;
2843       char *name, *end, *p = buf;
2844
2845       /* Extract names of libraries and add to list.  */
2846       PARSE_LDD_OUTPUT (p);
2847       if (p == 0)
2848         continue;
2849
2850       name = p;
2851       if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2852         fatal_error ("dynamic dependency %s not found", buf);
2853
2854       /* Find the end of the symbol name.  */
2855       for (end = p;
2856            (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2857            end++)
2858         continue;
2859       *end = '\0';
2860
2861       if (access (name, R_OK) == 0)
2862         add_to_list (&libraries, name);
2863       else
2864         fatal_error ("unable to open dynamic dependency '%s'", buf);
2865
2866       if (debug)
2867         fprintf (stderr, "\t%s\n", buf);
2868     }
2869   if (debug)
2870     fprintf (stderr, "\n");
2871
2872   do_wait (ldd_file_name, pex);
2873
2874   signal (SIGINT,  int_handler);
2875 #ifdef SIGQUIT
2876   signal (SIGQUIT, quit_handler);
2877 #endif
2878
2879   /* Now iterate through the library list adding their symbols to
2880      the list.  */
2881   for (list = libraries.first; list; list = list->next)
2882     scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2883 }
2884
2885 #endif /* LDD_SUFFIX */
2886
2887 #endif /* OBJECT_FORMAT_NONE */
2888
2889 \f
2890 /*
2891  * COFF specific stuff.
2892  */
2893
2894 #ifdef OBJECT_FORMAT_COFF
2895
2896 #if defined (EXTENDED_COFF)
2897
2898 #   define GCC_SYMBOLS(X)       (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2899 #   define GCC_SYMENT           SYMR
2900 #   define GCC_OK_SYMBOL(X)     ((X).st == stProc || (X).st == stGlobal)
2901 #   define GCC_SYMINC(X)        (1)
2902 #   define GCC_SYMZERO(X)       (SYMHEADER(X).isymMax)
2903 #   define GCC_CHECK_HDR(X)     (PSYMTAB(X) != 0)
2904
2905 #else
2906
2907 #   define GCC_SYMBOLS(X)       (HEADER(ldptr).f_nsyms)
2908 #   define GCC_SYMENT           SYMENT
2909 #   if defined (C_WEAKEXT)
2910 #     define GCC_OK_SYMBOL(X) \
2911        (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2912         ((X).n_scnum > N_UNDEF) && \
2913         (aix64_flag \
2914          || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2915              || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2916 #     define GCC_UNDEF_SYMBOL(X) \
2917        (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2918         ((X).n_scnum == N_UNDEF))
2919 #   else
2920 #     define GCC_OK_SYMBOL(X) \
2921        (((X).n_sclass == C_EXT) && \
2922         ((X).n_scnum > N_UNDEF) && \
2923         (aix64_flag \
2924          || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2925              || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2926 #     define GCC_UNDEF_SYMBOL(X) \
2927        (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2928 #   endif
2929 #   define GCC_SYMINC(X)        ((X).n_numaux+1)
2930 #   define GCC_SYMZERO(X)       0
2931
2932 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2933 #if TARGET_AIX_VERSION >= 51
2934 #   define GCC_CHECK_HDR(X) \
2935      (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2936        || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2937       && !(HEADER (X).f_flags & F_LOADONLY))
2938 #else
2939 #   define GCC_CHECK_HDR(X) \
2940      (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2941        || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2942       && !(HEADER (X).f_flags & F_LOADONLY))
2943 #endif
2944
2945 #endif
2946
2947 #ifdef COLLECT_EXPORT_LIST
2948 /* Array of standard AIX libraries which should not
2949    be scanned for ctors/dtors.  */
2950 static const char *const aix_std_libs[] = {
2951   "/unix",
2952   "/lib/libc.a",
2953   "/lib/libm.a",
2954   "/lib/libc_r.a",
2955   "/lib/libm_r.a",
2956   "/usr/lib/libc.a",
2957   "/usr/lib/libm.a",
2958   "/usr/lib/libc_r.a",
2959   "/usr/lib/libm_r.a",
2960   "/usr/lib/threads/libc.a",
2961   "/usr/ccs/lib/libc.a",
2962   "/usr/ccs/lib/libm.a",
2963   "/usr/ccs/lib/libc_r.a",
2964   "/usr/ccs/lib/libm_r.a",
2965   NULL
2966 };
2967
2968 /* This function checks the filename and returns 1
2969    if this name matches the location of a standard AIX library.  */
2970 static int ignore_library (const char *);
2971 static int
2972 ignore_library (const char *name)
2973 {
2974   const char *const *p;
2975   size_t length;
2976
2977   if (target_system_root[0] != '\0')
2978     {
2979       length = strlen (target_system_root);
2980       if (strncmp (name, target_system_root, length) != 0)
2981         return 0;
2982       name += length;
2983     }
2984   for (p = &aix_std_libs[0]; *p != NULL; ++p)
2985     if (strcmp (name, *p) == 0)
2986       return 1;
2987   return 0;
2988 }
2989 #endif /* COLLECT_EXPORT_LIST */
2990
2991 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2992 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2993 #endif
2994
2995 /* COFF version to scan the name list of the loaded program for
2996    the symbols g++ uses for static constructors and destructors.  */
2997
2998 static void
2999 scan_prog_file (const char *prog_name, scanpass which_pass,
3000                 scanfilter filter)
3001 {
3002   LDFILE *ldptr = NULL;
3003   int sym_index, sym_count;
3004   int is_shared = 0;
3005
3006   if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
3007     return;
3008
3009 #ifdef COLLECT_EXPORT_LIST
3010   /* We do not need scanning for some standard C libraries.  */
3011   if (which_pass == PASS_FIRST && ignore_library (prog_name))
3012     return;
3013
3014   /* On AIX we have a loop, because there is not much difference
3015      between an object and an archive. This trick allows us to
3016      eliminate scan_libraries() function.  */
3017   do
3018     {
3019 #endif
3020       /* Some platforms (e.g. OSF4) declare ldopen as taking a
3021          non-const char * filename parameter, even though it will not
3022          modify that string.  So we must cast away const-ness here,
3023          using CONST_CAST to prevent complaints from -Wcast-qual.  */
3024       if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
3025         {
3026           if (! MY_ISCOFF (HEADER (ldptr).f_magic))
3027             fatal_error ("%s: not a COFF file", prog_name);
3028
3029           if (GCC_CHECK_HDR (ldptr))
3030             {
3031               sym_count = GCC_SYMBOLS (ldptr);
3032               sym_index = GCC_SYMZERO (ldptr);
3033
3034 #ifdef COLLECT_EXPORT_LIST
3035               /* Is current archive member a shared object?  */
3036               is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
3037 #endif
3038
3039               while (sym_index < sym_count)
3040                 {
3041                   GCC_SYMENT symbol;
3042
3043                   if (ldtbread (ldptr, sym_index, &symbol) <= 0)
3044                     break;
3045                   sym_index += GCC_SYMINC (symbol);
3046
3047                   if (GCC_OK_SYMBOL (symbol))
3048                     {
3049                       char *name;
3050
3051                       if ((name = ldgetname (ldptr, &symbol)) == NULL)
3052                         continue;               /* Should never happen.  */
3053
3054 #ifdef XCOFF_DEBUGGING_INFO
3055                       /* All AIX function names have a duplicate entry
3056                          beginning with a dot.  */
3057                       if (*name == '.')
3058                         ++name;
3059 #endif
3060
3061                       switch (is_ctor_dtor (name))
3062                         {
3063                         case SYM_CTOR:
3064                           if (! (filter & SCAN_CTOR))
3065                             break;
3066                           if (! is_shared)
3067                             add_to_list (&constructors, name);
3068 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3069                           if (which_pass == PASS_OBJ)
3070                             add_to_list (&exports, name);
3071 #endif
3072                           break;
3073
3074                         case SYM_DTOR:
3075                           if (! (filter & SCAN_DTOR))
3076                             break;
3077                           if (! is_shared)
3078                             add_to_list (&destructors, name);
3079 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3080                           if (which_pass == PASS_OBJ)
3081                             add_to_list (&exports, name);
3082 #endif
3083                           break;
3084
3085 #ifdef COLLECT_EXPORT_LIST
3086                         case SYM_INIT:
3087                           if (! (filter & SCAN_INIT))
3088                             break;
3089 #ifndef LD_INIT_SWITCH
3090                           if (is_shared)
3091                             add_to_list (&constructors, name);
3092 #endif
3093                           break;
3094
3095                         case SYM_FINI:
3096                           if (! (filter & SCAN_FINI))
3097                             break;
3098 #ifndef LD_INIT_SWITCH
3099                           if (is_shared)
3100                             add_to_list (&destructors, name);
3101 #endif
3102                           break;
3103 #endif
3104
3105                         case SYM_DWEH:
3106                           if (! (filter & SCAN_DWEH))
3107                             break;
3108                           if (! is_shared)
3109                             add_to_list (&frame_tables, name);
3110 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3111                           if (which_pass == PASS_OBJ)
3112                             add_to_list (&exports, name);
3113 #endif
3114                           break;
3115
3116                         default:        /* not a constructor or destructor */
3117 #ifdef COLLECT_EXPORT_LIST
3118                           /* Explicitly export all global symbols when
3119                              building a shared object on AIX, but do not
3120                              re-export symbols from another shared object
3121                              and do not export symbols if the user
3122                              provides an explicit export list.  */
3123                           if (shared_obj && !is_shared
3124                               && which_pass == PASS_OBJ && !export_flag)
3125                             add_to_list (&exports, name);
3126 #endif
3127                           continue;
3128                         }
3129
3130                       if (debug)
3131 #if !defined(EXTENDED_COFF)
3132                         fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3133                                  symbol.n_scnum, symbol.n_sclass,
3134                                  (symbol.n_type ? "0" : ""), symbol.n_type,
3135                                  name);
3136 #else
3137                         fprintf (stderr,
3138                                  "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3139                                  symbol.iss, (long) symbol.value, symbol.index, name);
3140 #endif
3141                     }
3142                 }
3143             }
3144 #ifdef COLLECT_EXPORT_LIST
3145           else
3146             {
3147               /* If archive contains both 32-bit and 64-bit objects,
3148                  we want to skip objects in other mode so mismatch normal.  */
3149               if (debug)
3150                 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3151                          prog_name, HEADER (ldptr).f_magic, aix64_flag);
3152             }
3153 #endif
3154         }
3155       else
3156         {
3157           fatal_error ("%s: cannot open as COFF file", prog_name);
3158         }
3159 #ifdef COLLECT_EXPORT_LIST
3160       /* On AIX loop continues while there are more members in archive.  */
3161     }
3162   while (ldclose (ldptr) == FAILURE);
3163 #else
3164   /* Otherwise we simply close ldptr.  */
3165   (void) ldclose(ldptr);
3166 #endif
3167 }
3168 #endif /* OBJECT_FORMAT_COFF */
3169
3170 #ifdef COLLECT_EXPORT_LIST
3171 /* Given a library name without "lib" prefix, this function
3172    returns a full library name including a path.  */
3173 static char *
3174 resolve_lib_name (const char *name)
3175 {
3176   char *lib_buf;
3177   int i, j, l = 0;
3178   /* Library extensions for AIX dynamic linking.  */
3179   const char * const libexts[2] = {"a", "so"};
3180
3181   for (i = 0; libpaths[i]; i++)
3182     if (libpaths[i]->max_len > l)
3183       l = libpaths[i]->max_len;
3184
3185   lib_buf = XNEWVEC (char, l + strlen(name) + 10);
3186
3187   for (i = 0; libpaths[i]; i++)
3188     {
3189       struct prefix_list *list = libpaths[i]->plist;
3190       for (; list; list = list->next)
3191         {
3192           /* The following lines are needed because path_prefix list
3193              may contain directories both with trailing DIR_SEPARATOR and
3194              without it.  */
3195           const char *p = "";
3196           if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1]))
3197             p = "/";
3198           for (j = 0; j < 2; j++)
3199             {
3200               sprintf (lib_buf, "%s%slib%s.%s",
3201                        list->prefix, p, name,
3202                        libexts[(j + aixrtl_flag) % 2]);
3203               if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3204               if (file_exists (lib_buf))
3205                 {
3206                   if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3207                   return (lib_buf);
3208                 }
3209             }
3210         }
3211     }
3212   if (debug)
3213     fprintf (stderr, "not found\n");
3214   else
3215     fatal_error ("library lib%s not found", name);
3216   return (NULL);
3217 }
3218 #endif /* COLLECT_EXPORT_LIST */
3219
3220 #ifdef COLLECT_RUN_DSYMUTIL
3221 static int flag_dsym = false;
3222 static int flag_idsym = false;
3223
3224 static void
3225 process_args (int *argcp, char **argv) {
3226   int i, j;
3227   int argc = *argcp;
3228   for (i=0; i<argc; ++i)
3229     {
3230       if (strcmp (argv[i], "-dsym") == 0)
3231         {
3232           flag_dsym = true;
3233           /* Remove the flag, as we handle all processing for it.  */
3234           j = i;
3235           do
3236             argv[j] = argv[j+1];
3237           while (++j < argc);
3238           --i;
3239           argc = --(*argcp);
3240         }
3241       else if (strcmp (argv[i], "-idsym") == 0)
3242         {
3243           flag_idsym = true;
3244           /* Remove the flag, as we handle all processing for it.  */
3245           j = i;
3246           do
3247             argv[j] = argv[j+1];
3248           while (++j < argc);
3249           --i;
3250           argc = --(*argcp);
3251         }
3252     }
3253 }
3254
3255 static void
3256 do_dsymutil (const char *output_file) {
3257   const char *dsymutil = DSYMUTIL + 1;
3258   struct pex_obj *pex;
3259   char **real_argv = XCNEWVEC (char *, 3);
3260   const char ** argv = CONST_CAST2 (const char **, char **,
3261                                     real_argv);
3262
3263   argv[0] = dsymutil;
3264   argv[1] = output_file;
3265   argv[2] = (char *) 0;
3266
3267   pex = collect_execute (dsymutil, real_argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
3268   do_wait (dsymutil, pex);
3269 }
3270
3271 static void
3272 post_ld_pass (bool temp_file) {
3273   if (!(temp_file && flag_idsym) && !flag_dsym)
3274     return;
3275       
3276   do_dsymutil (output_file);
3277 }
3278 #else
3279 static void
3280 process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }
3281 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }
3282 #endif