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