Automatic date update in version.in
[binutils-gdb.git] / ld / ldmisc.c
blobe204811a03ef08100fe4971cb107f8969b371a1a
1 /* ldmisc.c
2 Copyright (C) 1991-2022 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support.
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libiberty.h"
26 #include "ctf-api.h"
27 #include "safe-ctype.h"
28 #include "filenames.h"
29 #include "demangle.h"
30 #include <stdarg.h>
31 #include "ld.h"
32 #include "ldmisc.h"
33 #include "ldexp.h"
34 #include "ldlang.h"
35 #include <ldgram.h>
36 #include "ldlex.h"
37 #include "ldmain.h"
38 #include "ldfile.h"
41 %% literal %
42 %C clever filename:linenumber with function
43 %D like %C, but no function name
44 %E current bfd error or errno
45 %F error is fatal
46 %G like %D, but only function name
47 %H like %C but in addition emit section+offset
48 %P print program name
49 %V hex bfd_vma
50 %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces
51 %X no object output, fail return
52 %d integer, like printf
53 %ld long, like printf
54 %lu unsigned long, like printf
55 %p native (host) void* pointer, like printf
56 %pA section name from a section
57 %pB filename from a bfd
58 %pI filename from a lang_input_statement_type
59 %pR info about a relent
60 %pS print script file and linenumber from etree_type.
61 %pT symbol name
62 %pU print script file without linenumber from etree_type.
63 %s arbitrary string, like printf
64 %u integer, like printf
65 %v hex bfd_vma, no leading zeros
68 void
69 vfinfo (FILE *fp, const char *fmt, va_list ap, bool is_warning)
71 bool fatal = false;
72 const char *scan;
73 int arg_type;
74 unsigned int arg_count = 0;
75 unsigned int arg_no;
76 union vfinfo_args
78 int i;
79 long l;
80 void *p;
81 bfd_vma v;
82 struct {
83 bfd *abfd;
84 asection *sec;
85 bfd_vma off;
86 } reladdr;
87 enum
89 Bad,
90 Int,
91 Long,
92 Ptr,
93 Vma,
94 RelAddr
95 } type;
96 } args[9];
98 for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++)
99 args[arg_no].type = Bad;
101 arg_count = 0;
102 scan = fmt;
103 while (*scan != '\0')
105 while (*scan != '%' && *scan != '\0')
106 scan++;
108 if (*scan == '%')
110 scan++;
112 arg_no = arg_count;
113 if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$')
115 arg_no = *scan - '1';
116 scan += 2;
119 arg_type = Bad;
120 switch (*scan++)
122 case '\0':
123 --scan;
124 break;
126 case 'V':
127 case 'v':
128 case 'W':
129 arg_type = Vma;
130 break;
132 case 's':
133 arg_type = Ptr;
134 break;
136 case 'p':
137 if (*scan == 'A' || *scan == 'B' || *scan == 'I'
138 || *scan == 'R' || *scan == 'S' || *scan == 'T')
139 scan++;
140 arg_type = Ptr;
141 break;
143 case 'C':
144 case 'D':
145 case 'G':
146 case 'H':
147 arg_type = RelAddr;
148 break;
150 case 'd':
151 case 'u':
152 arg_type = Int;
153 break;
155 case 'l':
156 if (*scan == 'd' || *scan == 'u')
158 ++scan;
159 arg_type = Long;
161 break;
163 default:
164 break;
166 if (arg_type != Bad)
168 if (arg_no >= sizeof (args) / sizeof (args[0]))
169 abort ();
170 args[arg_no].type = arg_type;
171 ++arg_count;
176 for (arg_no = 0; arg_no < arg_count; arg_no++)
178 switch (args[arg_no].type)
180 case Int:
181 args[arg_no].i = va_arg (ap, int);
182 break;
183 case Long:
184 args[arg_no].l = va_arg (ap, long);
185 break;
186 case Ptr:
187 args[arg_no].p = va_arg (ap, void *);
188 break;
189 case Vma:
190 args[arg_no].v = va_arg (ap, bfd_vma);
191 break;
192 case RelAddr:
193 args[arg_no].reladdr.abfd = va_arg (ap, bfd *);
194 args[arg_no].reladdr.sec = va_arg (ap, asection *);
195 args[arg_no].reladdr.off = va_arg (ap, bfd_vma);
196 break;
197 default:
198 abort ();
202 arg_count = 0;
203 while (*fmt != '\0')
205 const char *str = fmt;
206 while (*fmt != '%' && *fmt != '\0')
207 fmt++;
208 if (fmt != str)
209 if (fwrite (str, 1, fmt - str, fp))
211 /* Ignore. */
214 if (*fmt == '%')
216 fmt++;
218 arg_no = arg_count;
219 if (*fmt != '0' && ISDIGIT (*fmt) && fmt[1] == '$')
221 arg_no = *fmt - '1';
222 fmt += 2;
225 switch (*fmt++)
227 case '\0':
228 --fmt;
229 /* Fall through. */
231 case '%':
232 /* literal % */
233 putc ('%', fp);
234 break;
236 case 'X':
237 /* no object output, fail return */
238 config.make_executable = false;
239 break;
241 case 'V':
242 /* hex bfd_vma */
244 bfd_vma value = args[arg_no].v;
245 ++arg_count;
246 fprintf_vma (fp, value);
248 break;
250 case 'v':
251 /* hex bfd_vma, no leading zeros */
253 char buf[100];
254 char *p = buf;
255 bfd_vma value = args[arg_no].v;
256 ++arg_count;
257 sprintf_vma (p, value);
258 while (*p == '0')
259 p++;
260 if (!*p)
261 p--;
262 fputs (p, fp);
264 break;
266 case 'W':
267 /* hex bfd_vma with 0x with no leading zeroes taking up
268 8 spaces. */
270 char buf[100];
271 bfd_vma value;
272 char *p;
273 int len;
275 value = args[arg_no].v;
276 ++arg_count;
277 sprintf_vma (buf, value);
278 for (p = buf; *p == '0'; ++p)
280 if (*p == '\0')
281 --p;
282 len = strlen (p);
283 while (len < 8)
285 putc (' ', fp);
286 ++len;
288 fprintf (fp, "0x%s", p);
290 break;
292 case 'F':
293 /* Error is fatal. */
294 fatal = true;
295 break;
297 case 'P':
298 /* Print program name. */
299 fprintf (fp, "%s", program_name);
300 break;
302 case 'E':
303 /* current bfd error or errno */
304 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
305 break;
307 case 'C':
308 case 'D':
309 case 'G':
310 case 'H':
311 /* Clever filename:linenumber with function name if possible.
312 The arguments are a BFD, a section, and an offset. */
314 static bfd *last_bfd;
315 static char *last_file;
316 static char *last_function;
317 bfd *abfd;
318 asection *section;
319 bfd_vma offset;
320 asymbol **asymbols = NULL;
321 const char *filename;
322 const char *functionname;
323 unsigned int linenumber;
324 bool discard_last;
325 bool done;
326 bfd_error_type last_bfd_error = bfd_get_error ();
328 abfd = args[arg_no].reladdr.abfd;
329 section = args[arg_no].reladdr.sec;
330 offset = args[arg_no].reladdr.off;
331 ++arg_count;
333 if (abfd != NULL)
335 if (!bfd_generic_link_read_symbols (abfd))
336 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
338 asymbols = bfd_get_outsymbols (abfd);
341 /* The GNU Coding Standard requires that error messages
342 be of the form:
344 source-file-name:lineno: message
346 We do not always have a line number available so if
347 we cannot find them we print out the section name and
348 offset instead. */
349 discard_last = true;
350 if (abfd != NULL
351 && bfd_find_nearest_line (abfd, section, asymbols, offset,
352 &filename, &functionname,
353 &linenumber))
355 if (functionname != NULL
356 && (fmt[-1] == 'C' || fmt[-1] == 'H'))
358 /* Detect the case where we are printing out a
359 message for the same function as the last
360 call to vinfo ("%C"). In this situation do
361 not print out the ABFD filename or the
362 function name again. Note - we do still
363 print out the source filename, as this will
364 allow programs that parse the linker's output
365 (eg emacs) to correctly locate multiple
366 errors in the same source file. */
367 if (last_bfd == NULL
368 || last_function == NULL
369 || last_bfd != abfd
370 || (last_file == NULL) != (filename == NULL)
371 || (filename != NULL
372 && filename_cmp (last_file, filename) != 0)
373 || strcmp (last_function, functionname) != 0)
375 lfinfo (fp, _("%pB: in function `%pT':\n"),
376 abfd, functionname);
378 last_bfd = abfd;
379 free (last_file);
380 last_file = NULL;
381 if (filename)
382 last_file = xstrdup (filename);
383 free (last_function);
384 last_function = xstrdup (functionname);
386 discard_last = false;
388 else
389 lfinfo (fp, "%pB:", abfd);
391 if (filename != NULL)
392 fprintf (fp, "%s:", filename);
394 done = fmt[-1] != 'H';
395 if (functionname != NULL && fmt[-1] == 'G')
396 lfinfo (fp, "%pT", functionname);
397 else if (filename != NULL && linenumber != 0)
398 fprintf (fp, "%u%s", linenumber, done ? "" : ":");
399 else
400 done = false;
402 else
404 lfinfo (fp, "%pB:", abfd);
405 done = false;
407 if (!done)
408 lfinfo (fp, "(%pA+0x%v)", section, offset);
409 bfd_set_error (last_bfd_error);
411 if (discard_last)
413 last_bfd = NULL;
414 free (last_file);
415 last_file = NULL;
416 free (last_function);
417 last_function = NULL;
420 break;
422 case 'p':
423 if (*fmt == 'A')
425 /* section name from a section */
426 asection *sec;
427 bfd *abfd;
429 fmt++;
430 sec = (asection *) args[arg_no].p;
431 ++arg_count;
432 fprintf (fp, "%s", sec->name);
433 abfd = sec->owner;
434 if (abfd != NULL)
436 const char *group = bfd_group_name (abfd, sec);
437 if (group != NULL)
438 fprintf (fp, "[%s]", group);
441 else if (*fmt == 'B')
443 /* filename from a bfd */
444 bfd *abfd = (bfd *) args[arg_no].p;
446 fmt++;
447 ++arg_count;
448 if (abfd == NULL)
449 fprintf (fp, "%s generated", program_name);
450 else if (abfd->my_archive != NULL
451 && !bfd_is_thin_archive (abfd->my_archive))
452 fprintf (fp, "%s(%s)",
453 bfd_get_filename (abfd->my_archive),
454 bfd_get_filename (abfd));
455 else
456 fprintf (fp, "%s", bfd_get_filename (abfd));
458 else if (*fmt == 'I')
460 /* filename from a lang_input_statement_type */
461 lang_input_statement_type *i;
463 fmt++;
464 i = (lang_input_statement_type *) args[arg_no].p;
465 ++arg_count;
466 if (i->the_bfd != NULL
467 && i->the_bfd->my_archive != NULL
468 && !bfd_is_thin_archive (i->the_bfd->my_archive))
469 fprintf (fp, "(%s)%s",
470 bfd_get_filename (i->the_bfd->my_archive),
471 i->local_sym_name);
472 else
473 fprintf (fp, "%s", i->filename);
475 else if (*fmt == 'R')
477 /* Print all that's interesting about a relent. */
478 arelent *relent = (arelent *) args[arg_no].p;
480 fmt++;
481 ++arg_count;
482 lfinfo (fp, "%s+0x%v (type %s)",
483 (*(relent->sym_ptr_ptr))->name,
484 relent->addend,
485 relent->howto->name);
487 else if (*fmt == 'S' || *fmt == 'U')
489 /* Print script file and perhaps the associated linenumber. */
490 etree_type node;
491 etree_type *tp = (etree_type *) args[arg_no].p;
493 fmt++;
494 ++arg_count;
495 if (tp == NULL)
497 tp = &node;
498 tp->type.filename = ldlex_filename ();
499 tp->type.lineno = lineno;
501 if (tp->type.filename != NULL && fmt[-1] == 'S')
502 fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
503 else if (tp->type.filename != NULL && fmt[-1] == 'U')
504 fprintf (fp, "%s", tp->type.filename);
506 else if (*fmt == 'T')
508 /* Symbol name. */
509 const char *name = (const char *) args[arg_no].p;
511 fmt++;
512 ++arg_count;
513 if (name == NULL || *name == 0)
515 fprintf (fp, _("no symbol"));
516 break;
518 else if (demangling)
520 char *demangled;
522 demangled = bfd_demangle (link_info.output_bfd, name,
523 DMGL_ANSI | DMGL_PARAMS);
524 if (demangled != NULL)
526 fprintf (fp, "%s", demangled);
527 free (demangled);
528 break;
531 fprintf (fp, "%s", name);
533 else
535 /* native (host) void* pointer, like printf */
536 fprintf (fp, "%p", args[arg_no].p);
537 ++arg_count;
539 break;
541 case 's':
542 /* arbitrary string, like printf */
543 fprintf (fp, "%s", (char *) args[arg_no].p);
544 ++arg_count;
545 break;
547 case 'd':
548 /* integer, like printf */
549 fprintf (fp, "%d", args[arg_no].i);
550 ++arg_count;
551 break;
553 case 'u':
554 /* unsigned integer, like printf */
555 fprintf (fp, "%u", args[arg_no].i);
556 ++arg_count;
557 break;
559 case 'l':
560 if (*fmt == 'd')
562 fprintf (fp, "%ld", args[arg_no].l);
563 ++arg_count;
564 ++fmt;
565 break;
567 else if (*fmt == 'u')
569 fprintf (fp, "%lu", args[arg_no].l);
570 ++arg_count;
571 ++fmt;
572 break;
574 /* Fallthru */
576 default:
577 fprintf (fp, "%%%c", fmt[-1]);
578 break;
583 if (is_warning && config.fatal_warnings)
584 config.make_executable = false;
586 if (fatal)
587 xexit (1);
590 /* Format info message and print on stdout. */
592 /* (You would think this should be called just "info", but then you
593 would be hosed by LynxOS, which defines that name in its libc.) */
595 void
596 info_msg (const char *fmt, ...)
598 va_list arg;
600 va_start (arg, fmt);
601 vfinfo (stdout, fmt, arg, false);
602 va_end (arg);
605 /* ('e' for error.) Format info message and print on stderr. */
607 void
608 einfo (const char *fmt, ...)
610 va_list arg;
612 fflush (stdout);
613 va_start (arg, fmt);
614 vfinfo (stderr, fmt, arg, true);
615 va_end (arg);
616 fflush (stderr);
619 void
620 info_assert (const char *file, unsigned int line)
622 einfo (_("%F%P: internal error %s %d\n"), file, line);
625 /* ('m' for map) Format info message and print on map. */
627 void
628 minfo (const char *fmt, ...)
630 if (config.map_file != NULL)
632 va_list arg;
634 va_start (arg, fmt);
635 if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
637 /* Stash info about --as-needed shared libraries. Print
638 later so they don't appear intermingled with archive
639 library info. */
640 struct asneeded_minfo *m = xmalloc (sizeof *m);
642 m->next = NULL;
643 m->soname = va_arg (arg, const char *);
644 m->ref = va_arg (arg, bfd *);
645 m->name = va_arg (arg, const char *);
646 *asneeded_list_tail = m;
647 asneeded_list_tail = &m->next;
649 else
650 vfinfo (config.map_file, fmt, arg, false);
651 va_end (arg);
655 void
656 lfinfo (FILE *file, const char *fmt, ...)
658 va_list arg;
660 va_start (arg, fmt);
661 vfinfo (file, fmt, arg, false);
662 va_end (arg);
665 /* Functions to print the link map. */
667 void
668 print_space (void)
670 fprintf (config.map_file, " ");
673 void
674 print_nl (void)
676 fprintf (config.map_file, "\n");
679 /* A more or less friendly abort message. In ld.h abort is defined to
680 call this function. */
682 void
683 ld_abort (const char *file, int line, const char *fn)
685 if (fn != NULL)
686 einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
687 file, line, fn);
688 else
689 einfo (_("%P: internal error: aborting at %s:%d\n"),
690 file, line);
691 einfo (_("%F%P: please report this bug\n"));
692 xexit (1);