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
65 static void
vfinfo(FILE * fp,const char * fmt,va_list arg,bfd_boolean is_warning)66 vfinfo (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
447 void
info_msg(const char * fmt,...)448 info_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
459 void
einfo(const char * fmt,...)460 einfo (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
469 void
info_assert(const char * file,unsigned int line)470 info_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
477 void
minfo(const char * fmt,...)478 minfo (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
490 void
lfinfo(FILE * file,const char * fmt,...)491 lfinfo (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
502 void
print_space(void)503 print_space (void)
504 {
505 fprintf (config.map_file, " ");
506 }
507
508 void
print_nl(void)509 print_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
517 void
ld_abort(const char * file,int line,const char * fn)518 ld_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