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