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