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