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