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