]>
Commit | Line | Data |
---|---|---|
1 | /* Scan linker error messages for missing template instantiations and provide | |
2 | them. | |
3 | ||
4 | Copyright (C) 1995-2014 Free Software Foundation, Inc. | |
5 | Contributed by Jason Merrill (jason@cygnus.com). | |
6 | ||
7 | This file is part of GCC. | |
8 | ||
9 | GCC is free software; you can redistribute it and/or modify it under | |
10 | the terms of the GNU General Public License as published by the Free | |
11 | Software Foundation; either version 3, or (at your option) any later | |
12 | version. | |
13 | ||
14 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
15 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
16 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
17 | for more details. | |
18 | ||
19 | You should have received a copy of the GNU General Public License | |
20 | along with GCC; see the file COPYING3. If not see | |
21 | <http://www.gnu.org/licenses/>. */ | |
22 | ||
23 | #include "config.h" | |
24 | #include "system.h" | |
25 | #include "coretypes.h" | |
26 | #include "tm.h" | |
27 | #include "intl.h" | |
28 | #include "obstack.h" | |
29 | #include "hashtab.h" | |
30 | #include "demangle.h" | |
31 | #include "collect2.h" | |
32 | #include "collect-utils.h" | |
33 | #include "filenames.h" | |
34 | #include "diagnostic-core.h" | |
35 | #include "vec.h" | |
36 | ||
37 | /* TARGET_64BIT may be defined to use driver specific functionality. */ | |
38 | #undef TARGET_64BIT | |
39 | #define TARGET_64BIT TARGET_64BIT_DEFAULT | |
40 | ||
41 | #define MAX_ITERATIONS 17 | |
42 | ||
43 | /* Defined in the automatically-generated underscore.c. */ | |
44 | extern int prepends_underscore; | |
45 | ||
46 | static int tlink_verbose; | |
47 | ||
48 | static char *initial_cwd; | |
49 | \f | |
50 | /* Hash table boilerplate for working with htab_t. We have hash tables | |
51 | for symbol names, file names, and demangled symbols. */ | |
52 | ||
53 | typedef struct symbol_hash_entry | |
54 | { | |
55 | const char *key; | |
56 | struct file_hash_entry *file; | |
57 | int chosen; | |
58 | int tweaking; | |
59 | int tweaked; | |
60 | } symbol; | |
61 | ||
62 | typedef struct file_hash_entry | |
63 | { | |
64 | const char *key; | |
65 | const char *args; | |
66 | const char *dir; | |
67 | const char *main; | |
68 | int tweaking; | |
69 | } file; | |
70 | ||
71 | typedef const char *str; | |
72 | ||
73 | typedef struct demangled_hash_entry | |
74 | { | |
75 | const char *key; | |
76 | vec<str> mangled; | |
77 | } demangled; | |
78 | ||
79 | /* Hash and comparison functions for these hash tables. */ | |
80 | ||
81 | static int hash_string_eq (const void *, const void *); | |
82 | static hashval_t hash_string_hash (const void *); | |
83 | ||
84 | static int | |
85 | hash_string_eq (const void *s1_p, const void *s2_p) | |
86 | { | |
87 | const char *const *s1 = (const char *const *) s1_p; | |
88 | const char *s2 = (const char *) s2_p; | |
89 | return strcmp (*s1, s2) == 0; | |
90 | } | |
91 | ||
92 | static hashval_t | |
93 | hash_string_hash (const void *s_p) | |
94 | { | |
95 | const char *const *s = (const char *const *) s_p; | |
96 | return (*htab_hash_string) (*s); | |
97 | } | |
98 | ||
99 | static htab_t symbol_table; | |
100 | ||
101 | static struct symbol_hash_entry * symbol_hash_lookup (const char *, int); | |
102 | static struct file_hash_entry * file_hash_lookup (const char *); | |
103 | static struct demangled_hash_entry *demangled_hash_lookup (const char *, int); | |
104 | static void symbol_push (symbol *); | |
105 | static symbol * symbol_pop (void); | |
106 | static void file_push (file *); | |
107 | static file * file_pop (void); | |
108 | static char * frob_extension (const char *, const char *); | |
109 | static char * obstack_fgets (FILE *, struct obstack *); | |
110 | static char * tfgets (FILE *); | |
111 | static char * pfgets (FILE *); | |
112 | static void freadsym (FILE *, file *, int); | |
113 | static void read_repo_file (file *); | |
114 | static void maybe_tweak (char *, file *); | |
115 | static int recompile_files (void); | |
116 | static int read_repo_files (char **); | |
117 | static void demangle_new_symbols (void); | |
118 | static int scan_linker_output (const char *); | |
119 | ||
120 | /* Look up an entry in the symbol hash table. */ | |
121 | ||
122 | static struct symbol_hash_entry * | |
123 | symbol_hash_lookup (const char *string, int create) | |
124 | { | |
125 | void **e; | |
126 | e = htab_find_slot_with_hash (symbol_table, string, | |
127 | (*htab_hash_string) (string), | |
128 | create ? INSERT : NO_INSERT); | |
129 | if (e == NULL) | |
130 | return NULL; | |
131 | if (*e == NULL) | |
132 | { | |
133 | struct symbol_hash_entry *v; | |
134 | *e = v = XCNEW (struct symbol_hash_entry); | |
135 | v->key = xstrdup (string); | |
136 | } | |
137 | return (struct symbol_hash_entry *) *e; | |
138 | } | |
139 | ||
140 | static htab_t file_table; | |
141 | ||
142 | /* Look up an entry in the file hash table. */ | |
143 | ||
144 | static struct file_hash_entry * | |
145 | file_hash_lookup (const char *string) | |
146 | { | |
147 | void **e; | |
148 | e = htab_find_slot_with_hash (file_table, string, | |
149 | (*htab_hash_string) (string), | |
150 | INSERT); | |
151 | if (*e == NULL) | |
152 | { | |
153 | struct file_hash_entry *v; | |
154 | *e = v = XCNEW (struct file_hash_entry); | |
155 | v->key = xstrdup (string); | |
156 | } | |
157 | return (struct file_hash_entry *) *e; | |
158 | } | |
159 | ||
160 | static htab_t demangled_table; | |
161 | ||
162 | /* Look up an entry in the demangled name hash table. */ | |
163 | ||
164 | static struct demangled_hash_entry * | |
165 | demangled_hash_lookup (const char *string, int create) | |
166 | { | |
167 | void **e; | |
168 | e = htab_find_slot_with_hash (demangled_table, string, | |
169 | (*htab_hash_string) (string), | |
170 | create ? INSERT : NO_INSERT); | |
171 | if (e == NULL) | |
172 | return NULL; | |
173 | if (*e == NULL) | |
174 | { | |
175 | struct demangled_hash_entry *v; | |
176 | *e = v = XCNEW (struct demangled_hash_entry); | |
177 | v->key = xstrdup (string); | |
178 | } | |
179 | return (struct demangled_hash_entry *) *e; | |
180 | } | |
181 | \f | |
182 | /* Stack code. */ | |
183 | ||
184 | struct symbol_stack_entry | |
185 | { | |
186 | symbol *value; | |
187 | struct symbol_stack_entry *next; | |
188 | }; | |
189 | struct obstack symbol_stack_obstack; | |
190 | struct symbol_stack_entry *symbol_stack; | |
191 | ||
192 | struct file_stack_entry | |
193 | { | |
194 | file *value; | |
195 | struct file_stack_entry *next; | |
196 | }; | |
197 | struct obstack file_stack_obstack; | |
198 | struct file_stack_entry *file_stack; | |
199 | ||
200 | static void | |
201 | symbol_push (symbol *p) | |
202 | { | |
203 | struct symbol_stack_entry *ep | |
204 | = XOBNEW (&symbol_stack_obstack, struct symbol_stack_entry); | |
205 | ep->value = p; | |
206 | ep->next = symbol_stack; | |
207 | symbol_stack = ep; | |
208 | } | |
209 | ||
210 | static symbol * | |
211 | symbol_pop (void) | |
212 | { | |
213 | struct symbol_stack_entry *ep = symbol_stack; | |
214 | symbol *p; | |
215 | if (ep == NULL) | |
216 | return NULL; | |
217 | p = ep->value; | |
218 | symbol_stack = ep->next; | |
219 | obstack_free (&symbol_stack_obstack, ep); | |
220 | return p; | |
221 | } | |
222 | ||
223 | static void | |
224 | file_push (file *p) | |
225 | { | |
226 | struct file_stack_entry *ep; | |
227 | ||
228 | if (p->tweaking) | |
229 | return; | |
230 | ||
231 | ep = XOBNEW (&file_stack_obstack, struct file_stack_entry); | |
232 | ep->value = p; | |
233 | ep->next = file_stack; | |
234 | file_stack = ep; | |
235 | p->tweaking = 1; | |
236 | } | |
237 | ||
238 | static file * | |
239 | file_pop (void) | |
240 | { | |
241 | struct file_stack_entry *ep = file_stack; | |
242 | file *p; | |
243 | if (ep == NULL) | |
244 | return NULL; | |
245 | p = ep->value; | |
246 | file_stack = ep->next; | |
247 | obstack_free (&file_stack_obstack, ep); | |
248 | p->tweaking = 0; | |
249 | return p; | |
250 | } | |
251 | \f | |
252 | /* Other machinery. */ | |
253 | ||
254 | /* Initialize the tlink machinery. Called from do_tlink. */ | |
255 | ||
256 | static void | |
257 | tlink_init (void) | |
258 | { | |
259 | const char *p; | |
260 | ||
261 | symbol_table = htab_create (500, hash_string_hash, hash_string_eq, | |
262 | NULL); | |
263 | file_table = htab_create (500, hash_string_hash, hash_string_eq, | |
264 | NULL); | |
265 | demangled_table = htab_create (500, hash_string_hash, hash_string_eq, | |
266 | NULL); | |
267 | ||
268 | obstack_begin (&symbol_stack_obstack, 0); | |
269 | obstack_begin (&file_stack_obstack, 0); | |
270 | ||
271 | p = getenv ("TLINK_VERBOSE"); | |
272 | if (p) | |
273 | tlink_verbose = atoi (p); | |
274 | else | |
275 | { | |
276 | tlink_verbose = 1; | |
277 | if (verbose) | |
278 | tlink_verbose = 2; | |
279 | if (debug) | |
280 | tlink_verbose = 3; | |
281 | } | |
282 | ||
283 | initial_cwd = getpwd (); | |
284 | } | |
285 | ||
286 | static int | |
287 | tlink_execute (const char *prog, char **argv, const char *outname, | |
288 | const char *errname, bool use_atfile) | |
289 | { | |
290 | struct pex_obj *pex; | |
291 | ||
292 | pex = collect_execute (prog, argv, outname, errname, | |
293 | PEX_LAST | PEX_SEARCH, use_atfile); | |
294 | return collect_wait (prog, pex); | |
295 | } | |
296 | ||
297 | static char * | |
298 | frob_extension (const char *s, const char *ext) | |
299 | { | |
300 | const char *p; | |
301 | ||
302 | p = strrchr (lbasename (s), '.'); | |
303 | if (! p) | |
304 | p = s + strlen (s); | |
305 | ||
306 | obstack_grow (&temporary_obstack, s, p - s); | |
307 | return (char *) obstack_copy0 (&temporary_obstack, ext, strlen (ext)); | |
308 | } | |
309 | ||
310 | static char * | |
311 | obstack_fgets (FILE *stream, struct obstack *ob) | |
312 | { | |
313 | int c; | |
314 | while ((c = getc (stream)) != EOF && c != '\n') | |
315 | obstack_1grow (ob, c); | |
316 | if (obstack_object_size (ob) == 0) | |
317 | return NULL; | |
318 | obstack_1grow (ob, '\0'); | |
319 | return XOBFINISH (ob, char *); | |
320 | } | |
321 | ||
322 | static char * | |
323 | tfgets (FILE *stream) | |
324 | { | |
325 | return obstack_fgets (stream, &temporary_obstack); | |
326 | } | |
327 | ||
328 | static char * | |
329 | pfgets (FILE *stream) | |
330 | { | |
331 | return xstrdup (tfgets (stream)); | |
332 | } | |
333 | \f | |
334 | /* Real tlink code. */ | |
335 | ||
336 | /* Subroutine of read_repo_file. We are reading the repo file for file F, | |
337 | which is coming in on STREAM, and the symbol that comes next in STREAM | |
338 | is offered, chosen or provided if CHOSEN is 0, 1 or 2, respectively. | |
339 | ||
340 | XXX "provided" is unimplemented, both here and in the compiler. */ | |
341 | ||
342 | static void | |
343 | freadsym (FILE *stream, file *f, int chosen) | |
344 | { | |
345 | symbol *sym; | |
346 | ||
347 | { | |
348 | const char *name = tfgets (stream); | |
349 | sym = symbol_hash_lookup (name, true); | |
350 | } | |
351 | ||
352 | if (sym->file == NULL) | |
353 | { | |
354 | /* We didn't have this symbol already, so we choose this file. */ | |
355 | ||
356 | symbol_push (sym); | |
357 | sym->file = f; | |
358 | sym->chosen = chosen; | |
359 | } | |
360 | else if (chosen) | |
361 | { | |
362 | /* We want this file; cast aside any pretender. */ | |
363 | ||
364 | if (sym->chosen && sym->file != f) | |
365 | { | |
366 | if (sym->chosen == 1) | |
367 | file_push (sym->file); | |
368 | else | |
369 | { | |
370 | file_push (f); | |
371 | f = sym->file; | |
372 | chosen = sym->chosen; | |
373 | } | |
374 | } | |
375 | sym->file = f; | |
376 | sym->chosen = chosen; | |
377 | } | |
378 | } | |
379 | ||
380 | /* Read in the repo file denoted by F, and record all its information. */ | |
381 | ||
382 | static void | |
383 | read_repo_file (file *f) | |
384 | { | |
385 | char c; | |
386 | FILE *stream = fopen (f->key, "r"); | |
387 | ||
388 | if (tlink_verbose >= 2) | |
389 | fprintf (stderr, _("collect: reading %s\n"), f->key); | |
390 | ||
391 | while (fscanf (stream, "%c ", &c) == 1) | |
392 | { | |
393 | switch (c) | |
394 | { | |
395 | case 'A': | |
396 | f->args = pfgets (stream); | |
397 | break; | |
398 | case 'D': | |
399 | f->dir = pfgets (stream); | |
400 | break; | |
401 | case 'M': | |
402 | f->main = pfgets (stream); | |
403 | break; | |
404 | case 'P': | |
405 | freadsym (stream, f, 2); | |
406 | break; | |
407 | case 'C': | |
408 | freadsym (stream, f, 1); | |
409 | break; | |
410 | case 'O': | |
411 | freadsym (stream, f, 0); | |
412 | break; | |
413 | } | |
414 | obstack_free (&temporary_obstack, temporary_firstobj); | |
415 | } | |
416 | fclose (stream); | |
417 | if (f->args == NULL) | |
418 | f->args = getenv ("COLLECT_GCC_OPTIONS"); | |
419 | if (f->dir == NULL) | |
420 | f->dir = "."; | |
421 | } | |
422 | ||
423 | /* We might want to modify LINE, which is a symbol line from file F. We do | |
424 | this if either we saw an error message referring to the symbol in | |
425 | question, or we have already allocated the symbol to another file and | |
426 | this one wants to emit it as well. */ | |
427 | ||
428 | static void | |
429 | maybe_tweak (char *line, file *f) | |
430 | { | |
431 | symbol *sym = symbol_hash_lookup (line + 2, false); | |
432 | ||
433 | if ((sym->file == f && sym->tweaking) | |
434 | || (sym->file != f && line[0] == 'C')) | |
435 | { | |
436 | sym->tweaking = 0; | |
437 | sym->tweaked = 1; | |
438 | ||
439 | if (line[0] == 'O') | |
440 | { | |
441 | line[0] = 'C'; | |
442 | sym->chosen = 1; | |
443 | } | |
444 | else | |
445 | { | |
446 | line[0] = 'O'; | |
447 | sym->chosen = 0; | |
448 | } | |
449 | } | |
450 | } | |
451 | ||
452 | /* Update the repo files for each of the object files we have adjusted and | |
453 | recompile. */ | |
454 | ||
455 | static int | |
456 | recompile_files (void) | |
457 | { | |
458 | file *f; | |
459 | ||
460 | putenv (xstrdup ("COMPILER_PATH=")); | |
461 | putenv (xstrdup ("LIBRARY_PATH=")); | |
462 | ||
463 | while ((f = file_pop ()) != NULL) | |
464 | { | |
465 | char *line; | |
466 | const char *p, *q; | |
467 | char **argv; | |
468 | struct obstack arg_stack; | |
469 | FILE *stream = fopen (f->key, "r"); | |
470 | const char *const outname = frob_extension (f->key, ".rnw"); | |
471 | FILE *output = fopen (outname, "w"); | |
472 | ||
473 | while ((line = tfgets (stream)) != NULL) | |
474 | { | |
475 | switch (line[0]) | |
476 | { | |
477 | case 'C': | |
478 | case 'O': | |
479 | maybe_tweak (line, f); | |
480 | } | |
481 | fprintf (output, "%s\n", line); | |
482 | } | |
483 | fclose (stream); | |
484 | fclose (output); | |
485 | /* On Windows "rename" returns -1 and sets ERRNO to EACCESS if | |
486 | the new file name already exists. Therefore, we explicitly | |
487 | remove the old file first. */ | |
488 | if (remove (f->key) == -1) | |
489 | fatal_error ("removing .rpo file: %m"); | |
490 | if (rename (outname, f->key) == -1) | |
491 | fatal_error ("renaming .rpo file: %m"); | |
492 | ||
493 | if (!f->args) | |
494 | { | |
495 | error ("repository file '%s' does not contain command-line " | |
496 | "arguments", f->key); | |
497 | return 0; | |
498 | } | |
499 | ||
500 | /* Build a null-terminated argv array suitable for | |
501 | tlink_execute(). Manipulate arguments on the arg_stack while | |
502 | building argv on the temporary_obstack. */ | |
503 | ||
504 | obstack_init (&arg_stack); | |
505 | obstack_ptr_grow (&temporary_obstack, c_file_name); | |
506 | ||
507 | for (p = f->args; *p != '\0'; p = q + 1) | |
508 | { | |
509 | /* Arguments are delimited by single-quotes. Find the | |
510 | opening quote. */ | |
511 | p = strchr (p, '\''); | |
512 | if (!p) | |
513 | goto done; | |
514 | ||
515 | /* Find the closing quote. */ | |
516 | q = strchr (p + 1, '\''); | |
517 | if (!q) | |
518 | goto done; | |
519 | ||
520 | obstack_grow (&arg_stack, p + 1, q - (p + 1)); | |
521 | ||
522 | /* Replace '\'' with '. This is how set_collect_gcc_options | |
523 | encodes a single-quote. */ | |
524 | while (q[1] == '\\' && q[2] == '\'' && q[3] == '\'') | |
525 | { | |
526 | const char *r; | |
527 | ||
528 | r = strchr (q + 4, '\''); | |
529 | if (!r) | |
530 | goto done; | |
531 | ||
532 | obstack_grow (&arg_stack, q + 3, r - (q + 3)); | |
533 | q = r; | |
534 | } | |
535 | ||
536 | obstack_1grow (&arg_stack, '\0'); | |
537 | obstack_ptr_grow (&temporary_obstack, obstack_finish (&arg_stack)); | |
538 | } | |
539 | done: | |
540 | obstack_ptr_grow (&temporary_obstack, f->main); | |
541 | obstack_ptr_grow (&temporary_obstack, NULL); | |
542 | argv = XOBFINISH (&temporary_obstack, char **); | |
543 | ||
544 | if (tlink_verbose) | |
545 | fprintf (stderr, _("collect: recompiling %s\n"), f->main); | |
546 | ||
547 | if (chdir (f->dir) != 0 | |
548 | || tlink_execute (c_file_name, argv, NULL, NULL, false) != 0 | |
549 | || chdir (initial_cwd) != 0) | |
550 | return 0; | |
551 | ||
552 | read_repo_file (f); | |
553 | ||
554 | obstack_free (&arg_stack, NULL); | |
555 | obstack_free (&temporary_obstack, temporary_firstobj); | |
556 | } | |
557 | return 1; | |
558 | } | |
559 | ||
560 | /* The first phase of processing: determine which object files have | |
561 | .rpo files associated with them, and read in the information. */ | |
562 | ||
563 | static int | |
564 | read_repo_files (char **object_lst) | |
565 | { | |
566 | char **object = object_lst; | |
567 | ||
568 | for (; *object; object++) | |
569 | { | |
570 | const char *p; | |
571 | file *f; | |
572 | ||
573 | /* Don't bother trying for ld flags. */ | |
574 | if (*object[0] == '-') | |
575 | continue; | |
576 | ||
577 | p = frob_extension (*object, ".rpo"); | |
578 | ||
579 | if (! file_exists (p)) | |
580 | continue; | |
581 | ||
582 | f = file_hash_lookup (p); | |
583 | ||
584 | read_repo_file (f); | |
585 | } | |
586 | ||
587 | if (file_stack != NULL && ! recompile_files ()) | |
588 | return 0; | |
589 | ||
590 | return (symbol_stack != NULL); | |
591 | } | |
592 | ||
593 | /* Add the demangled forms of any new symbols to the hash table. */ | |
594 | ||
595 | static void | |
596 | demangle_new_symbols (void) | |
597 | { | |
598 | symbol *sym; | |
599 | ||
600 | while ((sym = symbol_pop ()) != NULL) | |
601 | { | |
602 | demangled *dem; | |
603 | const char *p = cplus_demangle (sym->key, DMGL_PARAMS | DMGL_ANSI); | |
604 | ||
605 | if (! p) | |
606 | continue; | |
607 | ||
608 | dem = demangled_hash_lookup (p, true); | |
609 | dem->mangled.safe_push (sym->key); | |
610 | } | |
611 | } | |
612 | ||
613 | /* We want to tweak symbol SYM. Return true if all is well, false on | |
614 | error. */ | |
615 | ||
616 | static bool | |
617 | start_tweaking (symbol *sym) | |
618 | { | |
619 | if (sym && sym->tweaked) | |
620 | { | |
621 | error ("'%s' was assigned to '%s', but was not defined " | |
622 | "during recompilation, or vice versa", | |
623 | sym->key, sym->file->key); | |
624 | return 0; | |
625 | } | |
626 | if (sym && !sym->tweaking) | |
627 | { | |
628 | if (tlink_verbose >= 2) | |
629 | fprintf (stderr, _("collect: tweaking %s in %s\n"), | |
630 | sym->key, sym->file->key); | |
631 | sym->tweaking = 1; | |
632 | file_push (sym->file); | |
633 | } | |
634 | return true; | |
635 | } | |
636 | ||
637 | /* Step through the output of the linker, in the file named FNAME, and | |
638 | adjust the settings for each symbol encountered. */ | |
639 | ||
640 | static int | |
641 | scan_linker_output (const char *fname) | |
642 | { | |
643 | FILE *stream = fopen (fname, "r"); | |
644 | char *line; | |
645 | int skip_next_in_line = 0; | |
646 | ||
647 | while ((line = tfgets (stream)) != NULL) | |
648 | { | |
649 | char *p = line, *q; | |
650 | symbol *sym; | |
651 | demangled *dem = 0; | |
652 | int end; | |
653 | int ok = 0; | |
654 | unsigned ix; | |
655 | str s; | |
656 | ||
657 | /* On darwin9, we might have to skip " in " lines as well. */ | |
658 | if (skip_next_in_line | |
659 | && strstr (p, " in ")) | |
660 | continue; | |
661 | skip_next_in_line = 0; | |
662 | ||
663 | while (*p && ISSPACE ((unsigned char) *p)) | |
664 | ++p; | |
665 | ||
666 | if (! *p) | |
667 | continue; | |
668 | ||
669 | for (q = p; *q && ! ISSPACE ((unsigned char) *q); ++q) | |
670 | ; | |
671 | ||
672 | /* Try the first word on the line. */ | |
673 | if (*p == '.') | |
674 | ++p; | |
675 | if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX))) | |
676 | p += strlen (USER_LABEL_PREFIX); | |
677 | ||
678 | end = ! *q; | |
679 | *q = 0; | |
680 | sym = symbol_hash_lookup (p, false); | |
681 | ||
682 | /* Some SVR4 linkers produce messages like | |
683 | ld: 0711-317 ERROR: Undefined symbol: .g__t3foo1Zi | |
684 | */ | |
685 | if (! sym && ! end && strstr (q + 1, "Undefined symbol: ")) | |
686 | { | |
687 | char *p = strrchr (q + 1, ' '); | |
688 | p++; | |
689 | if (*p == '.') | |
690 | p++; | |
691 | if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX))) | |
692 | p += strlen (USER_LABEL_PREFIX); | |
693 | sym = symbol_hash_lookup (p, false); | |
694 | } | |
695 | ||
696 | if (! sym && ! end) | |
697 | /* Try a mangled name in quotes. */ | |
698 | { | |
699 | char *oldq = q + 1; | |
700 | q = 0; | |
701 | ||
702 | /* On darwin9, we look for "foo" referenced from:\n\(.* in .*\n\)* */ | |
703 | if (strcmp (oldq, "referenced from:") == 0) | |
704 | { | |
705 | /* We have to remember that we found a symbol to tweak. */ | |
706 | ok = 1; | |
707 | ||
708 | /* We actually want to start from the first word on the | |
709 | line. */ | |
710 | oldq = p; | |
711 | ||
712 | /* Since the format is multiline, we have to skip | |
713 | following lines with " in ". */ | |
714 | skip_next_in_line = 1; | |
715 | } | |
716 | ||
717 | /* First try `GNU style'. */ | |
718 | p = strchr (oldq, '`'); | |
719 | if (p) | |
720 | p++, q = strchr (p, '\''); | |
721 | /* Then try "double quotes". */ | |
722 | else if (p = strchr (oldq, '"'), p) | |
723 | p++, q = strchr (p, '"'); | |
724 | /* Then try 'single quotes'. */ | |
725 | else if (p = strchr (oldq, '\''), p) | |
726 | p++, q = strchr (p, '\''); | |
727 | else { | |
728 | /* Then try entire line. */ | |
729 | q = strchr (oldq, 0); | |
730 | if (q != oldq) | |
731 | p = (char *)oldq; | |
732 | } | |
733 | ||
734 | if (p) | |
735 | { | |
736 | /* Don't let the strstr's below see the demangled name; we | |
737 | might get spurious matches. */ | |
738 | p[-1] = '\0'; | |
739 | ||
740 | /* powerpc64-linux references .foo when calling function foo. */ | |
741 | if (*p == '.') | |
742 | p++; | |
743 | } | |
744 | ||
745 | /* We need to check for certain error keywords here, or we would | |
746 | mistakenly use GNU ld's "In function `foo':" message. */ | |
747 | if (q && (ok | |
748 | || strstr (oldq, "ndefined") | |
749 | || strstr (oldq, "nresolved") | |
750 | || strstr (oldq, "nsatisfied") | |
751 | || strstr (oldq, "ultiple"))) | |
752 | { | |
753 | *q = 0; | |
754 | dem = demangled_hash_lookup (p, false); | |
755 | if (!dem) | |
756 | { | |
757 | if (!strncmp (p, USER_LABEL_PREFIX, | |
758 | strlen (USER_LABEL_PREFIX))) | |
759 | p += strlen (USER_LABEL_PREFIX); | |
760 | sym = symbol_hash_lookup (p, false); | |
761 | } | |
762 | } | |
763 | } | |
764 | ||
765 | if (dem) | |
766 | { | |
767 | /* We found a demangled name. If this is the name of a | |
768 | constructor or destructor, there can be several mangled names | |
769 | that match it, so choose or unchoose all of them. If some are | |
770 | chosen and some not, leave the later ones that don't match | |
771 | alone for now; either this will cause the link to succeed, or | |
772 | on the next attempt we will switch all of them the other way | |
773 | and that will cause it to succeed. */ | |
774 | int chosen = 0; | |
775 | int len = dem->mangled.length (); | |
776 | ok = true; | |
777 | FOR_EACH_VEC_ELT (dem->mangled, ix, s) | |
778 | { | |
779 | sym = symbol_hash_lookup (s, false); | |
780 | if (ix == 0) | |
781 | chosen = sym->chosen; | |
782 | else if (sym->chosen != chosen) | |
783 | /* Mismatch. */ | |
784 | continue; | |
785 | /* Avoid an error about re-tweaking when we guess wrong in | |
786 | the case of mismatch. */ | |
787 | if (len > 1) | |
788 | sym->tweaked = false; | |
789 | ok = start_tweaking (sym); | |
790 | } | |
791 | } | |
792 | else | |
793 | ok = start_tweaking (sym); | |
794 | ||
795 | obstack_free (&temporary_obstack, temporary_firstobj); | |
796 | ||
797 | if (!ok) | |
798 | { | |
799 | fclose (stream); | |
800 | return 0; | |
801 | } | |
802 | } | |
803 | ||
804 | fclose (stream); | |
805 | return (file_stack != NULL); | |
806 | } | |
807 | ||
808 | /* Entry point for tlink. Called from main in collect2.c. | |
809 | ||
810 | Iteratively try to provide definitions for all the unresolved symbols | |
811 | mentioned in the linker error messages. | |
812 | ||
813 | LD_ARGV is an array of arguments for the linker. | |
814 | OBJECT_LST is an array of object files that we may be able to recompile | |
815 | to provide missing definitions. Currently ignored. */ | |
816 | ||
817 | void | |
818 | do_tlink (char **ld_argv, char **object_lst ATTRIBUTE_UNUSED) | |
819 | { | |
820 | int ret = tlink_execute ("ld", ld_argv, ldout, lderrout, | |
821 | HAVE_GNU_LD && at_file_supplied); | |
822 | ||
823 | tlink_init (); | |
824 | ||
825 | if (ret) | |
826 | { | |
827 | int i = 0; | |
828 | ||
829 | /* Until collect does a better job of figuring out which are object | |
830 | files, assume that everything on the command line could be. */ | |
831 | if (read_repo_files (ld_argv)) | |
832 | while (ret && i++ < MAX_ITERATIONS) | |
833 | { | |
834 | if (tlink_verbose >= 3) | |
835 | { | |
836 | dump_ld_file (ldout, stdout); | |
837 | dump_ld_file (lderrout, stderr); | |
838 | } | |
839 | demangle_new_symbols (); | |
840 | if (! scan_linker_output (ldout) | |
841 | && ! scan_linker_output (lderrout)) | |
842 | break; | |
843 | if (! recompile_files ()) | |
844 | break; | |
845 | if (tlink_verbose) | |
846 | fprintf (stderr, _("collect: relinking\n")); | |
847 | ret = tlink_execute ("ld", ld_argv, ldout, lderrout, | |
848 | HAVE_GNU_LD && at_file_supplied); | |
849 | } | |
850 | } | |
851 | ||
852 | dump_ld_file (ldout, stdout); | |
853 | unlink (ldout); | |
854 | dump_ld_file (lderrout, stderr); | |
855 | unlink (lderrout); | |
856 | if (ret) | |
857 | { | |
858 | error ("ld returned %d exit status", ret); | |
859 | exit (ret); | |
860 | } | |
861 | else | |
862 | { | |
863 | /* We have just successfully produced an output file, so assume that we | |
864 | may unlink it if need be for now on. */ | |
865 | may_unlink_output_file = true; | |
866 | } | |
867 | } |