1 /* ldmisc.c
2 Copyright (C) 1991-2024 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 10 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 %lx unsigned long, like printf
56 %p native (host) void* pointer, like printf
57 %pA section name from a section
58 %pB filename from a bfd
59 %pI filename from a lang_input_statement_type
60 %pR info about a relent
61 %pS print script file and linenumber from etree_type.
62 %pT symbol name
63 %pU print script file without linenumber from etree_type.
64 %s arbitrary string, like printf
65 %u integer, like printf
66 %v hex bfd_vma, no leading zeros
67 %x integer, like printf
68 */
69
70 void
vfinfo(FILE * fp,const char * fmt,va_list ap,bool is_warning)71 vfinfo (FILE *fp, const char *fmt, va_list ap, bool is_warning)
72 {
73 bool fatal = false;
74 const char *scan;
75 int arg_type;
76 unsigned int arg_count = 0;
77 unsigned int arg_no;
78 union vfinfo_args
79 {
80 int i;
81 long l;
82 void *p;
83 bfd_vma v;
84 struct {
85 bfd *abfd;
86 asection *sec;
87 bfd_vma off;
88 } reladdr;
89 enum
90 {
91 Bad,
92 Int,
93 Long,
94 Ptr,
95 Vma,
96 RelAddr
97 } type;
98 } args[9];
99
100 if (is_warning && config.no_warnings)
101 return;
102
103 for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++)
104 args[arg_no].type = Bad;
105
106 arg_count = 0;
107 scan = fmt;
108 while (*scan != '\0')
109 {
110 while (*scan != '%' && *scan != '\0')
111 scan++;
112
113 if (*scan == '%')
114 {
115 scan++;
116
117 arg_no = arg_count;
118 if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$')
119 {
120 arg_no = *scan - '1';
121 scan += 2;
122 }
123
124 arg_type = Bad;
125 switch (*scan++)
126 {
127 case '\0':
128 --scan;
129 break;
130
131 case 'V':
132 case 'v':
133 case 'W':
134 arg_type = Vma;
135 break;
136
137 case 's':
138 arg_type = Ptr;
139 break;
140
141 case 'p':
142 if (*scan == 'A' || *scan == 'B' || *scan == 'I'
143 || *scan == 'R' || *scan == 'S' || *scan == 'T')
144 scan++;
145 arg_type = Ptr;
146 break;
147
148 case 'C':
149 case 'D':
150 case 'G':
151 case 'H':
152 arg_type = RelAddr;
153 break;
154
155 case 'd':
156 case 'u':
157 case 'x':
158 arg_type = Int;
159 break;
160
161 case 'l':
162 if (*scan == 'd' || *scan == 'u' || *scan == 'x')
163 {
164 ++scan;
165 arg_type = Long;
166 }
167 break;
168
169 default:
170 break;
171 }
172 if (arg_type != Bad)
173 {
174 if (arg_no >= sizeof (args) / sizeof (args[0]))
175 abort ();
176 args[arg_no].type = arg_type;
177 ++arg_count;
178 }
179 }
180 }
181
182 for (arg_no = 0; arg_no < arg_count; arg_no++)
183 {
184 switch (args[arg_no].type)
185 {
186 case Int:
187 args[arg_no].i = va_arg (ap, int);
188 break;
189 case Long:
190 args[arg_no].l = va_arg (ap, long);
191 break;
192 case Ptr:
193 args[arg_no].p = va_arg (ap, void *);
194 break;
195 case Vma:
196 args[arg_no].v = va_arg (ap, bfd_vma);
197 break;
198 case RelAddr:
199 args[arg_no].reladdr.abfd = va_arg (ap, bfd *);
200 args[arg_no].reladdr.sec = va_arg (ap, asection *);
201 args[arg_no].reladdr.off = va_arg (ap, bfd_vma);
202 break;
203 default:
204 abort ();
205 }
206 }
207
208 arg_count = 0;
209 while (*fmt != '\0')
210 {
211 const char *str = fmt;
212 while (*fmt != '%' && *fmt != '\0')
213 fmt++;
214 if (fmt != str)
215 if (fwrite (str, 1, fmt - str, fp))
216 {
217 /* Ignore. */
218 }
219
220 if (*fmt == '%')
221 {
222 fmt++;
223
224 arg_no = arg_count;
225 if (*fmt != '0' && ISDIGIT (*fmt) && fmt[1] == '$')
226 {
227 arg_no = *fmt - '1';
228 fmt += 2;
229 }
230
231 switch (*fmt++)
232 {
233 case '\0':
234 --fmt;
235 /* Fall through. */
236
237 case '%':
238 /* literal % */
239 putc ('%', fp);
240 break;
241
242 case 'X':
243 /* no object output, fail return */
244 config.make_executable = false;
245 break;
246
247 case 'V':
248 /* hex bfd_vma */
249 {
250 char buf[32];
251 bfd_vma value;
252
253 value = args[arg_no].v;
254 ++arg_count;
255 bfd_sprintf_vma (link_info.output_bfd, buf, value);
256 fprintf (fp, "%s", buf);
257 }
258 break;
259
260 case 'v':
261 /* hex bfd_vma, no leading zeros */
262 {
263 uint64_t value = args[arg_no].v;
264 ++arg_count;
265 fprintf (fp, "%" PRIx64, value);
266 }
267 break;
268
269 case 'W':
270 /* hex bfd_vma with 0x with no leading zeroes taking up
271 10 spaces (including the 0x). */
272 {
273 char buf[32];
274 uint64_t value;
275
276 value = args[arg_no].v;
277 ++arg_count;
278 sprintf (buf, "0x%" PRIx64, value);
279 fprintf (fp, "%10s", buf);
280 }
281 break;
282
283 case 'F':
284 /* Error is fatal. */
285 fatal = true;
286 break;
287
288 case 'P':
289 /* Print program name. */
290 fprintf (fp, "%s", program_name);
291 break;
292
293 case 'E':
294 /* current bfd error or errno */
295 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
296 break;
297
298 case 'C':
299 case 'D':
300 case 'G':
301 case 'H':
302 /* Clever filename:linenumber with function name if possible.
303 The arguments are a BFD, a section, and an offset. */
304 {
305 static bfd *last_bfd;
306 static char *last_file;
307 static char *last_function;
308 bfd *abfd;
309 asection *section;
310 bfd_vma offset;
311 asymbol **asymbols = NULL;
312 const char *filename;
313 const char *functionname;
314 unsigned int linenumber;
315 bool discard_last;
316 bool done;
317 bfd_error_type last_bfd_error = bfd_get_error ();
318
319 abfd = args[arg_no].reladdr.abfd;
320 section = args[arg_no].reladdr.sec;
321 offset = args[arg_no].reladdr.off;
322 ++arg_count;
323
324 if (abfd != NULL)
325 {
326 if (!bfd_generic_link_read_symbols (abfd))
327 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
328
329 asymbols = bfd_get_outsymbols (abfd);
330 }
331
332 /* The GNU Coding Standard requires that error messages
333 be of the form:
334
335 source-file-name:lineno: message
336
337 We do not always have a line number available so if
338 we cannot find them we print out the section name and
339 offset instead. */
340 discard_last = true;
341 if (abfd != NULL
342 && bfd_find_nearest_line (abfd, section, asymbols, offset,
343 &filename, &functionname,
344 &linenumber))
345 {
346 if (functionname != NULL
347 && (fmt[-1] == 'C' || fmt[-1] == 'H'))
348 {
349 /* Detect the case where we are printing out a
350 message for the same function as the last
351 call to vinfo ("%C"). In this situation do
352 not print out the ABFD filename or the
353 function name again. Note - we do still
354 print out the source filename, as this will
355 allow programs that parse the linker's output
356 (eg emacs) to correctly locate multiple
357 errors in the same source file. */
358 if (last_bfd == NULL
359 || last_function == NULL
360 || last_bfd != abfd
361 || (last_file == NULL) != (filename == NULL)
362 || (filename != NULL
363 && filename_cmp (last_file, filename) != 0)
364 || strcmp (last_function, functionname) != 0)
365 {
366 lfinfo (fp, _("%pB: in function `%pT':\n"),
367 abfd, functionname);
368
369 last_bfd = abfd;
370 free (last_file);
371 last_file = NULL;
372 if (filename)
373 last_file = xstrdup (filename);
374 free (last_function);
375 last_function = xstrdup (functionname);
376 }
377 discard_last = false;
378 }
379 else
380 lfinfo (fp, "%pB:", abfd);
381
382 if (filename != NULL)
383 fprintf (fp, "%s:", filename);
384
385 done = fmt[-1] != 'H';
386 if (functionname != NULL && fmt[-1] == 'G')
387 lfinfo (fp, "%pT", functionname);
388 else if (filename != NULL && linenumber != 0)
389 fprintf (fp, "%u%s", linenumber, done ? "" : ":");
390 else
391 done = false;
392 }
393 else
394 {
395 lfinfo (fp, "%pB:", abfd);
396 done = false;
397 }
398 if (!done)
399 lfinfo (fp, "(%pA+0x%v)", section, offset);
400 bfd_set_error (last_bfd_error);
401
402 if (discard_last)
403 {
404 last_bfd = NULL;
405 free (last_file);
406 last_file = NULL;
407 free (last_function);
408 last_function = NULL;
409 }
410 }
411 break;
412
413 case 'p':
414 if (*fmt == 'A')
415 {
416 /* section name from a section */
417 asection *sec;
418 bfd *abfd;
419
420 fmt++;
421 sec = (asection *) args[arg_no].p;
422 ++arg_count;
423 fprintf (fp, "%s", sec->name);
424 abfd = sec->owner;
425 if (abfd != NULL)
426 {
427 const char *group = bfd_group_name (abfd, sec);
428 if (group != NULL)
429 fprintf (fp, "[%s]", group);
430 }
431 }
432 else if (*fmt == 'B')
433 {
434 /* filename from a bfd */
435 bfd *abfd = (bfd *) args[arg_no].p;
436
437 fmt++;
438 ++arg_count;
439 if (abfd == NULL)
440 fprintf (fp, "%s generated", program_name);
441 else if (abfd->my_archive != NULL
442 && !bfd_is_thin_archive (abfd->my_archive))
443 fprintf (fp, "%s(%s)",
444 bfd_get_filename (abfd->my_archive),
445 bfd_get_filename (abfd));
446 else
447 fprintf (fp, "%s", bfd_get_filename (abfd));
448 }
449 else if (*fmt == 'I')
450 {
451 /* filename from a lang_input_statement_type */
452 lang_input_statement_type *i;
453
454 fmt++;
455 i = (lang_input_statement_type *) args[arg_no].p;
456 ++arg_count;
457 if (i->the_bfd != NULL
458 && i->the_bfd->my_archive != NULL
459 && !bfd_is_thin_archive (i->the_bfd->my_archive))
460 fprintf (fp, "(%s)%s",
461 bfd_get_filename (i->the_bfd->my_archive),
462 i->local_sym_name);
463 else
464 fprintf (fp, "%s", i->filename);
465 }
466 else if (*fmt == 'R')
467 {
468 /* Print all that's interesting about a relent. */
469 arelent *relent = (arelent *) args[arg_no].p;
470
471 fmt++;
472 ++arg_count;
473 lfinfo (fp, "%s+0x%v (type %s)",
474 (*(relent->sym_ptr_ptr))->name,
475 relent->addend,
476 relent->howto->name);
477 }
478 else if (*fmt == 'S' || *fmt == 'U')
479 {
480 /* Print script file and perhaps the associated linenumber. */
481 etree_type node;
482 etree_type *tp = (etree_type *) args[arg_no].p;
483
484 fmt++;
485 ++arg_count;
486 if (tp == NULL)
487 {
488 tp = &node;
489 tp->type.filename = ldlex_filename ();
490 tp->type.lineno = lineno;
491 }
492 if (tp->type.filename != NULL && fmt[-1] == 'S')
493 fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
494 else if (tp->type.filename != NULL && fmt[-1] == 'U')
495 fprintf (fp, "%s", tp->type.filename);
496 }
497 else if (*fmt == 'T')
498 {
499 /* Symbol name. */
500 const char *name = (const char *) args[arg_no].p;
501
502 fmt++;
503 ++arg_count;
504 if (name == NULL || *name == 0)
505 {
506 fprintf (fp, _("no symbol"));
507 break;
508 }
509 else if (demangling)
510 {
511 char *demangled;
512
513 demangled = bfd_demangle (link_info.output_bfd, name,
514 DMGL_ANSI | DMGL_PARAMS);
515 if (demangled != NULL)
516 {
517 fprintf (fp, "%s", demangled);
518 free (demangled);
519 break;
520 }
521 }
522 fprintf (fp, "%s", name);
523 }
524 else
525 {
526 /* native (host) void* pointer, like printf */
527 fprintf (fp, "%p", args[arg_no].p);
528 ++arg_count;
529 }
530 break;
531
532 case 's':
533 /* arbitrary string, like printf */
534 fprintf (fp, "%s", (char *) args[arg_no].p);
535 ++arg_count;
536 break;
537
538 case 'd':
539 /* integer, like printf */
540 fprintf (fp, "%d", args[arg_no].i);
541 ++arg_count;
542 break;
543
544 case 'u':
545 /* unsigned integer, like printf */
546 fprintf (fp, "%u", args[arg_no].i);
547 ++arg_count;
548 break;
549
550 case 'x':
551 /* unsigned integer, like printf */
552 fprintf (fp, "%x", args[arg_no].i);
553 ++arg_count;
554 break;
555
556 case 'l':
557 if (*fmt == 'd')
558 {
559 fprintf (fp, "%ld", args[arg_no].l);
560 ++arg_count;
561 ++fmt;
562 break;
563 }
564 else if (*fmt == 'u')
565 {
566 fprintf (fp, "%lu", args[arg_no].l);
567 ++arg_count;
568 ++fmt;
569 break;
570 }
571 else if (*fmt == 'x')
572 {
573 fprintf (fp, "%lx", args[arg_no].l);
574 ++arg_count;
575 ++fmt;
576 break;
577 }
578 /* Fallthru */
579
580 default:
581 fprintf (fp, "%%%c", fmt[-1]);
582 break;
583 }
584 }
585 }
586
587 if (is_warning && config.fatal_warnings)
588 config.make_executable = false;
589
590 if (fatal)
591 xexit (1);
592 }
593
594 /* Format info message and print on stdout. */
595
596 /* (You would think this should be called just "info", but then you
597 would be hosed by LynxOS, which defines that name in its libc.) */
598
599 void
info_msg(const char * fmt,...)600 info_msg (const char *fmt, ...)
601 {
602 va_list arg;
603
604 va_start (arg, fmt);
605 vfinfo (stdout, fmt, arg, false);
606 va_end (arg);
607 }
608
609 /* ('e' for error.) Format info message and print on stderr. */
610
611 void
einfo(const char * fmt,...)612 einfo (const char *fmt, ...)
613 {
614 va_list arg;
615
616 fflush (stdout);
617 va_start (arg, fmt);
618 vfinfo (stderr, fmt, arg, true);
619 va_end (arg);
620 fflush (stderr);
621 }
622
623 void
info_assert(const char * file,unsigned int line)624 info_assert (const char *file, unsigned int line)
625 {
626 einfo (_("%F%P: internal error %s %d\n"), file, line);
627 }
628
629 /* ('m' for map) Format info message and print on map. */
630
631 void
minfo(const char * fmt,...)632 minfo (const char *fmt, ...)
633 {
634 if (config.map_file != NULL)
635 {
636 va_list arg;
637
638 va_start (arg, fmt);
639 if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
640 {
641 /* Stash info about --as-needed shared libraries. Print
642 later so they don't appear intermingled with archive
643 library info. */
644 struct asneeded_minfo *m = xmalloc (sizeof *m);
645
646 m->next = NULL;
647 m->soname = va_arg (arg, const char *);
648 m->ref = va_arg (arg, bfd *);
649 m->name = va_arg (arg, const char *);
650 *asneeded_list_tail = m;
651 asneeded_list_tail = &m->next;
652 }
653 else
654 vfinfo (config.map_file, fmt, arg, false);
655 va_end (arg);
656 }
657 }
658
659 void
lfinfo(FILE * file,const char * fmt,...)660 lfinfo (FILE *file, const char *fmt, ...)
661 {
662 va_list arg;
663
664 va_start (arg, fmt);
665 vfinfo (file, fmt, arg, false);
666 va_end (arg);
667 }
668
669 /* Functions to print the link map. */
670
671 void
print_spaces(int count)672 print_spaces (int count)
673 {
674 fprintf (config.map_file, "%*s", count, "");
675 }
676
677 void
print_nl(void)678 print_nl (void)
679 {
680 fprintf (config.map_file, "\n");
681 }
682
683 /* A more or less friendly abort message. In ld.h abort is defined to
684 call this function. */
685
686 void
ld_abort(const char * file,int line,const char * fn)687 ld_abort (const char *file, int line, const char *fn)
688 {
689 if (fn != NULL)
690 einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
691 file, line, fn);
692 else
693 einfo (_("%P: internal error: aborting at %s:%d\n"),
694 file, line);
695 einfo (_("%F%P: please report this bug\n"));
696 xexit (1);
697 }
698