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, 2003, 2004, 2005, 2007, 2008,
   5    2009, 2010 Free Software Foundation, Inc.
   6    Contributed by Jason Merrill (jason@cygnus.com).
   7
   8 This file is part of GCC.
   9
  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 3, or (at your option) any later
  13 version.
  14
  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
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "intl.h"
  29 #include "obstack.h"
  30 #include "hashtab.h"
  31 #include "demangle.h"
  32 #include "collect2.h"
  33 #include "filenames.h"
  34
  35 /* TARGET_64BIT may be defined to use driver specific functionality. */
  36 #undef TARGET_64BIT
  37 #define TARGET_64BIT TARGET_64BIT_DEFAULT
  38
  39 #define MAX_ITERATIONS 17
  40
  41 /* Defined in the automatically-generated underscore.c.  */
  42 extern int prepends_underscore;
  43
  44 static int tlink_verbose;
  45
  46 static char *initial_cwd;
  47 \f
  48 /* Hash table boilerplate for working with htab_t.  We have hash tables
  49    for symbol names, file names, and demangled symbols.  */
  50
  51 typedef struct symbol_hash_entry
  52 {
  53   const char *key;
  54   struct file_hash_entry *file;
  55   int chosen;
  56   int tweaking;
  57   int tweaked;
  58 } symbol;
  59
  60 typedef struct file_hash_entry
  61 {
  62   const char *key;
  63   const char *args;
  64   const char *dir;
  65   const char *main;
  66   int tweaking;
  67 } file;
  68
  69 typedef struct demangled_hash_entry
  70 {
  71   const char *key;
  72   const char *mangled;
  73 } demangled;
  74
  75 /* Hash and comparison functions for these hash tables.  */
  76
  77 static int hash_string_eq (const void *, const void *);
  78 static hashval_t hash_string_hash (const void *);
  79
  80 static int
  81 hash_string_eq (const void *s1_p, const void *s2_p)
  82 {
  83   const char *const *s1 = (const char *const *) s1_p;
  84   const char *s2 = (const char *) s2_p;
  85   return strcmp (*s1, s2) == 0;
  86 }
  87
  88 static hashval_t
  89 hash_string_hash (const void *s_p)
  90 {
  91   const char *const *s = (const char *const *) s_p;
  92   return (*htab_hash_string) (*s);
  93 }
  94
  95 static htab_t symbol_table;
  96
  97 static struct symbol_hash_entry * symbol_hash_lookup (const char *, int);
  98 static struct file_hash_entry * file_hash_lookup (const char *);
  99 static struct demangled_hash_entry *demangled_hash_lookup (const char *, int);
 100 static void symbol_push (symbol *);
 101 static symbol * symbol_pop (void);
 102 static void file_push (file *);
 103 static file * file_pop (void);
 104 static void tlink_init (void);
 105 static int tlink_execute (const char *, char **, const char *, const char *);
 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 *);
 117
 118 /* Look up an entry in the symbol hash table.  */
 119
 120 static struct symbol_hash_entry *
 121 symbol_hash_lookup (const char *string, int create)
 122 {
 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)
 130     {
 131       struct symbol_hash_entry *v;
 132       *e = v = XCNEW (struct symbol_hash_entry);
 133       v->key = xstrdup (string);
 134     }
 135   return (struct symbol_hash_entry *) *e;
 136 }
 137
 138 static htab_t file_table;
 139
 140 /* Look up an entry in the file hash table.  */
 141
 142 static struct file_hash_entry *
 143 file_hash_lookup (const char *string)
 144 {
 145   void **e;
 146   e = htab_find_slot_with_hash (file_table, string,
 147                                 (*htab_hash_string) (string),
 148                                 INSERT);
 149   if (*e == NULL)
 150     {
 151       struct file_hash_entry *v;
 152       *e = v = XCNEW (struct file_hash_entry);
 153       v->key = xstrdup (string);
 154     }
 155   return (struct file_hash_entry *) *e;
 156 }
 157
 158 static htab_t demangled_table;
 159
 160 /* Look up an entry in the demangled name hash table.  */
 161
 162 static struct demangled_hash_entry *
 163 demangled_hash_lookup (const char *string, int create)
 164 {
 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)
 172     {
 173       struct demangled_hash_entry *v;
 174       *e = v = XCNEW (struct demangled_hash_entry);
 175       v->key = xstrdup (string);
 176     }
 177   return (struct demangled_hash_entry *) *e;
 178 }
 179 \f
 180 /* Stack code.  */
 181
 182 struct symbol_stack_entry
 183 {
 184   symbol *value;
 185   struct symbol_stack_entry *next;
 186 };
 187 struct obstack symbol_stack_obstack;
 188 struct symbol_stack_entry *symbol_stack;
 189
 190 struct file_stack_entry
 191 {
 192   file *value;
 193   struct file_stack_entry *next;
 194 };
 195 struct obstack file_stack_obstack;
 196 struct file_stack_entry *file_stack;
 197
 198 static void
 199 symbol_push (symbol *p)
 200 {
 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;
 206 }
 207
 208 static symbol *
 209 symbol_pop (void)
 210 {
 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;
 219 }
 220
 221 static void
 222 file_push (file *p)
 223 {
 224   struct file_stack_entry *ep;
 225
 226   if (p->tweaking)
 227     return;
 228
 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;
 234 }
 235
 236 static file *
 237 file_pop (void)
 238 {
 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;
 248 }
 249 \f
 250 /* Other machinery.  */
 251
 252 /* Initialize the tlink machinery.  Called from do_tlink.  */
 253
 254 static void
 255 tlink_init (void)
 256 {
 257   const char *p;
 258
 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);
 265
 266   obstack_begin (&symbol_stack_obstack, 0);
 267   obstack_begin (&file_stack_obstack, 0);
 268
 269   p = getenv ("TLINK_VERBOSE");
 270   if (p)
 271     tlink_verbose = atoi (p);
 272   else
 273     {
 274       tlink_verbose = 1;
 275       if (vflag)
 276         tlink_verbose = 2;
 277       if (debug)
 278         tlink_verbose = 3;
 279     }
 280
 281   initial_cwd = getpwd ();
 282 }
 283
 284 static int
 285 tlink_execute (const char *prog, char **argv, const char *outname,
 286                const char *errname)
 287 {
 288   struct pex_obj *pex;
 289
 290   pex = collect_execute (prog, argv, outname, errname, PEX_LAST | PEX_SEARCH);
 291   return collect_wait (prog, pex);
 292 }
 293
 294 static char *
 295 frob_extension (const char *s, const char *ext)
 296 {
 297   const char *p;
 298
 299   p = strrchr (lbasename (s), '.');
 300   if (! p)
 301     p = s + strlen (s);
 302
 303   obstack_grow (&temporary_obstack, s, p - s);
 304   return (char *) obstack_copy0 (&temporary_obstack, ext, strlen (ext));
 305 }
 306
 307 static char *
 308 obstack_fgets (FILE *stream, struct obstack *ob)
 309 {
 310   int c;
 311   while ((c = getc (stream)) != EOF && c != '\n')
 312     obstack_1grow (ob, c);
 313   if (obstack_object_size (ob) == 0)
 314     return NULL;
 315   obstack_1grow (ob, '\0');
 316   return XOBFINISH (ob, char *);
 317 }
 318
 319 static char *
 320 tfgets (FILE *stream)
 321 {
 322   return obstack_fgets (stream, &temporary_obstack);
 323 }
 324
 325 static char *
 326 pfgets (FILE *stream)
 327 {
 328   return xstrdup (tfgets (stream));
 329 }
 330 \f
 331 /* Real tlink code.  */
 332
 333 /* Subroutine of read_repo_file.  We are reading the repo file for file F,
 334    which is coming in on STREAM, and the symbol that comes next in STREAM
 335    is offered, chosen or provided if CHOSEN is 0, 1 or 2, respectively.
 336
 337    XXX "provided" is unimplemented, both here and in the compiler.  */
 338
 339 static void
 340 freadsym (FILE *stream, file *f, int chosen)
 341 {
 342   symbol *sym;
 343
 344   {
 345     const char *name = tfgets (stream);
 346     sym = symbol_hash_lookup (name, true);
 347   }
 348
 349   if (sym->file == NULL)
 350     {
 351       /* We didn't have this symbol already, so we choose this file.  */
 352
 353       symbol_push (sym);
 354       sym->file = f;
 355       sym->chosen = chosen;
 356     }
 357   else if (chosen)
 358     {
 359       /* We want this file; cast aside any pretender.  */
 360
 361       if (sym->chosen && sym->file != f)
 362         {
 363           if (sym->chosen == 1)
 364             file_push (sym->file);
 365           else
 366             {
 367               file_push (f);
 368               f = sym->file;
 369               chosen = sym->chosen;
 370             }
 371         }
 372       sym->file = f;
 373       sym->chosen = chosen;
 374     }
 375 }
 376
 377 /* Read in the repo file denoted by F, and record all its information.  */
 378
 379 static void
 380 read_repo_file (file *f)
 381 {
 382   char c;
 383   FILE *stream = fopen (f->key, "r");
 384
 385   if (tlink_verbose >= 2)
 386     fprintf (stderr, _("collect: reading %s\n"), f->key);
 387
 388   while (fscanf (stream, "%c ", &c) == 1)
 389     {
 390       switch (c)
 391         {
 392         case 'A':
 393           f->args = pfgets (stream);
 394           break;
 395         case 'D':
 396           f->dir = pfgets (stream);
 397           break;
 398         case 'M':
 399           f->main = pfgets (stream);
 400           break;
 401         case 'P':
 402           freadsym (stream, f, 2);
 403           break;
 404         case 'C':
 405           freadsym (stream, f, 1);
 406           break;
 407         case 'O':
 408           freadsym (stream, f, 0);
 409           break;
 410         }
 411       obstack_free (&temporary_obstack, temporary_firstobj);
 412     }
 413   fclose (stream);
 414   if (f->args == NULL)
 415     f->args = getenv ("COLLECT_GCC_OPTIONS");
 416   if (f->dir == NULL)
 417     f->dir = ".";
 418 }
 419
 420 /* We might want to modify LINE, which is a symbol line from file F.  We do
 421    this if either we saw an error message referring to the symbol in
 422    question, or we have already allocated the symbol to another file and
 423    this one wants to emit it as well.  */
 424
 425 static void
 426 maybe_tweak (char *line, file *f)
 427 {
 428   symbol *sym = symbol_hash_lookup (line + 2, false);
 429
 430   if ((sym->file == f && sym->tweaking)
 431       || (sym->file != f && line[0] == 'C'))
 432     {
 433       sym->tweaking = 0;
 434       sym->tweaked = 1;
 435
 436       if (line[0] == 'O')
 437         line[0] = 'C';
 438       else
 439         line[0] = 'O';
 440     }
 441 }
 442
 443 /* Update the repo files for each of the object files we have adjusted and
 444    recompile.  */
 445
 446 static int
 447 recompile_files (void)
 448 {
 449   file *f;
 450
 451   putenv (xstrdup ("COMPILER_PATH="));
 452   putenv (xstrdup ("LIBRARY_PATH="));
 453
 454   while ((f = file_pop ()) != NULL)
 455     {
 456       char *line;
 457       const char *p, *q;
 458       char **argv;
 459       struct obstack arg_stack;
 460       FILE *stream = fopen (f->key, "r");
 461       const char *const outname = frob_extension (f->key, ".rnw");
 462       FILE *output = fopen (outname, "w");
 463
 464       while ((line = tfgets (stream)) != NULL)
 465         {
 466           switch (line[0])
 467             {
 468             case 'C':
 469             case 'O':
 470               maybe_tweak (line, f);
 471             }
 472           fprintf (output, "%s\n", line);
 473         }
 474       fclose (stream);
 475       fclose (output);
 476       /* On Windows "rename" returns -1 and sets ERRNO to EACCESS if
 477          the new file name already exists.  Therefore, we explicitly
 478          remove the old file first.  */
 479       if (remove (f->key) == -1)
 480         fatal_perror ("removing .rpo file");
 481       if (rename (outname, f->key) == -1)
 482         fatal_perror ("renaming .rpo file");
 483
 484       if (!f->args)
 485         {
 486           error ("repository file '%s' does not contain command-line "
 487                  "arguments", f->key);
 488           return 0;
 489         }
 490
 491       /* Build a null-terminated argv array suitable for
 492          tlink_execute().  Manipulate arguments on the arg_stack while
 493          building argv on the temporary_obstack.  */
 494
 495       obstack_init (&arg_stack);
 496       obstack_ptr_grow (&temporary_obstack, c_file_name);
 497
 498       for (p = f->args; *p != '\0'; p = q + 1)
 499         {
 500           /* Arguments are delimited by single-quotes.  Find the
 501              opening quote.  */
 502           p = strchr (p, '\'');
 503           if (!p)
 504             goto done;
 505
 506           /* Find the closing quote.  */
 507           q = strchr (p + 1, '\'');
 508           if (!q)
 509             goto done;
 510
 511           obstack_grow (&arg_stack, p + 1, q - (p + 1));
 512
 513           /* Replace '\'' with '.  This is how set_collect_gcc_options
 514              encodes a single-quote.  */
 515           while (q[1] == '\\' && q[2] == '\'' && q[3] == '\'')
 516             {
 517               const char *r;
 518
 519               r = strchr (q + 4, '\'');
 520               if (!r)
 521                 goto done;
 522
 523               obstack_grow (&arg_stack, q + 3, r - (q + 3));
 524               q = r;
 525             }
 526
 527           obstack_1grow (&arg_stack, '\0');
 528           obstack_ptr_grow (&temporary_obstack, obstack_finish (&arg_stack));
 529         }
 530     done:
 531       obstack_ptr_grow (&temporary_obstack, f->main);
 532       obstack_ptr_grow (&temporary_obstack, NULL);
 533       argv = XOBFINISH (&temporary_obstack, char **);
 534
 535       if (tlink_verbose)
 536         fprintf (stderr, _("collect: recompiling %s\n"), f->main);
 537
 538       if (chdir (f->dir) != 0
 539           || tlink_execute (c_file_name, argv, NULL, NULL) != 0
 540           || chdir (initial_cwd) != 0)
 541         return 0;
 542
 543       read_repo_file (f);
 544
 545       obstack_free (&arg_stack, NULL);
 546       obstack_free (&temporary_obstack, temporary_firstobj);
 547     }
 548   return 1;
 549 }
 550
 551 /* The first phase of processing: determine which object files have
 552    .rpo files associated with them, and read in the information.  */
 553
 554 static int
 555 read_repo_files (char **object_lst)
 556 {
 557   char **object = object_lst;
 558
 559   for (; *object; object++)
 560     {
 561       const char *p;
 562       file *f;
 563
 564       /* Don't bother trying for ld flags.  */
 565       if (*object[0] == '-')
 566         continue;
 567
 568       p = frob_extension (*object, ".rpo");
 569
 570       if (! file_exists (p))
 571         continue;
 572
 573       f = file_hash_lookup (p);
 574
 575       read_repo_file (f);
 576     }
 577
 578   if (file_stack != NULL && ! recompile_files ())
 579     return 0;
 580
 581   return (symbol_stack != NULL);
 582 }
 583
 584 /* Add the demangled forms of any new symbols to the hash table.  */
 585
 586 static void
 587 demangle_new_symbols (void)
 588 {
 589   symbol *sym;
 590
 591   while ((sym = symbol_pop ()) != NULL)
 592     {
 593       demangled *dem;
 594       const char *p = cplus_demangle (sym->key, DMGL_PARAMS | DMGL_ANSI);
 595
 596       if (! p)
 597         continue;
 598
 599       dem = demangled_hash_lookup (p, true);
 600       dem->mangled = sym->key;
 601     }
 602 }
 603
 604 /* Step through the output of the linker, in the file named FNAME, and
 605    adjust the settings for each symbol encountered.  */
 606
 607 static int
 608 scan_linker_output (const char *fname)
 609 {
 610   FILE *stream = fopen (fname, "r");
 611   char *line;
 612   int skip_next_in_line = 0;
 613
 614   while ((line = tfgets (stream)) != NULL)
 615     {
 616       char *p = line, *q;
 617       symbol *sym;
 618       int end;
 619       int ok = 0;
 620
 621       /* On darwin9, we might have to skip " in " lines as well.  */
 622       if (skip_next_in_line
 623           && strstr (p, " in "))
 624           continue;
 625       skip_next_in_line = 0;
 626
 627       while (*p && ISSPACE ((unsigned char) *p))
 628         ++p;
 629
 630       if (! *p)
 631         continue;
 632
 633       for (q = p; *q && ! ISSPACE ((unsigned char) *q); ++q)
 634         ;
 635
 636       /* Try the first word on the line.  */
 637       if (*p == '.')
 638         ++p;
 639       if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
 640         p += strlen (USER_LABEL_PREFIX);
 641
 642       end = ! *q;
 643       *q = 0;
 644       sym = symbol_hash_lookup (p, false);
 645
 646       /* Some SVR4 linkers produce messages like
 647          ld: 0711-317 ERROR: Undefined symbol: .g__t3foo1Zi
 648          */
 649       if (! sym && ! end && strstr (q + 1, "Undefined symbol: "))
 650         {
 651           char *p = strrchr (q + 1, ' ');
 652           p++;
 653           if (*p == '.')
 654             p++;
 655           if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
 656             p += strlen (USER_LABEL_PREFIX);
 657           sym = symbol_hash_lookup (p, false);
 658         }
 659
 660       if (! sym && ! end)
 661         /* Try a mangled name in quotes.  */
 662         {
 663           char *oldq = q + 1;
 664           demangled *dem = 0;
 665           q = 0;
 666
 667           /* On darwin9, we look for "foo" referenced from:\n\(.* in .*\n\)*  */
 668           if (strcmp (oldq, "referenced from:") == 0)
 669             {
 670               /* We have to remember that we found a symbol to tweak.  */
 671               ok = 1;
 672
 673               /* We actually want to start from the first word on the
 674                  line.  */
 675               oldq = p;
 676
 677               /* Since the format is multiline, we have to skip
 678                  following lines with " in ".  */
 679               skip_next_in_line = 1;
 680             }
 681
 682           /* First try `GNU style'.  */
 683           p = strchr (oldq, '`');
 684           if (p)
 685             p++, q = strchr (p, '\'');
 686           /* Then try "double quotes".  */
 687           else if (p = strchr (oldq, '"'), p)
 688             p++, q = strchr (p, '"');
 689           /* Then try 'single quotes'.  */
 690           else if (p = strchr (oldq, '\''), p)
 691             p++, q = strchr (p, '\'');
 692           else {
 693             /* Then try entire line.  */
 694             q = strchr (oldq, 0);
 695             if (q != oldq)
 696               p = (char *)oldq;
 697           }
 698
 699           if (p)
 700             {
 701               /* Don't let the strstr's below see the demangled name; we
 702                  might get spurious matches.  */
 703               p[-1] = '\0';
 704
 705               /* powerpc64-linux references .foo when calling function foo.  */
 706               if (*p == '.')
 707                 p++;
 708             }
 709
 710           /* We need to check for certain error keywords here, or we would
 711              mistakenly use GNU ld's "In function `foo':" message.  */
 712           if (q && (ok
 713                     || strstr (oldq, "ndefined")
 714                     || strstr (oldq, "nresolved")
 715                     || strstr (oldq, "nsatisfied")
 716                     || strstr (oldq, "ultiple")))
 717             {
 718               *q = 0;
 719               dem = demangled_hash_lookup (p, false);
 720               if (dem)
 721                 sym = symbol_hash_lookup (dem->mangled, false);
 722               else
 723                 {
 724                   if (!strncmp (p, USER_LABEL_PREFIX,
 725                                 strlen (USER_LABEL_PREFIX)))
 726                     p += strlen (USER_LABEL_PREFIX);
 727                   sym = symbol_hash_lookup (p, false);
 728                 }
 729             }
 730         }
 731
 732       if (sym && sym->tweaked)
 733         {
 734           error ("'%s' was assigned to '%s', but was not defined "
 735                  "during recompilation, or vice versa",
 736                  sym->key, sym->file->key);
 737           fclose (stream);
 738           return 0;
 739         }
 740       if (sym && !sym->tweaking)
 741         {
 742           if (tlink_verbose >= 2)
 743             fprintf (stderr, _("collect: tweaking %s in %s\n"),
 744                      sym->key, sym->file->key);
 745           sym->tweaking = 1;
 746           file_push (sym->file);
 747         }
 748
 749       obstack_free (&temporary_obstack, temporary_firstobj);
 750     }
 751
 752   fclose (stream);
 753   return (file_stack != NULL);
 754 }
 755
 756 /* Entry point for tlink.  Called from main in collect2.c.
 757
 758    Iteratively try to provide definitions for all the unresolved symbols
 759    mentioned in the linker error messages.
 760
 761    LD_ARGV is an array of arguments for the linker.
 762    OBJECT_LST is an array of object files that we may be able to recompile
 763      to provide missing definitions.  Currently ignored.  */
 764
 765 void
 766 do_tlink (char **ld_argv, char **object_lst ATTRIBUTE_UNUSED)
 767 {
 768   int exit = tlink_execute ("ld", ld_argv, ldout, lderrout);
 769
 770   tlink_init ();
 771
 772   if (exit)
 773     {
 774       int i = 0;
 775
 776       /* Until collect does a better job of figuring out which are object
 777          files, assume that everything on the command line could be.  */
 778       if (read_repo_files (ld_argv))
 779         while (exit && i++ < MAX_ITERATIONS)
 780           {
 781             if (tlink_verbose >= 3)
 782               {
 783                 dump_file (ldout, stdout);
 784                 dump_file (lderrout, stderr);
 785               }
 786             demangle_new_symbols ();
 787             if (! scan_linker_output (ldout)
 788                 && ! scan_linker_output (lderrout))
 789               break;
 790             if (! recompile_files ())
 791               break;
 792             if (tlink_verbose)
 793               fprintf (stderr, _("collect: relinking\n"));
 794             exit = tlink_execute ("ld", ld_argv, ldout, lderrout);
 795           }
 796     }
 797
 798   dump_file (ldout, stdout);
 799   unlink (ldout);
 800   dump_file (lderrout, stderr);
 801   unlink (lderrout);
 802   if (exit)
 803     {
 804       error ("ld returned %d exit status", exit);
 805       collect_exit (exit);
 806     }
 807 }