1 /* ldmisc.c
2 Copyright (C) 1991-2020 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support.
4
5 This file is part of the GNU Binutils.
6
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.
11
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.
16
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. */
21
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"
39
40 /*
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
66 */
67
68 void
vfinfo(FILE * fp,const char * fmt,va_list ap,bfd_boolean is_warning)69 vfinfo (FILE *fp, const char *fmt, va_list ap, bfd_boolean is_warning)
70 {
71 bfd_boolean 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
77 {
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
88 {
89 Bad,
90 Int,
91 Long,
92 Ptr,
93 Vma,
94 RelAddr
95 } type;
96 } args[9];
97
98 for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++)
99 args[arg_no].type = Bad;
100
101 arg_count = 0;
102 scan = fmt;
103 while (*scan != '\0')
104 {
105 while (*scan != '%' && *scan != '\0')
106 scan++;
107
108 if (*scan == '%')
109 {
110 scan++;
111
112 arg_no = arg_count;
113 if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$')
114 {
115 arg_no = *scan - '1';
116 scan += 2;
117 }
118
119 arg_type = Bad;
120 switch (*scan++)
121 {
122 case '\0':
123 --scan;
124 break;
125
126 case 'V':
127 case 'v':
128 case 'W':
129 arg_type = Vma;
130 break;
131
132 case 's':
133 arg_type = Ptr;
134 break;
135
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;
142
143 case 'C':
144 case 'D':
145 case 'G':
146 case 'H':
147 arg_type = RelAddr;
148 break;
149
150 case 'd':
151 case 'u':
152 arg_type = Int;
153 break;
154
155 case 'l':
156 if (*scan == 'd' || *scan == 'u')
157 {
158 ++scan;
159 arg_type = Long;
160 }
161 break;
162
163 default:
164 break;
165 }
166 if (arg_type != Bad)
167 {
168 if (arg_no >= sizeof (args) / sizeof (args[0]))
169 abort ();
170 args[arg_no].type = arg_type;
171 ++arg_count;
172 }
173 }
174 }
175
176 for (arg_no = 0; arg_no < arg_count; arg_no++)
177 {
178 switch (args[arg_no].type)
179 {
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 ();
199 }
200 }
201
202 arg_count = 0;
203 while (*fmt != '\0')
204 {
205 const char *str = fmt;
206 while (*fmt != '%' && *fmt != '\0')
207 fmt++;
208 if (fmt != str)
209 if (fwrite (str, 1, fmt - str, fp))
210 {
211 /* Ignore. */
212 }
213
214 if (*fmt == '%')
215 {
216 fmt++;
217
218 arg_no = arg_count;
219 if (*fmt != '0' && ISDIGIT (*fmt) && fmt[1] == '$')
220 {
221 arg_no = *fmt - '1';
222 fmt += 2;
223 }
224
225 switch (*fmt++)
226 {
227 case '\0':
228 --fmt;
229 /* Fall through. */
230
231 case '%':
232 /* literal % */
233 putc ('%', fp);
234 break;
235
236 case 'X':
237 /* no object output, fail return */
238 config.make_executable = FALSE;
239 break;
240
241 case 'V':
242 /* hex bfd_vma */
243 {
244 bfd_vma value = args[arg_no].v;
245 ++arg_count;
246 fprintf_vma (fp, value);
247 }
248 break;
249
250 case 'v':
251 /* hex bfd_vma, no leading zeros */
252 {
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);
263 }
264 break;
265
266 case 'W':
267 /* hex bfd_vma with 0x with no leading zeroes taking up
268 8 spaces. */
269 {
270 char buf[100];
271 bfd_vma value;
272 char *p;
273 int len;
274
275 value = args[arg_no].v;
276 ++arg_count;
277 sprintf_vma (buf, value);
278 for (p = buf; *p == '0'; ++p)
279 ;
280 if (*p == '\0')
281 --p;
282 len = strlen (p);
283 while (len < 8)
284 {
285 putc (' ', fp);
286 ++len;
287 }
288 fprintf (fp, "0x%s", p);
289 }
290 break;
291
292 case 'F':
293 /* Error is fatal. */
294 fatal = TRUE;
295 break;
296
297 case 'P':
298 /* Print program name. */
299 fprintf (fp, "%s", program_name);
300 break;
301
302 case 'E':
303 /* current bfd error or errno */
304 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
305 break;
306
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. */
313 {
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 bfd_boolean discard_last;
325 bfd_boolean done;
326 bfd_error_type last_bfd_error = bfd_get_error ();
327
328 abfd = args[arg_no].reladdr.abfd;
329 section = args[arg_no].reladdr.sec;
330 offset = args[arg_no].reladdr.off;
331 ++arg_count;
332
333 if (abfd != NULL)
334 {
335 if (!bfd_generic_link_read_symbols (abfd))
336 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
337
338 asymbols = bfd_get_outsymbols (abfd);
339 }
340
341 /* The GNU Coding Standard requires that error messages
342 be of the form:
343
344 source-file-name:lineno: message
345
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))
354 {
355 if (functionname != NULL
356 && (fmt[-1] == 'C' || fmt[-1] == 'H'))
357 {
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)
374 {
375 lfinfo (fp, _("%pB: in function `%pT':\n"),
376 abfd, functionname);
377
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);
385 }
386 discard_last = FALSE;
387 }
388 else
389 lfinfo (fp, "%pB:", abfd);
390
391 if (filename != NULL)
392 fprintf (fp, "%s:", filename);
393
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;
401 }
402 else
403 {
404 lfinfo (fp, "%pB:", abfd);
405 done = FALSE;
406 }
407 if (!done)
408 lfinfo (fp, "(%pA+0x%v)", section, offset);
409 bfd_set_error (last_bfd_error);
410
411 if (discard_last)
412 {
413 last_bfd = NULL;
414 free (last_file);
415 last_file = NULL;
416 free (last_function);
417 last_function = NULL;
418 }
419 }
420 break;
421
422 case 'p':
423 if (*fmt == 'A')
424 {
425 /* section name from a section */
426 asection *sec;
427 bfd *abfd;
428
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)
435 {
436 const char *group = bfd_group_name (abfd, sec);
437 if (group != NULL)
438 fprintf (fp, "[%s]", group);
439 }
440 }
441 else if (*fmt == 'B')
442 {
443 /* filename from a bfd */
444 bfd *abfd = (bfd *) args[arg_no].p;
445
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));
457 }
458 else if (*fmt == 'I')
459 {
460 /* filename from a lang_input_statement_type */
461 lang_input_statement_type *i;
462
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);
474 }
475 else if (*fmt == 'R')
476 {
477 /* Print all that's interesting about a relent. */
478 arelent *relent = (arelent *) args[arg_no].p;
479
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);
486 }
487 else if (*fmt == 'S' || *fmt == 'U')
488 {
489 /* Print script file and perhaps the associated linenumber. */
490 etree_type node;
491 etree_type *tp = (etree_type *) args[arg_no].p;
492
493 fmt++;
494 ++arg_count;
495 if (tp == NULL)
496 {
497 tp = &node;
498 tp->type.filename = ldlex_filename ();
499 tp->type.lineno = lineno;
500 }
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);
505 }
506 else if (*fmt == 'T')
507 {
508 /* Symbol name. */
509 const char *name = (const char *) args[arg_no].p;
510
511 fmt++;
512 ++arg_count;
513 if (name == NULL || *name == 0)
514 {
515 fprintf (fp, _("no symbol"));
516 break;
517 }
518 else if (demangling)
519 {
520 char *demangled;
521
522 demangled = bfd_demangle (link_info.output_bfd, name,
523 DMGL_ANSI | DMGL_PARAMS);
524 if (demangled != NULL)
525 {
526 fprintf (fp, "%s", demangled);
527 free (demangled);
528 break;
529 }
530 }
531 fprintf (fp, "%s", name);
532 }
533 else
534 {
535 /* native (host) void* pointer, like printf */
536 fprintf (fp, "%p", args[arg_no].p);
537 ++arg_count;
538 }
539 break;
540
541 case 's':
542 /* arbitrary string, like printf */
543 fprintf (fp, "%s", (char *) args[arg_no].p);
544 ++arg_count;
545 break;
546
547 case 'd':
548 /* integer, like printf */
549 fprintf (fp, "%d", args[arg_no].i);
550 ++arg_count;
551 break;
552
553 case 'u':
554 /* unsigned integer, like printf */
555 fprintf (fp, "%u", args[arg_no].i);
556 ++arg_count;
557 break;
558
559 case 'l':
560 if (*fmt == 'd')
561 {
562 fprintf (fp, "%ld", args[arg_no].l);
563 ++arg_count;
564 ++fmt;
565 break;
566 }
567 else if (*fmt == 'u')
568 {
569 fprintf (fp, "%lu", args[arg_no].l);
570 ++arg_count;
571 ++fmt;
572 break;
573 }
574 /* Fallthru */
575
576 default:
577 fprintf (fp, "%%%c", fmt[-1]);
578 break;
579 }
580 }
581 }
582
583 if (is_warning && config.fatal_warnings)
584 config.make_executable = FALSE;
585
586 if (fatal)
587 xexit (1);
588 }
589
590 /* Format info message and print on stdout. */
591
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.) */
594
595 void
info_msg(const char * fmt,...)596 info_msg (const char *fmt, ...)
597 {
598 va_list arg;
599
600 va_start (arg, fmt);
601 vfinfo (stdout, fmt, arg, FALSE);
602 va_end (arg);
603 }
604
605 /* ('e' for error.) Format info message and print on stderr. */
606
607 void
einfo(const char * fmt,...)608 einfo (const char *fmt, ...)
609 {
610 va_list arg;
611
612 fflush (stdout);
613 va_start (arg, fmt);
614 vfinfo (stderr, fmt, arg, TRUE);
615 va_end (arg);
616 fflush (stderr);
617 }
618
619 void
info_assert(const char * file,unsigned int line)620 info_assert (const char *file, unsigned int line)
621 {
622 einfo (_("%F%P: internal error %s %d\n"), file, line);
623 }
624
625 /* ('m' for map) Format info message and print on map. */
626
627 void
minfo(const char * fmt,...)628 minfo (const char *fmt, ...)
629 {
630 if (config.map_file != NULL)
631 {
632 va_list arg;
633
634 va_start (arg, fmt);
635 if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
636 {
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);
641
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;
648 }
649 else
650 vfinfo (config.map_file, fmt, arg, FALSE);
651 va_end (arg);
652 }
653 }
654
655 void
lfinfo(FILE * file,const char * fmt,...)656 lfinfo (FILE *file, const char *fmt, ...)
657 {
658 va_list arg;
659
660 va_start (arg, fmt);
661 vfinfo (file, fmt, arg, FALSE);
662 va_end (arg);
663 }
664
665 /* Functions to print the link map. */
666
667 void
print_space(void)668 print_space (void)
669 {
670 fprintf (config.map_file, " ");
671 }
672
673 void
print_nl(void)674 print_nl (void)
675 {
676 fprintf (config.map_file, "\n");
677 }
678
679 /* A more or less friendly abort message. In ld.h abort is defined to
680 call this function. */
681
682 void
ld_abort(const char * file,int line,const char * fn)683 ld_abort (const char *file, int line, const char *fn)
684 {
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);
693 }
694