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