gcc/tlink.c

   1 /* Scan linker error messages for missing template instantiations and provide
   2    them.
   3
   4    Copyright (C) 1995, 1998, 1999, 2000 Free Software Foundation, Inc.
   5    Contributed by Jason Merrill (jason@cygnus.com).
   6
   7 This file is part of GNU CC.
   8
   9 GNU CC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GNU CC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU CC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-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.  */
  38 extern int prepends_underscore;
  39
  40 static int tlink_verbose;
  41 \f
  42 /* Hash table boilerplate for working with hash.[ch].  We have hash tables
  43    for symbol names, file names, and demangled symbols.  */
  44
  45 typedef struct symbol_hash_entry
  46 {
  47   struct hash_entry root;
  48   struct file_hash_entry *file;
  49   int chosen;
  50   int tweaking;
  51   int tweaked;
  52 } symbol;
  53
  54 typedef struct file_hash_entry
  55 {
  56   struct hash_entry root;
  57   const char *args;
  58   const char *dir;
  59   const char *main;
  60   int tweaking;
  61 } file;
  62
  63 typedef struct demangled_hash_entry
  64 {
  65   struct hash_entry root;
  66   const char *mangled;
  67 } demangled;
  68
  69 static struct hash_table symbol_table;
  70
  71 static struct hash_entry * symbol_hash_newfunc PARAMS ((struct hash_entry *,
  72                                                         struct hash_table *,
  73                                                         hash_table_key));
  74 static struct symbol_hash_entry * symbol_hash_lookup PARAMS ((const char *,
  75                                                               int));
  76 static struct hash_entry * file_hash_newfunc PARAMS ((struct hash_entry *,
  77                                                       struct hash_table *,
  78                                                       hash_table_key));
  79 static struct file_hash_entry * file_hash_lookup PARAMS ((const char *));
  80 static struct hash_entry * demangled_hash_newfunc PARAMS ((struct hash_entry *,
  81                                                            struct hash_table *,
  82                                                            hash_table_key));
  83 static struct demangled_hash_entry *
  84   demangled_hash_lookup PARAMS ((const char *, int));
  85 static void symbol_push PARAMS ((symbol *));
  86 static symbol * symbol_pop PARAMS ((void));
  87 static void file_push PARAMS ((file *));
  88 static file * file_pop PARAMS ((void));
  89 static void tlink_init PARAMS ((void));
  90 static int tlink_execute PARAMS ((const char *, char **, const char *));
  91 static char * frob_extension PARAMS ((const char *, const char *));
  92 static char * obstack_fgets PARAMS ((FILE *, struct obstack *));
  93 static char * tfgets PARAMS ((FILE *));
  94 static char * pfgets PARAMS ((FILE *));
  95 static void freadsym PARAMS ((FILE *, file *, int));
  96 static void read_repo_file PARAMS ((file *));
  97 static void maybe_tweak PARAMS ((char *, file *));
  98 static int recompile_files PARAMS ((void));
  99 static int read_repo_files PARAMS ((char **));
 100 static void demangle_new_symbols PARAMS ((void));
 101 static 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
 106 static struct hash_entry *
 107 symbol_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;
 119     }
 120   ret->file = NULL;
 121   ret->chosen = 0;
 122   ret->tweaking = 0;
 123   ret->tweaked = 0;
 124   return (struct hash_entry *) ret;
 125 }
 126
 127 /* Look up an entry in the symbol hash table.  */
 128
 129 static struct symbol_hash_entry *
 130 symbol_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
 139 static struct hash_table file_table;
 140
 141 /* Create a new entry for the file hash table.
 142    Passed to hash_table_init.  */
 143
 144 static struct hash_entry *
 145 file_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;
 157     }
 158   ret->args = NULL;
 159   ret->dir = NULL;
 160   ret->main = NULL;
 161   ret->tweaking = 0;
 162   return (struct hash_entry *) ret;
 163 }
 164
 165 /* Look up an entry in the file hash table.  */
 166
 167 static struct file_hash_entry *
 168 file_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
 176 static struct hash_table demangled_table;
 177
 178 /* Create a new entry for the demangled name hash table.
 179    Passed to hash_table_init.  */
 180
 181 static struct hash_entry *
 182 demangled_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
 201 static struct demangled_hash_entry *
 202 demangled_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 \f
 211 /* Stack code.  */
 212
 213 struct symbol_stack_entry
 214 {
 215   symbol *value;
 216   struct symbol_stack_entry *next;
 217 };
 218 struct obstack symbol_stack_obstack;
 219 struct symbol_stack_entry *symbol_stack;
 220
 221 struct file_stack_entry
 222 {
 223   file *value;
 224   struct file_stack_entry *next;
 225 };
 226 struct obstack file_stack_obstack;
 227 struct file_stack_entry *file_stack;
 228
 229 static void
 230 symbol_push (p)
 231      symbol *p;
 232 {
 233   struct symbol_stack_entry *ep = (struct symbol_stack_entry *) obstack_alloc
 234     (&symbol_stack_obstack, sizeof (struct symbol_stack_entry));
 235   ep->value = p;
 236   ep->next = symbol_stack;
 237   symbol_stack = ep;
 238 }
 239
 240 static symbol *
 241 symbol_pop ()
 242 {
 243   struct symbol_stack_entry *ep = symbol_stack;
 244   symbol *p;
 245   if (ep == NULL)
 246     return NULL;
 247   p = ep->value;
 248   symbol_stack = ep->next;
 249   obstack_free (&symbol_stack_obstack, ep);
 250   return p;
 251 }
 252
 253 static void
 254 file_push (p)
 255      file *p;
 256 {
 257   struct file_stack_entry *ep;
 258
 259   if (p->tweaking)
 260     return;
 261
 262   ep = (struct file_stack_entry *) obstack_alloc
 263     (&file_stack_obstack, sizeof (struct file_stack_entry));
 264   ep->value = p;
 265   ep->next = file_stack;
 266   file_stack = ep;
 267   p->tweaking = 1;
 268 }
 269
 270 static file *
 271 file_pop ()
 272 {
 273   struct file_stack_entry *ep = file_stack;
 274   file *p;
 275   if (ep == NULL)
 276     return NULL;
 277   p = ep->value;
 278   file_stack = ep->next;
 279   obstack_free (&file_stack_obstack, ep);
 280   p->tweaking = 0;
 281   return p;
 282 }
 283 \f
 284 /* Other machinery.  */
 285
 286 /* Initialize the tlink machinery.  Called from do_tlink.  */
 287
 288 static void
 289 tlink_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
 315 static int
 316 tlink_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
 325 static char *
 326 frob_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
 341 static char *
 342 obstack_fgets (stream, ob)
 343      FILE *stream;
 344      struct obstack *ob;
 345 {
 346   int c;
 347   while ((c = getc (stream)) != EOF && c != '\n')
 348     obstack_1grow (ob, c);
 349   if (obstack_object_size (ob) == 0)
 350     return NULL;
 351   obstack_1grow (ob, '\0');
 352   return obstack_finish (ob);
 353 }
 354
 355 static char *
 356 tfgets (stream)
 357      FILE *stream;
 358 {
 359   return obstack_fgets (stream, &temporary_obstack);
 360 }
 361
 362 static char *
 363 pfgets (stream)
 364      FILE *stream;
 365 {
 366   return obstack_fgets (stream, &permanent_obstack);
 367 }
 368 \f
 369 /* Real tlink code.  */
 370
 371 /* Subroutine of read_repo_file.  We are reading the repo file for file F,
 372    which is coming in on STREAM, and the symbol that comes next in STREAM
 373    is offerred, chosen or provided if CHOSEN is 0, 1 or 2, respectively.
 374
 375    XXX "provided" is unimplemented, both here and in the compiler.  */
 376
 377 static void
 378 freadsym (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);
 395       sym->file = f;
 396       sym->chosen = chosen;
 397     }
 398   else if (chosen)
 399     {
 400       /* We want this file; cast aside any pretender.  */
 401
 402       if (sym->chosen && sym->file != f)
 403         {
 404           if (sym->chosen == 1)
 405             file_push (sym->file);
 406           else
 407             {
 408               file_push (f);
 409               f = sym->file;
 410               chosen = sym->chosen;
 411             }
 412         }
 413       sym->file = f;
 414       sym->chosen = chosen;
 415     }
 416 }
 417
 418 /* Read in the repo file denoted by F, and record all its information.  */
 419
 420 static void
 421 read_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);
 437           break;
 438         case 'D':
 439           f->dir = pfgets (stream);
 440           break;
 441         case 'M':
 442           f->main = pfgets (stream);
 443           break;
 444         case 'P':
 445           freadsym (stream, f, 2);
 446           break;
 447         case 'C':
 448           freadsym (stream, f, 1);
 449           break;
 450         case 'O':
 451           freadsym (stream, f, 0);
 452           break;
 453         }
 454       obstack_free (&temporary_obstack, temporary_firstobj);
 455     }
 456   fclose (stream);
 457   if (f->args == NULL)
 458     f->args = getenv ("COLLECT_GCC_OPTIONS");
 459   if (f->dir == NULL)
 460     f->dir = ".";
 461 }
 462
 463 /* We might want to modify LINE, which is a symbol line from file F.  We do
 464    this if either we saw an error message referring to the symbol in
 465    question, or we have already allocated the symbol to another file and
 466    this one wants to emit it as well.  */
 467
 468 static void
 469 maybe_tweak (line, f)
 470      char *line;
 471      file *f;
 472 {
 473   symbol *sym = symbol_hash_lookup (line + 2, false);
 474
 475   if ((sym->file == f && sym->tweaking)
 476       || (sym->file != f && line[0] == 'C'))
 477     {
 478       sym->tweaking = 0;
 479       sym->tweaked = 1;
 480
 481       if (line[0] == 'O')
 482         line[0] = 'C';
 483       else
 484         line[0] = 'O';
 485     }
 486 }
 487
 488 /* Update the repo files for each of the object files we have adjusted and
 489    recompile.
 490
 491    XXX Should this use collect_execute instead of system?  */
 492
 493 static int
 494 recompile_files ()
 495 {
 496   file *f;
 497
 498   while ((f = file_pop ()) != NULL)
 499     {
 500       char *line, *command;
 501       FILE *stream = fopen ((char*) f->root.key, "r");
 502       const char *outname = frob_extension ((char*) f->root.key, ".rnw");
 503       FILE *output = fopen (outname, "w");
 504
 505       while ((line = tfgets (stream)) != NULL)
 506         {
 507           switch (line[0])
 508             {
 509             case 'C':
 510             case 'O':
 511               maybe_tweak (line, f);
 512             }
 513           fprintf (output, "%s\n", line);
 514         }
 515       fclose (stream);
 516       fclose (output);
 517       rename (outname, (char*) f->root.key);
 518
 519       obstack_grow (&temporary_obstack, "cd ", 3);
 520       obstack_grow (&temporary_obstack, f->dir, strlen (f->dir));
 521       obstack_grow (&temporary_obstack, "; ", 2);
 522       obstack_grow (&temporary_obstack, c_file_name, strlen (c_file_name));
 523       obstack_1grow (&temporary_obstack, ' ');
 524       obstack_grow (&temporary_obstack, f->args, strlen (f->args));
 525       obstack_1grow (&temporary_obstack, ' ');
 526       command = obstack_copy0 (&temporary_obstack, f->main, strlen (f->main));
 527
 528       if (tlink_verbose)
 529         fprintf (stderr, _("collect: recompiling %s\n"), f->main);
 530       if (tlink_verbose >= 3)
 531         fprintf (stderr, "%s\n", command);
 532
 533       if (system (command) != 0)
 534         return 0;
 535
 536       read_repo_file (f);
 537
 538       obstack_free (&temporary_obstack, temporary_firstobj);
 539     }
 540   return 1;
 541 }
 542
 543 /* The first phase of processing: determine which object files have
 544    .rpo files associated with them, and read in the information.  */
 545
 546 static int
 547 read_repo_files (object_lst)
 548      char **object_lst;
 549 {
 550   char **object = object_lst;
 551
 552   for (; *object; object++)
 553     {
 554       const char *p;
 555       file *f;
 556
 557       /* Don't bother trying for ld flags.  */
 558       if (*object[0] == '-')
 559         continue;
 560
 561       p = frob_extension (*object, ".rpo");
 562
 563       if (! file_exists (p))
 564         continue;
 565
 566       f = file_hash_lookup (p);
 567
 568       read_repo_file (f);
 569     }
 570
 571   if (file_stack != NULL && ! recompile_files ())
 572     return 0;
 573
 574   return (symbol_stack != NULL);
 575 }
 576
 577 /* Add the demangled forms of any new symbols to the hash table.  */
 578
 579 static void
 580 demangle_new_symbols ()
 581 {
 582   symbol *sym;
 583
 584   while ((sym = symbol_pop ()) != NULL)
 585     {
 586       demangled *dem;
 587       const char *p = cplus_demangle ((char*) sym->root.key,
 588                                 DMGL_PARAMS | DMGL_ANSI);
 589
 590       if (! p)
 591         continue;
 592
 593       dem = demangled_hash_lookup (p, true);
 594       dem->mangled = (char*) sym->root.key;
 595     }
 596 }
 597
 598 /* Step through the output of the linker, in the file named FNAME, and
 599    adjust the settings for each symbol encountered.  */
 600
 601 static int
 602 scan_linker_output (fname)
 603      const char *fname;
 604 {
 605   FILE *stream = fopen (fname, "r");
 606   char *line;
 607
 608   while ((line = tfgets (stream)) != NULL)
 609     {
 610       char *p = line, *q;
 611       symbol *sym;
 612       int end;
 613
 614       while (*p && ISSPACE ((unsigned char)*p))
 615         ++p;
 616
 617       if (! *p)
 618         continue;
 619
 620       for (q = p; *q && ! ISSPACE ((unsigned char)*q); ++q)
 621         ;
 622
 623       /* Try the first word on the line.  */
 624       if (*p == '.')
 625         ++p;
 626       if (*p == '_' && prepends_underscore)
 627         ++p;
 628
 629       end = ! *q;
 630       *q = 0;
 631       sym = symbol_hash_lookup (p, false);
 632
 633       /* Some SVR4 linkers produce messages like
 634          ld: 0711-317 ERROR: Undefined symbol: .g__t3foo1Zi
 635          */
 636       if (! sym && ! end && strstr (q+1, "Undefined symbol: "))
 637         {
 638           char *p = strrchr (q+1, ' ');
 639           p++;
 640           if (*p == '.')
 641             p++;
 642           if (*p == '_' && prepends_underscore)
 643             p++;
 644           sym = symbol_hash_lookup (p, false);
 645         }
 646
 647       if (! sym && ! end)
 648         /* Try a mangled name in quotes.  */
 649         {
 650           const char *oldq = q+1;
 651           demangled *dem = 0;
 652           q = 0;
 653
 654           /* First try `GNU style'.  */
 655           p = strchr (oldq, '`');
 656           if (p)
 657             p++, q = strchr (p, '\'');
 658           /* Then try "double quotes".  */
 659           else if (p = strchr (oldq, '"'), p)
 660             p++, q = strchr (p, '"');
 661
 662           /* Don't let the strstr's below see the demangled name; we
 663              might get spurious matches.  */
 664           if (p)
 665             p[-1] = '\0';
 666
 667           /* We need to check for certain error keywords here, or we would
 668              mistakenly use GNU ld's "In function `foo':" message.  */
 669           if (q && (strstr (oldq, "ndefined")
 670                     || strstr (oldq, "nresolved")
 671                     || strstr (oldq, "ultiple")))
 672             {
 673               *q = 0;
 674               dem = demangled_hash_lookup (p, false);
 675               if (dem)
 676                 sym = symbol_hash_lookup (dem->mangled, false);
 677               else
 678                 {
 679                   if (*p == '_' && prepends_underscore)
 680                     ++p;
 681                   sym = symbol_hash_lookup (p, false);
 682                 }
 683             }
 684         }
 685
 686       if (sym && sym->tweaked)
 687         {
 688           fclose (stream);
 689           return 0;
 690         }
 691       if (sym && !sym->tweaking)
 692         {
 693           if (tlink_verbose >= 2)
 694             fprintf (stderr, _("collect: tweaking %s in %s\n"),
 695                      (char*) sym->root.key, (char*) sym->file->root.key);
 696           sym->tweaking = 1;
 697           file_push (sym->file);
 698         }
 699
 700       obstack_free (&temporary_obstack, temporary_firstobj);
 701     }
 702
 703   fclose (stream);
 704   return (file_stack != NULL);
 705 }
 706
 707 /* Entry point for tlink.  Called from main in collect2.c.
 708
 709    Iteratively try to provide definitions for all the unresolved symbols
 710    mentioned in the linker error messages.
 711
 712    LD_ARGV is an array of arguments for the linker.
 713    OBJECT_LST is an array of object files that we may be able to recompile
 714      to provide missing definitions.  Currently ignored.  */
 715
 716 void
 717 do_tlink (ld_argv, object_lst)
 718      char **ld_argv, **object_lst ATTRIBUTE_UNUSED;
 719 {
 720   int exit = tlink_execute ("ld", ld_argv, ldout);
 721
 722   tlink_init ();
 723
 724   if (exit)
 725     {
 726       int i = 0;
 727
 728       /* Until collect does a better job of figuring out which are object
 729          files, assume that everything on the command line could be.  */
 730       if (read_repo_files (ld_argv))
 731         while (exit && i++ < MAX_ITERATIONS)
 732           {
 733             if (tlink_verbose >= 3)
 734               dump_file (ldout);
 735             demangle_new_symbols ();
 736             if (! scan_linker_output (ldout))
 737               break;
 738             if (! recompile_files ())
 739               break;
 740             if (tlink_verbose)
 741               fprintf (stderr, _("collect: relinking\n"));
 742             exit = tlink_execute ("ld", ld_argv, ldout);
 743           }
 744     }
 745
 746   dump_file (ldout);
 747   unlink (ldout);
 748   if (exit)
 749     {
 750       error ("ld returned %d exit status", exit);
 751       collect_exit (exit);
 752     }
 753 }