bfd/
[binutils.git] / ld / ldmisc.c
blob3ba4221e6ee2b9dcfd60ba298c7cbe67ce3d21d8
1 /* ldmisc.c
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support.
7 This file is part of GLD, the Gnu Linker.
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.
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.
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. */
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "sysdep.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"
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
65 static void
66 vfinfo (FILE *fp, const char *fmt, va_list arg, bfd_boolean is_warning)
68 bfd_boolean fatal = FALSE;
70 while (*fmt != '\0')
72 while (*fmt != '%' && *fmt != '\0')
74 putc (*fmt, fp);
75 fmt++;
78 if (*fmt == '%')
80 fmt++;
81 switch (*fmt++)
83 case '%':
84 /* literal % */
85 putc ('%', fp);
86 break;
88 case 'X':
89 /* no object output, fail return */
90 config.make_executable = FALSE;
91 break;
93 case 'V':
94 /* hex bfd_vma */
96 bfd_vma value = va_arg (arg, bfd_vma);
97 fprintf_vma (fp, value);
99 break;
101 case 'v':
102 /* hex bfd_vma, no leading zeros */
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);
114 break;
116 case 'W':
117 /* hex bfd_vma with 0x with no leading zeroes taking up
118 8 spaces. */
120 char buf[100];
121 bfd_vma value;
122 char *p;
123 int len;
125 value = va_arg (arg, bfd_vma);
126 sprintf_vma (buf, value);
127 for (p = buf; *p == '0'; ++p)
129 if (*p == '\0')
130 --p;
131 len = strlen (p);
132 while (len < 8)
134 putc (' ', fp);
135 ++len;
137 fprintf (fp, "0x%s", p);
139 break;
141 case 'T':
142 /* Symbol name. */
144 const char *name = va_arg (arg, const char *);
146 if (name == NULL || *name == 0)
147 fprintf (fp, _("no symbol"));
148 else if (! demangling)
149 fprintf (fp, "%s", name);
150 else
152 char *demangled;
154 demangled = demangle (name);
155 fprintf (fp, "%s", demangled);
156 free (demangled);
159 break;
161 case 'A':
162 /* section name from a section */
164 asection *sec = va_arg (arg, asection *);
165 bfd *abfd = sec->owner;
166 const char *group = NULL;
167 struct coff_comdat_info *ci;
169 fprintf (fp, "%s", sec->name);
170 if (abfd != NULL
171 && bfd_get_flavour (abfd) == bfd_target_elf_flavour
172 && elf_next_in_group (sec) != NULL
173 && (sec->flags & SEC_GROUP) == 0)
174 group = elf_group_name (sec);
175 else if (abfd != NULL
176 && bfd_get_flavour (abfd) == bfd_target_coff_flavour
177 && (ci = bfd_coff_get_comdat_section (sec->owner,
178 sec)) != NULL)
179 group = ci->name;
180 if (group != NULL)
181 fprintf (fp, "[%s]", group);
183 break;
185 case 'B':
186 /* filename from a bfd */
188 bfd *abfd = va_arg (arg, bfd *);
190 if (abfd == NULL)
191 fprintf (fp, "%s generated", program_name);
192 else if (abfd->my_archive)
193 fprintf (fp, "%s(%s)", abfd->my_archive->filename,
194 abfd->filename);
195 else
196 fprintf (fp, "%s", abfd->filename);
198 break;
200 case 'F':
201 /* Error is fatal. */
202 fatal = TRUE;
203 break;
205 case 'P':
206 /* Print program name. */
207 fprintf (fp, "%s", program_name);
208 break;
210 case 'E':
211 /* current bfd error or errno */
212 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
213 break;
215 case 'I':
216 /* filename from a lang_input_statement_type */
218 lang_input_statement_type *i;
220 i = va_arg (arg, lang_input_statement_type *);
221 if (bfd_my_archive (i->the_bfd) != NULL)
222 fprintf (fp, "(%s)",
223 bfd_get_filename (bfd_my_archive (i->the_bfd)));
224 fprintf (fp, "%s", i->local_sym_name);
225 if (bfd_my_archive (i->the_bfd) == NULL
226 && strcmp (i->local_sym_name, i->filename) != 0)
227 fprintf (fp, " (%s)", i->filename);
229 break;
231 case 'S':
232 /* Print script file and linenumber. */
233 if (parsing_defsym)
234 fprintf (fp, "--defsym %s", lex_string);
235 else if (ldfile_input_filename != NULL)
236 fprintf (fp, "%s:%u", ldfile_input_filename, lineno);
237 else
238 fprintf (fp, _("built in linker script:%u"), lineno);
239 break;
241 case 'R':
242 /* Print all that's interesting about a relent. */
244 arelent *relent = va_arg (arg, arelent *);
246 lfinfo (fp, "%s+0x%v (type %s)",
247 (*(relent->sym_ptr_ptr))->name,
248 relent->addend,
249 relent->howto->name);
251 break;
253 case 'C':
254 case 'D':
255 case 'G':
256 /* Clever filename:linenumber with function name if possible.
257 The arguments are a BFD, a section, and an offset. */
259 static bfd *last_bfd;
260 static char *last_file = NULL;
261 static char *last_function = NULL;
262 bfd *abfd;
263 asection *section;
264 bfd_vma offset;
265 lang_input_statement_type *entry;
266 asymbol **asymbols;
267 const char *filename;
268 const char *functionname;
269 unsigned int linenumber;
270 bfd_boolean discard_last;
272 abfd = va_arg (arg, bfd *);
273 section = va_arg (arg, asection *);
274 offset = va_arg (arg, bfd_vma);
276 if (abfd == NULL)
278 entry = NULL;
279 asymbols = NULL;
281 else
283 entry = (lang_input_statement_type *) abfd->usrdata;
284 if (entry != (lang_input_statement_type *) NULL
285 && entry->asymbols != (asymbol **) NULL)
286 asymbols = entry->asymbols;
287 else
289 long symsize;
290 long sym_count;
292 symsize = bfd_get_symtab_upper_bound (abfd);
293 if (symsize < 0)
294 einfo (_("%B%F: could not read symbols\n"), abfd);
295 asymbols = xmalloc (symsize);
296 sym_count = bfd_canonicalize_symtab (abfd, asymbols);
297 if (sym_count < 0)
298 einfo (_("%B%F: could not read symbols\n"), abfd);
299 if (entry != (lang_input_statement_type *) NULL)
301 entry->asymbols = asymbols;
302 entry->symbol_count = sym_count;
307 /* The GNU Coding Standard requires that error messages
308 be of the form:
310 source-file-name:lineno: message
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 instread. */
315 discard_last = TRUE;
316 if (abfd != NULL
317 && bfd_find_nearest_line (abfd, section, asymbols, offset,
318 &filename, &functionname,
319 &linenumber))
321 if (functionname != NULL && fmt[-1] == 'C')
323 /* Detect the case where we are printing out a
324 message for the same function as the last
325 call to vinfo ("%C"). In this situation do
326 not print out the ABFD filename or the
327 function name again. Note - we do still
328 print out the source filename, as this will
329 allow programs that parse the linker's output
330 (eg emacs) to correctly locate multiple
331 errors in the same source file. */
332 if (last_bfd == NULL
333 || last_file == NULL
334 || last_function == NULL
335 || last_bfd != abfd
336 || (filename != NULL
337 && strcmp (last_file, filename) != 0)
338 || strcmp (last_function, functionname) != 0)
340 lfinfo (fp, _("%B: In function `%T'"),
341 abfd, functionname);
343 last_bfd = abfd;
344 if (last_file != NULL)
345 free (last_file);
346 last_file = NULL;
347 if (filename)
348 last_file = xstrdup (filename);
349 if (last_function != NULL)
350 free (last_function);
351 last_function = xstrdup (functionname);
353 discard_last = FALSE;
355 else
356 lfinfo (fp, "%B", abfd);
358 if (filename != NULL)
359 fprintf (fp, ":%s", filename);
361 if (functionname != NULL && fmt[-1] == 'G')
362 lfinfo (fp, ":%T", functionname);
363 else if (filename != NULL)
365 if (linenumber != 0)
366 fprintf (fp, ":%u", linenumber);
367 else
368 lfinfo (fp, ":(%A+0x%v)", section, offset);
371 else
372 lfinfo (fp, "%B:(%A+0x%v)", abfd, section, offset);
374 if (asymbols != NULL && entry == NULL)
375 free (asymbols);
377 if (discard_last)
379 last_bfd = NULL;
380 if (last_file != NULL)
382 free (last_file);
383 last_file = NULL;
385 if (last_function != NULL)
387 free (last_function);
388 last_function = NULL;
392 break;
394 case 's':
395 /* arbitrary string, like printf */
396 fprintf (fp, "%s", va_arg (arg, char *));
397 break;
399 case 'd':
400 /* integer, like printf */
401 fprintf (fp, "%d", va_arg (arg, int));
402 break;
404 case 'u':
405 /* unsigned integer, like printf */
406 fprintf (fp, "%u", va_arg (arg, unsigned int));
407 break;
409 case 'l':
410 if (*fmt == 'd')
412 fprintf (fp, "%ld", va_arg (arg, long));
413 ++fmt;
414 break;
416 else if (*fmt == 'u')
418 fprintf (fp, "%lu", va_arg (arg, unsigned long));
419 ++fmt;
420 break;
422 /* Fall thru */
424 default:
425 fprintf (fp, "%%%c", fmt[-1]);
426 break;
431 if (is_warning && config.fatal_warnings)
432 config.make_executable = FALSE;
434 if (fatal)
435 xexit (1);
438 /* Wrapper around cplus_demangle. Strips leading underscores and
439 other such chars that would otherwise confuse the demangler. */
441 char *
442 demangle (const char *name)
444 char *res;
445 const char *p;
447 if (output_bfd != NULL
448 && bfd_get_symbol_leading_char (output_bfd) == name[0])
449 ++name;
451 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
452 or the MS PE format. These formats have a number of leading '.'s
453 on at least some symbols, so we remove all dots to avoid
454 confusing the demangler. */
455 p = name;
456 while (*p == '.')
457 ++p;
459 res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS);
460 if (res)
462 size_t dots = p - name;
464 /* Now put back any stripped dots. */
465 if (dots != 0)
467 size_t len = strlen (res) + 1;
468 char *add_dots = xmalloc (len + dots);
470 memcpy (add_dots, name, dots);
471 memcpy (add_dots + dots, res, len);
472 free (res);
473 res = add_dots;
475 return res;
477 return xstrdup (name);
480 /* Format info message and print on stdout. */
482 /* (You would think this should be called just "info", but then you
483 would be hosed by LynxOS, which defines that name in its libc.) */
485 void
486 info_msg (const char *fmt, ...)
488 va_list arg;
490 va_start (arg, fmt);
491 vfinfo (stdout, fmt, arg, FALSE);
492 va_end (arg);
495 /* ('e' for error.) Format info message and print on stderr. */
497 void
498 einfo (const char *fmt, ...)
500 va_list arg;
502 va_start (arg, fmt);
503 vfinfo (stderr, fmt, arg, TRUE);
504 va_end (arg);
507 void
508 info_assert (const char *file, unsigned int line)
510 einfo (_("%F%P: internal error %s %d\n"), file, line);
513 /* ('m' for map) Format info message and print on map. */
515 void
516 minfo (const char *fmt, ...)
518 va_list arg;
520 va_start (arg, fmt);
521 vfinfo (config.map_file, fmt, arg, FALSE);
522 va_end (arg);
525 void
526 lfinfo (FILE *file, const char *fmt, ...)
528 va_list arg;
530 va_start (arg, fmt);
531 vfinfo (file, fmt, arg, FALSE);
532 va_end (arg);
535 /* Functions to print the link map. */
537 void
538 print_space (void)
540 fprintf (config.map_file, " ");
543 void
544 print_nl (void)
546 fprintf (config.map_file, "\n");
549 /* A more or less friendly abort message. In ld.h abort is defined to
550 call this function. */
552 void
553 ld_abort (const char *file, int line, const char *fn)
555 if (fn != NULL)
556 einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
557 file, line, fn);
558 else
559 einfo (_("%P: internal error: aborting at %s line %d\n"),
560 file, line);
561 einfo (_("%P%F: please report this bug\n"));
562 xexit (1);