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