1/* ldmisc.c
2   Copyright (C) 1991-2017 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 "filenames.h"
27#include "demangle.h"
28#include <stdarg.h>
29#include "ld.h"
30#include "ldmisc.h"
31#include "ldexp.h"
32#include "ldlang.h"
33#include <ldgram.h>
34#include "ldlex.h"
35#include "ldmain.h"
36#include "ldfile.h"
37#include "elf-bfd.h"
38#include "coff-bfd.h"
39
40/*
41 %% literal %
42 %A section name from a section
43 %B filename from a bfd
44 %C clever filename:linenumber with function
45 %D like %C, but no function name
46 %E current bfd error or errno
47 %F error is fatal
48 %G like %D, but only function name
49 %H like %C but in addition emit section+offset
50 %I filename from a lang_input_statement_type
51 %P print program name
52 %R info about a relent
53 %S print script file and linenumber from etree_type.
54 %T symbol name
55 %V hex bfd_vma
56 %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces
57 %X no object output, fail return
58 %d integer, like printf
59 %ld long, like printf
60 %lu unsigned long, like printf
61 %p native (host) void* pointer, like printf
62 %s arbitrary string, like printf
63 %u integer, like printf
64 %v hex bfd_vma, no leading zeros
65*/
66
67void
68vfinfo (FILE *fp, const char *fmt, va_list arg, bfd_boolean is_warning)
69{
70  bfd_boolean fatal = FALSE;
71
72  while (*fmt != '\0')
73    {
74      const char *str = fmt;
75      while (*fmt != '%' && *fmt != '\0')
76	fmt++;
77      if (fmt != str)
78	if (fwrite (str, 1, fmt - str, fp))
79	  {
80	    /* Ignore.  */
81	  }
82
83      if (*fmt == '%')
84	{
85	  fmt++;
86	  switch (*fmt++)
87	    {
88	    case '%':
89	      /* literal % */
90	      putc ('%', fp);
91	      break;
92
93	    case 'X':
94	      /* no object output, fail return */
95	      config.make_executable = FALSE;
96	      break;
97
98	    case 'V':
99	      /* hex bfd_vma */
100	      {
101		bfd_vma value = va_arg (arg, bfd_vma);
102		fprintf_vma (fp, value);
103	      }
104	      break;
105
106	    case 'v':
107	      /* hex bfd_vma, no leading zeros */
108	      {
109		char buf[100];
110		char *p = buf;
111		bfd_vma value = va_arg (arg, bfd_vma);
112		sprintf_vma (p, value);
113		while (*p == '0')
114		  p++;
115		if (!*p)
116		  p--;
117		fputs (p, fp);
118	      }
119	      break;
120
121	    case 'W':
122	      /* hex bfd_vma with 0x with no leading zeroes taking up
123		 8 spaces.  */
124	      {
125		char buf[100];
126		bfd_vma value;
127		char *p;
128		int len;
129
130		value = va_arg (arg, bfd_vma);
131		sprintf_vma (buf, value);
132		for (p = buf; *p == '0'; ++p)
133		  ;
134		if (*p == '\0')
135		  --p;
136		len = strlen (p);
137		while (len < 8)
138		  {
139		    putc (' ', fp);
140		    ++len;
141		  }
142		fprintf (fp, "0x%s", p);
143	      }
144	      break;
145
146	    case 'T':
147	      /* Symbol name.  */
148	      {
149		const char *name = va_arg (arg, const char *);
150
151		if (name == NULL || *name == 0)
152		  {
153		    fprintf (fp, _("no symbol"));
154		    break;
155		  }
156		else if (demangling)
157		  {
158		    char *demangled;
159
160		    demangled = bfd_demangle (link_info.output_bfd, name,
161					      DMGL_ANSI | DMGL_PARAMS);
162		    if (demangled != NULL)
163		      {
164			fprintf (fp, "%s", demangled);
165			free (demangled);
166			break;
167		      }
168		  }
169		fprintf (fp, "%s", name);
170	      }
171	      break;
172
173	    case 'A':
174	      /* section name from a section */
175	      {
176		asection *sec = va_arg (arg, asection *);
177		bfd *abfd = sec->owner;
178		const char *group = NULL;
179		struct coff_comdat_info *ci;
180
181		fprintf (fp, "%s", sec->name);
182		if (abfd != NULL
183		    && bfd_get_flavour (abfd) == bfd_target_elf_flavour
184		    && elf_next_in_group (sec) != NULL
185		    && (sec->flags & SEC_GROUP) == 0)
186		  group = elf_group_name (sec);
187		else if (abfd != NULL
188			 && bfd_get_flavour (abfd) == bfd_target_coff_flavour
189			 && (ci = bfd_coff_get_comdat_section (sec->owner,
190							       sec)) != NULL)
191		  group = ci->name;
192		if (group != NULL)
193		  fprintf (fp, "[%s]", group);
194	      }
195	      break;
196
197	    case 'B':
198	      /* filename from a bfd */
199	      {
200		bfd *abfd = va_arg (arg, bfd *);
201
202		if (abfd == NULL)
203		  fprintf (fp, "%s generated", program_name);
204		else if (abfd->my_archive != NULL
205			 && !bfd_is_thin_archive (abfd->my_archive))
206		  fprintf (fp, "%s(%s)", abfd->my_archive->filename,
207			   abfd->filename);
208		else
209		  fprintf (fp, "%s", abfd->filename);
210	      }
211	      break;
212
213	    case 'F':
214	      /* Error is fatal.  */
215	      fatal = TRUE;
216	      break;
217
218	    case 'P':
219	      /* Print program name.  */
220	      fprintf (fp, "%s", program_name);
221	      break;
222
223	    case 'E':
224	      /* current bfd error or errno */
225	      fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
226	      break;
227
228	    case 'I':
229	      /* filename from a lang_input_statement_type */
230	      {
231		lang_input_statement_type *i;
232
233		i = va_arg (arg, lang_input_statement_type *);
234		if (i->the_bfd->my_archive != NULL
235		    && !bfd_is_thin_archive (i->the_bfd->my_archive))
236		  fprintf (fp, "(%s)",
237			   bfd_get_filename (i->the_bfd->my_archive));
238		fprintf (fp, "%s", i->local_sym_name);
239		if ((i->the_bfd->my_archive == NULL
240		     || bfd_is_thin_archive (i->the_bfd->my_archive))
241		    && filename_cmp (i->local_sym_name, i->filename) != 0)
242		  fprintf (fp, " (%s)", i->filename);
243	      }
244	      break;
245
246	    case 'S':
247	      /* Print script file and linenumber.  */
248	      {
249		etree_type node;
250		etree_type *tp = va_arg (arg, etree_type *);
251
252		if (tp == NULL)
253		  {
254		    tp = &node;
255		    tp->type.filename = ldlex_filename ();
256		    tp->type.lineno = lineno;
257		  }
258		if (tp->type.filename != NULL)
259		  fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
260	      }
261	      break;
262
263	    case 'R':
264	      /* Print all that's interesting about a relent.  */
265	      {
266		arelent *relent = va_arg (arg, arelent *);
267
268		lfinfo (fp, "%s+0x%v (type %s)",
269			(*(relent->sym_ptr_ptr))->name,
270			relent->addend,
271			relent->howto->name);
272	      }
273	      break;
274
275	    case 'C':
276	    case 'D':
277	    case 'G':
278	    case 'H':
279	      /* Clever filename:linenumber with function name if possible.
280		 The arguments are a BFD, a section, and an offset.  */
281	      {
282		static bfd *last_bfd;
283		static char *last_file = NULL;
284		static char *last_function = NULL;
285		bfd *abfd;
286		asection *section;
287		bfd_vma offset;
288		asymbol **asymbols = NULL;
289		const char *filename;
290		const char *functionname;
291		unsigned int linenumber;
292		bfd_boolean discard_last;
293		bfd_boolean done;
294
295		abfd = va_arg (arg, bfd *);
296		section = va_arg (arg, asection *);
297		offset = va_arg (arg, bfd_vma);
298
299		if (abfd != NULL)
300		  {
301		    if (!bfd_generic_link_read_symbols (abfd))
302		      einfo (_("%B%F: could not read symbols: %E\n"), abfd);
303
304		    asymbols = bfd_get_outsymbols (abfd);
305		  }
306
307		/* The GNU Coding Standard requires that error messages
308		   be of the form:
309
310		     source-file-name:lineno: message
311
312		   We do not always have a line number available so if
313		   we cannot find them we print out the section name and
314		   offset instead.  */
315		discard_last = TRUE;
316		if (abfd != NULL
317		    && bfd_find_nearest_line (abfd, section, asymbols, offset,
318					      &filename, &functionname,
319					      &linenumber))
320		  {
321		    if (functionname != NULL
322			&& (fmt[-1] == 'C' || fmt[-1] == 'H'))
323		      {
324			/* Detect the case where we are printing out a
325			   message for the same function as the last
326			   call to vinfo ("%C").  In this situation do
327			   not print out the ABFD filename or the
328			   function name again.  Note - we do still
329			   print out the source filename, as this will
330			   allow programs that parse the linker's output
331			   (eg emacs) to correctly locate multiple
332			   errors in the same source file.  */
333			if (last_bfd == NULL
334			    || last_file == NULL
335			    || last_function == NULL
336			    || last_bfd != abfd
337			    || (filename != NULL
338				&& filename_cmp (last_file, filename) != 0)
339			    || strcmp (last_function, functionname) != 0)
340			  {
341			    lfinfo (fp, _("%B: In function `%T':\n"),
342				    abfd, functionname);
343
344			    last_bfd = abfd;
345			    if (last_file != NULL)
346			      free (last_file);
347			    last_file = NULL;
348			    if (filename)
349			      last_file = xstrdup (filename);
350			    if (last_function != NULL)
351			      free (last_function);
352			    last_function = xstrdup (functionname);
353			  }
354			discard_last = FALSE;
355		      }
356		    else
357		      lfinfo (fp, "%B:", abfd);
358
359		    if (filename != NULL)
360		      fprintf (fp, "%s:", filename);
361
362		    done = fmt[-1] != 'H';
363		    if (functionname != NULL && fmt[-1] == 'G')
364		      lfinfo (fp, "%T", functionname);
365		    else if (filename != NULL && linenumber != 0)
366		      fprintf (fp, "%u%s", linenumber, done ? "" : ":");
367		    else
368		      done = FALSE;
369		  }
370		else
371		  {
372		    lfinfo (fp, "%B:", abfd);
373		    done = FALSE;
374		  }
375		if (!done)
376		  lfinfo (fp, "(%A+0x%v)", section, offset);
377
378		if (discard_last)
379		  {
380		    last_bfd = NULL;
381		    if (last_file != NULL)
382		      {
383			free (last_file);
384			last_file = NULL;
385		      }
386		    if (last_function != NULL)
387		      {
388			free (last_function);
389			last_function = NULL;
390		      }
391		  }
392	      }
393	      break;
394
395	    case 'p':
396	      /* native (host) void* pointer, like printf */
397	      fprintf (fp, "%p", va_arg (arg, void *));
398	      break;
399
400	    case 's':
401	      /* arbitrary string, like printf */
402	      fprintf (fp, "%s", va_arg (arg, char *));
403	      break;
404
405	    case 'd':
406	      /* integer, like printf */
407	      fprintf (fp, "%d", va_arg (arg, int));
408	      break;
409
410	    case 'u':
411	      /* unsigned integer, like printf */
412	      fprintf (fp, "%u", va_arg (arg, unsigned int));
413	      break;
414
415	    case 'l':
416	      if (*fmt == 'd')
417		{
418		  fprintf (fp, "%ld", va_arg (arg, long));
419		  ++fmt;
420		  break;
421		}
422	      else if (*fmt == 'u')
423		{
424		  fprintf (fp, "%lu", va_arg (arg, unsigned long));
425		  ++fmt;
426		  break;
427		}
428	      /* Fallthru */
429
430	    default:
431	      fprintf (fp, "%%%c", fmt[-1]);
432	      break;
433	    }
434	}
435    }
436
437  if (is_warning && config.fatal_warnings)
438    config.make_executable = FALSE;
439
440  if (fatal)
441    xexit (1);
442}
443
444/* Format info message and print on stdout.  */
445
446/* (You would think this should be called just "info", but then you
447   would be hosed by LynxOS, which defines that name in its libc.)  */
448
449void
450info_msg (const char *fmt, ...)
451{
452  va_list arg;
453
454  va_start (arg, fmt);
455  vfinfo (stdout, fmt, arg, FALSE);
456  va_end (arg);
457}
458
459/* ('e' for error.) Format info message and print on stderr.  */
460
461void
462einfo (const char *fmt, ...)
463{
464  va_list arg;
465
466  fflush (stdout);
467  va_start (arg, fmt);
468  vfinfo (stderr, fmt, arg, TRUE);
469  va_end (arg);
470  fflush (stderr);
471}
472
473void
474info_assert (const char *file, unsigned int line)
475{
476  einfo (_("%F%P: internal error %s %d\n"), file, line);
477}
478
479/* ('m' for map) Format info message and print on map.  */
480
481void
482minfo (const char *fmt, ...)
483{
484  if (config.map_file != NULL)
485    {
486      va_list arg;
487
488      va_start (arg, fmt);
489      if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
490	{
491	  /* Stash info about --as-needed shared libraries.  Print
492	     later so they don't appear intermingled with archive
493	     library info.  */
494	  struct asneeded_minfo *m = xmalloc (sizeof *m);
495
496	  m->next = NULL;
497	  m->soname = va_arg (arg, const char *);
498	  m->ref = va_arg (arg, bfd *);
499	  m->name = va_arg (arg, const char *);
500	  *asneeded_list_tail = m;
501	  asneeded_list_tail = &m->next;
502	}
503      else
504	vfinfo (config.map_file, fmt, arg, FALSE);
505      va_end (arg);
506    }
507}
508
509void
510lfinfo (FILE *file, const char *fmt, ...)
511{
512  va_list arg;
513
514  va_start (arg, fmt);
515  vfinfo (file, fmt, arg, FALSE);
516  va_end (arg);
517}
518
519/* Functions to print the link map.  */
520
521void
522print_space (void)
523{
524  fprintf (config.map_file, " ");
525}
526
527void
528print_nl (void)
529{
530  fprintf (config.map_file, "\n");
531}
532
533/* A more or less friendly abort message.  In ld.h abort is defined to
534   call this function.  */
535
536void
537ld_abort (const char *file, int line, const char *fn)
538{
539  if (fn != NULL)
540    einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
541	   file, line, fn);
542  else
543    einfo (_("%P: internal error: aborting at %s:%d\n"),
544	   file, line);
545  einfo (_("%P%F: please report this bug\n"));
546  xexit (1);
547}
548