xref: /dragonfly/contrib/binutils-2.27/ld/ldmisc.c (revision 71990c18) 
1 /* ldmisc.c
2    Copyright (C) 1991-2016 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 
67 void
68 vfinfo (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 	      /* Fall thru */
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 
449 void
450 info_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 
461 void
462 einfo (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 
473 void
474 info_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 
481 void
482 minfo (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 
509 void
510 lfinfo (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 
521 void
522 print_space (void)
523 {
524   fprintf (config.map_file, " ");
525 }
526 
527 void
528 print_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 
536 void
537 ld_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