1 /* Scan linker error messages for missing template instantiations and provide
4 Copyright (C) 1995, 1998, 1999, 2000, 2001, 2003, 2004, 2005
5 Free Software Foundation, Inc.
6 Contributed by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
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
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to the Free
22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
27 #include "coretypes.h"
35 #define MAX_ITERATIONS 17
37 /* Defined in the automatically-generated underscore.c. */
38 extern int prepends_underscore;
40 static int tlink_verbose;
42 static char initial_cwd[MAXPATHLEN + 1];
44 /* Hash table boilerplate for working with htab_t. We have hash tables
45 for symbol names, file names, and demangled symbols. */
47 typedef struct symbol_hash_entry
50 struct file_hash_entry *file;
56 typedef struct file_hash_entry
65 typedef struct demangled_hash_entry
71 /* Hash and comparison functions for these hash tables. */
73 static int hash_string_eq (const void *, const void *);
74 static hashval_t hash_string_hash (const void *);
77 hash_string_eq (const void *s1_p, const void *s2_p)
79 const char *const *s1 = (const char *const *) s1_p;
80 const char *s2 = (const char *) s2_p;
81 return strcmp (*s1, s2) == 0;
85 hash_string_hash (const void *s_p)
87 const char *const *s = (const char *const *) s_p;
88 return (*htab_hash_string) (*s);
91 static htab_t symbol_table;
93 static struct symbol_hash_entry * symbol_hash_lookup (const char *, int);
94 static struct file_hash_entry * file_hash_lookup (const char *);
95 static struct demangled_hash_entry *demangled_hash_lookup (const char *, int);
96 static void symbol_push (symbol *);
97 static symbol * symbol_pop (void);
98 static void file_push (file *);
99 static file * file_pop (void);
100 static void tlink_init (void);
101 static int tlink_execute (const char *, char **, const char *);
102 static char * frob_extension (const char *, const char *);
103 static char * obstack_fgets (FILE *, struct obstack *);
104 static char * tfgets (FILE *);
105 static char * pfgets (FILE *);
106 static void freadsym (FILE *, file *, int);
107 static void read_repo_file (file *);
108 static void maybe_tweak (char *, file *);
109 static int recompile_files (void);
110 static int read_repo_files (char **);
111 static void demangle_new_symbols (void);
112 static int scan_linker_output (const char *);
114 /* Look up an entry in the symbol hash table. */
116 static struct symbol_hash_entry *
117 symbol_hash_lookup (const char *string, int create)
120 e = htab_find_slot_with_hash (symbol_table, string,
121 (*htab_hash_string) (string),
122 create ? INSERT : NO_INSERT);
127 struct symbol_hash_entry *v;
128 *e = v = xcalloc (1, sizeof (*v));
129 v->key = xstrdup (string);
134 static htab_t file_table;
136 /* Look up an entry in the file hash table. */
138 static struct file_hash_entry *
139 file_hash_lookup (const char *string)
142 e = htab_find_slot_with_hash (file_table, string,
143 (*htab_hash_string) (string),
147 struct file_hash_entry *v;
148 *e = v = xcalloc (1, sizeof (*v));
149 v->key = xstrdup (string);
154 static htab_t demangled_table;
156 /* Look up an entry in the demangled name hash table. */
158 static struct demangled_hash_entry *
159 demangled_hash_lookup (const char *string, int create)
162 e = htab_find_slot_with_hash (demangled_table, string,
163 (*htab_hash_string) (string),
164 create ? INSERT : NO_INSERT);
169 struct demangled_hash_entry *v;
170 *e = v = xcalloc (1, sizeof (*v));
171 v->key = xstrdup (string);
178 struct symbol_stack_entry
181 struct symbol_stack_entry *next;
183 struct obstack symbol_stack_obstack;
184 struct symbol_stack_entry *symbol_stack;
186 struct file_stack_entry
189 struct file_stack_entry *next;
191 struct obstack file_stack_obstack;
192 struct file_stack_entry *file_stack;
195 symbol_push (symbol *p)
197 struct symbol_stack_entry *ep = obstack_alloc
198 (&symbol_stack_obstack, sizeof (struct symbol_stack_entry));
200 ep->next = symbol_stack;
207 struct symbol_stack_entry *ep = symbol_stack;
212 symbol_stack = ep->next;
213 obstack_free (&symbol_stack_obstack, ep);
220 struct file_stack_entry *ep;
226 (&file_stack_obstack, sizeof (struct file_stack_entry));
228 ep->next = file_stack;
236 struct file_stack_entry *ep = file_stack;
241 file_stack = ep->next;
242 obstack_free (&file_stack_obstack, ep);
247 /* Other machinery. */
249 /* Initialize the tlink machinery. Called from do_tlink. */
256 symbol_table = htab_create (500, hash_string_hash, hash_string_eq,
258 file_table = htab_create (500, hash_string_hash, hash_string_eq,
260 demangled_table = htab_create (500, hash_string_hash, hash_string_eq,
263 obstack_begin (&symbol_stack_obstack, 0);
264 obstack_begin (&file_stack_obstack, 0);
266 p = getenv ("TLINK_VERBOSE");
268 tlink_verbose = atoi (p);
278 getcwd (initial_cwd, sizeof (initial_cwd));
282 tlink_execute (const char *prog, char **argv, const char *redir)
286 pex = collect_execute (prog, argv, redir);
287 return collect_wait (prog, pex);
291 frob_extension (const char *s, const char *ext)
293 const char *p = strrchr (s, '/');
296 p = strrchr (p, '.');
300 obstack_grow (&temporary_obstack, s, p - s);
301 return obstack_copy0 (&temporary_obstack, ext, strlen (ext));
305 obstack_fgets (FILE *stream, struct obstack *ob)
308 while ((c = getc (stream)) != EOF && c != '\n')
309 obstack_1grow (ob, c);
310 if (obstack_object_size (ob) == 0)
312 obstack_1grow (ob, '\0');
313 return obstack_finish (ob);
317 tfgets (FILE *stream)
319 return obstack_fgets (stream, &temporary_obstack);
323 pfgets (FILE *stream)
325 return xstrdup (tfgets (stream));
328 /* Real tlink code. */
330 /* Subroutine of read_repo_file. We are reading the repo file for file F,
331 which is coming in on STREAM, and the symbol that comes next in STREAM
332 is offered, chosen or provided if CHOSEN is 0, 1 or 2, respectively.
334 XXX "provided" is unimplemented, both here and in the compiler. */
337 freadsym (FILE *stream, file *f, int chosen)
342 const char *name = tfgets (stream);
343 sym = symbol_hash_lookup (name, true);
346 if (sym->file == NULL)
348 /* We didn't have this symbol already, so we choose this file. */
352 sym->chosen = chosen;
356 /* We want this file; cast aside any pretender. */
358 if (sym->chosen && sym->file != f)
360 if (sym->chosen == 1)
361 file_push (sym->file);
366 chosen = sym->chosen;
370 sym->chosen = chosen;
374 /* Read in the repo file denoted by F, and record all its information. */
377 read_repo_file (file *f)
380 FILE *stream = fopen (f->key, "r");
382 if (tlink_verbose >= 2)
383 fprintf (stderr, _("collect: reading %s\n"), f->key);
385 while (fscanf (stream, "%c ", &c) == 1)
390 f->args = pfgets (stream);
393 f->dir = pfgets (stream);
396 f->main = pfgets (stream);
399 freadsym (stream, f, 2);
402 freadsym (stream, f, 1);
405 freadsym (stream, f, 0);
408 obstack_free (&temporary_obstack, temporary_firstobj);
412 f->args = getenv ("COLLECT_GCC_OPTIONS");
417 /* We might want to modify LINE, which is a symbol line from file F. We do
418 this if either we saw an error message referring to the symbol in
419 question, or we have already allocated the symbol to another file and
420 this one wants to emit it as well. */
423 maybe_tweak (char *line, file *f)
425 symbol *sym = symbol_hash_lookup (line + 2, false);
427 if ((sym->file == f && sym->tweaking)
428 || (sym->file != f && line[0] == 'C'))
440 /* Update the repo files for each of the object files we have adjusted and
444 recompile_files (void)
448 putenv (xstrdup ("COMPILER_PATH="));
449 putenv (xstrdup ("LIBRARY_PATH="));
451 while ((f = file_pop ()) != NULL)
456 struct obstack arg_stack;
457 FILE *stream = fopen (f->key, "r");
458 const char *const outname = frob_extension (f->key, ".rnw");
459 FILE *output = fopen (outname, "w");
461 while ((line = tfgets (stream)) != NULL)
467 maybe_tweak (line, f);
469 fprintf (output, "%s\n", line);
473 rename (outname, f->key);
477 error ("repository file '%s' does not contain command-line "
478 "arguments", f->key);
482 /* Build a null-terminated argv array suitable for
483 tlink_execute(). Manipulate arguments on the arg_stack while
484 building argv on the temporary_obstack. */
486 obstack_init (&arg_stack);
487 obstack_ptr_grow (&temporary_obstack, c_file_name);
489 for (p = f->args; *p != '\0'; p = q + 1)
491 /* Arguments are delimited by single-quotes. Find the
493 p = strchr (p, '\'');
497 /* Find the closing quote. */
498 q = strchr (p + 1, '\'');
502 obstack_grow (&arg_stack, p + 1, q - (p + 1));
504 /* Replace '\'' with '. This is how set_collect_gcc_options
505 encodes a single-quote. */
506 while (q[1] == '\\' && q[2] == '\'' && q[3] == '\'')
510 r = strchr (q + 4, '\'');
514 obstack_grow (&arg_stack, q + 3, r - (q + 3));
518 obstack_1grow (&arg_stack, '\0');
519 obstack_ptr_grow (&temporary_obstack, obstack_finish (&arg_stack));
522 obstack_ptr_grow (&temporary_obstack, f->main);
523 obstack_ptr_grow (&temporary_obstack, NULL);
524 argv = obstack_finish (&temporary_obstack);
527 fprintf (stderr, _("collect: recompiling %s\n"), f->main);
529 if (chdir (f->dir) != 0
530 || tlink_execute (c_file_name, argv, NULL) != 0
531 || chdir (initial_cwd) != 0)
536 obstack_free (&arg_stack, NULL);
537 obstack_free (&temporary_obstack, temporary_firstobj);
542 /* The first phase of processing: determine which object files have
543 .rpo files associated with them, and read in the information. */
546 read_repo_files (char **object_lst)
548 char **object = object_lst;
550 for (; *object; object++)
555 /* Don't bother trying for ld flags. */
556 if (*object[0] == '-')
559 p = frob_extension (*object, ".rpo");
561 if (! file_exists (p))
564 f = file_hash_lookup (p);
569 if (file_stack != NULL && ! recompile_files ())
572 return (symbol_stack != NULL);
575 /* Add the demangled forms of any new symbols to the hash table. */
578 demangle_new_symbols (void)
582 while ((sym = symbol_pop ()) != NULL)
585 const char *p = cplus_demangle (sym->key, DMGL_PARAMS | DMGL_ANSI);
590 dem = demangled_hash_lookup (p, true);
591 dem->mangled = sym->key;
595 /* Step through the output of the linker, in the file named FNAME, and
596 adjust the settings for each symbol encountered. */
599 scan_linker_output (const char *fname)
601 FILE *stream = fopen (fname, "r");
604 while ((line = tfgets (stream)) != NULL)
610 while (*p && ISSPACE ((unsigned char) *p))
616 for (q = p; *q && ! ISSPACE ((unsigned char) *q); ++q)
619 /* Try the first word on the line. */
622 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
623 p += strlen (USER_LABEL_PREFIX);
627 sym = symbol_hash_lookup (p, false);
629 /* Some SVR4 linkers produce messages like
630 ld: 0711-317 ERROR: Undefined symbol: .g__t3foo1Zi
632 if (! sym && ! end && strstr (q + 1, "Undefined symbol: "))
634 char *p = strrchr (q + 1, ' ');
638 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
639 p += strlen (USER_LABEL_PREFIX);
640 sym = symbol_hash_lookup (p, false);
644 /* Try a mangled name in quotes. */
646 const char *oldq = q + 1;
650 /* First try `GNU style'. */
651 p = strchr (oldq, '`');
653 p++, q = strchr (p, '\'');
654 /* Then try "double quotes". */
655 else if (p = strchr (oldq, '"'), p)
656 p++, q = strchr (p, '"');
658 /* Then try entire line. */
659 q = strchr (oldq, 0);
666 /* Don't let the strstr's below see the demangled name; we
667 might get spurious matches. */
670 /* powerpc64-linux references .foo when calling function foo. */
675 /* We need to check for certain error keywords here, or we would
676 mistakenly use GNU ld's "In function `foo':" message. */
677 if (q && (strstr (oldq, "ndefined")
678 || strstr (oldq, "nresolved")
679 || strstr (oldq, "nsatisfied")
680 || strstr (oldq, "ultiple")))
683 dem = demangled_hash_lookup (p, false);
685 sym = symbol_hash_lookup (dem->mangled, false);
688 if (!strncmp (p, USER_LABEL_PREFIX,
689 strlen (USER_LABEL_PREFIX)))
690 p += strlen (USER_LABEL_PREFIX);
691 sym = symbol_hash_lookup (p, false);
696 if (sym && sym->tweaked)
698 error ("'%s' was assigned to '%s', but was not defined "
699 "during recompilation, or vice versa",
700 sym->key, sym->file->key);
704 if (sym && !sym->tweaking)
706 if (tlink_verbose >= 2)
707 fprintf (stderr, _("collect: tweaking %s in %s\n"),
708 sym->key, sym->file->key);
710 file_push (sym->file);
713 obstack_free (&temporary_obstack, temporary_firstobj);
717 return (file_stack != NULL);
720 /* Entry point for tlink. Called from main in collect2.c.
722 Iteratively try to provide definitions for all the unresolved symbols
723 mentioned in the linker error messages.
725 LD_ARGV is an array of arguments for the linker.
726 OBJECT_LST is an array of object files that we may be able to recompile
727 to provide missing definitions. Currently ignored. */
730 do_tlink (char **ld_argv, char **object_lst ATTRIBUTE_UNUSED)
732 int exit = tlink_execute ("ld", ld_argv, ldout);
740 /* Until collect does a better job of figuring out which are object
741 files, assume that everything on the command line could be. */
742 if (read_repo_files (ld_argv))
743 while (exit && i++ < MAX_ITERATIONS)
745 if (tlink_verbose >= 3)
747 demangle_new_symbols ();
748 if (! scan_linker_output (ldout))
750 if (! recompile_files ())
753 fprintf (stderr, _("collect: relinking\n"));
754 exit = tlink_execute ("ld", ld_argv, ldout);
762 error ("ld returned %d exit status", exit);