1/* Scan linker error messages for missing template instantiations and provide
2 them.
3
4 Copyright (C) 1995, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 Contributed by Jason Merrill (jason@cygnus.com).
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify it under
10the terms of the GNU General Public License as published by the Free
11Software Foundation; either version 2, or (at your option) any later
12version.
13
14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING. If not, write to the Free
21Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2202111-1307, USA. */
23
24#include "config.h"
25#include "system.h"
26#include "intl.h"
27#include "hash.h"
28#include "demangle.h"
29#include "collect2.h"
30
31#define MAX_ITERATIONS 17
32
33/* Obstack allocation and deallocation routines. */
34#define obstack_chunk_alloc xmalloc
35#define obstack_chunk_free free
36
37/* Defined in the automatically-generated underscore.c. */
38extern int prepends_underscore;
39
40static int tlink_verbose;
41
42/* Hash table boilerplate for working with hash.[ch]. We have hash tables
43 for symbol names, file names, and demangled symbols. */
44

--- 22 unchanged lines hidden (view full) ---

67} demangled;
68
69static struct hash_table symbol_table;
70
71static struct hash_entry * symbol_hash_newfunc PARAMS ((struct hash_entry *,
72 struct hash_table *,
73 hash_table_key));
74static struct symbol_hash_entry * symbol_hash_lookup PARAMS ((const char *,
75 int));
76static struct hash_entry * file_hash_newfunc PARAMS ((struct hash_entry *,
77 struct hash_table *,
78 hash_table_key));
79static struct file_hash_entry * file_hash_lookup PARAMS ((const char *));
80static struct hash_entry * demangled_hash_newfunc PARAMS ((struct hash_entry *,
81 struct hash_table *,
82 hash_table_key));
83static struct demangled_hash_entry *
84 demangled_hash_lookup PARAMS ((const char *, int));
85static void symbol_push PARAMS ((symbol *));
86static symbol * symbol_pop PARAMS ((void));
87static void file_push PARAMS ((file *));
88static file * file_pop PARAMS ((void));
89static void tlink_init PARAMS ((void));
90static int tlink_execute PARAMS ((const char *, char **, const char *));
91static char * frob_extension PARAMS ((const char *, const char *));
92static char * obstack_fgets PARAMS ((FILE *, struct obstack *));
93static char * tfgets PARAMS ((FILE *));
94static char * pfgets PARAMS ((FILE *));
95static void freadsym PARAMS ((FILE *, file *, int));
96static void read_repo_file PARAMS ((file *));
97static void maybe_tweak PARAMS ((char *, file *));
98static int recompile_files PARAMS ((void));
99static int read_repo_files PARAMS ((char **));
100static void demangle_new_symbols PARAMS ((void));
101static int scan_linker_output PARAMS ((const char *));
102
103/* Create a new entry for the symbol hash table.
104 Passed to hash_table_init. */
105
106static struct hash_entry *
107symbol_hash_newfunc (entry, table, string)
108 struct hash_entry *entry;
109 struct hash_table *table;
110 hash_table_key string ATTRIBUTE_UNUSED;
111{
112 struct symbol_hash_entry *ret = (struct symbol_hash_entry *) entry;
113 if (ret == NULL)
114 {
115 ret = ((struct symbol_hash_entry *)
116 hash_allocate (table, sizeof (struct symbol_hash_entry)));
117 if (ret == NULL)
118 return NULL;

--- 5 unchanged lines hidden (view full) ---

124 return (struct hash_entry *) ret;
125}
126
127/* Look up an entry in the symbol hash table. */
128
129static struct symbol_hash_entry *
130symbol_hash_lookup (string, create)
131 const char *string;
132 int create;
133{
134 return ((struct symbol_hash_entry *)
135 hash_lookup (&symbol_table, (const hash_table_key) string,
136 create, string_copy));
137}
138
139static struct hash_table file_table;
140
141/* Create a new entry for the file hash table.
142 Passed to hash_table_init. */
143
144static struct hash_entry *
145file_hash_newfunc (entry, table, string)
146 struct hash_entry *entry;
147 struct hash_table *table;
148 hash_table_key string ATTRIBUTE_UNUSED;
149{
150 struct file_hash_entry *ret = (struct file_hash_entry *) entry;
151 if (ret == NULL)
152 {
153 ret = ((struct file_hash_entry *)
154 hash_allocate (table, sizeof (struct file_hash_entry)));
155 if (ret == NULL)
156 return NULL;

--- 7 unchanged lines hidden (view full) ---

164
165/* Look up an entry in the file hash table. */
166
167static struct file_hash_entry *
168file_hash_lookup (string)
169 const char *string;
170{
171 return ((struct file_hash_entry *)
172 hash_lookup (&file_table, (const hash_table_key) string, true,
173 string_copy));
174}
175
176static struct hash_table demangled_table;
177
178/* Create a new entry for the demangled name hash table.
179 Passed to hash_table_init. */
180
181static struct hash_entry *
182demangled_hash_newfunc (entry, table, string)
183 struct hash_entry *entry;
184 struct hash_table *table;
185 hash_table_key string ATTRIBUTE_UNUSED;
186{
187 struct demangled_hash_entry *ret = (struct demangled_hash_entry *) entry;
188 if (ret == NULL)
189 {
190 ret = ((struct demangled_hash_entry *)
191 hash_allocate (table, sizeof (struct demangled_hash_entry)));
192 if (ret == NULL)
193 return NULL;
194 }
195 ret->mangled = NULL;
196 return (struct hash_entry *) ret;
197}
198
199/* Look up an entry in the demangled name hash table. */
200
201static struct demangled_hash_entry *
202demangled_hash_lookup (string, create)
203 const char *string;
204 int create;
205{
206 return ((struct demangled_hash_entry *)
207 hash_lookup (&demangled_table, (const hash_table_key) string,
208 create, string_copy));
209}
210
211/* Stack code. */
212
213struct symbol_stack_entry
214{
215 symbol *value;
216 struct symbol_stack_entry *next;

--- 66 unchanged lines hidden (view full) ---

283
284/* Other machinery. */
285
286/* Initialize the tlink machinery. Called from do_tlink. */
287
288static void
289tlink_init ()
290{
291 const char *p;
292
293 hash_table_init (&symbol_table, symbol_hash_newfunc, string_hash,
294 string_compare);
295 hash_table_init (&file_table, file_hash_newfunc, string_hash,
296 string_compare);
297 hash_table_init (&demangled_table, demangled_hash_newfunc,
298 string_hash, string_compare);
299 obstack_begin (&symbol_stack_obstack, 0);
300 obstack_begin (&file_stack_obstack, 0);
301
302 p = getenv ("TLINK_VERBOSE");
303 if (p)
304 tlink_verbose = atoi (p);
305 else
306 {
307 tlink_verbose = 1;
308 if (vflag)
309 tlink_verbose = 2;
310 if (debug)
311 tlink_verbose = 3;
312 }
313}
314
315static int
316tlink_execute (prog, argv, redir)
317 const char *prog;
318 char **argv;
319 const char *redir;
320{
321 collect_execute (prog, argv, redir);
322 return collect_wait (prog);
323}
324
325static char *
326frob_extension (s, ext)
327 const char *s;
328 const char *ext;
329{
330 const char *p = strrchr (s, '/');
331 if (! p)
332 p = s;
333 p = strrchr (p, '.');
334 if (! p)
335 p = s + strlen (s);
336
337 obstack_grow (&temporary_obstack, s, p - s);
338 return obstack_copy0 (&temporary_obstack, ext, strlen (ext));
339}
340
341static char *

--- 36 unchanged lines hidden (view full) ---

378freadsym (stream, f, chosen)
379 FILE *stream;
380 file *f;
381 int chosen;
382{
383 symbol *sym;
384
385 {
386 const char *name = tfgets (stream);
387 sym = symbol_hash_lookup (name, true);
388 }
389
390 if (sym->file == NULL)
391 {
392 /* We didn't have this symbol already, so we choose this file. */
393
394 symbol_push (sym);

--- 25 unchanged lines hidden (view full) ---

420static void
421read_repo_file (f)
422 file *f;
423{
424 char c;
425 FILE *stream = fopen ((char*) f->root.key, "r");
426
427 if (tlink_verbose >= 2)
428 fprintf (stderr, _("collect: reading %s\n"),
429 (char*) f->root.key);
430
431 while (fscanf (stream, "%c ", &c) == 1)
432 {
433 switch (c)
434 {
435 case 'A':
436 f->args = pfgets (stream);

--- 53 unchanged lines hidden (view full) ---

490
491 XXX Should this use collect_execute instead of system? */
492
493static int
494recompile_files ()
495{
496 file *f;
497
498 putenv (xstrdup ("COMPILER_PATH"));
499 putenv (xstrdup ("LIBRARY_PATH"));
500
501 while ((f = file_pop ()) != NULL)
502 {
503 char *line, *command;
504 FILE *stream = fopen ((char*) f->root.key, "r");
505 const char *const outname = frob_extension ((char*) f->root.key, ".rnw");
506 FILE *output = fopen (outname, "w");
507
508 while ((line = tfgets (stream)) != NULL)
509 {
510 switch (line[0])
511 {
512 case 'C':
513 case 'O':

--- 10 unchanged lines hidden (view full) ---

524 obstack_grow (&temporary_obstack, "; ", 2);
525 obstack_grow (&temporary_obstack, c_file_name, strlen (c_file_name));
526 obstack_1grow (&temporary_obstack, ' ');
527 obstack_grow (&temporary_obstack, f->args, strlen (f->args));
528 obstack_1grow (&temporary_obstack, ' ');
529 command = obstack_copy0 (&temporary_obstack, f->main, strlen (f->main));
530
531 if (tlink_verbose)
532 fprintf (stderr, _("collect: recompiling %s\n"), f->main);
533 if (tlink_verbose >= 3)
534 fprintf (stderr, "%s\n", command);
535
536 if (system (command) != 0)
537 return 0;
538
539 read_repo_file (f);
540

--- 8 unchanged lines hidden (view full) ---

549static int
550read_repo_files (object_lst)
551 char **object_lst;
552{
553 char **object = object_lst;
554
555 for (; *object; object++)
556 {
557 const char *p;
558 file *f;
559
560 /* Don't bother trying for ld flags. */
561 if (*object[0] == '-')
562 continue;
563
564 p = frob_extension (*object, ".rpo");
565
566 if (! file_exists (p))
567 continue;
568
569 f = file_hash_lookup (p);
570
571 read_repo_file (f);
572 }
573

--- 8 unchanged lines hidden (view full) ---

582static void
583demangle_new_symbols ()
584{
585 symbol *sym;
586
587 while ((sym = symbol_pop ()) != NULL)
588 {
589 demangled *dem;
590 const char *p = cplus_demangle ((char*) sym->root.key,
591 DMGL_PARAMS | DMGL_ANSI);
592
593 if (! p)
594 continue;
595
596 dem = demangled_hash_lookup (p, true);
597 dem->mangled = (char*) sym->root.key;
598 }

--- 29 unchanged lines hidden (view full) ---

628 ++p;
629 if (*p == '_' && prepends_underscore)
630 ++p;
631
632 end = ! *q;
633 *q = 0;
634 sym = symbol_hash_lookup (p, false);
635
636 /* Some SVR4 linkers produce messages like
637 ld: 0711-317 ERROR: Undefined symbol: .g__t3foo1Zi
638 */
639 if (! sym && ! end && strstr (q+1, "Undefined symbol: "))
640 {
641 char *p = strrchr (q+1, ' ');
642 p++;
643 if (*p == '.')
644 p++;
645 if (*p == '_' && prepends_underscore)
646 p++;
647 sym = symbol_hash_lookup (p, false);
648 }
649
650 if (! sym && ! end)
651 /* Try a mangled name in quotes. */
652 {
653 const char *oldq = q+1;
654 demangled *dem = 0;
655 q = 0;
656
657 /* First try `GNU style'. */
658 p = strchr (oldq, '`');
659 if (p)
660 p++, q = strchr (p, '\'');
661 /* Then try "double quotes". */
662 else if (p = strchr (oldq, '"'), p)
663 p++, q = strchr (p, '"');
664
665 /* Don't let the strstr's below see the demangled name; we
666 might get spurious matches. */
667 if (p)
668 p[-1] = '\0';
669
670 /* We need to check for certain error keywords here, or we would
671 mistakenly use GNU ld's "In function `foo':" message. */
672 if (q && (strstr (oldq, "ndefined")
673 || strstr (oldq, "nresolved")
674 || strstr (oldq, "nsatisfied")
675 || strstr (oldq, "ultiple")))
676 {
677 *q = 0;
678 dem = demangled_hash_lookup (p, false);
679 if (dem)
680 sym = symbol_hash_lookup (dem->mangled, false);
681 else
682 {
683 if (*p == '_' && prepends_underscore)

--- 6 unchanged lines hidden (view full) ---

690 if (sym && sym->tweaked)
691 {
692 fclose (stream);
693 return 0;
694 }
695 if (sym && !sym->tweaking)
696 {
697 if (tlink_verbose >= 2)
698 fprintf (stderr, _("collect: tweaking %s in %s\n"),
699 (char*) sym->root.key, (char*) sym->file->root.key);
700 sym->tweaking = 1;
701 file_push (sym->file);
702 }
703
704 obstack_free (&temporary_obstack, temporary_firstobj);
705 }
706

--- 7 unchanged lines hidden (view full) ---

714 mentioned in the linker error messages.
715
716 LD_ARGV is an array of arguments for the linker.
717 OBJECT_LST is an array of object files that we may be able to recompile
718 to provide missing definitions. Currently ignored. */
719
720void
721do_tlink (ld_argv, object_lst)
722 char **ld_argv, **object_lst ATTRIBUTE_UNUSED;
723{
724 int exit = tlink_execute ("ld", ld_argv, ldout);
725
726 tlink_init ();
727
728 if (exit)
729 {
730 int i = 0;

--- 6 unchanged lines hidden (view full) ---

737 if (tlink_verbose >= 3)
738 dump_file (ldout);
739 demangle_new_symbols ();
740 if (! scan_linker_output (ldout))
741 break;
742 if (! recompile_files ())
743 break;
744 if (tlink_verbose)
745 fprintf (stderr, _("collect: relinking\n"));
746 exit = tlink_execute ("ld", ld_argv, ldout);
747 }
748 }
749
750 dump_file (ldout);
751 unlink (ldout);
752 if (exit)
753 {
754 error ("ld returned %d exit status", exit);
755 collect_exit (exit);
756 }
757}