PR tree-optimization/85699
[official-gcc.git] / gcc / tlink.c
blobec20bd2fa0fb993c31a62732db829f7b4ed15514
1 /* Scan linker error messages for missing template instantiations and provide
2 them.
4 Copyright (C) 1995-2018 Free Software Foundation, Inc.
5 Contributed by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
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.
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.
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/>. */
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 "demangle.h"
30 #include "collect2.h"
31 #include "collect-utils.h"
32 #include "filenames.h"
33 #include "diagnostic-core.h"
35 /* TARGET_64BIT may be defined to use driver specific functionality. */
36 #undef TARGET_64BIT
37 #define TARGET_64BIT TARGET_64BIT_DEFAULT
39 #define MAX_ITERATIONS 17
41 /* Defined in the automatically-generated underscore.c. */
42 extern int prepends_underscore;
44 static int tlink_verbose;
46 static char *initial_cwd;
48 /* Hash table boilerplate for working with htab_t. We have hash tables
49 for symbol names, file names, and demangled symbols. */
51 typedef struct symbol_hash_entry
53 const char *key;
54 struct file_hash_entry *file;
55 int chosen;
56 int tweaking;
57 int tweaked;
58 } symbol;
60 typedef struct file_hash_entry
62 const char *key;
63 const char *args;
64 const char *dir;
65 const char *main;
66 int tweaking;
67 } file;
69 typedef const char *str;
71 typedef struct demangled_hash_entry
73 const char *key;
74 vec<str> mangled;
75 } demangled;
77 /* Hash and comparison functions for these hash tables. */
79 static int hash_string_eq (const void *, const void *);
80 static hashval_t hash_string_hash (const void *);
82 static int
83 hash_string_eq (const void *s1_p, const void *s2_p)
85 const char *const *s1 = (const char *const *) s1_p;
86 const char *s2 = (const char *) s2_p;
87 return strcmp (*s1, s2) == 0;
90 static hashval_t
91 hash_string_hash (const void *s_p)
93 const char *const *s = (const char *const *) s_p;
94 return (*htab_hash_string) (*s);
97 static htab_t symbol_table;
99 static struct symbol_hash_entry * symbol_hash_lookup (const char *, int);
100 static struct file_hash_entry * file_hash_lookup (const char *);
101 static struct demangled_hash_entry *demangled_hash_lookup (const char *, int);
102 static void symbol_push (symbol *);
103 static symbol * symbol_pop (void);
104 static void file_push (file *);
105 static file * file_pop (void);
106 static char * frob_extension (const char *, const char *);
107 static char * obstack_fgets (FILE *, struct obstack *);
108 static char * tfgets (FILE *);
109 static char * pfgets (FILE *);
110 static void freadsym (FILE *, file *, int);
111 static void read_repo_file (file *);
112 static void maybe_tweak (char *, file *);
113 static int recompile_files (void);
114 static int read_repo_files (char **);
115 static void demangle_new_symbols (void);
116 static int scan_linker_output (const char *);
118 /* Look up an entry in the symbol hash table. */
120 static struct symbol_hash_entry *
121 symbol_hash_lookup (const char *string, int create)
123 void **e;
124 e = htab_find_slot_with_hash (symbol_table, string,
125 (*htab_hash_string) (string),
126 create ? INSERT : NO_INSERT);
127 if (e == NULL)
128 return NULL;
129 if (*e == NULL)
131 struct symbol_hash_entry *v;
132 *e = v = XCNEW (struct symbol_hash_entry);
133 v->key = xstrdup (string);
135 return (struct symbol_hash_entry *) *e;
138 static htab_t file_table;
140 /* Look up an entry in the file hash table. */
142 static struct file_hash_entry *
143 file_hash_lookup (const char *string)
145 void **e;
146 e = htab_find_slot_with_hash (file_table, string,
147 (*htab_hash_string) (string),
148 INSERT);
149 if (*e == NULL)
151 struct file_hash_entry *v;
152 *e = v = XCNEW (struct file_hash_entry);
153 v->key = xstrdup (string);
155 return (struct file_hash_entry *) *e;
158 static htab_t demangled_table;
160 /* Look up an entry in the demangled name hash table. */
162 static struct demangled_hash_entry *
163 demangled_hash_lookup (const char *string, int create)
165 void **e;
166 e = htab_find_slot_with_hash (demangled_table, string,
167 (*htab_hash_string) (string),
168 create ? INSERT : NO_INSERT);
169 if (e == NULL)
170 return NULL;
171 if (*e == NULL)
173 struct demangled_hash_entry *v;
174 *e = v = XCNEW (struct demangled_hash_entry);
175 v->key = xstrdup (string);
177 return (struct demangled_hash_entry *) *e;
180 /* Stack code. */
182 struct symbol_stack_entry
184 symbol *value;
185 struct symbol_stack_entry *next;
187 struct obstack symbol_stack_obstack;
188 struct symbol_stack_entry *symbol_stack;
190 struct file_stack_entry
192 file *value;
193 struct file_stack_entry *next;
195 struct obstack file_stack_obstack;
196 struct file_stack_entry *file_stack;
198 static void
199 symbol_push (symbol *p)
201 struct symbol_stack_entry *ep
202 = XOBNEW (&symbol_stack_obstack, struct symbol_stack_entry);
203 ep->value = p;
204 ep->next = symbol_stack;
205 symbol_stack = ep;
208 static symbol *
209 symbol_pop (void)
211 struct symbol_stack_entry *ep = symbol_stack;
212 symbol *p;
213 if (ep == NULL)
214 return NULL;
215 p = ep->value;
216 symbol_stack = ep->next;
217 obstack_free (&symbol_stack_obstack, ep);
218 return p;
221 static void
222 file_push (file *p)
224 struct file_stack_entry *ep;
226 if (p->tweaking)
227 return;
229 ep = XOBNEW (&file_stack_obstack, struct file_stack_entry);
230 ep->value = p;
231 ep->next = file_stack;
232 file_stack = ep;
233 p->tweaking = 1;
236 static file *
237 file_pop (void)
239 struct file_stack_entry *ep = file_stack;
240 file *p;
241 if (ep == NULL)
242 return NULL;
243 p = ep->value;
244 file_stack = ep->next;
245 obstack_free (&file_stack_obstack, ep);
246 p->tweaking = 0;
247 return p;
250 /* Other machinery. */
252 /* Initialize the tlink machinery. Called from do_tlink. */
254 static void
255 tlink_init (void)
257 const char *p;
259 symbol_table = htab_create (500, hash_string_hash, hash_string_eq,
260 NULL);
261 file_table = htab_create (500, hash_string_hash, hash_string_eq,
262 NULL);
263 demangled_table = htab_create (500, hash_string_hash, hash_string_eq,
264 NULL);
266 obstack_begin (&symbol_stack_obstack, 0);
267 obstack_begin (&file_stack_obstack, 0);
269 p = getenv ("TLINK_VERBOSE");
270 if (p)
271 tlink_verbose = atoi (p);
272 else
274 tlink_verbose = 1;
275 if (verbose)
276 tlink_verbose = 2;
277 if (debug)
278 tlink_verbose = 3;
281 initial_cwd = getpwd ();
284 static int
285 tlink_execute (const char *prog, char **argv, const char *outname,
286 const char *errname, bool use_atfile)
288 struct pex_obj *pex;
290 pex = collect_execute (prog, argv, outname, errname,
291 PEX_LAST | PEX_SEARCH, use_atfile);
292 return collect_wait (prog, pex);
295 static char *
296 frob_extension (const char *s, const char *ext)
298 const char *p;
300 p = strrchr (lbasename (s), '.');
301 if (! p)
302 p = s + strlen (s);
304 obstack_grow (&temporary_obstack, s, p - s);
305 return (char *) obstack_copy0 (&temporary_obstack, ext, strlen (ext));
308 static char *
309 obstack_fgets (FILE *stream, struct obstack *ob)
311 int c;
312 while ((c = getc (stream)) != EOF && c != '\n')
313 obstack_1grow (ob, c);
314 if (obstack_object_size (ob) == 0)
315 return NULL;
316 obstack_1grow (ob, '\0');
317 return XOBFINISH (ob, char *);
320 static char *
321 tfgets (FILE *stream)
323 return obstack_fgets (stream, &temporary_obstack);
326 static char *
327 pfgets (FILE *stream)
329 return xstrdup (tfgets (stream));
332 /* Real tlink code. */
334 /* Subroutine of read_repo_file. We are reading the repo file for file F,
335 which is coming in on STREAM, and the symbol that comes next in STREAM
336 is offered, chosen or provided if CHOSEN is 0, 1 or 2, respectively.
338 XXX "provided" is unimplemented, both here and in the compiler. */
340 static void
341 freadsym (FILE *stream, file *f, int chosen)
343 symbol *sym;
346 const char *name = tfgets (stream);
347 sym = symbol_hash_lookup (name, true);
350 if (sym->file == NULL)
352 /* We didn't have this symbol already, so we choose this file. */
354 symbol_push (sym);
355 sym->file = f;
356 sym->chosen = chosen;
358 else if (chosen)
360 /* We want this file; cast aside any pretender. */
362 if (sym->chosen && sym->file != f)
364 if (sym->chosen == 1)
365 file_push (sym->file);
366 else
368 file_push (f);
369 f = sym->file;
370 chosen = sym->chosen;
373 sym->file = f;
374 sym->chosen = chosen;
378 /* Read in the repo file denoted by F, and record all its information. */
380 static void
381 read_repo_file (file *f)
383 char c;
384 FILE *stream = fopen (f->key, "r");
386 if (tlink_verbose >= 2)
387 fprintf (stderr, _("collect: reading %s\n"), f->key);
389 while (fscanf (stream, "%c ", &c) == 1)
391 switch (c)
393 case 'A':
394 f->args = pfgets (stream);
395 break;
396 case 'D':
397 f->dir = pfgets (stream);
398 break;
399 case 'M':
400 f->main = pfgets (stream);
401 break;
402 case 'P':
403 freadsym (stream, f, 2);
404 break;
405 case 'C':
406 freadsym (stream, f, 1);
407 break;
408 case 'O':
409 freadsym (stream, f, 0);
410 break;
412 obstack_free (&temporary_obstack, temporary_firstobj);
414 fclose (stream);
415 if (f->args == NULL)
416 f->args = getenv ("COLLECT_GCC_OPTIONS");
417 if (f->dir == NULL)
418 f->dir = ".";
421 /* We might want to modify LINE, which is a symbol line from file F. We do
422 this if either we saw an error message referring to the symbol in
423 question, or we have already allocated the symbol to another file and
424 this one wants to emit it as well. */
426 static void
427 maybe_tweak (char *line, file *f)
429 symbol *sym = symbol_hash_lookup (line + 2, false);
431 if ((sym->file == f && sym->tweaking)
432 || (sym->file != f && line[0] == 'C'))
434 sym->tweaking = 0;
435 sym->tweaked = 1;
437 if (line[0] == 'O')
439 line[0] = 'C';
440 sym->chosen = 1;
442 else
444 line[0] = 'O';
445 sym->chosen = 0;
450 /* Update the repo files for each of the object files we have adjusted and
451 recompile. */
453 static int
454 recompile_files (void)
456 file *f;
458 putenv (xstrdup ("COMPILER_PATH="));
459 putenv (xstrdup ("LIBRARY_PATH="));
461 while ((f = file_pop ()) != NULL)
463 char *line;
464 const char *p, *q;
465 char **argv;
466 struct obstack arg_stack;
467 FILE *stream = fopen (f->key, "r");
468 const char *const outname = frob_extension (f->key, ".rnw");
469 FILE *output = fopen (outname, "w");
471 while ((line = tfgets (stream)) != NULL)
473 switch (line[0])
475 case 'C':
476 case 'O':
477 maybe_tweak (line, f);
479 fprintf (output, "%s\n", line);
481 fclose (stream);
482 fclose (output);
483 /* On Windows "rename" returns -1 and sets ERRNO to EACCESS if
484 the new file name already exists. Therefore, we explicitly
485 remove the old file first. */
486 if (remove (f->key) == -1)
487 fatal_error (input_location, "removing .rpo file: %m");
488 if (rename (outname, f->key) == -1)
489 fatal_error (input_location, "renaming .rpo file: %m");
491 if (!f->args)
493 error ("repository file '%s' does not contain command-line "
494 "arguments", f->key);
495 return 0;
498 /* Build a null-terminated argv array suitable for
499 tlink_execute(). Manipulate arguments on the arg_stack while
500 building argv on the temporary_obstack. */
502 obstack_init (&arg_stack);
503 obstack_ptr_grow (&temporary_obstack, c_file_name);
505 for (p = f->args; *p != '\0'; p = q + 1)
507 /* Arguments are delimited by single-quotes. Find the
508 opening quote. */
509 p = strchr (p, '\'');
510 if (!p)
511 goto done;
513 /* Find the closing quote. */
514 q = strchr (p + 1, '\'');
515 if (!q)
516 goto done;
518 obstack_grow (&arg_stack, p + 1, q - (p + 1));
520 /* Replace '\'' with '. This is how set_collect_gcc_options
521 encodes a single-quote. */
522 while (q[1] == '\\' && q[2] == '\'' && q[3] == '\'')
524 const char *r;
526 r = strchr (q + 4, '\'');
527 if (!r)
528 goto done;
530 obstack_grow (&arg_stack, q + 3, r - (q + 3));
531 q = r;
534 obstack_1grow (&arg_stack, '\0');
535 obstack_ptr_grow (&temporary_obstack, obstack_finish (&arg_stack));
537 done:
538 obstack_ptr_grow (&temporary_obstack, f->main);
539 obstack_ptr_grow (&temporary_obstack, NULL);
540 argv = XOBFINISH (&temporary_obstack, char **);
542 if (tlink_verbose)
543 fprintf (stderr, _("collect: recompiling %s\n"), f->main);
545 if (chdir (f->dir) != 0
546 || tlink_execute (c_file_name, argv, NULL, NULL, false) != 0
547 || chdir (initial_cwd) != 0)
548 return 0;
550 read_repo_file (f);
552 obstack_free (&arg_stack, NULL);
553 obstack_free (&temporary_obstack, temporary_firstobj);
555 return 1;
558 /* The first phase of processing: determine which object files have
559 .rpo files associated with them, and read in the information. */
561 static int
562 read_repo_files (char **object_lst)
564 char **object = object_lst;
566 for (; *object; object++)
568 const char *p;
569 file *f;
571 /* Don't bother trying for ld flags. */
572 if (*object[0] == '-')
573 continue;
575 p = frob_extension (*object, ".rpo");
577 if (! file_exists (p))
578 continue;
580 f = file_hash_lookup (p);
582 read_repo_file (f);
585 if (file_stack != NULL && ! recompile_files ())
586 return 0;
588 return (symbol_stack != NULL);
591 /* Add the demangled forms of any new symbols to the hash table. */
593 static void
594 demangle_new_symbols (void)
596 symbol *sym;
598 while ((sym = symbol_pop ()) != NULL)
600 demangled *dem;
601 const char *p = cplus_demangle (sym->key, DMGL_PARAMS | DMGL_ANSI);
603 if (! p)
604 continue;
606 dem = demangled_hash_lookup (p, true);
607 dem->mangled.safe_push (sym->key);
611 /* We want to tweak symbol SYM. Return true if all is well, false on
612 error. */
614 static bool
615 start_tweaking (symbol *sym)
617 if (sym && sym->tweaked)
619 error ("'%s' was assigned to '%s', but was not defined "
620 "during recompilation, or vice versa",
621 sym->key, sym->file->key);
622 return 0;
624 if (sym && !sym->tweaking)
626 if (tlink_verbose >= 2)
627 fprintf (stderr, _("collect: tweaking %s in %s\n"),
628 sym->key, sym->file->key);
629 sym->tweaking = 1;
630 file_push (sym->file);
632 return true;
635 /* Step through the output of the linker, in the file named FNAME, and
636 adjust the settings for each symbol encountered. */
638 static int
639 scan_linker_output (const char *fname)
641 FILE *stream = fopen (fname, "r");
642 char *line;
643 int skip_next_in_line = 0;
645 while ((line = tfgets (stream)) != NULL)
647 char *p = line, *q;
648 symbol *sym;
649 demangled *dem = 0;
650 int end;
651 int ok = 0;
652 unsigned ix;
653 str s;
655 /* On darwin9, we might have to skip " in " lines as well. */
656 if (skip_next_in_line
657 && strstr (p, " in "))
658 continue;
659 skip_next_in_line = 0;
661 while (*p && ISSPACE ((unsigned char) *p))
662 ++p;
664 if (! *p)
665 continue;
667 for (q = p; *q && ! ISSPACE ((unsigned char) *q); ++q)
670 /* Try the first word on the line. */
671 if (*p == '.')
672 ++p;
673 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
674 p += strlen (USER_LABEL_PREFIX);
676 end = ! *q;
677 *q = 0;
678 sym = symbol_hash_lookup (p, false);
680 /* Some SVR4 linkers produce messages like
681 ld: 0711-317 ERROR: Undefined symbol: .g__t3foo1Zi
683 if (! sym && ! end && strstr (q + 1, "Undefined symbol: "))
685 char *p = strrchr (q + 1, ' ');
686 p++;
687 if (*p == '.')
688 p++;
689 if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
690 p += strlen (USER_LABEL_PREFIX);
691 sym = symbol_hash_lookup (p, false);
694 if (! sym && ! end)
695 /* Try a mangled name in quotes. */
697 char *oldq = q + 1;
698 q = 0;
700 /* On darwin9, we look for "foo" referenced from:\n\(.* in .*\n\)* */
701 if (strcmp (oldq, "referenced from:") == 0)
703 /* We have to remember that we found a symbol to tweak. */
704 ok = 1;
706 /* We actually want to start from the first word on the
707 line. */
708 oldq = p;
710 /* Since the format is multiline, we have to skip
711 following lines with " in ". */
712 skip_next_in_line = 1;
715 /* First try `GNU style'. */
716 p = strchr (oldq, '`');
717 if (p)
718 p++, q = strchr (p, '\'');
719 /* Then try "double quotes". */
720 else if (p = strchr (oldq, '"'), p)
721 p++, q = strchr (p, '"');
722 /* Then try 'single quotes'. */
723 else if (p = strchr (oldq, '\''), p)
724 p++, q = strchr (p, '\'');
725 else {
726 /* Then try entire line. */
727 q = strchr (oldq, 0);
728 if (q != oldq)
729 p = (char *)oldq;
732 if (p)
734 /* Don't let the strstr's below see the demangled name; we
735 might get spurious matches. */
736 p[-1] = '\0';
738 /* powerpc64-linux references .foo when calling function foo. */
739 if (*p == '.')
740 p++;
743 /* We need to check for certain error keywords here, or we would
744 mistakenly use GNU ld's "In function `foo':" message. */
745 if (q && (ok
746 || strstr (oldq, "ndefined")
747 || strstr (oldq, "nresolved")
748 || strstr (oldq, "nsatisfied")
749 || strstr (oldq, "ultiple")))
751 *q = 0;
752 dem = demangled_hash_lookup (p, false);
753 if (!dem)
755 if (!strncmp (p, USER_LABEL_PREFIX,
756 strlen (USER_LABEL_PREFIX)))
757 p += strlen (USER_LABEL_PREFIX);
758 sym = symbol_hash_lookup (p, false);
763 if (dem)
765 /* We found a demangled name. If this is the name of a
766 constructor or destructor, there can be several mangled names
767 that match it, so choose or unchoose all of them. If some are
768 chosen and some not, leave the later ones that don't match
769 alone for now; either this will cause the link to succeed, or
770 on the next attempt we will switch all of them the other way
771 and that will cause it to succeed. */
772 int chosen = 0;
773 int len = dem->mangled.length ();
774 ok = true;
775 FOR_EACH_VEC_ELT (dem->mangled, ix, s)
777 sym = symbol_hash_lookup (s, false);
778 if (ix == 0)
779 chosen = sym->chosen;
780 else if (sym->chosen != chosen)
781 /* Mismatch. */
782 continue;
783 /* Avoid an error about re-tweaking when we guess wrong in
784 the case of mismatch. */
785 if (len > 1)
786 sym->tweaked = false;
787 ok = start_tweaking (sym);
790 else
791 ok = start_tweaking (sym);
793 obstack_free (&temporary_obstack, temporary_firstobj);
795 if (!ok)
797 fclose (stream);
798 return 0;
802 fclose (stream);
803 return (file_stack != NULL);
806 /* Entry point for tlink. Called from main in collect2.c.
808 Iteratively try to provide definitions for all the unresolved symbols
809 mentioned in the linker error messages.
811 LD_ARGV is an array of arguments for the linker.
812 OBJECT_LST is an array of object files that we may be able to recompile
813 to provide missing definitions. Currently ignored. */
815 void
816 do_tlink (char **ld_argv, char **object_lst ATTRIBUTE_UNUSED)
818 int ret = tlink_execute ("ld", ld_argv, ldout, lderrout,
819 HAVE_GNU_LD && at_file_supplied);
821 tlink_init ();
823 if (ret)
825 int i = 0;
827 /* Until collect does a better job of figuring out which are object
828 files, assume that everything on the command line could be. */
829 if (read_repo_files (ld_argv))
830 while (ret && i++ < MAX_ITERATIONS)
832 if (tlink_verbose >= 3)
834 dump_ld_file (ldout, stdout);
835 dump_ld_file (lderrout, stderr);
837 demangle_new_symbols ();
838 if (! scan_linker_output (ldout)
839 && ! scan_linker_output (lderrout))
840 break;
841 if (! recompile_files ())
842 break;
843 if (tlink_verbose)
844 fprintf (stderr, _("collect: relinking\n"));
845 ret = tlink_execute ("ld", ld_argv, ldout, lderrout,
846 HAVE_GNU_LD && at_file_supplied);
850 dump_ld_file (ldout, stdout);
851 unlink (ldout);
852 dump_ld_file (lderrout, stderr);
853 unlink (lderrout);
854 if (ret)
856 error ("ld returned %d exit status", ret);
857 exit (ret);
859 else
861 /* We have just successfully produced an output file, so assume that we
862 may unlink it if need be for now on. */
863 may_unlink_output_file = true;