OSDN Git Service

92ef7ba024e45d7c0b085b743e055b80d1204fc9
[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 = object - (const char **)object_lst;
1485                           add_max = (add_max == 0) ? 16 : add_max * 2;
1486                           object_lst = XRESIZEVEC (char *, object_lst,
1487                                                    object_nbr + add_max);
1488                           object = (const char **) object_lst + pos;
1489                           object_nbr += add_max;
1490                         }
1491                       *object++ = xstrdup (buf);
1492                       add_nbr++;
1493                     }
1494                   fclose (stream);
1495                 }
1496 #endif
1497               break;
1498
1499             case 'l':
1500               if (first_file)
1501                 {
1502                   /* place o_file BEFORE this argument! */
1503                   first_file = 0;
1504                   ld2--;
1505                   *ld2++ = o_file;
1506                   *ld2++ = arg;
1507                 }
1508 #ifdef COLLECT_EXPORT_LIST
1509               {
1510                 /* Resolving full library name.  */
1511                 const char *s = resolve_lib_name (arg+2);
1512
1513                 /* Saving a full library name.  */
1514                 add_to_list (&libs, s);
1515               }
1516 #endif
1517               break;
1518
1519 #ifdef COLLECT_EXPORT_LIST
1520             /* Saving directories where to search for libraries.  */
1521             case 'L':
1522               add_prefix (&cmdline_lib_dirs, arg+2);
1523               break;
1524 #else
1525 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1526             case 'L':
1527               if (is_in_args (arg,
1528                               CONST_CAST2 (const char **, char **, ld1_argv),
1529                               ld1 - 1))
1530                 --ld1;
1531               break;
1532 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1533 #endif
1534
1535             case 'o':
1536               if (arg[2] == '\0')
1537                 output_file = *ld1++ = *ld2++ = *++argv;
1538               else
1539                 output_file = &arg[2];
1540               break;
1541
1542             case 'r':
1543               if (arg[2] == '\0')
1544                 rflag = 1;
1545               break;
1546
1547             case 's':
1548               if (arg[2] == '\0' && do_collecting)
1549                 {
1550                   /* We must strip after the nm run, otherwise C++ linking
1551                      will not work.  Thus we strip in the second ld run, or
1552                      else with strip if there is no second ld run.  */
1553                   strip_flag = 1;
1554                   ld1--;
1555                 }
1556               break;
1557
1558             case 'v':
1559               if (arg[2] == '\0')
1560                 vflag = true;
1561               break;
1562
1563             case '-':
1564               if (strcmp (arg, "--no-demangle") == 0)
1565                 {
1566 #ifndef HAVE_LD_DEMANGLE
1567                   no_demangle = 1;
1568                   ld1--;
1569                   ld2--;
1570 #endif
1571                 }
1572               else if (strncmp (arg, "--demangle", 10) == 0)
1573                 {
1574 #ifndef HAVE_LD_DEMANGLE
1575                   no_demangle = 0;
1576                   if (arg[10] == '=')
1577                     {
1578                       enum demangling_styles style
1579                         = cplus_demangle_name_to_style (arg+11);
1580                       if (style == unknown_demangling)
1581                         error ("unknown demangling style '%s'", arg+11);
1582                       else
1583                         current_demangling_style = style;
1584                     }
1585                   ld1--;
1586                   ld2--;
1587 #endif
1588                 }
1589               else if (strncmp (arg, "--sysroot=", 10) == 0)
1590                 target_system_root = arg + 10;
1591               else if (strcmp (arg, "--version") == 0)
1592                 vflag = true;
1593               else if (strcmp (arg, "--help") == 0)
1594                 helpflag = true;
1595               break;
1596             }
1597         }
1598       else if ((p = strrchr (arg, '.')) != (char *) 0
1599                && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1600                    || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1601                    || strcmp (p, ".obj") == 0))
1602         {
1603           if (first_file)
1604             {
1605               first_file = 0;
1606               if (p[1] == 'o')
1607                 *ld2++ = o_file;
1608               else
1609                 {
1610                   /* place o_file BEFORE this argument! */
1611                   ld2--;
1612                   *ld2++ = o_file;
1613                   *ld2++ = arg;
1614                 }
1615             }
1616           if (p[1] == 'o' || p[1] == 'l')
1617             *object++ = arg;
1618 #ifdef COLLECT_EXPORT_LIST
1619           /* libraries can be specified directly, i.e. without -l flag.  */
1620           else
1621             {
1622               /* Saving a full library name.  */
1623               add_to_list (&libs, arg);
1624             }
1625 #endif
1626         }
1627     }
1628
1629 #ifdef COLLECT_EXPORT_LIST
1630   /* This is added only for debugging purposes.  */
1631   if (debug)
1632     {
1633       fprintf (stderr, "List of libraries:\n");
1634       dump_list (stderr, "\t", libs.first);
1635     }
1636
1637   /* The AIX linker will discard static constructors in object files if
1638      nothing else in the file is referenced, so look at them first.  Unless
1639      we are building a shared object, ignore the eh frame tables, as we
1640      would otherwise reference them all, hence drag all the corresponding
1641      objects even if nothing else is referenced.  */
1642   {
1643     const char **export_object_lst
1644       = CONST_CAST2 (const char **, char **, object_lst);
1645
1646     struct id *list = libs.first;
1647
1648     /* Compute the filter to use from the current one, do scan, then adjust
1649        the "current" filter to remove what we just included here.  This will
1650        control whether we need a first pass link later on or not, and what
1651        will remain to be scanned there.  */
1652
1653     scanfilter this_filter = ld1_filter;
1654 #if HAVE_AS_REF
1655     if (!shared_obj)
1656       this_filter &= ~SCAN_DWEH;
1657 #endif
1658
1659     while (export_object_lst < object)
1660       scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1661
1662     for (; list; list = list->next)
1663       scan_prog_file (list->name, PASS_FIRST, this_filter);
1664
1665     ld1_filter = ld1_filter & ~this_filter;
1666   }
1667
1668   if (exports.first)
1669     {
1670       char *buf = concat ("-bE:", export_file, NULL);
1671
1672       *ld1++ = buf;
1673       *ld2++ = buf;
1674
1675       exportf = fopen (export_file, "w");
1676       if (exportf == (FILE *) 0)
1677         fatal_error ("fopen %s: %m", export_file);
1678       write_aix_file (exportf, exports.first);
1679       if (fclose (exportf))
1680         fatal_error ("fclose %s: %m", export_file);
1681     }
1682 #endif
1683
1684   *c_ptr++ = c_file;
1685   *c_ptr = *ld1 = *object = (char *) 0;
1686
1687   if (vflag)
1688     notice ("collect2 version %s\n", version_string);
1689
1690   if (helpflag)
1691     {
1692       printf ("Usage: collect2 [options]\n");
1693       printf (" Wrap linker and generate constructor code if needed.\n");
1694       printf (" Options:\n");
1695       printf ("  -debug          Enable debug output\n");
1696       printf ("  --help          Display this information\n");
1697       printf ("  -v, --version   Display this program's version number\n");
1698       printf ("\n");
1699       printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1700       printf ("Report bugs: %s\n", bug_report_url);
1701       printf ("\n");
1702     }
1703
1704   if (debug)
1705     {
1706       const char *ptr;
1707       fprintf (stderr, "ld_file_name        = %s\n",
1708                (ld_file_name ? ld_file_name : "not found"));
1709       fprintf (stderr, "c_file_name         = %s\n",
1710                (c_file_name ? c_file_name : "not found"));
1711       fprintf (stderr, "nm_file_name        = %s\n",
1712                (nm_file_name ? nm_file_name : "not found"));
1713 #ifdef LDD_SUFFIX
1714       fprintf (stderr, "ldd_file_name       = %s\n",
1715                (ldd_file_name ? ldd_file_name : "not found"));
1716 #endif
1717       fprintf (stderr, "strip_file_name     = %s\n",
1718                (strip_file_name ? strip_file_name : "not found"));
1719       fprintf (stderr, "c_file              = %s\n",
1720                (c_file ? c_file : "not found"));
1721       fprintf (stderr, "o_file              = %s\n",
1722                (o_file ? o_file : "not found"));
1723
1724       ptr = getenv ("COLLECT_GCC_OPTIONS");
1725       if (ptr)
1726         fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1727
1728       ptr = getenv ("COLLECT_GCC");
1729       if (ptr)
1730         fprintf (stderr, "COLLECT_GCC         = %s\n", ptr);
1731
1732       ptr = getenv ("COMPILER_PATH");
1733       if (ptr)
1734         fprintf (stderr, "COMPILER_PATH       = %s\n", ptr);
1735
1736       ptr = getenv (LIBRARY_PATH_ENV);
1737       if (ptr)
1738         fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1739
1740       fprintf (stderr, "\n");
1741     }
1742
1743   /* Load the program, searching all libraries and attempting to provide
1744      undefined symbols from repository information.
1745
1746      If -r or they will be run via some other method, do not build the
1747      constructor or destructor list, just return now.  */
1748   {
1749     bool early_exit
1750       = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1751
1752     /* Perform the first pass link now, if we're about to exit or if we need
1753        to scan for things we haven't collected yet before pursuing further.
1754
1755        On AIX, the latter typically includes nothing for shared objects or
1756        frame tables for an executable, out of what the required early scan on
1757        objects and libraries has performed above.  In the !shared_obj case, we
1758        expect the relevant tables to be dragged together with their associated
1759        functions from precise cross reference insertions by the compiler.  */
1760
1761     if (early_exit || ld1_filter != SCAN_NOTHING)
1762       do_tlink (ld1_argv, object_lst);
1763
1764     if (early_exit)
1765       {
1766 #ifdef COLLECT_EXPORT_LIST
1767         /* Make sure we delete the export file we may have created.  */
1768         if (export_file != 0 && export_file[0])
1769           maybe_unlink (export_file);
1770 #endif
1771         if (lto_mode != LTO_MODE_NONE)
1772           maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1773         else
1774           post_ld_pass (false);
1775
1776         maybe_unlink (c_file);
1777         maybe_unlink (o_file);
1778         return 0;
1779       }
1780   }
1781
1782   /* Unless we have done it all already, examine the namelist and search for
1783      static constructors and destructors to call.  Write the constructor and
1784      destructor tables to a .s file and reload.  */
1785
1786   if (ld1_filter != SCAN_NOTHING)
1787     scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1788
1789 #ifdef SCAN_LIBRARIES
1790   scan_libraries (output_file);
1791 #endif
1792
1793   if (debug)
1794     {
1795       notice_translated (ngettext ("%d constructor found\n",
1796                                    "%d constructors found\n",
1797                                    constructors.number),
1798                          constructors.number);
1799       notice_translated (ngettext ("%d destructor found\n",
1800                                    "%d destructors found\n",
1801                                    destructors.number),
1802                          destructors.number);
1803       notice_translated (ngettext("%d frame table found\n",
1804                                   "%d frame tables found\n",
1805                                   frame_tables.number),
1806                          frame_tables.number);
1807     }
1808
1809   /* If the scan exposed nothing of special interest, there's no need to
1810      generate the glue code and relink so return now.  */
1811
1812   if (constructors.number == 0 && destructors.number == 0
1813       && frame_tables.number == 0
1814 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1815       /* If we will be running these functions ourselves, we want to emit
1816          stubs into the shared library so that we do not have to relink
1817          dependent programs when we add static objects.  */
1818       && ! shared_obj
1819 #endif
1820       )
1821     {
1822       /* Do tlink without additional code generation now if we didn't
1823          do it earlier for scanning purposes.  */
1824       if (ld1_filter == SCAN_NOTHING)
1825         do_tlink (ld1_argv, object_lst);
1826
1827       if (lto_mode)
1828         maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1829
1830       /* Strip now if it was requested on the command line.  */
1831       if (strip_flag)
1832         {
1833           char **real_strip_argv = XCNEWVEC (char *, 3);
1834           const char ** strip_argv = CONST_CAST2 (const char **, char **,
1835                                                   real_strip_argv);
1836
1837           strip_argv[0] = strip_file_name;
1838           strip_argv[1] = output_file;
1839           strip_argv[2] = (char *) 0;
1840           fork_execute ("strip", real_strip_argv);
1841         }
1842
1843 #ifdef COLLECT_EXPORT_LIST
1844       maybe_unlink (export_file);
1845 #endif
1846       post_ld_pass (false);
1847
1848       maybe_unlink (c_file);
1849       maybe_unlink (o_file);
1850       return 0;
1851     }
1852
1853   /* Sort ctor and dtor lists by priority.  */
1854   sort_ids (&constructors);
1855   sort_ids (&destructors);
1856
1857   maybe_unlink(output_file);
1858   outf = fopen (c_file, "w");
1859   if (outf == (FILE *) 0)
1860     fatal_error ("fopen %s: %m", c_file);
1861
1862   write_c_file (outf, c_file);
1863
1864   if (fclose (outf))
1865     fatal_error ("fclose %s: %m", c_file);
1866
1867   /* Tell the linker that we have initializer and finalizer functions.  */
1868 #ifdef LD_INIT_SWITCH
1869 #ifdef COLLECT_EXPORT_LIST
1870   *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1871 #else
1872   *ld2++ = LD_INIT_SWITCH;
1873   *ld2++ = initname;
1874   *ld2++ = LD_FINI_SWITCH;
1875   *ld2++ = fininame;
1876 #endif
1877 #endif
1878
1879 #ifdef COLLECT_EXPORT_LIST
1880   if (shared_obj)
1881     {
1882       /* If we did not add export flag to link arguments before, add it to
1883          second link phase now.  No new exports should have been added.  */
1884       if (! exports.first)
1885         *ld2++ = concat ("-bE:", export_file, NULL);
1886
1887 #ifndef LD_INIT_SWITCH
1888       add_to_list (&exports, initname);
1889       add_to_list (&exports, fininame);
1890       add_to_list (&exports, "_GLOBAL__DI");
1891       add_to_list (&exports, "_GLOBAL__DD");
1892 #endif
1893       exportf = fopen (export_file, "w");
1894       if (exportf == (FILE *) 0)
1895         fatal_error ("fopen %s: %m", export_file);
1896       write_aix_file (exportf, exports.first);
1897       if (fclose (exportf))
1898         fatal_error ("fclose %s: %m", export_file);
1899     }
1900 #endif
1901
1902   /* End of arguments to second link phase.  */
1903   *ld2 = (char*) 0;
1904
1905   if (debug)
1906     {
1907       fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1908                output_file, c_file);
1909       write_c_file (stderr, "stderr");
1910       fprintf (stderr, "========== end of c_file\n\n");
1911 #ifdef COLLECT_EXPORT_LIST
1912       fprintf (stderr, "\n========== export_file = %s\n", export_file);
1913       write_aix_file (stderr, exports.first);
1914       fprintf (stderr, "========== end of export_file\n\n");
1915 #endif
1916     }
1917
1918   /* Assemble the constructor and destructor tables.
1919      Link the tables in with the rest of the program.  */
1920
1921   fork_execute ("gcc",  c_argv);
1922 #ifdef COLLECT_EXPORT_LIST
1923   /* On AIX we must call tlink because of possible templates resolution.  */
1924   do_tlink (ld2_argv, object_lst);
1925
1926   if (lto_mode)
1927     maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1928 #else
1929   /* Otherwise, simply call ld because tlink is already done.  */
1930   if (lto_mode)
1931     maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1932   else
1933     {
1934       fork_execute ("ld", ld2_argv);
1935       post_ld_pass (false);
1936     }
1937
1938   /* Let scan_prog_file do any final mods (OSF/rose needs this for
1939      constructors/destructors in shared libraries.  */
1940   scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1941 #endif
1942
1943   maybe_unlink (c_file);
1944   maybe_unlink (o_file);
1945
1946 #ifdef COLLECT_EXPORT_LIST
1947   maybe_unlink (export_file);
1948 #endif
1949
1950   return 0;
1951 }
1952
1953 \f
1954 /* Wait for a process to finish, and exit if a nonzero status is found.  */
1955
1956 int
1957 collect_wait (const char *prog, struct pex_obj *pex)
1958 {
1959   int status;
1960
1961   if (!pex_get_status (pex, 1, &status))
1962     fatal_error ("can't get program status: %m");
1963   pex_free (pex);
1964
1965   if (status)
1966     {
1967       if (WIFSIGNALED (status))
1968         {
1969           int sig = WTERMSIG (status);
1970           error ("%s terminated with signal %d [%s]%s",
1971                  prog, sig, strsignal(sig),
1972                  WCOREDUMP(status) ? ", core dumped" : "");
1973           collect_exit (FATAL_EXIT_CODE);
1974         }
1975
1976       if (WIFEXITED (status))
1977         return WEXITSTATUS (status);
1978     }
1979   return 0;
1980 }
1981
1982 static void
1983 do_wait (const char *prog, struct pex_obj *pex)
1984 {
1985   int ret = collect_wait (prog, pex);
1986   if (ret != 0)
1987     {
1988       error ("%s returned %d exit status", prog, ret);
1989       collect_exit (ret);
1990     }
1991
1992   if (response_file)
1993     {
1994       unlink (response_file);
1995       response_file = NULL;
1996     }
1997 }
1998
1999 \f
2000 /* Execute a program, and wait for the reply.  */
2001
2002 struct pex_obj *
2003 collect_execute (const char *prog, char **argv, const char *outname,
2004                  const char *errname, int flags)
2005 {
2006   struct pex_obj *pex;
2007   const char *errmsg;
2008   int err;
2009   char *response_arg = NULL;
2010   char *response_argv[3] ATTRIBUTE_UNUSED;
2011
2012   if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
2013     {
2014       /* If using @file arguments, create a temporary file and put the
2015          contents of argv into it.  Then change argv to an array corresponding
2016          to a single argument @FILE, where FILE is the temporary filename.  */
2017
2018       char **current_argv = argv + 1;
2019       char *argv0 = argv[0];
2020       int status;
2021       FILE *f;
2022
2023       /* Note: we assume argv contains at least one element; this is
2024          checked above.  */
2025
2026       response_file = make_temp_file ("");
2027
2028       f = fopen (response_file, "w");
2029
2030       if (f == NULL)
2031         fatal_error ("could not open response file %s", response_file);
2032
2033       status = writeargv (current_argv, f);
2034
2035       if (status)
2036         fatal_error ("could not write to response file %s", response_file);
2037
2038       status = fclose (f);
2039
2040       if (EOF == status)
2041         fatal_error ("could not close response file %s", response_file);
2042
2043       response_arg = concat ("@", response_file, NULL);
2044       response_argv[0] = argv0;
2045       response_argv[1] = response_arg;
2046       response_argv[2] = NULL;
2047
2048       argv = response_argv;
2049     }
2050
2051   if (vflag || debug)
2052     {
2053       char **p_argv;
2054       const char *str;
2055
2056       if (argv[0])
2057         fprintf (stderr, "%s", argv[0]);
2058       else
2059         notice ("[cannot find %s]", prog);
2060
2061       for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
2062         fprintf (stderr, " %s", str);
2063
2064       fprintf (stderr, "\n");
2065     }
2066
2067   fflush (stdout);
2068   fflush (stderr);
2069
2070   /* If we cannot find a program we need, complain error.  Do this here
2071      since we might not end up needing something that we could not find.  */
2072
2073   if (argv[0] == 0)
2074     fatal_error ("cannot find '%s'", prog);
2075
2076   pex = pex_init (0, "collect2", NULL);
2077   if (pex == NULL)
2078     fatal_error ("pex_init failed: %m");
2079
2080   errmsg = pex_run (pex, flags, argv[0], argv, outname,
2081                     errname, &err);
2082   if (errmsg != NULL)
2083     {
2084       if (err != 0)
2085         {
2086           errno = err;
2087           fatal_error ("%s: %m", _(errmsg));
2088         }
2089       else
2090         fatal_error (errmsg);
2091     }
2092
2093   free (response_arg);
2094
2095   return pex;
2096 }
2097
2098 static void
2099 fork_execute (const char *prog, char **argv)
2100 {
2101   struct pex_obj *pex;
2102
2103   pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
2104   do_wait (prog, pex);
2105 }
2106 \f
2107 /* Unlink a file unless we are debugging.  */
2108
2109 static void
2110 maybe_unlink (const char *file)
2111 {
2112   if (!debug)
2113     unlink_if_ordinary (file);
2114   else
2115     notice ("[Leaving %s]\n", file);
2116 }
2117
2118 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST.  */
2119
2120 static void
2121 maybe_unlink_list (char **file_list)
2122 {
2123   char **tmp = file_list;
2124
2125   while (*tmp)
2126     maybe_unlink (*(tmp++));
2127 }
2128
2129 \f
2130 static long sequence_number = 0;
2131
2132 /* Add a name to a linked list.  */
2133
2134 static void
2135 add_to_list (struct head *head_ptr, const char *name)
2136 {
2137   struct id *newid
2138     = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2139   struct id *p;
2140   strcpy (newid->name, name);
2141
2142   if (head_ptr->first)
2143     head_ptr->last->next = newid;
2144   else
2145     head_ptr->first = newid;
2146
2147   /* Check for duplicate symbols.  */
2148   for (p = head_ptr->first;
2149        strcmp (name, p->name) != 0;
2150        p = p->next)
2151     ;
2152   if (p != newid)
2153     {
2154       head_ptr->last->next = 0;
2155       free (newid);
2156       return;
2157     }
2158
2159   newid->sequence = ++sequence_number;
2160   head_ptr->last = newid;
2161   head_ptr->number++;
2162 }
2163
2164 /* Grab the init priority number from an init function name that
2165    looks like "_GLOBAL_.I.12345.foo".  */
2166
2167 static int
2168 extract_init_priority (const char *name)
2169 {
2170   int pos = 0, pri;
2171
2172   while (name[pos] == '_')
2173     ++pos;
2174   pos += 10; /* strlen ("GLOBAL__X_") */
2175
2176   /* Extract init_p number from ctor/dtor name.  */
2177   pri = atoi (name + pos);
2178   return pri ? pri : DEFAULT_INIT_PRIORITY;
2179 }
2180
2181 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2182    ctors will be run from right to left, dtors from left to right.  */
2183
2184 static void
2185 sort_ids (struct head *head_ptr)
2186 {
2187   /* id holds the current element to insert.  id_next holds the next
2188      element to insert.  id_ptr iterates through the already sorted elements
2189      looking for the place to insert id.  */
2190   struct id *id, *id_next, **id_ptr;
2191
2192   id = head_ptr->first;
2193
2194   /* We don't have any sorted elements yet.  */
2195   head_ptr->first = NULL;
2196
2197   for (; id; id = id_next)
2198     {
2199       id_next = id->next;
2200       id->sequence = extract_init_priority (id->name);
2201
2202       for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2203         if (*id_ptr == NULL
2204             /* If the sequence numbers are the same, we put the id from the
2205                file later on the command line later in the list.  */
2206             || id->sequence > (*id_ptr)->sequence
2207             /* Hack: do lexical compare, too.
2208             || (id->sequence == (*id_ptr)->sequence
2209                 && strcmp (id->name, (*id_ptr)->name) > 0) */
2210             )
2211           {
2212             id->next = *id_ptr;
2213             *id_ptr = id;
2214             break;
2215           }
2216     }
2217
2218   /* Now set the sequence numbers properly so write_c_file works.  */
2219   for (id = head_ptr->first; id; id = id->next)
2220     id->sequence = ++sequence_number;
2221 }
2222
2223 /* Write: `prefix', the names on list LIST, `suffix'.  */
2224
2225 static void
2226 write_list (FILE *stream, const char *prefix, struct id *list)
2227 {
2228   while (list)
2229     {
2230       fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2231       list = list->next;
2232     }
2233 }
2234
2235 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
2236 /* Given a STRING, return nonzero if it occurs in the list in range
2237    [ARGS_BEGIN,ARGS_END).  */
2238
2239 static int
2240 is_in_args (const char *string, const char **args_begin,
2241             const char **args_end)
2242 {
2243   const char **args_pointer;
2244   for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
2245     if (strcmp (string, *args_pointer) == 0)
2246       return 1;
2247   return 0;
2248 }
2249 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
2250
2251 #ifdef COLLECT_EXPORT_LIST
2252 /* This function is really used only on AIX, but may be useful.  */
2253 #if 0
2254 static int
2255 is_in_list (const char *prefix, struct id *list)
2256 {
2257   while (list)
2258     {
2259       if (!strcmp (prefix, list->name)) return 1;
2260       list = list->next;
2261     }
2262     return 0;
2263 }
2264 #endif
2265 #endif /* COLLECT_EXPORT_LIST */
2266
2267 /* Added for debugging purpose.  */
2268 #ifdef COLLECT_EXPORT_LIST
2269 static void
2270 dump_list (FILE *stream, const char *prefix, struct id *list)
2271 {
2272   while (list)
2273     {
2274       fprintf (stream, "%s%s,\n", prefix, list->name);
2275       list = list->next;
2276     }
2277 }
2278 #endif
2279
2280 #if 0
2281 static void
2282 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2283 {
2284   while (list)
2285     {
2286       fprintf (stream, "%s%s,\n", prefix, list->prefix);
2287       list = list->next;
2288     }
2289 }
2290 #endif
2291
2292 static void
2293 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2294 {
2295   while (list)
2296     {
2297       fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2298                prefix, list->sequence, list->name);
2299       list = list->next;
2300     }
2301 }
2302
2303 /* Write out the constructor and destructor tables statically (for a shared
2304    object), along with the functions to execute them.  */
2305
2306 static void
2307 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2308 {
2309   const char *p, *q;
2310   char *prefix, *r;
2311   int frames = (frame_tables.number > 0);
2312
2313   /* Figure out name of output_file, stripping off .so version.  */
2314   q = p = lbasename (output_file);
2315
2316   while (q)
2317     {
2318       q = strchr (q,'.');
2319       if (q == 0)
2320         {
2321           q = p + strlen (p);
2322           break;
2323         }
2324       else
2325         {
2326           if (filename_ncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2327             {
2328               q += strlen (SHLIB_SUFFIX);
2329               break;
2330             }
2331           else
2332             q++;
2333         }
2334     }
2335   /* q points to null at end of the string (or . of the .so version) */
2336   prefix = XNEWVEC (char, q - p + 1);
2337   strncpy (prefix, p, q - p);
2338   prefix[q - p] = 0;
2339   for (r = prefix; *r; r++)
2340     if (!ISALNUM ((unsigned char)*r))
2341       *r = '_';
2342   if (debug)
2343     notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2344             output_file, prefix);
2345
2346   initname = concat ("_GLOBAL__FI_", prefix, NULL);
2347   fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2348
2349   free (prefix);
2350
2351   /* Write the tables as C code.  */
2352
2353   fprintf (stream, "static int count;\n");
2354   fprintf (stream, "typedef void entry_pt();\n");
2355   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2356
2357   if (frames)
2358     {
2359       write_list_with_asm (stream, "extern void *", frame_tables.first);
2360
2361       fprintf (stream, "\tstatic void *frame_table[] = {\n");
2362       write_list (stream, "\t\t&", frame_tables.first);
2363       fprintf (stream, "\t0\n};\n");
2364
2365       /* This must match what's in frame.h.  */
2366       fprintf (stream, "struct object {\n");
2367       fprintf (stream, "  void *pc_begin;\n");
2368       fprintf (stream, "  void *pc_end;\n");
2369       fprintf (stream, "  void *fde_begin;\n");
2370       fprintf (stream, "  void *fde_array;\n");
2371       fprintf (stream, "  __SIZE_TYPE__ count;\n");
2372       fprintf (stream, "  struct object *next;\n");
2373       fprintf (stream, "};\n");
2374
2375       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2376       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2377
2378       fprintf (stream, "static void reg_frame () {\n");
2379       fprintf (stream, "\tstatic struct object ob;\n");
2380       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2381       fprintf (stream, "\t}\n");
2382
2383       fprintf (stream, "static void dereg_frame () {\n");
2384       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2385       fprintf (stream, "\t}\n");
2386     }
2387
2388   fprintf (stream, "void %s() {\n", initname);
2389   if (constructors.number > 0 || frames)
2390     {
2391       fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2392       write_list (stream, "\t\t", constructors.first);
2393       if (frames)
2394         fprintf (stream, "\treg_frame,\n");
2395       fprintf (stream, "\t};\n");
2396       fprintf (stream, "\tentry_pt **p;\n");
2397       fprintf (stream, "\tif (count++ != 0) return;\n");
2398       fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2399       fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2400     }
2401   else
2402     fprintf (stream, "\t++count;\n");
2403   fprintf (stream, "}\n");
2404   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2405   fprintf (stream, "void %s() {\n", fininame);
2406   if (destructors.number > 0 || frames)
2407     {
2408       fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2409       write_list (stream, "\t\t", destructors.first);
2410       if (frames)
2411         fprintf (stream, "\tdereg_frame,\n");
2412       fprintf (stream, "\t};\n");
2413       fprintf (stream, "\tentry_pt **p;\n");
2414       fprintf (stream, "\tif (--count != 0) return;\n");
2415       fprintf (stream, "\tp = dtors;\n");
2416       fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2417                destructors.number + frames);
2418     }
2419   fprintf (stream, "}\n");
2420
2421   if (shared_obj)
2422     {
2423       COLLECT_SHARED_INIT_FUNC(stream, initname);
2424       COLLECT_SHARED_FINI_FUNC(stream, fininame);
2425     }
2426 }
2427
2428 /* Write the constructor/destructor tables.  */
2429
2430 #ifndef LD_INIT_SWITCH
2431 static void
2432 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2433 {
2434   /* Write the tables as C code.  */
2435
2436   int frames = (frame_tables.number > 0);
2437
2438   fprintf (stream, "typedef void entry_pt();\n\n");
2439
2440   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2441
2442   if (frames)
2443     {
2444       write_list_with_asm (stream, "extern void *", frame_tables.first);
2445
2446       fprintf (stream, "\tstatic void *frame_table[] = {\n");
2447       write_list (stream, "\t\t&", frame_tables.first);
2448       fprintf (stream, "\t0\n};\n");
2449
2450       /* This must match what's in frame.h.  */
2451       fprintf (stream, "struct object {\n");
2452       fprintf (stream, "  void *pc_begin;\n");
2453       fprintf (stream, "  void *pc_end;\n");
2454       fprintf (stream, "  void *fde_begin;\n");
2455       fprintf (stream, "  void *fde_array;\n");
2456       fprintf (stream, "  __SIZE_TYPE__ count;\n");
2457       fprintf (stream, "  struct object *next;\n");
2458       fprintf (stream, "};\n");
2459
2460       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2461       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2462
2463       fprintf (stream, "static void reg_frame () {\n");
2464       fprintf (stream, "\tstatic struct object ob;\n");
2465       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2466       fprintf (stream, "\t}\n");
2467
2468       fprintf (stream, "static void dereg_frame () {\n");
2469       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2470       fprintf (stream, "\t}\n");
2471     }
2472
2473   fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2474   fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2475   write_list (stream, "\t", constructors.first);
2476   if (frames)
2477     fprintf (stream, "\treg_frame,\n");
2478   fprintf (stream, "\t0\n};\n\n");
2479
2480   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2481
2482   fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2483   fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2484   write_list (stream, "\t", destructors.first);
2485   if (frames)
2486     fprintf (stream, "\tdereg_frame,\n");
2487   fprintf (stream, "\t0\n};\n\n");
2488
2489   fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2490   fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2491 }
2492 #endif /* ! LD_INIT_SWITCH */
2493
2494 static void
2495 write_c_file (FILE *stream, const char *name)
2496 {
2497 #ifndef LD_INIT_SWITCH
2498   if (! shared_obj)
2499     write_c_file_glob (stream, name);
2500   else
2501 #endif
2502     write_c_file_stat (stream, name);
2503 }
2504
2505 #ifdef COLLECT_EXPORT_LIST
2506 static void
2507 write_aix_file (FILE *stream, struct id *list)
2508 {
2509   for (; list; list = list->next)
2510     {
2511       fputs (list->name, stream);
2512       putc ('\n', stream);
2513     }
2514 }
2515 #endif
2516 \f
2517 #ifdef OBJECT_FORMAT_NONE
2518
2519 /* Check to make sure the file is an LTO object file.  */
2520
2521 static bool
2522 maybe_lto_object_file (const char *prog_name)
2523 {
2524   FILE *f;
2525   unsigned char buf[4];
2526   int i;
2527
2528   static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' };
2529   static unsigned char coffmagic[2] = { 0x4c, 0x01 };
2530   static unsigned char coffmagic_x64[2] = { 0x64, 0x86 };
2531   static unsigned char machomagic[4][4] = {
2532     { 0xcf, 0xfa, 0xed, 0xfe },
2533     { 0xce, 0xfa, 0xed, 0xfe },
2534     { 0xfe, 0xed, 0xfa, 0xcf },
2535     { 0xfe, 0xed, 0xfa, 0xce }
2536   };
2537
2538   f = fopen (prog_name, "rb");
2539   if (f == NULL)
2540     return false;
2541   if (fread (buf, sizeof (buf), 1, f) != 1)
2542     buf[0] = 0;
2543   fclose (f);
2544
2545   if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0
2546       || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0
2547       || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0)
2548     return true;
2549   for (i = 0; i < 4; i++)
2550     if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0)
2551       return true;
2552
2553   return false;
2554 }
2555
2556 /* Generic version to scan the name list of the loaded program for
2557    the symbols g++ uses for static constructors and destructors.  */
2558
2559 static void
2560 scan_prog_file (const char *prog_name, scanpass which_pass,
2561                 scanfilter filter)
2562 {
2563   void (*int_handler) (int);
2564 #ifdef SIGQUIT
2565   void (*quit_handler) (int);
2566 #endif
2567   char *real_nm_argv[4];
2568   const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2569   int argc = 0;
2570   struct pex_obj *pex;
2571   const char *errmsg;
2572   int err;
2573   char *p, buf[1024];
2574   FILE *inf;
2575   int found_lto = 0;
2576
2577   if (which_pass == PASS_SECOND)
2578     return;
2579
2580   /* LTO objects must be in a known format.  This check prevents
2581      us from accepting an archive containing LTO objects, which
2582      gcc cannnot currently handle.  */
2583   if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
2584     return;
2585
2586   /* If we do not have an `nm', complain.  */
2587   if (nm_file_name == 0)
2588     fatal_error ("cannot find 'nm'");
2589
2590   nm_argv[argc++] = nm_file_name;
2591   if (NM_FLAGS[0] != '\0')
2592     nm_argv[argc++] = NM_FLAGS;
2593
2594   nm_argv[argc++] = prog_name;
2595   nm_argv[argc++] = (char *) 0;
2596
2597   /* Trace if needed.  */
2598   if (vflag)
2599     {
2600       const char **p_argv;
2601       const char *str;
2602
2603       for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2604         fprintf (stderr, " %s", str);
2605
2606       fprintf (stderr, "\n");
2607     }
2608
2609   fflush (stdout);
2610   fflush (stderr);
2611
2612   pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2613   if (pex == NULL)
2614     fatal_error ("pex_init failed: %m");
2615
2616   errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2617                     &err);
2618   if (errmsg != NULL)
2619     {
2620       if (err != 0)
2621         {
2622           errno = err;
2623           fatal_error ("%s: %m", _(errmsg));
2624         }
2625       else
2626         fatal_error (errmsg);
2627     }
2628
2629   int_handler  = (void (*) (int)) signal (SIGINT,  SIG_IGN);
2630 #ifdef SIGQUIT
2631   quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2632 #endif
2633
2634   inf = pex_read_output (pex, 0);
2635   if (inf == NULL)
2636     fatal_error ("can't open nm output: %m");
2637
2638   if (debug)
2639     {
2640       if (which_pass == PASS_LTOINFO)
2641         fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2642       else
2643         fprintf (stderr, "\nnm output with constructors/destructors.\n");
2644     }
2645
2646   /* Read each line of nm output.  */
2647   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2648     {
2649       int ch, ch2;
2650       char *name, *end;
2651
2652       if (debug)
2653         fprintf (stderr, "\t%s\n", buf);
2654
2655       if (which_pass == PASS_LTOINFO)
2656         {
2657           if (found_lto)
2658             continue;
2659
2660           /* Look for the LTO info marker symbol, and add filename to
2661              the LTO objects list if found.  */
2662           for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2663             if (ch == ' '  && p[1] == '_' && p[2] == '_'
2664                 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2665                 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2666               {
2667                 add_lto_object (&lto_objects, prog_name);
2668
2669                 /* We need to read all the input, so we can't just
2670                    return here.  But we can avoid useless work.  */
2671                 found_lto = 1;
2672
2673                 break;
2674               }
2675
2676           continue;
2677         }
2678
2679       /* If it contains a constructor or destructor name, add the name
2680          to the appropriate list unless this is a kind of symbol we're
2681          not supposed to even consider.  */
2682
2683       for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2684         if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2685           break;
2686
2687       if (ch != '_')
2688         continue;
2689
2690       name = p;
2691       /* Find the end of the symbol name.
2692          Do not include `|', because Encore nm can tack that on the end.  */
2693       for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2694            end++)
2695         continue;
2696
2697
2698       *end = '\0';
2699       switch (is_ctor_dtor (name))
2700         {
2701         case SYM_CTOR:
2702           if (! (filter & SCAN_CTOR))
2703             break;
2704           if (which_pass != PASS_LIB)
2705             add_to_list (&constructors, name);
2706           break;
2707
2708         case SYM_DTOR:
2709           if (! (filter & SCAN_DTOR))
2710             break;
2711           if (which_pass != PASS_LIB)
2712             add_to_list (&destructors, name);
2713           break;
2714
2715         case SYM_INIT:
2716           if (! (filter & SCAN_INIT))
2717             break;
2718           if (which_pass != PASS_LIB)
2719             fatal_error ("init function found in object %s", prog_name);
2720 #ifndef LD_INIT_SWITCH
2721           add_to_list (&constructors, name);
2722 #endif
2723           break;
2724
2725         case SYM_FINI:
2726           if (! (filter & SCAN_FINI))
2727             break;
2728           if (which_pass != PASS_LIB)
2729             fatal_error ("fini function found in object %s", prog_name);
2730 #ifndef LD_FINI_SWITCH
2731           add_to_list (&destructors, name);
2732 #endif
2733           break;
2734
2735         case SYM_DWEH:
2736           if (! (filter & SCAN_DWEH))
2737             break;
2738           if (which_pass != PASS_LIB)
2739             add_to_list (&frame_tables, name);
2740           break;
2741
2742         default:                /* not a constructor or destructor */
2743           continue;
2744         }
2745     }
2746
2747   if (debug)
2748     fprintf (stderr, "\n");
2749
2750   do_wait (nm_file_name, pex);
2751
2752   signal (SIGINT,  int_handler);
2753 #ifdef SIGQUIT
2754   signal (SIGQUIT, quit_handler);
2755 #endif
2756 }
2757
2758 #ifdef LDD_SUFFIX
2759
2760 /* Use the List Dynamic Dependencies program to find shared libraries that
2761    the output file depends upon and their initialization/finalization
2762    routines, if any.  */
2763
2764 static void
2765 scan_libraries (const char *prog_name)
2766 {
2767   static struct head libraries;         /* list of shared libraries found */
2768   struct id *list;
2769   void (*int_handler) (int);
2770 #ifdef SIGQUIT
2771   void (*quit_handler) (int);
2772 #endif
2773   char *real_ldd_argv[4];
2774   const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2775   int argc = 0;
2776   struct pex_obj *pex;
2777   const char *errmsg;
2778   int err;
2779   char buf[1024];
2780   FILE *inf;
2781
2782   /* If we do not have an `ldd', complain.  */
2783   if (ldd_file_name == 0)
2784     {
2785       error ("cannot find 'ldd'");
2786       return;
2787     }
2788
2789   ldd_argv[argc++] = ldd_file_name;
2790   ldd_argv[argc++] = prog_name;
2791   ldd_argv[argc++] = (char *) 0;
2792
2793   /* Trace if needed.  */
2794   if (vflag)
2795     {
2796       const char **p_argv;
2797       const char *str;
2798
2799       for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2800         fprintf (stderr, " %s", str);
2801
2802       fprintf (stderr, "\n");
2803     }
2804
2805   fflush (stdout);
2806   fflush (stderr);
2807
2808   pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2809   if (pex == NULL)
2810     fatal_error ("pex_init failed: %m");
2811
2812   errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2813   if (errmsg != NULL)
2814     {
2815       if (err != 0)
2816         {
2817           errno = err;
2818           fatal_error ("%s: %m", _(errmsg));
2819         }
2820       else
2821         fatal_error (errmsg);
2822     }
2823
2824   int_handler  = (void (*) (int)) signal (SIGINT,  SIG_IGN);
2825 #ifdef SIGQUIT
2826   quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2827 #endif
2828
2829   inf = pex_read_output (pex, 0);
2830   if (inf == NULL)
2831     fatal_error ("can't open ldd output: %m");
2832
2833   if (debug)
2834     notice ("\nldd output with constructors/destructors.\n");
2835
2836   /* Read each line of ldd output.  */
2837   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2838     {
2839       int ch2;
2840       char *name, *end, *p = buf;
2841
2842       /* Extract names of libraries and add to list.  */
2843       PARSE_LDD_OUTPUT (p);
2844       if (p == 0)
2845         continue;
2846
2847       name = p;
2848       if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2849         fatal_error ("dynamic dependency %s not found", buf);
2850
2851       /* Find the end of the symbol name.  */
2852       for (end = p;
2853            (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2854            end++)
2855         continue;
2856       *end = '\0';
2857
2858       if (access (name, R_OK) == 0)
2859         add_to_list (&libraries, name);
2860       else
2861         fatal_error ("unable to open dynamic dependency '%s'", buf);
2862
2863       if (debug)
2864         fprintf (stderr, "\t%s\n", buf);
2865     }
2866   if (debug)
2867     fprintf (stderr, "\n");
2868
2869   do_wait (ldd_file_name, pex);
2870
2871   signal (SIGINT,  int_handler);
2872 #ifdef SIGQUIT
2873   signal (SIGQUIT, quit_handler);
2874 #endif
2875
2876   /* Now iterate through the library list adding their symbols to
2877      the list.  */
2878   for (list = libraries.first; list; list = list->next)
2879     scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2880 }
2881
2882 #endif /* LDD_SUFFIX */
2883
2884 #endif /* OBJECT_FORMAT_NONE */
2885
2886 \f
2887 /*
2888  * COFF specific stuff.
2889  */
2890
2891 #ifdef OBJECT_FORMAT_COFF
2892
2893 #if defined (EXTENDED_COFF)
2894
2895 #   define GCC_SYMBOLS(X)       (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2896 #   define GCC_SYMENT           SYMR
2897 #   define GCC_OK_SYMBOL(X)     ((X).st == stProc || (X).st == stGlobal)
2898 #   define GCC_SYMINC(X)        (1)
2899 #   define GCC_SYMZERO(X)       (SYMHEADER(X).isymMax)
2900 #   define GCC_CHECK_HDR(X)     (PSYMTAB(X) != 0)
2901
2902 #else
2903
2904 #   define GCC_SYMBOLS(X)       (HEADER(ldptr).f_nsyms)
2905 #   define GCC_SYMENT           SYMENT
2906 #   if defined (C_WEAKEXT)
2907 #     define GCC_OK_SYMBOL(X) \
2908        (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2909         ((X).n_scnum > N_UNDEF) && \
2910         (aix64_flag \
2911          || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2912              || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2913 #     define GCC_UNDEF_SYMBOL(X) \
2914        (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2915         ((X).n_scnum == N_UNDEF))
2916 #   else
2917 #     define GCC_OK_SYMBOL(X) \
2918        (((X).n_sclass == C_EXT) && \
2919         ((X).n_scnum > N_UNDEF) && \
2920         (aix64_flag \
2921          || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2922              || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2923 #     define GCC_UNDEF_SYMBOL(X) \
2924        (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2925 #   endif
2926 #   define GCC_SYMINC(X)        ((X).n_numaux+1)
2927 #   define GCC_SYMZERO(X)       0
2928
2929 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2930 #if TARGET_AIX_VERSION >= 51
2931 #   define GCC_CHECK_HDR(X) \
2932      ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2933       || (HEADER (X).f_magic == 0767 && aix64_flag))
2934 #else
2935 #   define GCC_CHECK_HDR(X) \
2936      ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2937       || (HEADER (X).f_magic == 0757 && aix64_flag))
2938 #endif
2939
2940 #endif
2941
2942 #ifdef COLLECT_EXPORT_LIST
2943 /* Array of standard AIX libraries which should not
2944    be scanned for ctors/dtors.  */
2945 static const char *const aix_std_libs[] = {
2946   "/unix",
2947   "/lib/libc.a",
2948   "/lib/libm.a",
2949   "/lib/libc_r.a",
2950   "/lib/libm_r.a",
2951   "/usr/lib/libc.a",
2952   "/usr/lib/libm.a",
2953   "/usr/lib/libc_r.a",
2954   "/usr/lib/libm_r.a",
2955   "/usr/lib/threads/libc.a",
2956   "/usr/ccs/lib/libc.a",
2957   "/usr/ccs/lib/libm.a",
2958   "/usr/ccs/lib/libc_r.a",
2959   "/usr/ccs/lib/libm_r.a",
2960   NULL
2961 };
2962
2963 /* This function checks the filename and returns 1
2964    if this name matches the location of a standard AIX library.  */
2965 static int ignore_library (const char *);
2966 static int
2967 ignore_library (const char *name)
2968 {
2969   const char *const *p;
2970   size_t length;
2971
2972   if (target_system_root[0] != '\0')
2973     {
2974       length = strlen (target_system_root);
2975       if (strncmp (name, target_system_root, length) != 0)
2976         return 0;
2977       name += length;
2978     }
2979   for (p = &aix_std_libs[0]; *p != NULL; ++p)
2980     if (strcmp (name, *p) == 0)
2981       return 1;
2982   return 0;
2983 }
2984 #endif /* COLLECT_EXPORT_LIST */
2985
2986 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2987 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2988 #endif
2989
2990 /* COFF version to scan the name list of the loaded program for
2991    the symbols g++ uses for static constructors and destructors.  */
2992
2993 static void
2994 scan_prog_file (const char *prog_name, scanpass which_pass,
2995                 scanfilter filter)
2996 {
2997   LDFILE *ldptr = NULL;
2998   int sym_index, sym_count;
2999   int is_shared = 0;
3000
3001   if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
3002     return;
3003
3004 #ifdef COLLECT_EXPORT_LIST
3005   /* We do not need scanning for some standard C libraries.  */
3006   if (which_pass == PASS_FIRST && ignore_library (prog_name))
3007     return;
3008
3009   /* On AIX we have a loop, because there is not much difference
3010      between an object and an archive. This trick allows us to
3011      eliminate scan_libraries() function.  */
3012   do
3013     {
3014 #endif
3015       /* Some platforms (e.g. OSF4) declare ldopen as taking a
3016          non-const char * filename parameter, even though it will not
3017          modify that string.  So we must cast away const-ness here,
3018          using CONST_CAST to prevent complaints from -Wcast-qual.  */
3019       if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
3020         {
3021           if (! MY_ISCOFF (HEADER (ldptr).f_magic))
3022             fatal_error ("%s: not a COFF file", prog_name);
3023
3024           if (GCC_CHECK_HDR (ldptr))
3025             {
3026               sym_count = GCC_SYMBOLS (ldptr);
3027               sym_index = GCC_SYMZERO (ldptr);
3028
3029 #ifdef COLLECT_EXPORT_LIST
3030               /* Is current archive member a shared object?  */
3031               is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
3032 #endif
3033
3034               while (sym_index < sym_count)
3035                 {
3036                   GCC_SYMENT symbol;
3037
3038                   if (ldtbread (ldptr, sym_index, &symbol) <= 0)
3039                     break;
3040                   sym_index += GCC_SYMINC (symbol);
3041
3042                   if (GCC_OK_SYMBOL (symbol))
3043                     {
3044                       char *name;
3045
3046                       if ((name = ldgetname (ldptr, &symbol)) == NULL)
3047                         continue;               /* Should never happen.  */
3048
3049 #ifdef XCOFF_DEBUGGING_INFO
3050                       /* All AIX function names have a duplicate entry
3051                          beginning with a dot.  */
3052                       if (*name == '.')
3053                         ++name;
3054 #endif
3055
3056                       switch (is_ctor_dtor (name))
3057                         {
3058                         case SYM_CTOR:
3059                           if (! (filter & SCAN_CTOR))
3060                             break;
3061                           if (! is_shared)
3062                             add_to_list (&constructors, name);
3063 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3064                           if (which_pass == PASS_OBJ)
3065                             add_to_list (&exports, name);
3066 #endif
3067                           break;
3068
3069                         case SYM_DTOR:
3070                           if (! (filter & SCAN_DTOR))
3071                             break;
3072                           if (! is_shared)
3073                             add_to_list (&destructors, name);
3074 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3075                           if (which_pass == PASS_OBJ)
3076                             add_to_list (&exports, name);
3077 #endif
3078                           break;
3079
3080 #ifdef COLLECT_EXPORT_LIST
3081                         case SYM_INIT:
3082                           if (! (filter & SCAN_INIT))
3083                             break;
3084 #ifndef LD_INIT_SWITCH
3085                           if (is_shared)
3086                             add_to_list (&constructors, name);
3087 #endif
3088                           break;
3089
3090                         case SYM_FINI:
3091                           if (! (filter & SCAN_FINI))
3092                             break;
3093 #ifndef LD_INIT_SWITCH
3094                           if (is_shared)
3095                             add_to_list (&destructors, name);
3096 #endif
3097                           break;
3098 #endif
3099
3100                         case SYM_DWEH:
3101                           if (! (filter & SCAN_DWEH))
3102                             break;
3103                           if (! is_shared)
3104                             add_to_list (&frame_tables, name);
3105 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3106                           if (which_pass == PASS_OBJ)
3107                             add_to_list (&exports, name);
3108 #endif
3109                           break;
3110
3111                         default:        /* not a constructor or destructor */
3112 #ifdef COLLECT_EXPORT_LIST
3113                           /* Explicitly export all global symbols when
3114                              building a shared object on AIX, but do not
3115                              re-export symbols from another shared object
3116                              and do not export symbols if the user
3117                              provides an explicit export list.  */
3118                           if (shared_obj && !is_shared
3119                               && which_pass == PASS_OBJ && !export_flag)
3120                             add_to_list (&exports, name);
3121 #endif
3122                           continue;
3123                         }
3124
3125                       if (debug)
3126 #if !defined(EXTENDED_COFF)
3127                         fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3128                                  symbol.n_scnum, symbol.n_sclass,
3129                                  (symbol.n_type ? "0" : ""), symbol.n_type,
3130                                  name);
3131 #else
3132                         fprintf (stderr,
3133                                  "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3134                                  symbol.iss, (long) symbol.value, symbol.index, name);
3135 #endif
3136                     }
3137                 }
3138             }
3139 #ifdef COLLECT_EXPORT_LIST
3140           else
3141             {
3142               /* If archive contains both 32-bit and 64-bit objects,
3143                  we want to skip objects in other mode so mismatch normal.  */
3144               if (debug)
3145                 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3146                          prog_name, HEADER (ldptr).f_magic, aix64_flag);
3147             }
3148 #endif
3149         }
3150       else
3151         {
3152           fatal_error ("%s: cannot open as COFF file", prog_name);
3153         }
3154 #ifdef COLLECT_EXPORT_LIST
3155       /* On AIX loop continues while there are more members in archive.  */
3156     }
3157   while (ldclose (ldptr) == FAILURE);
3158 #else
3159   /* Otherwise we simply close ldptr.  */
3160   (void) ldclose(ldptr);
3161 #endif
3162 }
3163 #endif /* OBJECT_FORMAT_COFF */
3164
3165 #ifdef COLLECT_EXPORT_LIST
3166 /* Given a library name without "lib" prefix, this function
3167    returns a full library name including a path.  */
3168 static char *
3169 resolve_lib_name (const char *name)
3170 {
3171   char *lib_buf;
3172   int i, j, l = 0;
3173   /* Library extensions for AIX dynamic linking.  */
3174   const char * const libexts[2] = {"a", "so"};
3175
3176   for (i = 0; libpaths[i]; i++)
3177     if (libpaths[i]->max_len > l)
3178       l = libpaths[i]->max_len;
3179
3180   lib_buf = XNEWVEC (char, l + strlen(name) + 10);
3181
3182   for (i = 0; libpaths[i]; i++)
3183     {
3184       struct prefix_list *list = libpaths[i]->plist;
3185       for (; list; list = list->next)
3186         {
3187           /* The following lines are needed because path_prefix list
3188              may contain directories both with trailing DIR_SEPARATOR and
3189              without it.  */
3190           const char *p = "";
3191           if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1]))
3192             p = "/";
3193           for (j = 0; j < 2; j++)
3194             {
3195               sprintf (lib_buf, "%s%slib%s.%s",
3196                        list->prefix, p, name,
3197                        libexts[(j + aixrtl_flag) % 2]);
3198               if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3199               if (file_exists (lib_buf))
3200                 {
3201                   if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3202                   return (lib_buf);
3203                 }
3204             }
3205         }
3206     }
3207   if (debug)
3208     fprintf (stderr, "not found\n");
3209   else
3210     fatal_error ("library lib%s not found", name);
3211   return (NULL);
3212 }
3213 #endif /* COLLECT_EXPORT_LIST */
3214
3215 #ifdef COLLECT_RUN_DSYMUTIL
3216 static int flag_dsym = false;
3217 static int flag_idsym = false;
3218
3219 static void
3220 process_args (int *argcp, char **argv) {
3221   int i, j;
3222   int argc = *argcp;
3223   for (i=0; i<argc; ++i)
3224     {
3225       if (strcmp (argv[i], "-dsym") == 0)
3226         {
3227           flag_dsym = true;
3228           /* Remove the flag, as we handle all processing for it.  */
3229           j = i;
3230           do
3231             argv[j] = argv[j+1];
3232           while (++j < argc);
3233           --i;
3234           argc = --(*argcp);
3235         }
3236       else if (strcmp (argv[i], "-idsym") == 0)
3237         {
3238           flag_idsym = true;
3239           /* Remove the flag, as we handle all processing for it.  */
3240           j = i;
3241           do
3242             argv[j] = argv[j+1];
3243           while (++j < argc);
3244           --i;
3245           argc = --(*argcp);
3246         }
3247     }
3248 }
3249
3250 static void
3251 do_dsymutil (const char *output_file) {
3252   const char *dsymutil = DSYMUTIL + 1;
3253   struct pex_obj *pex;
3254   char **real_argv = XCNEWVEC (char *, 3);
3255   const char ** argv = CONST_CAST2 (const char **, char **,
3256                                     real_argv);
3257
3258   argv[0] = dsymutil;
3259   argv[1] = output_file;
3260   argv[2] = (char *) 0;
3261
3262   pex = collect_execute (dsymutil, real_argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
3263   do_wait (dsymutil, pex);
3264 }
3265
3266 static void
3267 post_ld_pass (bool temp_file) {
3268   if (!(temp_file && flag_idsym) && !flag_dsym)
3269     return;
3270       
3271   do_dsymutil (output_file);
3272 }
3273 #else
3274 static void
3275 process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }
3276 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }
3277 #endif