2014-01-24 Ed Smith-Rowland <3dw4rd@verizon.net>
[official-gcc.git] / gcc / collect2.c
blob38d3421c0dfd6603d47a98cdba3970ad2f91c295
1 /* Collect static initialization info into data structures that can be
2 traversed by C++ initialization and finalization routines.
3 Copyright (C) 1992-2014 Free Software Foundation, Inc.
4 Contributed by Chris Smith (csmith@convex.com).
5 Heavily modified by Michael Meissner (meissner@cygnus.com),
6 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
13 version.
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Build tables of static constructors and destructors and run ld. */
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "filenames.h"
32 #include "file-find.h"
34 /* TARGET_64BIT may be defined to use driver specific functionality. */
35 #undef TARGET_64BIT
36 #define TARGET_64BIT TARGET_64BIT_DEFAULT
38 #ifndef LIBRARY_PATH_ENV
39 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
40 #endif
42 #define COLLECT
44 #include "collect2.h"
45 #include "collect2-aix.h"
46 #include "diagnostic.h"
47 #include "demangle.h"
48 #include "obstack.h"
49 #include "intl.h"
50 #include "version.h"
52 /* On certain systems, we have code that works by scanning the object file
53 directly. But this code uses system-specific header files and library
54 functions, so turn it off in a cross-compiler. Likewise, the names of
55 the utilities are not correct for a cross-compiler; we have to hope that
56 cross-versions are in the proper directories. */
58 #ifdef CROSS_DIRECTORY_STRUCTURE
59 #ifndef CROSS_AIX_SUPPORT
60 #undef OBJECT_FORMAT_COFF
61 #endif
62 #undef MD_EXEC_PREFIX
63 #undef REAL_LD_FILE_NAME
64 #undef REAL_NM_FILE_NAME
65 #undef REAL_STRIP_FILE_NAME
66 #endif
68 /* If we cannot use a special method, use the ordinary one:
69 run nm to find what symbols are present.
70 In a cross-compiler, this means you need a cross nm,
71 but that is not quite as unpleasant as special headers. */
73 #if !defined (OBJECT_FORMAT_COFF)
74 #define OBJECT_FORMAT_NONE
75 #endif
77 #ifdef OBJECT_FORMAT_COFF
79 #ifndef CROSS_DIRECTORY_STRUCTURE
80 #include <a.out.h>
81 #include <ar.h>
83 #ifdef UMAX
84 #include <sgs.h>
85 #endif
87 /* Many versions of ldfcn.h define these. */
88 #ifdef FREAD
89 #undef FREAD
90 #undef FWRITE
91 #endif
93 #include <ldfcn.h>
94 #endif
96 /* Some systems have an ISCOFF macro, but others do not. In some cases
97 the macro may be wrong. MY_ISCOFF is defined in tm.h files for machines
98 that either do not have an ISCOFF macro in /usr/include or for those
99 where it is wrong. */
101 #ifndef MY_ISCOFF
102 #define MY_ISCOFF(X) ISCOFF (X)
103 #endif
105 #endif /* OBJECT_FORMAT_COFF */
107 #ifdef OBJECT_FORMAT_NONE
109 /* Default flags to pass to nm. */
110 #ifndef NM_FLAGS
111 #define NM_FLAGS "-n"
112 #endif
114 #endif /* OBJECT_FORMAT_NONE */
116 /* Some systems use __main in a way incompatible with its use in gcc, in these
117 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
118 give the same symbol without quotes for an alternative entry point. */
119 #ifndef NAME__MAIN
120 #define NAME__MAIN "__main"
121 #endif
123 /* This must match tree.h. */
124 #define DEFAULT_INIT_PRIORITY 65535
126 #ifndef COLLECT_SHARED_INIT_FUNC
127 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
128 fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
129 #endif
130 #ifndef COLLECT_SHARED_FINI_FUNC
131 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
132 fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
133 #endif
135 #ifdef LDD_SUFFIX
136 #define SCAN_LIBRARIES
137 #endif
139 #ifndef SHLIB_SUFFIX
140 #define SHLIB_SUFFIX ".so"
141 #endif
143 #ifdef USE_COLLECT2
144 int do_collecting = 1;
145 #else
146 int do_collecting = 0;
147 #endif
149 /* Cook up an always defined indication of whether we proceed the
150 "EXPORT_LIST" way. */
152 #ifdef COLLECT_EXPORT_LIST
153 #define DO_COLLECT_EXPORT_LIST 1
154 #else
155 #define DO_COLLECT_EXPORT_LIST 0
156 #endif
158 /* Nonzero if we should suppress the automatic demangling of identifiers
159 in linker error messages. Set from COLLECT_NO_DEMANGLE. */
160 int no_demangle;
162 /* Linked lists of constructor and destructor names. */
164 struct id
166 struct id *next;
167 int sequence;
168 char name[1];
171 struct head
173 struct id *first;
174 struct id *last;
175 int number;
178 bool vflag; /* true if -v or --version */
179 static int rflag; /* true if -r */
180 static int strip_flag; /* true if -s */
181 #ifdef COLLECT_EXPORT_LIST
182 static int export_flag; /* true if -bE */
183 static int aix64_flag; /* true if -b64 */
184 static int aixrtl_flag; /* true if -brtl */
185 static int aixlazy_flag; /* true if -blazy */
186 #endif
188 enum lto_mode_d {
189 LTO_MODE_NONE, /* Not doing LTO. */
190 LTO_MODE_LTO, /* Normal LTO. */
191 LTO_MODE_WHOPR /* WHOPR. */
194 /* Current LTO mode. */
195 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
197 bool debug; /* true if -debug */
198 bool helpflag; /* true if --help */
200 static int shared_obj; /* true if -shared */
202 static const char *c_file; /* <xxx>.c for constructor/destructor list. */
203 static const char *o_file; /* <xxx>.o for constructor/destructor list. */
204 #ifdef COLLECT_EXPORT_LIST
205 static const char *export_file; /* <xxx>.x for AIX export list. */
206 #endif
207 static char **lto_o_files; /* Output files for LTO. */
208 const char *ldout; /* File for ld stdout. */
209 const char *lderrout; /* File for ld stderr. */
210 static const char *output_file; /* Output file for ld. */
211 static const char *nm_file_name; /* pathname of nm */
212 #ifdef LDD_SUFFIX
213 static const char *ldd_file_name; /* pathname of ldd (or equivalent) */
214 #endif
215 static const char *strip_file_name; /* pathname of strip */
216 const char *c_file_name; /* pathname of gcc */
217 static char *initname, *fininame; /* names of init and fini funcs */
220 #ifdef TARGET_AIX_VERSION
221 static char *aix_shared_initname;
222 static char *aix_shared_fininame; /* init/fini names as per the scheme
223 described in config/rs6000/aix.h */
224 #endif
226 static struct head constructors; /* list of constructors found */
227 static struct head destructors; /* list of destructors found */
228 #ifdef COLLECT_EXPORT_LIST
229 static struct head exports; /* list of exported symbols */
230 #endif
231 static struct head frame_tables; /* list of frame unwind info tables */
233 static bool at_file_supplied; /* Whether to use @file arguments */
234 static char *response_file; /* Name of any current response file */
236 struct obstack temporary_obstack;
237 char * temporary_firstobj;
239 /* A string that must be prepended to a target OS path in order to find
240 it on the host system. */
241 #ifdef TARGET_SYSTEM_ROOT
242 static const char *target_system_root = TARGET_SYSTEM_ROOT;
243 #else
244 static const char *target_system_root = "";
245 #endif
247 /* Whether we may unlink the output file, which should be set as soon as we
248 know we have successfully produced it. This is typically useful to prevent
249 blindly attempting to unlink a read-only output that the target linker
250 would leave untouched. */
251 bool may_unlink_output_file = false;
253 #ifdef COLLECT_EXPORT_LIST
254 /* Lists to keep libraries to be scanned for global constructors/destructors. */
255 static struct head libs; /* list of libraries */
256 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
257 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
258 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
259 &libpath_lib_dirs, NULL};
260 #endif
262 /* List of names of object files containing LTO information.
263 These are a subset of the object file names appearing on the
264 command line, and must be identical, in the sense of pointer
265 equality, with the names passed to maybe_run_lto_and_relink(). */
267 struct lto_object
269 const char *name; /* Name of object file. */
270 struct lto_object *next; /* Next in linked list. */
273 struct lto_object_list
275 struct lto_object *first; /* First list element. */
276 struct lto_object *last; /* Last list element. */
279 static struct lto_object_list lto_objects;
281 /* Special kinds of symbols that a name may denote. */
283 typedef enum {
284 SYM_REGULAR = 0, /* nothing special */
286 SYM_CTOR = 1, /* constructor */
287 SYM_DTOR = 2, /* destructor */
288 SYM_INIT = 3, /* shared object routine that calls all the ctors */
289 SYM_FINI = 4, /* shared object routine that calls all the dtors */
290 SYM_DWEH = 5, /* DWARF exception handling table */
291 SYM_AIXI = 6,
292 SYM_AIXD = 7
293 } symkind;
295 static symkind is_ctor_dtor (const char *);
297 static void handler (int);
298 static void do_wait (const char *, struct pex_obj *);
299 static void fork_execute (const char *, char **);
300 static void maybe_unlink (const char *);
301 static void maybe_unlink_list (char **);
302 static void add_to_list (struct head *, const char *);
303 static int extract_init_priority (const char *);
304 static void sort_ids (struct head *);
305 static void write_list (FILE *, const char *, struct id *);
306 #ifdef COLLECT_EXPORT_LIST
307 static void dump_list (FILE *, const char *, struct id *);
308 #endif
309 #if 0
310 static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
311 #endif
312 static void write_list_with_asm (FILE *, const char *, struct id *);
313 static void write_c_file (FILE *, const char *);
314 static void write_c_file_stat (FILE *, const char *);
315 #ifndef LD_INIT_SWITCH
316 static void write_c_file_glob (FILE *, const char *);
317 #endif
318 #ifdef SCAN_LIBRARIES
319 static void scan_libraries (const char *);
320 #endif
321 #ifdef COLLECT_EXPORT_LIST
322 #if 0
323 static int is_in_list (const char *, struct id *);
324 #endif
325 static void write_aix_file (FILE *, struct id *);
326 static char *resolve_lib_name (const char *);
327 #endif
328 static char *extract_string (const char **);
329 static void post_ld_pass (bool);
330 static void process_args (int *argcp, char **argv);
332 /* Enumerations describing which pass this is for scanning the
333 program file ... */
335 typedef enum {
336 PASS_FIRST, /* without constructors */
337 PASS_OBJ, /* individual objects */
338 PASS_LIB, /* looking for shared libraries */
339 PASS_SECOND, /* with constructors linked in */
340 PASS_LTOINFO /* looking for objects with LTO info */
341 } scanpass;
343 /* ... and which kinds of symbols are to be considered. */
345 enum scanfilter_masks {
346 SCAN_NOTHING = 0,
348 SCAN_CTOR = 1 << SYM_CTOR,
349 SCAN_DTOR = 1 << SYM_DTOR,
350 SCAN_INIT = 1 << SYM_INIT,
351 SCAN_FINI = 1 << SYM_FINI,
352 SCAN_DWEH = 1 << SYM_DWEH,
353 SCAN_AIXI = 1 << SYM_AIXI,
354 SCAN_AIXD = 1 << SYM_AIXD,
355 SCAN_ALL = ~0
358 /* This type is used for parameters and variables which hold
359 combinations of the flags in enum scanfilter_masks. */
360 typedef int scanfilter;
362 /* Scan the name list of the loaded program for the symbols g++ uses for
363 static constructors and destructors.
365 The SCANPASS argument tells which collect processing pass this is for and
366 the SCANFILTER argument tells which kinds of symbols to consider in this
367 pass. Symbols of a special kind not in the filter mask are considered as
368 regular ones.
370 The constructor table begins at __CTOR_LIST__ and contains a count of the
371 number of pointers (or -1 if the constructors are built in a separate
372 section by the linker), followed by the pointers to the constructor
373 functions, terminated with a null pointer. The destructor table has the
374 same format, and begins at __DTOR_LIST__. */
376 static void scan_prog_file (const char *, scanpass, scanfilter);
379 /* Delete tempfiles and exit function. */
381 static void
382 collect_atexit (void)
384 if (c_file != 0 && c_file[0])
385 maybe_unlink (c_file);
387 if (o_file != 0 && o_file[0])
388 maybe_unlink (o_file);
390 #ifdef COLLECT_EXPORT_LIST
391 if (export_file != 0 && export_file[0])
392 maybe_unlink (export_file);
393 #endif
395 if (lto_o_files)
396 maybe_unlink_list (lto_o_files);
398 if (ldout != 0 && ldout[0])
400 dump_ld_file (ldout, stdout);
401 maybe_unlink (ldout);
404 if (lderrout != 0 && lderrout[0])
406 dump_ld_file (lderrout, stderr);
407 maybe_unlink (lderrout);
410 if (response_file)
411 maybe_unlink (response_file);
415 /* Notify user of a non-error. */
416 void
417 notice (const char *cmsgid, ...)
419 va_list ap;
421 va_start (ap, cmsgid);
422 vfprintf (stderr, _(cmsgid), ap);
423 va_end (ap);
426 /* Notify user of a non-error, without translating the format string. */
427 void
428 notice_translated (const char *cmsgid, ...)
430 va_list ap;
432 va_start (ap, cmsgid);
433 vfprintf (stderr, cmsgid, ap);
434 va_end (ap);
437 static void
438 handler (int signo)
440 if (c_file != 0 && c_file[0])
441 maybe_unlink (c_file);
443 if (o_file != 0 && o_file[0])
444 maybe_unlink (o_file);
446 if (ldout != 0 && ldout[0])
447 maybe_unlink (ldout);
449 if (lderrout != 0 && lderrout[0])
450 maybe_unlink (lderrout);
452 #ifdef COLLECT_EXPORT_LIST
453 if (export_file != 0 && export_file[0])
454 maybe_unlink (export_file);
455 #endif
457 if (lto_o_files)
458 maybe_unlink_list (lto_o_files);
460 if (response_file)
461 maybe_unlink (response_file);
463 signal (signo, SIG_DFL);
464 raise (signo);
469 file_exists (const char *name)
471 return access (name, R_OK) == 0;
474 /* Parse a reasonable subset of shell quoting syntax. */
476 static char *
477 extract_string (const char **pp)
479 const char *p = *pp;
480 int backquote = 0;
481 int inside = 0;
483 for (;;)
485 char c = *p;
486 if (c == '\0')
487 break;
488 ++p;
489 if (backquote)
490 obstack_1grow (&temporary_obstack, c);
491 else if (! inside && c == ' ')
492 break;
493 else if (! inside && c == '\\')
494 backquote = 1;
495 else if (c == '\'')
496 inside = !inside;
497 else
498 obstack_1grow (&temporary_obstack, c);
501 obstack_1grow (&temporary_obstack, '\0');
502 *pp = p;
503 return XOBFINISH (&temporary_obstack, char *);
506 void
507 dump_ld_file (const char *name, FILE *to)
509 FILE *stream = fopen (name, "r");
511 if (stream == 0)
512 return;
513 while (1)
515 int c;
516 while (c = getc (stream),
517 c != EOF && (ISIDNUM (c) || c == '$' || c == '.'))
518 obstack_1grow (&temporary_obstack, c);
519 if (obstack_object_size (&temporary_obstack) > 0)
521 const char *word, *p;
522 char *result;
523 obstack_1grow (&temporary_obstack, '\0');
524 word = XOBFINISH (&temporary_obstack, const char *);
526 if (*word == '.')
527 ++word, putc ('.', to);
528 p = word;
529 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
530 p += strlen (USER_LABEL_PREFIX);
532 #ifdef HAVE_LD_DEMANGLE
533 result = 0;
534 #else
535 if (no_demangle)
536 result = 0;
537 else
538 result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
539 #endif
541 if (result)
543 int diff;
544 fputs (result, to);
546 diff = strlen (word) - strlen (result);
547 while (diff > 0 && c == ' ')
548 --diff, putc (' ', to);
549 if (diff < 0 && c == ' ')
551 while (diff < 0 && c == ' ')
552 ++diff, c = getc (stream);
553 if (!ISSPACE (c))
555 /* Make sure we output at least one space, or
556 the demangled symbol name will run into
557 whatever text follows. */
558 putc (' ', to);
562 free (result);
564 else
565 fputs (word, to);
567 fflush (to);
568 obstack_free (&temporary_obstack, temporary_firstobj);
570 if (c == EOF)
571 break;
572 putc (c, to);
574 fclose (stream);
577 /* Return the kind of symbol denoted by name S. */
579 static symkind
580 is_ctor_dtor (const char *s)
582 struct names { const char *const name; const int len; symkind ret;
583 const int two_underscores; };
585 const struct names *p;
586 int ch;
587 const char *orig_s = s;
589 static const struct names special[] = {
590 #ifndef NO_DOLLAR_IN_LABEL
591 { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 },
592 { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 },
593 #else
594 #ifndef NO_DOT_IN_LABEL
595 { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR, 0 },
596 { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR, 0 },
597 #endif /* NO_DOT_IN_LABEL */
598 #endif /* NO_DOLLAR_IN_LABEL */
599 { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR, 0 },
600 { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR, 0 },
601 { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH, 0 },
602 { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT, 0 },
603 { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI, 0 },
604 #ifdef TARGET_AIX_VERSION
605 { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI, 0 },
606 { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD, 0 },
607 #endif
608 { NULL, 0, SYM_REGULAR, 0 }
611 while ((ch = *s) == '_')
612 ++s;
614 if (s == orig_s)
615 return SYM_REGULAR;
617 for (p = &special[0]; p->len > 0; p++)
619 if (ch == p->name[0]
620 && (!p->two_underscores || ((s - orig_s) >= 2))
621 && strncmp (s, p->name, p->len) == 0)
623 return p->ret;
626 return SYM_REGULAR;
629 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
630 and one from the PATH variable. */
632 static struct path_prefix cpath, path;
634 #ifdef CROSS_DIRECTORY_STRUCTURE
635 /* This is the name of the target machine. We use it to form the name
636 of the files to execute. */
638 static const char *const target_machine = TARGET_MACHINE;
639 #endif
641 /* Search for NAME using prefix list PPREFIX. We only look for executable
642 files.
644 Return 0 if not found, otherwise return its name, allocated with malloc. */
646 #ifdef OBJECT_FORMAT_NONE
648 /* Add an entry for the object file NAME to object file list LIST.
649 New entries are added at the end of the list. The original pointer
650 value of NAME is preserved, i.e., no string copy is performed. */
652 static void
653 add_lto_object (struct lto_object_list *list, const char *name)
655 struct lto_object *n = XNEW (struct lto_object);
656 n->name = name;
657 n->next = NULL;
659 if (list->last)
660 list->last->next = n;
661 else
662 list->first = n;
664 list->last = n;
666 #endif /* OBJECT_FORMAT_NONE */
669 /* Perform a link-time recompilation and relink if any of the object
670 files contain LTO info. The linker command line LTO_LD_ARGV
671 represents the linker command that would produce a final executable
672 without the use of LTO. OBJECT_LST is a vector of object file names
673 appearing in LTO_LD_ARGV that are to be considered for link-time
674 recompilation, where OBJECT is a pointer to the last valid element.
675 (This awkward convention avoids an impedance mismatch with the
676 usage of similarly-named variables in main().) The elements of
677 OBJECT_LST must be identical, i.e., pointer equal, to the
678 corresponding arguments in LTO_LD_ARGV.
680 Upon entry, at least one linker run has been performed without the
681 use of any LTO info that might be present. Any recompilations
682 necessary for template instantiations have been performed, and
683 initializer/finalizer tables have been created if needed and
684 included in the linker command line LTO_LD_ARGV. If any of the
685 object files contain LTO info, we run the LTO back end on all such
686 files, and perform the final link with the LTO back end output
687 substituted for the LTO-optimized files. In some cases, a final
688 link with all link-time generated code has already been performed,
689 so there is no need to relink if no LTO info is found. In other
690 cases, our caller has not produced the final executable, and is
691 relying on us to perform the required link whether LTO info is
692 present or not. In that case, the FORCE argument should be true.
693 Note that the linker command line argument LTO_LD_ARGV passed into
694 this function may be modified in place. */
696 static void
697 maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,
698 const char **object, bool force)
700 const char **object_file = CONST_CAST2 (const char **, char **, object_lst);
702 int num_lto_c_args = 1; /* Allow space for the terminating NULL. */
704 while (object_file < object)
706 /* If file contains LTO info, add it to the list of LTO objects. */
707 scan_prog_file (*object_file++, PASS_LTOINFO, SCAN_ALL);
709 /* Increment the argument count by the number of object file arguments
710 we will add. An upper bound suffices, so just count all of the
711 object files regardless of whether they contain LTO info. */
712 num_lto_c_args++;
715 if (lto_objects.first)
717 char **lto_c_argv;
718 const char **lto_c_ptr;
719 char **p;
720 char **lto_o_ptr;
721 struct lto_object *list;
722 char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER");
723 struct pex_obj *pex;
724 const char *prog = "lto-wrapper";
725 int lto_ld_argv_size = 0;
726 char **out_lto_ld_argv;
727 int out_lto_ld_argv_size;
728 size_t num_files;
730 if (!lto_wrapper)
731 fatal_error ("COLLECT_LTO_WRAPPER must be set");
733 num_lto_c_args++;
735 /* There is at least one object file containing LTO info,
736 so we need to run the LTO back end and relink.
738 To do so we build updated ld arguments with first
739 LTO object replaced by all partitions and other LTO
740 objects removed. */
742 lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
743 lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
745 *lto_c_ptr++ = lto_wrapper;
747 /* Add LTO objects to the wrapper command line. */
748 for (list = lto_objects.first; list; list = list->next)
749 *lto_c_ptr++ = list->name;
751 *lto_c_ptr = NULL;
753 /* Run the LTO back end. */
754 pex = collect_execute (prog, lto_c_argv, NULL, NULL, PEX_SEARCH);
756 int c;
757 FILE *stream;
758 size_t i;
759 char *start, *end;
761 stream = pex_read_output (pex, 0);
762 gcc_assert (stream);
764 num_files = 0;
765 while ((c = getc (stream)) != EOF)
767 obstack_1grow (&temporary_obstack, c);
768 if (c == '\n')
769 ++num_files;
772 lto_o_files = XNEWVEC (char *, num_files + 1);
773 lto_o_files[num_files] = NULL;
774 start = XOBFINISH (&temporary_obstack, char *);
775 for (i = 0; i < num_files; ++i)
777 end = start;
778 while (*end != '\n')
779 ++end;
780 *end = '\0';
782 lto_o_files[i] = xstrdup (start);
784 start = end + 1;
787 obstack_free (&temporary_obstack, temporary_firstobj);
789 do_wait (prog, pex);
790 pex = NULL;
792 /* Compute memory needed for new LD arguments. At most number of original arguemtns
793 plus number of partitions. */
794 for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++)
796 out_lto_ld_argv = XCNEWVEC (char *, num_files + lto_ld_argv_size + 1);
797 out_lto_ld_argv_size = 0;
799 /* After running the LTO back end, we will relink, substituting
800 the LTO output for the object files that we submitted to the
801 LTO. Here, we modify the linker command line for the relink. */
803 /* Copy all arguments until we find first LTO file. */
804 p = lto_ld_argv;
805 while (*p != NULL)
807 for (list = lto_objects.first; list; list = list->next)
808 if (*p == list->name) /* Note test for pointer equality! */
809 break;
810 if (list)
811 break;
812 out_lto_ld_argv[out_lto_ld_argv_size++] = *p++;
815 /* Now insert all LTO partitions. */
816 lto_o_ptr = lto_o_files;
817 while (*lto_o_ptr)
818 out_lto_ld_argv[out_lto_ld_argv_size++] = *lto_o_ptr++;
820 /* ... and copy the rest. */
821 while (*p != NULL)
823 for (list = lto_objects.first; list; list = list->next)
824 if (*p == list->name) /* Note test for pointer equality! */
825 break;
826 if (!list)
827 out_lto_ld_argv[out_lto_ld_argv_size++] = *p;
828 p++;
830 out_lto_ld_argv[out_lto_ld_argv_size++] = 0;
832 /* Run the linker again, this time replacing the object files
833 optimized by the LTO with the temporary file generated by the LTO. */
834 fork_execute ("ld", out_lto_ld_argv);
835 post_ld_pass (true);
836 free (lto_ld_argv);
838 maybe_unlink_list (lto_o_files);
840 else if (force)
842 /* Our caller is relying on us to do the link
843 even though there is no LTO back end work to be done. */
844 fork_execute ("ld", lto_ld_argv);
845 post_ld_pass (false);
849 /* Main program. */
852 main (int argc, char **argv)
854 enum linker_select
856 USE_DEFAULT_LD,
857 USE_PLUGIN_LD,
858 USE_GOLD_LD,
859 USE_BFD_LD,
860 USE_LD_MAX
861 } selected_linker = USE_DEFAULT_LD;
862 static const char *const ld_suffixes[USE_LD_MAX] =
864 "ld",
865 PLUGIN_LD_SUFFIX,
866 "ld.gold",
867 "ld.bfd"
869 static const char *const real_ld_suffix = "real-ld";
870 static const char *const collect_ld_suffix = "collect-ld";
871 static const char *const nm_suffix = "nm";
872 static const char *const gnm_suffix = "gnm";
873 #ifdef LDD_SUFFIX
874 static const char *const ldd_suffix = LDD_SUFFIX;
875 #endif
876 static const char *const strip_suffix = "strip";
877 static const char *const gstrip_suffix = "gstrip";
879 const char *full_ld_suffixes[USE_LD_MAX];
880 #ifdef CROSS_DIRECTORY_STRUCTURE
881 /* If we look for a program in the compiler directories, we just use
882 the short name, since these directories are already system-specific.
883 But it we look for a program in the system directories, we need to
884 qualify the program name with the target machine. */
886 const char *const full_nm_suffix =
887 concat (target_machine, "-", nm_suffix, NULL);
888 const char *const full_gnm_suffix =
889 concat (target_machine, "-", gnm_suffix, NULL);
890 #ifdef LDD_SUFFIX
891 const char *const full_ldd_suffix =
892 concat (target_machine, "-", ldd_suffix, NULL);
893 #endif
894 const char *const full_strip_suffix =
895 concat (target_machine, "-", strip_suffix, NULL);
896 const char *const full_gstrip_suffix =
897 concat (target_machine, "-", gstrip_suffix, NULL);
898 #else
899 #ifdef LDD_SUFFIX
900 const char *const full_ldd_suffix = ldd_suffix;
901 #endif
902 const char *const full_nm_suffix = nm_suffix;
903 const char *const full_gnm_suffix = gnm_suffix;
904 const char *const full_strip_suffix = strip_suffix;
905 const char *const full_gstrip_suffix = gstrip_suffix;
906 #endif /* CROSS_DIRECTORY_STRUCTURE */
908 const char *arg;
909 FILE *outf;
910 #ifdef COLLECT_EXPORT_LIST
911 FILE *exportf;
912 #endif
913 const char *ld_file_name;
914 const char *p;
915 char **c_argv;
916 const char **c_ptr;
917 char **ld1_argv;
918 const char **ld1;
919 bool use_plugin = false;
920 bool use_collect_ld = false;
922 /* The kinds of symbols we will have to consider when scanning the
923 outcome of a first pass link. This is ALL to start with, then might
924 be adjusted before getting to the first pass link per se, typically on
925 AIX where we perform an early scan of objects and libraries to fetch
926 the list of global ctors/dtors and make sure they are not garbage
927 collected. */
928 scanfilter ld1_filter = SCAN_ALL;
930 char **ld2_argv;
931 const char **ld2;
932 char **object_lst;
933 const char **object;
934 #ifdef TARGET_AIX_VERSION
935 int object_nbr = argc;
936 #endif
937 int first_file;
938 int num_c_args;
939 char **old_argv;
940 int i;
942 for (i = 0; i < USE_LD_MAX; i++)
943 full_ld_suffixes[i]
944 #ifdef CROSS_DIRECTORY_STRUCTURE
945 = concat (target_machine, "-", ld_suffixes[i], NULL);
946 #else
947 = ld_suffixes[i];
948 #endif
950 p = argv[0] + strlen (argv[0]);
951 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
952 --p;
953 progname = p;
955 xmalloc_set_program_name (progname);
957 old_argv = argv;
958 expandargv (&argc, &argv);
959 if (argv != old_argv)
960 at_file_supplied = 1;
962 process_args (&argc, argv);
964 num_c_args = argc + 9;
966 #ifndef HAVE_LD_DEMANGLE
967 no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
969 /* Suppress demangling by the real linker, which may be broken. */
970 putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
971 #endif
973 #if defined (COLLECT2_HOST_INITIALIZATION)
974 /* Perform system dependent initialization, if necessary. */
975 COLLECT2_HOST_INITIALIZATION;
976 #endif
978 #ifdef SIGCHLD
979 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
980 receive the signal. A different setting is inheritable */
981 signal (SIGCHLD, SIG_DFL);
982 #endif
984 if (atexit (collect_atexit) != 0)
985 fatal_error ("atexit failed");
987 /* Unlock the stdio streams. */
988 unlock_std_streams ();
990 gcc_init_libintl ();
992 diagnostic_initialize (global_dc, 0);
994 /* Do not invoke xcalloc before this point, since locale needs to be
995 set first, in case a diagnostic is issued. */
997 ld1_argv = XCNEWVEC (char *, argc + 4);
998 ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
999 ld2_argv = XCNEWVEC (char *, argc + 11);
1000 ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
1001 object_lst = XCNEWVEC (char *, argc);
1002 object = CONST_CAST2 (const char **, char **, object_lst);
1004 #ifdef DEBUG
1005 debug = 1;
1006 #endif
1008 /* Parse command line early for instances of -debug. This allows
1009 the debug flag to be set before functions like find_a_file()
1010 are called. We also look for the -flto or -flto-partition=none flag to know
1011 what LTO mode we are in. */
1013 bool no_partition = false;
1015 for (i = 1; argv[i] != NULL; i ++)
1017 if (! strcmp (argv[i], "-debug"))
1018 debug = true;
1019 else if (! strcmp (argv[i], "-flto-partition=none"))
1020 no_partition = true;
1021 else if ((! strncmp (argv[i], "-flto=", 6)
1022 || ! strcmp (argv[i], "-flto")) && ! use_plugin)
1023 lto_mode = LTO_MODE_WHOPR;
1024 else if (!strncmp (argv[i], "-fno-lto", 8))
1025 lto_mode = LTO_MODE_NONE;
1026 else if (! strcmp (argv[i], "-plugin"))
1028 use_plugin = true;
1029 lto_mode = LTO_MODE_NONE;
1030 if (selected_linker == USE_DEFAULT_LD)
1031 selected_linker = USE_PLUGIN_LD;
1033 else if (strcmp (argv[i], "-fuse-ld=bfd") == 0)
1034 selected_linker = USE_BFD_LD;
1035 else if (strcmp (argv[i], "-fuse-ld=gold") == 0)
1036 selected_linker = USE_GOLD_LD;
1038 #ifdef COLLECT_EXPORT_LIST
1039 /* These flags are position independent, although their order
1040 is important - subsequent flags override earlier ones. */
1041 else if (strcmp (argv[i], "-b64") == 0)
1042 aix64_flag = 1;
1043 /* -bexport:filename always needs the :filename */
1044 else if (strncmp (argv[i], "-bE:", 4) == 0
1045 || strncmp (argv[i], "-bexport:", 9) == 0)
1046 export_flag = 1;
1047 else if (strcmp (argv[i], "-brtl") == 0
1048 || strcmp (argv[i], "-bsvr4") == 0
1049 || strcmp (argv[i], "-G") == 0)
1050 aixrtl_flag = 1;
1051 else if (strcmp (argv[i], "-bnortl") == 0)
1052 aixrtl_flag = 0;
1053 else if (strcmp (argv[i], "-blazy") == 0)
1054 aixlazy_flag = 1;
1055 #endif
1057 vflag = debug;
1058 find_file_set_debug (debug);
1059 if (no_partition && lto_mode == LTO_MODE_WHOPR)
1060 lto_mode = LTO_MODE_LTO;
1063 #ifndef DEFAULT_A_OUT_NAME
1064 output_file = "a.out";
1065 #else
1066 output_file = DEFAULT_A_OUT_NAME;
1067 #endif
1069 obstack_begin (&temporary_obstack, 0);
1070 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
1072 #ifndef HAVE_LD_DEMANGLE
1073 current_demangling_style = auto_demangling;
1074 #endif
1075 p = getenv ("COLLECT_GCC_OPTIONS");
1076 while (p && *p)
1078 const char *q = extract_string (&p);
1079 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1080 num_c_args++;
1082 obstack_free (&temporary_obstack, temporary_firstobj);
1084 /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
1085 -fno-exceptions -w -fno-whole-program */
1086 num_c_args += 6;
1088 c_argv = XCNEWVEC (char *, num_c_args);
1089 c_ptr = CONST_CAST2 (const char **, char **, c_argv);
1091 if (argc < 2)
1092 fatal_error ("no arguments");
1094 #ifdef SIGQUIT
1095 if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1096 signal (SIGQUIT, handler);
1097 #endif
1098 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1099 signal (SIGINT, handler);
1100 #ifdef SIGALRM
1101 if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
1102 signal (SIGALRM, handler);
1103 #endif
1104 #ifdef SIGHUP
1105 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1106 signal (SIGHUP, handler);
1107 #endif
1108 if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1109 signal (SIGSEGV, handler);
1110 #ifdef SIGBUS
1111 if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1112 signal (SIGBUS, handler);
1113 #endif
1115 /* Extract COMPILER_PATH and PATH into our prefix list. */
1116 prefix_from_env ("COMPILER_PATH", &cpath);
1117 prefix_from_env ("PATH", &path);
1119 /* Try to discover a valid linker/nm/strip to use. */
1121 /* Maybe we know the right file to use (if not cross). */
1122 ld_file_name = 0;
1123 #ifdef DEFAULT_LINKER
1124 if (selected_linker == USE_BFD_LD || selected_linker == USE_GOLD_LD)
1126 char *linker_name;
1127 # ifdef HOST_EXECUTABLE_SUFFIX
1128 int len = (sizeof (DEFAULT_LINKER)
1129 - sizeof (HOST_EXECUTABLE_SUFFIX));
1130 linker_name = NULL;
1131 if (len > 0)
1133 char *default_linker = xstrdup (DEFAULT_LINKER);
1134 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
1135 HOST_EXECUTABLE_SUFFIX. */
1136 if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
1138 default_linker[len] = '\0';
1139 linker_name = concat (default_linker,
1140 &ld_suffixes[selected_linker][2],
1141 HOST_EXECUTABLE_SUFFIX, NULL);
1144 if (linker_name == NULL)
1145 # endif
1146 linker_name = concat (DEFAULT_LINKER,
1147 &ld_suffixes[selected_linker][2],
1148 NULL);
1149 if (access (linker_name, X_OK) == 0)
1150 ld_file_name = linker_name;
1152 if (ld_file_name == 0 && access (DEFAULT_LINKER, X_OK) == 0)
1153 ld_file_name = DEFAULT_LINKER;
1154 if (ld_file_name == 0)
1155 #endif
1156 #ifdef REAL_LD_FILE_NAME
1157 ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME, X_OK);
1158 if (ld_file_name == 0)
1159 #endif
1160 /* Search the (target-specific) compiler dirs for ld'. */
1161 ld_file_name = find_a_file (&cpath, real_ld_suffix, X_OK);
1162 /* Likewise for `collect-ld'. */
1163 if (ld_file_name == 0)
1165 ld_file_name = find_a_file (&cpath, collect_ld_suffix, X_OK);
1166 use_collect_ld = ld_file_name != 0;
1168 /* Search the compiler directories for `ld'. We have protection against
1169 recursive calls in find_a_file. */
1170 if (ld_file_name == 0)
1171 ld_file_name = find_a_file (&cpath, ld_suffixes[selected_linker], X_OK);
1172 /* Search the ordinary system bin directories
1173 for `ld' (if native linking) or `TARGET-ld' (if cross). */
1174 if (ld_file_name == 0)
1175 ld_file_name = find_a_file (&path, full_ld_suffixes[selected_linker], X_OK);
1177 #ifdef REAL_NM_FILE_NAME
1178 nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME, X_OK);
1179 if (nm_file_name == 0)
1180 #endif
1181 nm_file_name = find_a_file (&cpath, gnm_suffix, X_OK);
1182 if (nm_file_name == 0)
1183 nm_file_name = find_a_file (&path, full_gnm_suffix, X_OK);
1184 if (nm_file_name == 0)
1185 nm_file_name = find_a_file (&cpath, nm_suffix, X_OK);
1186 if (nm_file_name == 0)
1187 nm_file_name = find_a_file (&path, full_nm_suffix, X_OK);
1189 #ifdef LDD_SUFFIX
1190 ldd_file_name = find_a_file (&cpath, ldd_suffix, X_OK);
1191 if (ldd_file_name == 0)
1192 ldd_file_name = find_a_file (&path, full_ldd_suffix, X_OK);
1193 #endif
1195 #ifdef REAL_STRIP_FILE_NAME
1196 strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME, X_OK);
1197 if (strip_file_name == 0)
1198 #endif
1199 strip_file_name = find_a_file (&cpath, gstrip_suffix, X_OK);
1200 if (strip_file_name == 0)
1201 strip_file_name = find_a_file (&path, full_gstrip_suffix, X_OK);
1202 if (strip_file_name == 0)
1203 strip_file_name = find_a_file (&cpath, strip_suffix, X_OK);
1204 if (strip_file_name == 0)
1205 strip_file_name = find_a_file (&path, full_strip_suffix, X_OK);
1207 /* Determine the full path name of the C compiler to use. */
1208 c_file_name = getenv ("COLLECT_GCC");
1209 if (c_file_name == 0)
1211 #ifdef CROSS_DIRECTORY_STRUCTURE
1212 c_file_name = concat (target_machine, "-gcc", NULL);
1213 #else
1214 c_file_name = "gcc";
1215 #endif
1218 p = find_a_file (&cpath, c_file_name, X_OK);
1220 /* Here it should be safe to use the system search path since we should have
1221 already qualified the name of the compiler when it is needed. */
1222 if (p == 0)
1223 p = find_a_file (&path, c_file_name, X_OK);
1225 if (p)
1226 c_file_name = p;
1228 *ld1++ = *ld2++ = ld_file_name;
1230 /* Make temp file names. */
1231 c_file = make_temp_file (".c");
1232 o_file = make_temp_file (".o");
1233 #ifdef COLLECT_EXPORT_LIST
1234 export_file = make_temp_file (".x");
1235 #endif
1236 if (!debug)
1238 ldout = make_temp_file (".ld");
1239 lderrout = make_temp_file (".le");
1241 *c_ptr++ = c_file_name;
1242 *c_ptr++ = "-x";
1243 *c_ptr++ = "c";
1244 *c_ptr++ = "-c";
1245 *c_ptr++ = "-o";
1246 *c_ptr++ = o_file;
1248 #ifdef COLLECT_EXPORT_LIST
1249 /* Generate a list of directories from LIBPATH. */
1250 prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1251 /* Add to this list also two standard directories where
1252 AIX loader always searches for libraries. */
1253 add_prefix (&libpath_lib_dirs, "/lib");
1254 add_prefix (&libpath_lib_dirs, "/usr/lib");
1255 #endif
1257 /* Get any options that the upper GCC wants to pass to the sub-GCC.
1259 AIX support needs to know if -shared has been specified before
1260 parsing commandline arguments. */
1262 p = getenv ("COLLECT_GCC_OPTIONS");
1263 while (p && *p)
1265 const char *q = extract_string (&p);
1266 if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1267 *c_ptr++ = xstrdup (q);
1268 if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1269 *c_ptr++ = xstrdup (q);
1270 if (strcmp (q, "-shared") == 0)
1271 shared_obj = 1;
1272 if (*q == '-' && q[1] == 'B')
1274 *c_ptr++ = xstrdup (q);
1275 if (q[2] == 0)
1277 q = extract_string (&p);
1278 *c_ptr++ = xstrdup (q);
1282 obstack_free (&temporary_obstack, temporary_firstobj);
1283 *c_ptr++ = "-fno-profile-arcs";
1284 *c_ptr++ = "-fno-test-coverage";
1285 *c_ptr++ = "-fno-branch-probabilities";
1286 *c_ptr++ = "-fno-exceptions";
1287 *c_ptr++ = "-w";
1288 *c_ptr++ = "-fno-whole-program";
1290 /* !!! When GCC calls collect2,
1291 it does not know whether it is calling collect2 or ld.
1292 So collect2 cannot meaningfully understand any options
1293 except those ld understands.
1294 If you propose to make GCC pass some other option,
1295 just imagine what will happen if ld is really ld!!! */
1297 /* Parse arguments. Remember output file spec, pass the rest to ld. */
1298 /* After the first file, put in the c++ rt0. */
1300 first_file = 1;
1301 while ((arg = *++argv) != (char *) 0)
1303 *ld1++ = *ld2++ = arg;
1305 if (arg[0] == '-')
1307 switch (arg[1])
1309 case 'd':
1310 if (!strcmp (arg, "-debug"))
1312 /* Already parsed. */
1313 ld1--;
1314 ld2--;
1316 if (!strcmp (arg, "-dynamic-linker") && argv[1])
1318 ++argv;
1319 *ld1++ = *ld2++ = *argv;
1321 break;
1323 case 'f':
1324 if (strncmp (arg, "-flto", 5) == 0)
1326 #ifdef ENABLE_LTO
1327 /* Do not pass LTO flag to the linker. */
1328 ld1--;
1329 ld2--;
1330 #else
1331 error ("LTO support has not been enabled in this "
1332 "configuration");
1333 #endif
1335 else if (!use_collect_ld
1336 && strncmp (arg, "-fuse-ld=", 9) == 0)
1338 /* Do not pass -fuse-ld={bfd|gold} to the linker. */
1339 ld1--;
1340 ld2--;
1342 #ifdef TARGET_AIX_VERSION
1343 else
1345 /* File containing a list of input files to process. */
1347 FILE *stream;
1348 char buf[MAXPATHLEN + 2];
1349 /* Number of additionnal object files. */
1350 int add_nbr = 0;
1351 /* Maximum of additionnal object files before vector
1352 expansion. */
1353 int add_max = 0;
1354 const char *list_filename = arg + 2;
1356 /* Accept -fFILENAME and -f FILENAME. */
1357 if (*list_filename == '\0' && argv[1])
1359 ++argv;
1360 list_filename = *argv;
1361 *ld1++ = *ld2++ = *argv;
1364 stream = fopen (list_filename, "r");
1365 if (stream == NULL)
1366 fatal_error ("can't open %s: %m", list_filename);
1368 while (fgets (buf, sizeof buf, stream) != NULL)
1370 /* Remove end of line. */
1371 int len = strlen (buf);
1372 if (len >= 1 && buf[len - 1] =='\n')
1373 buf[len - 1] = '\0';
1375 /* Put on object vector.
1376 Note: we only expanse vector here, so we must keep
1377 extra space for remaining arguments. */
1378 if (add_nbr >= add_max)
1380 int pos =
1381 object - CONST_CAST2 (const char **, char **,
1382 object_lst);
1383 add_max = (add_max == 0) ? 16 : add_max * 2;
1384 object_lst = XRESIZEVEC (char *, object_lst,
1385 object_nbr + add_max);
1386 object = CONST_CAST2 (const char **, char **,
1387 object_lst) + pos;
1388 object_nbr += add_max;
1390 *object++ = xstrdup (buf);
1391 add_nbr++;
1393 fclose (stream);
1395 #endif
1396 break;
1398 case 'l':
1399 if (first_file)
1401 /* place o_file BEFORE this argument! */
1402 first_file = 0;
1403 ld2--;
1404 *ld2++ = o_file;
1405 *ld2++ = arg;
1407 #ifdef COLLECT_EXPORT_LIST
1409 /* Resolving full library name. */
1410 const char *s = resolve_lib_name (arg+2);
1412 /* Saving a full library name. */
1413 add_to_list (&libs, s);
1415 #endif
1416 break;
1418 #ifdef COLLECT_EXPORT_LIST
1419 /* Saving directories where to search for libraries. */
1420 case 'L':
1421 add_prefix (&cmdline_lib_dirs, arg+2);
1422 break;
1423 #endif
1425 case 'o':
1426 if (arg[2] == '\0')
1427 output_file = *ld1++ = *ld2++ = *++argv;
1428 else
1429 output_file = &arg[2];
1430 break;
1432 case 'r':
1433 if (arg[2] == '\0')
1434 rflag = 1;
1435 break;
1437 case 's':
1438 if (arg[2] == '\0' && do_collecting)
1440 /* We must strip after the nm run, otherwise C++ linking
1441 will not work. Thus we strip in the second ld run, or
1442 else with strip if there is no second ld run. */
1443 strip_flag = 1;
1444 ld1--;
1446 break;
1448 case 'v':
1449 if (arg[2] == '\0')
1450 vflag = true;
1451 break;
1453 case '-':
1454 if (strcmp (arg, "--no-demangle") == 0)
1456 #ifndef HAVE_LD_DEMANGLE
1457 no_demangle = 1;
1458 ld1--;
1459 ld2--;
1460 #endif
1462 else if (strncmp (arg, "--demangle", 10) == 0)
1464 #ifndef HAVE_LD_DEMANGLE
1465 no_demangle = 0;
1466 if (arg[10] == '=')
1468 enum demangling_styles style
1469 = cplus_demangle_name_to_style (arg+11);
1470 if (style == unknown_demangling)
1471 error ("unknown demangling style '%s'", arg+11);
1472 else
1473 current_demangling_style = style;
1475 ld1--;
1476 ld2--;
1477 #endif
1479 else if (strncmp (arg, "--sysroot=", 10) == 0)
1480 target_system_root = arg + 10;
1481 else if (strcmp (arg, "--version") == 0)
1482 vflag = true;
1483 else if (strcmp (arg, "--help") == 0)
1484 helpflag = true;
1485 break;
1488 else if ((p = strrchr (arg, '.')) != (char *) 0
1489 && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1490 || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1491 || strcmp (p, ".obj") == 0))
1493 if (first_file)
1495 first_file = 0;
1496 if (p[1] == 'o')
1497 *ld2++ = o_file;
1498 else
1500 /* place o_file BEFORE this argument! */
1501 ld2--;
1502 *ld2++ = o_file;
1503 *ld2++ = arg;
1506 if (p[1] == 'o' || p[1] == 'l')
1507 *object++ = arg;
1508 #ifdef COLLECT_EXPORT_LIST
1509 /* libraries can be specified directly, i.e. without -l flag. */
1510 else
1512 /* Saving a full library name. */
1513 add_to_list (&libs, arg);
1515 #endif
1519 #ifdef COLLECT_EXPORT_LIST
1520 /* This is added only for debugging purposes. */
1521 if (debug)
1523 fprintf (stderr, "List of libraries:\n");
1524 dump_list (stderr, "\t", libs.first);
1527 /* The AIX linker will discard static constructors in object files if
1528 nothing else in the file is referenced, so look at them first. Unless
1529 we are building a shared object, ignore the eh frame tables, as we
1530 would otherwise reference them all, hence drag all the corresponding
1531 objects even if nothing else is referenced. */
1533 const char **export_object_lst
1534 = CONST_CAST2 (const char **, char **, object_lst);
1536 struct id *list = libs.first;
1538 /* Compute the filter to use from the current one, do scan, then adjust
1539 the "current" filter to remove what we just included here. This will
1540 control whether we need a first pass link later on or not, and what
1541 will remain to be scanned there. */
1543 scanfilter this_filter = ld1_filter;
1544 #if HAVE_AS_REF
1545 if (!shared_obj)
1546 this_filter &= ~SCAN_DWEH;
1547 #endif
1549 while (export_object_lst < object)
1550 scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);
1552 for (; list; list = list->next)
1553 scan_prog_file (list->name, PASS_FIRST, this_filter);
1555 ld1_filter = ld1_filter & ~this_filter;
1558 if (exports.first)
1560 char *buf = concat ("-bE:", export_file, NULL);
1562 *ld1++ = buf;
1563 *ld2++ = buf;
1565 exportf = fopen (export_file, "w");
1566 if (exportf == (FILE *) 0)
1567 fatal_error ("fopen %s: %m", export_file);
1568 write_aix_file (exportf, exports.first);
1569 if (fclose (exportf))
1570 fatal_error ("fclose %s: %m", export_file);
1572 #endif
1574 *c_ptr++ = c_file;
1575 *c_ptr = *ld1 = *object = (char *) 0;
1577 if (vflag)
1578 notice ("collect2 version %s\n", version_string);
1580 if (helpflag)
1582 printf ("Usage: collect2 [options]\n");
1583 printf (" Wrap linker and generate constructor code if needed.\n");
1584 printf (" Options:\n");
1585 printf (" -debug Enable debug output\n");
1586 printf (" --help Display this information\n");
1587 printf (" -v, --version Display this program's version number\n");
1588 printf ("\n");
1589 printf ("Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
1590 printf ("Report bugs: %s\n", bug_report_url);
1591 printf ("\n");
1594 if (debug)
1596 const char *ptr;
1597 fprintf (stderr, "ld_file_name = %s\n",
1598 (ld_file_name ? ld_file_name : "not found"));
1599 fprintf (stderr, "c_file_name = %s\n",
1600 (c_file_name ? c_file_name : "not found"));
1601 fprintf (stderr, "nm_file_name = %s\n",
1602 (nm_file_name ? nm_file_name : "not found"));
1603 #ifdef LDD_SUFFIX
1604 fprintf (stderr, "ldd_file_name = %s\n",
1605 (ldd_file_name ? ldd_file_name : "not found"));
1606 #endif
1607 fprintf (stderr, "strip_file_name = %s\n",
1608 (strip_file_name ? strip_file_name : "not found"));
1609 fprintf (stderr, "c_file = %s\n",
1610 (c_file ? c_file : "not found"));
1611 fprintf (stderr, "o_file = %s\n",
1612 (o_file ? o_file : "not found"));
1614 ptr = getenv ("COLLECT_GCC_OPTIONS");
1615 if (ptr)
1616 fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1618 ptr = getenv ("COLLECT_GCC");
1619 if (ptr)
1620 fprintf (stderr, "COLLECT_GCC = %s\n", ptr);
1622 ptr = getenv ("COMPILER_PATH");
1623 if (ptr)
1624 fprintf (stderr, "COMPILER_PATH = %s\n", ptr);
1626 ptr = getenv (LIBRARY_PATH_ENV);
1627 if (ptr)
1628 fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1630 fprintf (stderr, "\n");
1633 /* Load the program, searching all libraries and attempting to provide
1634 undefined symbols from repository information.
1636 If -r or they will be run via some other method, do not build the
1637 constructor or destructor list, just return now. */
1639 bool early_exit
1640 = rflag || (! DO_COLLECT_EXPORT_LIST && ! do_collecting);
1642 /* Perform the first pass link now, if we're about to exit or if we need
1643 to scan for things we haven't collected yet before pursuing further.
1645 On AIX, the latter typically includes nothing for shared objects or
1646 frame tables for an executable, out of what the required early scan on
1647 objects and libraries has performed above. In the !shared_obj case, we
1648 expect the relevant tables to be dragged together with their associated
1649 functions from precise cross reference insertions by the compiler. */
1651 if (early_exit || ld1_filter != SCAN_NOTHING)
1652 do_tlink (ld1_argv, object_lst);
1654 if (early_exit)
1656 #ifdef COLLECT_EXPORT_LIST
1657 /* Make sure we delete the export file we may have created. */
1658 if (export_file != 0 && export_file[0])
1659 maybe_unlink (export_file);
1660 #endif
1661 if (lto_mode != LTO_MODE_NONE)
1662 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1663 else
1664 post_ld_pass (false);
1666 maybe_unlink (c_file);
1667 maybe_unlink (o_file);
1668 return 0;
1672 /* Unless we have done it all already, examine the namelist and search for
1673 static constructors and destructors to call. Write the constructor and
1674 destructor tables to a .s file and reload. */
1676 if (ld1_filter != SCAN_NOTHING)
1677 scan_prog_file (output_file, PASS_FIRST, ld1_filter);
1679 #ifdef SCAN_LIBRARIES
1680 scan_libraries (output_file);
1681 #endif
1683 if (debug)
1685 notice_translated (ngettext ("%d constructor found\n",
1686 "%d constructors found\n",
1687 constructors.number),
1688 constructors.number);
1689 notice_translated (ngettext ("%d destructor found\n",
1690 "%d destructors found\n",
1691 destructors.number),
1692 destructors.number);
1693 notice_translated (ngettext ("%d frame table found\n",
1694 "%d frame tables found\n",
1695 frame_tables.number),
1696 frame_tables.number);
1699 /* If the scan exposed nothing of special interest, there's no need to
1700 generate the glue code and relink so return now. */
1702 if (constructors.number == 0 && destructors.number == 0
1703 && frame_tables.number == 0
1704 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1705 /* If we will be running these functions ourselves, we want to emit
1706 stubs into the shared library so that we do not have to relink
1707 dependent programs when we add static objects. */
1708 && ! shared_obj
1709 #endif
1712 /* Do tlink without additional code generation now if we didn't
1713 do it earlier for scanning purposes. */
1714 if (ld1_filter == SCAN_NOTHING)
1715 do_tlink (ld1_argv, object_lst);
1717 if (lto_mode)
1718 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
1720 /* Strip now if it was requested on the command line. */
1721 if (strip_flag)
1723 char **real_strip_argv = XCNEWVEC (char *, 3);
1724 const char ** strip_argv = CONST_CAST2 (const char **, char **,
1725 real_strip_argv);
1727 strip_argv[0] = strip_file_name;
1728 strip_argv[1] = output_file;
1729 strip_argv[2] = (char *) 0;
1730 fork_execute ("strip", real_strip_argv);
1733 #ifdef COLLECT_EXPORT_LIST
1734 maybe_unlink (export_file);
1735 #endif
1736 post_ld_pass (false);
1738 maybe_unlink (c_file);
1739 maybe_unlink (o_file);
1740 return 0;
1743 /* Sort ctor and dtor lists by priority. */
1744 sort_ids (&constructors);
1745 sort_ids (&destructors);
1747 maybe_unlink (output_file);
1748 outf = fopen (c_file, "w");
1749 if (outf == (FILE *) 0)
1750 fatal_error ("fopen %s: %m", c_file);
1752 write_c_file (outf, c_file);
1754 if (fclose (outf))
1755 fatal_error ("fclose %s: %m", c_file);
1757 /* Tell the linker that we have initializer and finalizer functions. */
1758 #ifdef LD_INIT_SWITCH
1759 #ifdef COLLECT_EXPORT_LIST
1760 *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1761 #else
1762 *ld2++ = LD_INIT_SWITCH;
1763 *ld2++ = initname;
1764 *ld2++ = LD_FINI_SWITCH;
1765 *ld2++ = fininame;
1766 #endif
1767 #endif
1769 #ifdef COLLECT_EXPORT_LIST
1770 if (shared_obj)
1772 /* If we did not add export flag to link arguments before, add it to
1773 second link phase now. No new exports should have been added. */
1774 if (! exports.first)
1775 *ld2++ = concat ("-bE:", export_file, NULL);
1777 #ifdef TARGET_AIX_VERSION
1778 add_to_list (&exports, aix_shared_initname);
1779 add_to_list (&exports, aix_shared_fininame);
1780 #endif
1782 #ifndef LD_INIT_SWITCH
1783 add_to_list (&exports, initname);
1784 add_to_list (&exports, fininame);
1785 add_to_list (&exports, "_GLOBAL__DI");
1786 add_to_list (&exports, "_GLOBAL__DD");
1787 #endif
1788 exportf = fopen (export_file, "w");
1789 if (exportf == (FILE *) 0)
1790 fatal_error ("fopen %s: %m", export_file);
1791 write_aix_file (exportf, exports.first);
1792 if (fclose (exportf))
1793 fatal_error ("fclose %s: %m", export_file);
1795 #endif
1797 /* End of arguments to second link phase. */
1798 *ld2 = (char*) 0;
1800 if (debug)
1802 fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1803 output_file, c_file);
1804 write_c_file (stderr, "stderr");
1805 fprintf (stderr, "========== end of c_file\n\n");
1806 #ifdef COLLECT_EXPORT_LIST
1807 fprintf (stderr, "\n========== export_file = %s\n", export_file);
1808 write_aix_file (stderr, exports.first);
1809 fprintf (stderr, "========== end of export_file\n\n");
1810 #endif
1813 /* Assemble the constructor and destructor tables.
1814 Link the tables in with the rest of the program. */
1816 fork_execute ("gcc", c_argv);
1817 #ifdef COLLECT_EXPORT_LIST
1818 /* On AIX we must call tlink because of possible templates resolution. */
1819 do_tlink (ld2_argv, object_lst);
1821 if (lto_mode)
1822 maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1823 #else
1824 /* Otherwise, simply call ld because tlink is already done. */
1825 if (lto_mode)
1826 maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
1827 else
1829 fork_execute ("ld", ld2_argv);
1830 post_ld_pass (false);
1833 /* Let scan_prog_file do any final mods (OSF/rose needs this for
1834 constructors/destructors in shared libraries. */
1835 scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1836 #endif
1838 maybe_unlink (c_file);
1839 maybe_unlink (o_file);
1841 #ifdef COLLECT_EXPORT_LIST
1842 maybe_unlink (export_file);
1843 #endif
1845 return 0;
1849 /* Wait for a process to finish, and exit if a nonzero status is found. */
1852 collect_wait (const char *prog, struct pex_obj *pex)
1854 int status;
1856 if (!pex_get_status (pex, 1, &status))
1857 fatal_error ("can't get program status: %m");
1858 pex_free (pex);
1860 if (status)
1862 if (WIFSIGNALED (status))
1864 int sig = WTERMSIG (status);
1865 error ("%s terminated with signal %d [%s]%s",
1866 prog, sig, strsignal (sig),
1867 WCOREDUMP (status) ? ", core dumped" : "");
1868 exit (FATAL_EXIT_CODE);
1871 if (WIFEXITED (status))
1872 return WEXITSTATUS (status);
1874 return 0;
1877 static void
1878 do_wait (const char *prog, struct pex_obj *pex)
1880 int ret = collect_wait (prog, pex);
1881 if (ret != 0)
1883 error ("%s returned %d exit status", prog, ret);
1884 exit (ret);
1887 if (response_file)
1889 unlink (response_file);
1890 response_file = NULL;
1895 /* Execute a program, and wait for the reply. */
1897 struct pex_obj *
1898 collect_execute (const char *prog, char **argv, const char *outname,
1899 const char *errname, int flags)
1901 struct pex_obj *pex;
1902 const char *errmsg;
1903 int err;
1904 char *response_arg = NULL;
1905 char *response_argv[3] ATTRIBUTE_UNUSED;
1907 if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
1909 /* If using @file arguments, create a temporary file and put the
1910 contents of argv into it. Then change argv to an array corresponding
1911 to a single argument @FILE, where FILE is the temporary filename. */
1913 char **current_argv = argv + 1;
1914 char *argv0 = argv[0];
1915 int status;
1916 FILE *f;
1918 /* Note: we assume argv contains at least one element; this is
1919 checked above. */
1921 response_file = make_temp_file ("");
1923 f = fopen (response_file, "w");
1925 if (f == NULL)
1926 fatal_error ("could not open response file %s", response_file);
1928 status = writeargv (current_argv, f);
1930 if (status)
1931 fatal_error ("could not write to response file %s", response_file);
1933 status = fclose (f);
1935 if (EOF == status)
1936 fatal_error ("could not close response file %s", response_file);
1938 response_arg = concat ("@", response_file, NULL);
1939 response_argv[0] = argv0;
1940 response_argv[1] = response_arg;
1941 response_argv[2] = NULL;
1943 argv = response_argv;
1946 if (vflag || debug)
1948 char **p_argv;
1949 const char *str;
1951 if (argv[0])
1952 fprintf (stderr, "%s", argv[0]);
1953 else
1954 notice ("[cannot find %s]", prog);
1956 for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
1957 fprintf (stderr, " %s", str);
1959 fprintf (stderr, "\n");
1962 fflush (stdout);
1963 fflush (stderr);
1965 /* If we cannot find a program we need, complain error. Do this here
1966 since we might not end up needing something that we could not find. */
1968 if (argv[0] == 0)
1969 fatal_error ("cannot find '%s'", prog);
1971 pex = pex_init (0, "collect2", NULL);
1972 if (pex == NULL)
1973 fatal_error ("pex_init failed: %m");
1975 errmsg = pex_run (pex, flags, argv[0], argv, outname,
1976 errname, &err);
1977 if (errmsg != NULL)
1979 if (err != 0)
1981 errno = err;
1982 fatal_error ("%s: %m", _(errmsg));
1984 else
1985 fatal_error (errmsg);
1988 free (response_arg);
1990 return pex;
1993 static void
1994 fork_execute (const char *prog, char **argv)
1996 struct pex_obj *pex;
1998 pex = collect_execute (prog, argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
1999 do_wait (prog, pex);
2002 /* Unlink FILE unless we are debugging or this is the output_file
2003 and we may not unlink it. */
2005 static void
2006 maybe_unlink (const char *file)
2008 if (debug)
2010 notice ("[Leaving %s]\n", file);
2011 return;
2014 if (file == output_file && !may_unlink_output_file)
2015 return;
2017 unlink_if_ordinary (file);
2020 /* Call maybe_unlink on the NULL-terminated list, FILE_LIST. */
2022 static void
2023 maybe_unlink_list (char **file_list)
2025 char **tmp = file_list;
2027 while (*tmp)
2028 maybe_unlink (*(tmp++));
2032 static long sequence_number = 0;
2034 /* Add a name to a linked list. */
2036 static void
2037 add_to_list (struct head *head_ptr, const char *name)
2039 struct id *newid
2040 = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
2041 struct id *p;
2042 strcpy (newid->name, name);
2044 if (head_ptr->first)
2045 head_ptr->last->next = newid;
2046 else
2047 head_ptr->first = newid;
2049 /* Check for duplicate symbols. */
2050 for (p = head_ptr->first;
2051 strcmp (name, p->name) != 0;
2052 p = p->next)
2054 if (p != newid)
2056 head_ptr->last->next = 0;
2057 free (newid);
2058 return;
2061 newid->sequence = ++sequence_number;
2062 head_ptr->last = newid;
2063 head_ptr->number++;
2066 /* Grab the init priority number from an init function name that
2067 looks like "_GLOBAL_.I.12345.foo". */
2069 static int
2070 extract_init_priority (const char *name)
2072 int pos = 0, pri;
2074 #ifdef TARGET_AIX_VERSION
2075 /* Run dependent module initializers before any constructors in this
2076 module. */
2077 switch (is_ctor_dtor (name))
2079 case SYM_AIXI:
2080 case SYM_AIXD:
2081 return INT_MIN;
2082 default:
2083 break;
2085 #endif
2087 while (name[pos] == '_')
2088 ++pos;
2089 pos += 10; /* strlen ("GLOBAL__X_") */
2091 /* Extract init_p number from ctor/dtor name. */
2092 pri = atoi (name + pos);
2093 return pri ? pri : DEFAULT_INIT_PRIORITY;
2096 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
2097 ctors will be run from right to left, dtors from left to right. */
2099 static void
2100 sort_ids (struct head *head_ptr)
2102 /* id holds the current element to insert. id_next holds the next
2103 element to insert. id_ptr iterates through the already sorted elements
2104 looking for the place to insert id. */
2105 struct id *id, *id_next, **id_ptr;
2107 id = head_ptr->first;
2109 /* We don't have any sorted elements yet. */
2110 head_ptr->first = NULL;
2112 for (; id; id = id_next)
2114 id_next = id->next;
2115 id->sequence = extract_init_priority (id->name);
2117 for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
2118 if (*id_ptr == NULL
2119 /* If the sequence numbers are the same, we put the id from the
2120 file later on the command line later in the list. */
2121 || id->sequence > (*id_ptr)->sequence
2122 /* Hack: do lexical compare, too.
2123 || (id->sequence == (*id_ptr)->sequence
2124 && strcmp (id->name, (*id_ptr)->name) > 0) */
2127 id->next = *id_ptr;
2128 *id_ptr = id;
2129 break;
2133 /* Now set the sequence numbers properly so write_c_file works. */
2134 for (id = head_ptr->first; id; id = id->next)
2135 id->sequence = ++sequence_number;
2138 /* Write: `prefix', the names on list LIST, `suffix'. */
2140 static void
2141 write_list (FILE *stream, const char *prefix, struct id *list)
2143 while (list)
2145 fprintf (stream, "%sx%d,\n", prefix, list->sequence);
2146 list = list->next;
2150 #ifdef COLLECT_EXPORT_LIST
2151 /* This function is really used only on AIX, but may be useful. */
2152 #if 0
2153 static int
2154 is_in_list (const char *prefix, struct id *list)
2156 while (list)
2158 if (!strcmp (prefix, list->name)) return 1;
2159 list = list->next;
2161 return 0;
2163 #endif
2164 #endif /* COLLECT_EXPORT_LIST */
2166 /* Added for debugging purpose. */
2167 #ifdef COLLECT_EXPORT_LIST
2168 static void
2169 dump_list (FILE *stream, const char *prefix, struct id *list)
2171 while (list)
2173 fprintf (stream, "%s%s,\n", prefix, list->name);
2174 list = list->next;
2177 #endif
2179 #if 0
2180 static void
2181 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
2183 while (list)
2185 fprintf (stream, "%s%s,\n", prefix, list->prefix);
2186 list = list->next;
2189 #endif
2191 static void
2192 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2194 while (list)
2196 fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
2197 prefix, list->sequence, list->name);
2198 list = list->next;
2202 /* Write out the constructor and destructor tables statically (for a shared
2203 object), along with the functions to execute them. */
2205 static void
2206 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2208 const char *p, *q;
2209 char *prefix, *r;
2210 int frames = (frame_tables.number > 0);
2212 /* Figure out name of output_file, stripping off .so version. */
2213 q = p = lbasename (output_file);
2215 while (q)
2217 q = strchr (q,'.');
2218 if (q == 0)
2220 q = p + strlen (p);
2221 break;
2223 else
2225 if (filename_ncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
2227 q += strlen (SHLIB_SUFFIX);
2228 break;
2230 else
2231 q++;
2234 /* q points to null at end of the string (or . of the .so version) */
2235 prefix = XNEWVEC (char, q - p + 1);
2236 strncpy (prefix, p, q - p);
2237 prefix[q - p] = 0;
2238 for (r = prefix; *r; r++)
2239 if (!ISALNUM ((unsigned char)*r))
2240 *r = '_';
2241 if (debug)
2242 notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
2243 output_file, prefix);
2245 initname = concat ("_GLOBAL__FI_", prefix, NULL);
2246 fininame = concat ("_GLOBAL__FD_", prefix, NULL);
2247 #ifdef TARGET_AIX_VERSION
2248 aix_shared_initname = concat ("_GLOBAL__AIXI_", prefix, NULL);
2249 aix_shared_fininame = concat ("_GLOBAL__AIXD_", prefix, NULL);
2250 #endif
2252 free (prefix);
2254 /* Write the tables as C code. */
2256 /* This count variable is used to prevent multiple calls to the
2257 constructors/destructors.
2258 This guard against multiple calls is important on AIX as the initfini
2259 functions are deliberately invoked multiple times as part of the
2260 mechanisms GCC uses to order constructors across different dependent
2261 shared libraries (see config/rs6000/aix.h).
2263 fprintf (stream, "static int count;\n");
2264 fprintf (stream, "typedef void entry_pt();\n");
2265 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2267 if (frames)
2269 write_list_with_asm (stream, "extern void *", frame_tables.first);
2271 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2272 write_list (stream, "\t\t&", frame_tables.first);
2273 fprintf (stream, "\t0\n};\n");
2275 /* This must match what's in frame.h. */
2276 fprintf (stream, "struct object {\n");
2277 fprintf (stream, " void *pc_begin;\n");
2278 fprintf (stream, " void *pc_end;\n");
2279 fprintf (stream, " void *fde_begin;\n");
2280 fprintf (stream, " void *fde_array;\n");
2281 fprintf (stream, " __SIZE_TYPE__ count;\n");
2282 fprintf (stream, " struct object *next;\n");
2283 fprintf (stream, "};\n");
2285 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2286 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2288 fprintf (stream, "static void reg_frame () {\n");
2289 fprintf (stream, "\tstatic struct object ob;\n");
2290 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2291 fprintf (stream, "\t}\n");
2293 fprintf (stream, "static void dereg_frame () {\n");
2294 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2295 fprintf (stream, "\t}\n");
2298 fprintf (stream, "void %s() {\n", initname);
2299 if (constructors.number > 0 || frames)
2301 fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
2302 write_list (stream, "\t\t", constructors.first);
2303 if (frames)
2304 fprintf (stream, "\treg_frame,\n");
2305 fprintf (stream, "\t};\n");
2306 fprintf (stream, "\tentry_pt **p;\n");
2307 fprintf (stream, "\tif (count++ != 0) return;\n");
2308 fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
2309 fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
2311 else
2312 fprintf (stream, "\t++count;\n");
2313 fprintf (stream, "}\n");
2314 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2315 fprintf (stream, "void %s() {\n", fininame);
2316 if (destructors.number > 0 || frames)
2318 fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
2319 write_list (stream, "\t\t", destructors.first);
2320 if (frames)
2321 fprintf (stream, "\tdereg_frame,\n");
2322 fprintf (stream, "\t};\n");
2323 fprintf (stream, "\tentry_pt **p;\n");
2324 fprintf (stream, "\tif (--count != 0) return;\n");
2325 fprintf (stream, "\tp = dtors;\n");
2326 fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
2327 destructors.number + frames);
2329 fprintf (stream, "}\n");
2331 if (shared_obj)
2333 COLLECT_SHARED_INIT_FUNC (stream, initname);
2334 COLLECT_SHARED_FINI_FUNC (stream, fininame);
2338 /* Write the constructor/destructor tables. */
2340 #ifndef LD_INIT_SWITCH
2341 static void
2342 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2344 /* Write the tables as C code. */
2346 int frames = (frame_tables.number > 0);
2348 fprintf (stream, "typedef void entry_pt();\n\n");
2350 write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2352 if (frames)
2354 write_list_with_asm (stream, "extern void *", frame_tables.first);
2356 fprintf (stream, "\tstatic void *frame_table[] = {\n");
2357 write_list (stream, "\t\t&", frame_tables.first);
2358 fprintf (stream, "\t0\n};\n");
2360 /* This must match what's in frame.h. */
2361 fprintf (stream, "struct object {\n");
2362 fprintf (stream, " void *pc_begin;\n");
2363 fprintf (stream, " void *pc_end;\n");
2364 fprintf (stream, " void *fde_begin;\n");
2365 fprintf (stream, " void *fde_array;\n");
2366 fprintf (stream, " __SIZE_TYPE__ count;\n");
2367 fprintf (stream, " struct object *next;\n");
2368 fprintf (stream, "};\n");
2370 fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2371 fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2373 fprintf (stream, "static void reg_frame () {\n");
2374 fprintf (stream, "\tstatic struct object ob;\n");
2375 fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2376 fprintf (stream, "\t}\n");
2378 fprintf (stream, "static void dereg_frame () {\n");
2379 fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2380 fprintf (stream, "\t}\n");
2383 fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2384 fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2385 write_list (stream, "\t", constructors.first);
2386 if (frames)
2387 fprintf (stream, "\treg_frame,\n");
2388 fprintf (stream, "\t0\n};\n\n");
2390 write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2392 fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2393 fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2394 write_list (stream, "\t", destructors.first);
2395 if (frames)
2396 fprintf (stream, "\tdereg_frame,\n");
2397 fprintf (stream, "\t0\n};\n\n");
2399 fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2400 fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2402 #endif /* ! LD_INIT_SWITCH */
2404 static void
2405 write_c_file (FILE *stream, const char *name)
2407 #ifndef LD_INIT_SWITCH
2408 if (! shared_obj)
2409 write_c_file_glob (stream, name);
2410 else
2411 #endif
2412 write_c_file_stat (stream, name);
2415 #ifdef COLLECT_EXPORT_LIST
2416 static void
2417 write_aix_file (FILE *stream, struct id *list)
2419 for (; list; list = list->next)
2421 fputs (list->name, stream);
2422 putc ('\n', stream);
2425 #endif
2427 #ifdef OBJECT_FORMAT_NONE
2429 /* Check to make sure the file is an LTO object file. */
2431 static bool
2432 maybe_lto_object_file (const char *prog_name)
2434 FILE *f;
2435 unsigned char buf[4];
2436 int i;
2438 static unsigned char elfmagic[4] = { 0x7f, 'E', 'L', 'F' };
2439 static unsigned char coffmagic[2] = { 0x4c, 0x01 };
2440 static unsigned char coffmagic_x64[2] = { 0x64, 0x86 };
2441 static unsigned char machomagic[4][4] = {
2442 { 0xcf, 0xfa, 0xed, 0xfe },
2443 { 0xce, 0xfa, 0xed, 0xfe },
2444 { 0xfe, 0xed, 0xfa, 0xcf },
2445 { 0xfe, 0xed, 0xfa, 0xce }
2448 f = fopen (prog_name, "rb");
2449 if (f == NULL)
2450 return false;
2451 if (fread (buf, sizeof (buf), 1, f) != 1)
2452 buf[0] = 0;
2453 fclose (f);
2455 if (memcmp (buf, elfmagic, sizeof (elfmagic)) == 0
2456 || memcmp (buf, coffmagic, sizeof (coffmagic)) == 0
2457 || memcmp (buf, coffmagic_x64, sizeof (coffmagic_x64)) == 0)
2458 return true;
2459 for (i = 0; i < 4; i++)
2460 if (memcmp (buf, machomagic[i], sizeof (machomagic[i])) == 0)
2461 return true;
2463 return false;
2466 /* Generic version to scan the name list of the loaded program for
2467 the symbols g++ uses for static constructors and destructors. */
2469 static void
2470 scan_prog_file (const char *prog_name, scanpass which_pass,
2471 scanfilter filter)
2473 void (*int_handler) (int);
2474 #ifdef SIGQUIT
2475 void (*quit_handler) (int);
2476 #endif
2477 char *real_nm_argv[4];
2478 const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2479 int argc = 0;
2480 struct pex_obj *pex;
2481 const char *errmsg;
2482 int err;
2483 char *p, buf[1024];
2484 FILE *inf;
2485 int found_lto = 0;
2487 if (which_pass == PASS_SECOND)
2488 return;
2490 /* LTO objects must be in a known format. This check prevents
2491 us from accepting an archive containing LTO objects, which
2492 gcc cannot currently handle. */
2493 if (which_pass == PASS_LTOINFO && !maybe_lto_object_file (prog_name))
2494 return;
2496 /* If we do not have an `nm', complain. */
2497 if (nm_file_name == 0)
2498 fatal_error ("cannot find 'nm'");
2500 nm_argv[argc++] = nm_file_name;
2501 if (NM_FLAGS[0] != '\0')
2502 nm_argv[argc++] = NM_FLAGS;
2504 nm_argv[argc++] = prog_name;
2505 nm_argv[argc++] = (char *) 0;
2507 /* Trace if needed. */
2508 if (vflag)
2510 const char **p_argv;
2511 const char *str;
2513 for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2514 fprintf (stderr, " %s", str);
2516 fprintf (stderr, "\n");
2519 fflush (stdout);
2520 fflush (stderr);
2522 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2523 if (pex == NULL)
2524 fatal_error ("pex_init failed: %m");
2526 errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
2527 &err);
2528 if (errmsg != NULL)
2530 if (err != 0)
2532 errno = err;
2533 fatal_error ("%s: %m", _(errmsg));
2535 else
2536 fatal_error (errmsg);
2539 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2540 #ifdef SIGQUIT
2541 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2542 #endif
2544 inf = pex_read_output (pex, 0);
2545 if (inf == NULL)
2546 fatal_error ("can't open nm output: %m");
2548 if (debug)
2550 if (which_pass == PASS_LTOINFO)
2551 fprintf (stderr, "\nnm output with LTO info marker symbol.\n");
2552 else
2553 fprintf (stderr, "\nnm output with constructors/destructors.\n");
2556 /* Read each line of nm output. */
2557 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2559 int ch, ch2;
2560 char *name, *end;
2562 if (debug)
2563 fprintf (stderr, "\t%s\n", buf);
2565 if (which_pass == PASS_LTOINFO)
2567 if (found_lto)
2568 continue;
2570 /* Look for the LTO info marker symbol, and add filename to
2571 the LTO objects list if found. */
2572 for (p = buf; (ch = *p) != '\0' && ch != '\n'; p++)
2573 if (ch == ' ' && p[1] == '_' && p[2] == '_'
2574 && (strncmp (p + (p[3] == '_' ? 2 : 1), "__gnu_lto_v1", 12) == 0)
2575 && ISSPACE (p[p[3] == '_' ? 14 : 13]))
2577 add_lto_object (&lto_objects, prog_name);
2579 /* We need to read all the input, so we can't just
2580 return here. But we can avoid useless work. */
2581 found_lto = 1;
2583 break;
2586 continue;
2589 /* If it contains a constructor or destructor name, add the name
2590 to the appropriate list unless this is a kind of symbol we're
2591 not supposed to even consider. */
2593 for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2594 if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2595 break;
2597 if (ch != '_')
2598 continue;
2600 name = p;
2601 /* Find the end of the symbol name.
2602 Do not include `|', because Encore nm can tack that on the end. */
2603 for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2604 end++)
2605 continue;
2608 *end = '\0';
2610 switch (is_ctor_dtor (name))
2612 case SYM_CTOR:
2613 if (! (filter & SCAN_CTOR))
2614 break;
2615 if (which_pass != PASS_LIB)
2616 add_to_list (&constructors, name);
2617 break;
2619 case SYM_DTOR:
2620 if (! (filter & SCAN_DTOR))
2621 break;
2622 if (which_pass != PASS_LIB)
2623 add_to_list (&destructors, name);
2624 break;
2626 case SYM_INIT:
2627 if (! (filter & SCAN_INIT))
2628 break;
2629 if (which_pass != PASS_LIB)
2630 fatal_error ("init function found in object %s", prog_name);
2631 #ifndef LD_INIT_SWITCH
2632 add_to_list (&constructors, name);
2633 #endif
2634 break;
2636 case SYM_FINI:
2637 if (! (filter & SCAN_FINI))
2638 break;
2639 if (which_pass != PASS_LIB)
2640 fatal_error ("fini function found in object %s", prog_name);
2641 #ifndef LD_FINI_SWITCH
2642 add_to_list (&destructors, name);
2643 #endif
2644 break;
2646 case SYM_DWEH:
2647 if (! (filter & SCAN_DWEH))
2648 break;
2649 if (which_pass != PASS_LIB)
2650 add_to_list (&frame_tables, name);
2651 break;
2653 default: /* not a constructor or destructor */
2654 continue;
2658 if (debug)
2659 fprintf (stderr, "\n");
2661 do_wait (nm_file_name, pex);
2663 signal (SIGINT, int_handler);
2664 #ifdef SIGQUIT
2665 signal (SIGQUIT, quit_handler);
2666 #endif
2669 #ifdef LDD_SUFFIX
2671 /* Use the List Dynamic Dependencies program to find shared libraries that
2672 the output file depends upon and their initialization/finalization
2673 routines, if any. */
2675 static void
2676 scan_libraries (const char *prog_name)
2678 static struct head libraries; /* list of shared libraries found */
2679 struct id *list;
2680 void (*int_handler) (int);
2681 #ifdef SIGQUIT
2682 void (*quit_handler) (int);
2683 #endif
2684 char *real_ldd_argv[4];
2685 const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv);
2686 int argc = 0;
2687 struct pex_obj *pex;
2688 const char *errmsg;
2689 int err;
2690 char buf[1024];
2691 FILE *inf;
2693 /* If we do not have an `ldd', complain. */
2694 if (ldd_file_name == 0)
2696 error ("cannot find 'ldd'");
2697 return;
2700 ldd_argv[argc++] = ldd_file_name;
2701 ldd_argv[argc++] = prog_name;
2702 ldd_argv[argc++] = (char *) 0;
2704 /* Trace if needed. */
2705 if (vflag)
2707 const char **p_argv;
2708 const char *str;
2710 for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2711 fprintf (stderr, " %s", str);
2713 fprintf (stderr, "\n");
2716 fflush (stdout);
2717 fflush (stderr);
2719 pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2720 if (pex == NULL)
2721 fatal_error ("pex_init failed: %m");
2723 errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2724 if (errmsg != NULL)
2726 if (err != 0)
2728 errno = err;
2729 fatal_error ("%s: %m", _(errmsg));
2731 else
2732 fatal_error (errmsg);
2735 int_handler = (void (*) (int)) signal (SIGINT, SIG_IGN);
2736 #ifdef SIGQUIT
2737 quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2738 #endif
2740 inf = pex_read_output (pex, 0);
2741 if (inf == NULL)
2742 fatal_error ("can't open ldd output: %m");
2744 if (debug)
2745 notice ("\nldd output with constructors/destructors.\n");
2747 /* Read each line of ldd output. */
2748 while (fgets (buf, sizeof buf, inf) != (char *) 0)
2750 int ch2;
2751 char *name, *end, *p = buf;
2753 /* Extract names of libraries and add to list. */
2754 PARSE_LDD_OUTPUT (p);
2755 if (p == 0)
2756 continue;
2758 name = p;
2759 if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2760 fatal_error ("dynamic dependency %s not found", buf);
2762 /* Find the end of the symbol name. */
2763 for (end = p;
2764 (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2765 end++)
2766 continue;
2767 *end = '\0';
2769 if (access (name, R_OK) == 0)
2770 add_to_list (&libraries, name);
2771 else
2772 fatal_error ("unable to open dynamic dependency '%s'", buf);
2774 if (debug)
2775 fprintf (stderr, "\t%s\n", buf);
2777 if (debug)
2778 fprintf (stderr, "\n");
2780 do_wait (ldd_file_name, pex);
2782 signal (SIGINT, int_handler);
2783 #ifdef SIGQUIT
2784 signal (SIGQUIT, quit_handler);
2785 #endif
2787 /* Now iterate through the library list adding their symbols to
2788 the list. */
2789 for (list = libraries.first; list; list = list->next)
2790 scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2793 #endif /* LDD_SUFFIX */
2795 #endif /* OBJECT_FORMAT_NONE */
2799 * COFF specific stuff.
2802 #ifdef OBJECT_FORMAT_COFF
2804 #if defined (EXTENDED_COFF)
2806 # define GCC_SYMBOLS(X) (SYMHEADER (X).isymMax + SYMHEADER (X).iextMax)
2807 # define GCC_SYMENT SYMR
2808 # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
2809 # define GCC_SYMINC(X) (1)
2810 # define GCC_SYMZERO(X) (SYMHEADER (X).isymMax)
2811 # define GCC_CHECK_HDR(X) (PSYMTAB (X) != 0)
2813 #else
2815 # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
2816 # define GCC_SYMENT SYMENT
2817 # if defined (C_WEAKEXT)
2818 # define GCC_OK_SYMBOL(X) \
2819 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2820 ((X).n_scnum > N_UNDEF) && \
2821 (aix64_flag \
2822 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2823 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2824 # define GCC_UNDEF_SYMBOL(X) \
2825 (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2826 ((X).n_scnum == N_UNDEF))
2827 # else
2828 # define GCC_OK_SYMBOL(X) \
2829 (((X).n_sclass == C_EXT) && \
2830 ((X).n_scnum > N_UNDEF) && \
2831 (aix64_flag \
2832 || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2833 || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2834 # define GCC_UNDEF_SYMBOL(X) \
2835 (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2836 # endif
2837 # define GCC_SYMINC(X) ((X).n_numaux+1)
2838 # define GCC_SYMZERO(X) 0
2840 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2841 #if TARGET_AIX_VERSION >= 51
2842 # define GCC_CHECK_HDR(X) \
2843 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2844 || (HEADER (X).f_magic == 0767 && aix64_flag)) \
2845 && !(HEADER (X).f_flags & F_LOADONLY))
2846 #else
2847 # define GCC_CHECK_HDR(X) \
2848 (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2849 || (HEADER (X).f_magic == 0757 && aix64_flag)) \
2850 && !(HEADER (X).f_flags & F_LOADONLY))
2851 #endif
2853 #endif
2855 #ifdef COLLECT_EXPORT_LIST
2856 /* Array of standard AIX libraries which should not
2857 be scanned for ctors/dtors. */
2858 static const char *const aix_std_libs[] = {
2859 "/unix",
2860 "/lib/libc.a",
2861 "/lib/libm.a",
2862 "/lib/libc_r.a",
2863 "/lib/libm_r.a",
2864 "/usr/lib/libc.a",
2865 "/usr/lib/libm.a",
2866 "/usr/lib/libc_r.a",
2867 "/usr/lib/libm_r.a",
2868 "/usr/lib/threads/libc.a",
2869 "/usr/ccs/lib/libc.a",
2870 "/usr/ccs/lib/libm.a",
2871 "/usr/ccs/lib/libc_r.a",
2872 "/usr/ccs/lib/libm_r.a",
2873 NULL
2876 /* This function checks the filename and returns 1
2877 if this name matches the location of a standard AIX library. */
2878 static int ignore_library (const char *);
2879 static int
2880 ignore_library (const char *name)
2882 const char *const *p;
2883 size_t length;
2885 if (target_system_root[0] != '\0')
2887 length = strlen (target_system_root);
2888 if (strncmp (name, target_system_root, length) != 0)
2889 return 0;
2890 name += length;
2892 for (p = &aix_std_libs[0]; *p != NULL; ++p)
2893 if (strcmp (name, *p) == 0)
2894 return 1;
2895 return 0;
2897 #endif /* COLLECT_EXPORT_LIST */
2899 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2900 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2901 #endif
2903 /* COFF version to scan the name list of the loaded program for
2904 the symbols g++ uses for static constructors and destructors. */
2906 static void
2907 scan_prog_file (const char *prog_name, scanpass which_pass,
2908 scanfilter filter)
2910 LDFILE *ldptr = NULL;
2911 int sym_index, sym_count;
2912 int is_shared = 0;
2914 if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2915 return;
2917 #ifdef COLLECT_EXPORT_LIST
2918 /* We do not need scanning for some standard C libraries. */
2919 if (which_pass == PASS_FIRST && ignore_library (prog_name))
2920 return;
2922 /* On AIX we have a loop, because there is not much difference
2923 between an object and an archive. This trick allows us to
2924 eliminate scan_libraries() function. */
2927 #endif
2928 /* Some platforms (e.g. OSF4) declare ldopen as taking a
2929 non-const char * filename parameter, even though it will not
2930 modify that string. So we must cast away const-ness here,
2931 using CONST_CAST to prevent complaints from -Wcast-qual. */
2932 if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
2934 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
2935 fatal_error ("%s: not a COFF file", prog_name);
2937 if (GCC_CHECK_HDR (ldptr))
2939 sym_count = GCC_SYMBOLS (ldptr);
2940 sym_index = GCC_SYMZERO (ldptr);
2942 #ifdef COLLECT_EXPORT_LIST
2943 /* Is current archive member a shared object? */
2944 is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2945 #endif
2947 while (sym_index < sym_count)
2949 GCC_SYMENT symbol;
2951 if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2952 break;
2953 sym_index += GCC_SYMINC (symbol);
2955 if (GCC_OK_SYMBOL (symbol))
2957 char *name;
2959 if ((name = ldgetname (ldptr, &symbol)) == NULL)
2960 continue; /* Should never happen. */
2962 #ifdef XCOFF_DEBUGGING_INFO
2963 /* All AIX function names have a duplicate entry
2964 beginning with a dot. */
2965 if (*name == '.')
2966 ++name;
2967 #endif
2969 switch (is_ctor_dtor (name))
2971 #if TARGET_AIX_VERSION
2972 /* Add AIX shared library initalisers/finalisers
2973 to the constructors/destructors list of the
2974 current module. */
2975 case SYM_AIXI:
2976 if (! (filter & SCAN_CTOR))
2977 break;
2978 if (is_shared && !aixlazy_flag)
2979 add_to_list (&constructors, name);
2980 break;
2982 case SYM_AIXD:
2983 if (! (filter & SCAN_DTOR))
2984 break;
2985 if (is_shared && !aixlazy_flag)
2986 add_to_list (&destructors, name);
2987 break;
2988 #endif
2990 case SYM_CTOR:
2991 if (! (filter & SCAN_CTOR))
2992 break;
2993 if (! is_shared)
2994 add_to_list (&constructors, name);
2995 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2996 if (which_pass == PASS_OBJ)
2997 add_to_list (&exports, name);
2998 #endif
2999 break;
3001 case SYM_DTOR:
3002 if (! (filter & SCAN_DTOR))
3003 break;
3004 if (! is_shared)
3005 add_to_list (&destructors, name);
3006 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3007 if (which_pass == PASS_OBJ)
3008 add_to_list (&exports, name);
3009 #endif
3010 break;
3012 #ifdef COLLECT_EXPORT_LIST
3013 case SYM_INIT:
3014 if (! (filter & SCAN_INIT))
3015 break;
3016 #ifndef LD_INIT_SWITCH
3017 if (is_shared)
3018 add_to_list (&constructors, name);
3019 #endif
3020 break;
3022 case SYM_FINI:
3023 if (! (filter & SCAN_FINI))
3024 break;
3025 #ifndef LD_INIT_SWITCH
3026 if (is_shared)
3027 add_to_list (&destructors, name);
3028 #endif
3029 break;
3030 #endif
3032 case SYM_DWEH:
3033 if (! (filter & SCAN_DWEH))
3034 break;
3035 if (! is_shared)
3036 add_to_list (&frame_tables, name);
3037 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
3038 if (which_pass == PASS_OBJ)
3039 add_to_list (&exports, name);
3040 #endif
3041 break;
3043 default: /* not a constructor or destructor */
3044 #ifdef COLLECT_EXPORT_LIST
3045 /* Explicitly export all global symbols when
3046 building a shared object on AIX, but do not
3047 re-export symbols from another shared object
3048 and do not export symbols if the user
3049 provides an explicit export list. */
3050 if (shared_obj && !is_shared
3051 && which_pass == PASS_OBJ && !export_flag)
3052 add_to_list (&exports, name);
3053 #endif
3054 continue;
3057 if (debug)
3058 #if !defined(EXTENDED_COFF)
3059 fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
3060 symbol.n_scnum, symbol.n_sclass,
3061 (symbol.n_type ? "0" : ""), symbol.n_type,
3062 name);
3063 #else
3064 fprintf (stderr,
3065 "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
3066 symbol.iss, (long) symbol.value, symbol.index, name);
3067 #endif
3071 #ifdef COLLECT_EXPORT_LIST
3072 else
3074 /* If archive contains both 32-bit and 64-bit objects,
3075 we want to skip objects in other mode so mismatch normal. */
3076 if (debug)
3077 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
3078 prog_name, HEADER (ldptr).f_magic, aix64_flag);
3080 #endif
3082 else
3084 fatal_error ("%s: cannot open as COFF file", prog_name);
3086 #ifdef COLLECT_EXPORT_LIST
3087 /* On AIX loop continues while there are more members in archive. */
3089 while (ldclose (ldptr) == FAILURE);
3090 #else
3091 /* Otherwise we simply close ldptr. */
3092 (void) ldclose (ldptr);
3093 #endif
3095 #endif /* OBJECT_FORMAT_COFF */
3097 #ifdef COLLECT_EXPORT_LIST
3098 /* Given a library name without "lib" prefix, this function
3099 returns a full library name including a path. */
3100 static char *
3101 resolve_lib_name (const char *name)
3103 char *lib_buf;
3104 int i, j, l = 0;
3105 /* Library extensions for AIX dynamic linking. */
3106 const char * const libexts[2] = {"a", "so"};
3108 for (i = 0; libpaths[i]; i++)
3109 if (libpaths[i]->max_len > l)
3110 l = libpaths[i]->max_len;
3112 lib_buf = XNEWVEC (char, l + strlen (name) + 10);
3114 for (i = 0; libpaths[i]; i++)
3116 struct prefix_list *list = libpaths[i]->plist;
3117 for (; list; list = list->next)
3119 /* The following lines are needed because path_prefix list
3120 may contain directories both with trailing DIR_SEPARATOR and
3121 without it. */
3122 const char *p = "";
3123 if (!IS_DIR_SEPARATOR (list->prefix[strlen (list->prefix)-1]))
3124 p = "/";
3125 for (j = 0; j < 2; j++)
3127 sprintf (lib_buf, "%s%slib%s.%s",
3128 list->prefix, p, name,
3129 libexts[(j + aixrtl_flag) % 2]);
3130 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
3131 if (file_exists (lib_buf))
3133 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
3134 return (lib_buf);
3139 if (debug)
3140 fprintf (stderr, "not found\n");
3141 else
3142 fatal_error ("library lib%s not found", name);
3143 return (NULL);
3145 #endif /* COLLECT_EXPORT_LIST */
3147 #ifdef COLLECT_RUN_DSYMUTIL
3148 static int flag_dsym = false;
3149 static int flag_idsym = false;
3151 static void
3152 process_args (int *argcp, char **argv) {
3153 int i, j;
3154 int argc = *argcp;
3155 for (i=0; i<argc; ++i)
3157 if (strcmp (argv[i], "-dsym") == 0)
3159 flag_dsym = true;
3160 /* Remove the flag, as we handle all processing for it. */
3161 j = i;
3163 argv[j] = argv[j+1];
3164 while (++j < argc);
3165 --i;
3166 argc = --(*argcp);
3168 else if (strcmp (argv[i], "-idsym") == 0)
3170 flag_idsym = true;
3171 /* Remove the flag, as we handle all processing for it. */
3172 j = i;
3174 argv[j] = argv[j+1];
3175 while (++j < argc);
3176 --i;
3177 argc = --(*argcp);
3182 static void
3183 do_dsymutil (const char *output_file) {
3184 const char *dsymutil = DSYMUTIL + 1;
3185 struct pex_obj *pex;
3186 char **real_argv = XCNEWVEC (char *, 3);
3187 const char ** argv = CONST_CAST2 (const char **, char **,
3188 real_argv);
3190 argv[0] = dsymutil;
3191 argv[1] = output_file;
3192 argv[2] = (char *) 0;
3194 pex = collect_execute (dsymutil, real_argv, NULL, NULL, PEX_LAST | PEX_SEARCH);
3195 do_wait (dsymutil, pex);
3198 static void
3199 post_ld_pass (bool temp_file) {
3200 if (!(temp_file && flag_idsym) && !flag_dsym)
3201 return;
3203 do_dsymutil (output_file);
3205 #else
3206 static void
3207 process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }
3208 static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }
3209 #endif