daily update
[binutils.git] / ld / ldmisc.c
blob8af043aa2b24bc70be099ca8ffe0d98386e9f6c8
1 /* ldmisc.c
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006
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':\n"),
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 && linenumber != 0)
364 fprintf (fp, "%u", linenumber);
365 else
366 lfinfo (fp, "(%A+0x%v)", section, offset);
368 else
369 lfinfo (fp, "%B:(%A+0x%v)", abfd, section, offset);
371 if (asymbols != NULL && entry == NULL)
372 free (asymbols);
374 if (discard_last)
376 last_bfd = NULL;
377 if (last_file != NULL)
379 free (last_file);
380 last_file = NULL;
382 if (last_function != NULL)
384 free (last_function);
385 last_function = NULL;
389 break;
391 case 's':
392 /* arbitrary string, like printf */
393 fprintf (fp, "%s", va_arg (arg, char *));
394 break;
396 case 'd':
397 /* integer, like printf */
398 fprintf (fp, "%d", va_arg (arg, int));
399 break;
401 case 'u':
402 /* unsigned integer, like printf */
403 fprintf (fp, "%u", va_arg (arg, unsigned int));
404 break;
406 case 'l':
407 if (*fmt == 'd')
409 fprintf (fp, "%ld", va_arg (arg, long));
410 ++fmt;
411 break;
413 else if (*fmt == 'u')
415 fprintf (fp, "%lu", va_arg (arg, unsigned long));
416 ++fmt;
417 break;
419 /* Fall thru */
421 default:
422 fprintf (fp, "%%%c", fmt[-1]);
423 break;
428 if (is_warning && config.fatal_warnings)
429 config.make_executable = FALSE;
431 if (fatal)
432 xexit (1);
435 /* Wrapper around cplus_demangle. Strips leading underscores and
436 other such chars that would otherwise confuse the demangler. */
438 char *
439 demangle (const char *name)
441 char *res;
442 const char *p;
444 if (output_bfd != NULL
445 && bfd_get_symbol_leading_char (output_bfd) == name[0])
446 ++name;
448 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
449 or the MS PE format. These formats have a number of leading '.'s
450 on at least some symbols, so we remove all dots to avoid
451 confusing the demangler. */
452 p = name;
453 while (*p == '.')
454 ++p;
456 res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS);
457 if (res)
459 size_t dots = p - name;
461 /* Now put back any stripped dots. */
462 if (dots != 0)
464 size_t len = strlen (res) + 1;
465 char *add_dots = xmalloc (len + dots);
467 memcpy (add_dots, name, dots);
468 memcpy (add_dots + dots, res, len);
469 free (res);
470 res = add_dots;
472 return res;
474 return xstrdup (name);
477 /* Format info message and print on stdout. */
479 /* (You would think this should be called just "info", but then you
480 would be hosed by LynxOS, which defines that name in its libc.) */
482 void
483 info_msg (const char *fmt, ...)
485 va_list arg;
487 va_start (arg, fmt);
488 vfinfo (stdout, fmt, arg, FALSE);
489 va_end (arg);
492 /* ('e' for error.) Format info message and print on stderr. */
494 void
495 einfo (const char *fmt, ...)
497 va_list arg;
499 va_start (arg, fmt);
500 vfinfo (stderr, fmt, arg, TRUE);
501 va_end (arg);
504 void
505 info_assert (const char *file, unsigned int line)
507 einfo (_("%F%P: internal error %s %d\n"), file, line);
510 /* ('m' for map) Format info message and print on map. */
512 void
513 minfo (const char *fmt, ...)
515 va_list arg;
517 va_start (arg, fmt);
518 vfinfo (config.map_file, fmt, arg, FALSE);
519 va_end (arg);
522 void
523 lfinfo (FILE *file, const char *fmt, ...)
525 va_list arg;
527 va_start (arg, fmt);
528 vfinfo (file, fmt, arg, FALSE);
529 va_end (arg);
532 /* Functions to print the link map. */
534 void
535 print_space (void)
537 fprintf (config.map_file, " ");
540 void
541 print_nl (void)
543 fprintf (config.map_file, "\n");
546 /* A more or less friendly abort message. In ld.h abort is defined to
547 call this function. */
549 void
550 ld_abort (const char *file, int line, const char *fn)
552 if (fn != NULL)
553 einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
554 file, line, fn);
555 else
556 einfo (_("%P: internal error: aborting at %s line %d\n"),
557 file, line);
558 einfo (_("%P%F: please report this bug\n"));
559 xexit (1);