OSDN Git Service

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