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