gcc/tlink.c

   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
   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 2, 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 COPYING.  If not, write to the Free
  21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 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   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':
 514               maybe_tweak (line, f);
 515             }
 516           fprintf (output, "%s\n", line);
 517         }
 518       fclose (stream);
 519       fclose (output);
 520       rename (outname, (char*) f->root.key);
 521
 522       obstack_grow (&temporary_obstack, "cd ", 3);
 523       obstack_grow (&temporary_obstack, f->dir, strlen (f->dir));
 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
 541       obstack_free (&temporary_obstack, temporary_firstobj);
 542     }
 543   return 1;
 544 }
 545
 546 /* The first phase of processing: determine which object files have
 547    .rpo files associated with them, and read in the information.  */
 548
 549 static int
 550 read_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
 574   if (file_stack != NULL && ! recompile_files ())
 575     return 0;
 576
 577   return (symbol_stack != NULL);
 578 }
 579
 580 /* Add the demangled forms of any new symbols to the hash table.  */
 581
 582 static void
 583 demangle_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     }
 599 }
 600
 601 /* Step through the output of the linker, in the file named FNAME, and
 602    adjust the settings for each symbol encountered.  */
 603
 604 static int
 605 scan_linker_output (fname)
 606      const char *fname;
 607 {
 608   FILE *stream = fopen (fname, "r");
 609   char *line;
 610
 611   while ((line = tfgets (stream)) != NULL)
 612     {
 613       char *p = line, *q;
 614       symbol *sym;
 615       int end;
 616
 617       while (*p && ISSPACE ((unsigned char)*p))
 618         ++p;
 619
 620       if (! *p)
 621         continue;
 622
 623       for (q = p; *q && ! ISSPACE ((unsigned char)*q); ++q)
 624         ;
 625
 626       /* Try the first word on the line.  */
 627       if (*p == '.')
 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)
 684                     ++p;
 685                   sym = symbol_hash_lookup (p, false);
 686                 }
 687             }
 688         }
 689
 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
 707   fclose (stream);
 708   return (file_stack != NULL);
 709 }
 710
 711 /* Entry point for tlink.  Called from main in collect2.c.
 712
 713    Iteratively try to provide definitions for all the unresolved symbols
 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
 720 void
 721 do_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;
 731
 732       /* Until collect does a better job of figuring out which are object
 733          files, assume that everything on the command line could be.  */
 734       if (read_repo_files (ld_argv))
 735         while (exit && i++ < MAX_ITERATIONS)
 736           {
 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 }