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