1 /* ldmisc.c
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support.
4
5 This file is part of the GNU Binutils.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libiberty.h"
26 #include "filenames.h"
27 #include "demangle.h"
28 #include <stdarg.h>
29 #include "ld.h"
30 #include "ldmisc.h"
31 #include "ldexp.h"
32 #include "ldlang.h"
33 #include <ldgram.h>
34 #include "ldlex.h"
35 #include "ldmain.h"
36 #include "ldfile.h"
37 #include "elf-bfd.h"
38
39 /*
40 %% literal %
41 %A section name from a section
42 %B filename from a bfd
43 %C clever filename:linenumber with function
44 %D like %C, but no function name
45 %E current bfd error or errno
46 %F error is fatal
47 %G like %D, but only function name
48 %H like %C but in addition emit section+offset
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 from etree_type.
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
vfinfo(FILE * fp,const char * fmt,va_list arg,bfd_boolean is_warning)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 const char *str = fmt;
74 while (*fmt != '%' && *fmt != '\0')
75 fmt++;
76 if (fmt != str)
77 if (fwrite (str, 1, fmt - str, fp))
78 {
79 /* Ignore. */
80 }
81
82 if (*fmt == '%')
83 {
84 fmt++;
85 switch (*fmt++)
86 {
87 case '%':
88 /* literal % */
89 putc ('%', fp);
90 break;
91
92 case 'X':
93 /* no object output, fail return */
94 config.make_executable = FALSE;
95 break;
96
97 case 'V':
98 /* hex bfd_vma */
99 {
100 bfd_vma value = va_arg (arg, bfd_vma);
101 fprintf_vma (fp, value);
102 }
103 break;
104
105 case 'v':
106 /* hex bfd_vma, no leading zeros */
107 {
108 char buf[100];
109 char *p = buf;
110 bfd_vma value = va_arg (arg, bfd_vma);
111 sprintf_vma (p, value);
112 while (*p == '0')
113 p++;
114 if (!*p)
115 p--;
116 fputs (p, fp);
117 }
118 break;
119
120 case 'W':
121 /* hex bfd_vma with 0x with no leading zeroes taking up
122 8 spaces. */
123 {
124 char buf[100];
125 bfd_vma value;
126 char *p;
127 int len;
128
129 value = va_arg (arg, bfd_vma);
130 sprintf_vma (buf, value);
131 for (p = buf; *p == '0'; ++p)
132 ;
133 if (*p == '\0')
134 --p;
135 len = strlen (p);
136 while (len < 8)
137 {
138 putc (' ', fp);
139 ++len;
140 }
141 fprintf (fp, "0x%s", p);
142 }
143 break;
144
145 case 'T':
146 /* Symbol name. */
147 {
148 const char *name = va_arg (arg, const char *);
149
150 if (name == NULL || *name == 0)
151 {
152 fprintf (fp, _("no symbol"));
153 break;
154 }
155 else if (demangling)
156 {
157 char *demangled;
158
159 demangled = bfd_demangle (link_info.output_bfd, name,
160 DMGL_ANSI | DMGL_PARAMS);
161 if (demangled != NULL)
162 {
163 fprintf (fp, "%s", demangled);
164 free (demangled);
165 break;
166 }
167 }
168 fprintf (fp, "%s", name);
169 }
170 break;
171
172 case 'A':
173 /* section name from a section */
174 {
175 asection *sec = va_arg (arg, asection *);
176 bfd *abfd = sec->owner;
177 const char *group = NULL;
178 struct coff_comdat_info *ci;
179
180 fprintf (fp, "%s", sec->name);
181 if (abfd != NULL
182 && bfd_get_flavour (abfd) == bfd_target_elf_flavour
183 && elf_next_in_group (sec) != NULL
184 && (sec->flags & SEC_GROUP) == 0)
185 group = elf_group_name (sec);
186 else if (abfd != NULL
187 && bfd_get_flavour (abfd) == bfd_target_coff_flavour
188 && (ci = bfd_coff_get_comdat_section (sec->owner,
189 sec)) != NULL)
190 group = ci->name;
191 if (group != NULL)
192 fprintf (fp, "[%s]", group);
193 }
194 break;
195
196 case 'B':
197 /* filename from a bfd */
198 {
199 bfd *abfd = va_arg (arg, bfd *);
200
201 if (abfd == NULL)
202 fprintf (fp, "%s generated", program_name);
203 else if (abfd->my_archive)
204 fprintf (fp, "%s(%s)", abfd->my_archive->filename,
205 abfd->filename);
206 else
207 fprintf (fp, "%s", abfd->filename);
208 }
209 break;
210
211 case 'F':
212 /* Error is fatal. */
213 fatal = TRUE;
214 break;
215
216 case 'P':
217 /* Print program name. */
218 fprintf (fp, "%s", program_name);
219 break;
220
221 case 'E':
222 /* current bfd error or errno */
223 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
224 break;
225
226 case 'I':
227 /* filename from a lang_input_statement_type */
228 {
229 lang_input_statement_type *i;
230
231 i = va_arg (arg, lang_input_statement_type *);
232 if (bfd_my_archive (i->the_bfd) != NULL)
233 fprintf (fp, "(%s)",
234 bfd_get_filename (bfd_my_archive (i->the_bfd)));
235 fprintf (fp, "%s", i->local_sym_name);
236 if (bfd_my_archive (i->the_bfd) == NULL
237 && filename_cmp (i->local_sym_name, i->filename) != 0)
238 fprintf (fp, " (%s)", i->filename);
239 }
240 break;
241
242 case 'S':
243 /* Print script file and linenumber. */
244 {
245 etree_type node;
246 etree_type *tp = va_arg (arg, etree_type *);
247
248 if (tp == NULL)
249 {
250 tp = &node;
251 tp->type.filename = ldlex_filename ();
252 tp->type.lineno = lineno;
253 }
254 if (tp->type.filename != NULL)
255 fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
256 }
257 break;
258
259 case 'R':
260 /* Print all that's interesting about a relent. */
261 {
262 arelent *relent = va_arg (arg, arelent *);
263
264 lfinfo (fp, "%s+0x%v (type %s)",
265 (*(relent->sym_ptr_ptr))->name,
266 relent->addend,
267 relent->howto->name);
268 }
269 break;
270
271 case 'C':
272 case 'D':
273 case 'G':
274 case 'H':
275 /* Clever filename:linenumber with function name if possible.
276 The arguments are a BFD, a section, and an offset. */
277 {
278 static bfd *last_bfd;
279 static char *last_file = NULL;
280 static char *last_function = NULL;
281 bfd *abfd;
282 asection *section;
283 bfd_vma offset;
284 asymbol **asymbols = NULL;
285 const char *filename;
286 const char *functionname;
287 unsigned int linenumber;
288 bfd_boolean discard_last;
289 bfd_boolean done;
290
291 abfd = va_arg (arg, bfd *);
292 section = va_arg (arg, asection *);
293 offset = va_arg (arg, bfd_vma);
294
295 if (abfd != NULL)
296 {
297 if (!bfd_generic_link_read_symbols (abfd))
298 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
299
300 asymbols = bfd_get_outsymbols (abfd);
301 }
302
303 /* The GNU Coding Standard requires that error messages
304 be of the form:
305
306 source-file-name:lineno: message
307
308 We do not always have a line number available so if
309 we cannot find them we print out the section name and
310 offset instead. */
311 discard_last = TRUE;
312 if (abfd != NULL
313 && bfd_find_nearest_line (abfd, section, asymbols, offset,
314 &filename, &functionname,
315 &linenumber))
316 {
317 if (functionname != NULL
318 && (fmt[-1] == 'C' || fmt[-1] == 'H'))
319 {
320 /* Detect the case where we are printing out a
321 message for the same function as the last
322 call to vinfo ("%C"). In this situation do
323 not print out the ABFD filename or the
324 function name again. Note - we do still
325 print out the source filename, as this will
326 allow programs that parse the linker's output
327 (eg emacs) to correctly locate multiple
328 errors in the same source file. */
329 if (last_bfd == NULL
330 || last_file == NULL
331 || last_function == NULL
332 || last_bfd != abfd
333 || (filename != NULL
334 && filename_cmp (last_file, filename) != 0)
335 || strcmp (last_function, functionname) != 0)
336 {
337 lfinfo (fp, _("%B: In function `%T':\n"),
338 abfd, functionname);
339
340 last_bfd = abfd;
341 if (last_file != NULL)
342 free (last_file);
343 last_file = NULL;
344 if (filename)
345 last_file = xstrdup (filename);
346 if (last_function != NULL)
347 free (last_function);
348 last_function = xstrdup (functionname);
349 }
350 discard_last = FALSE;
351 }
352 else
353 lfinfo (fp, "%B:", abfd);
354
355 if (filename != NULL)
356 fprintf (fp, "%s:", filename);
357
358 done = fmt[-1] != 'H';
359 if (functionname != NULL && fmt[-1] == 'G')
360 lfinfo (fp, "%T", functionname);
361 else if (filename != NULL && linenumber != 0)
362 fprintf (fp, "%u%s", linenumber, done ? "" : ":");
363 else
364 done = FALSE;
365 }
366 else
367 {
368 lfinfo (fp, "%B:", abfd);
369 done = FALSE;
370 }
371 if (!done)
372 lfinfo (fp, "(%A+0x%v)", section, offset);
373
374 if (discard_last)
375 {
376 last_bfd = NULL;
377 if (last_file != NULL)
378 {
379 free (last_file);
380 last_file = NULL;
381 }
382 if (last_function != NULL)
383 {
384 free (last_function);
385 last_function = NULL;
386 }
387 }
388 }
389 break;
390
391 case 'p':
392 /* native (host) void* pointer, like printf */
393 fprintf (fp, "%p", va_arg (arg, void *));
394 break;
395
396 case 's':
397 /* arbitrary string, like printf */
398 fprintf (fp, "%s", va_arg (arg, char *));
399 break;
400
401 case 'd':
402 /* integer, like printf */
403 fprintf (fp, "%d", va_arg (arg, int));
404 break;
405
406 case 'u':
407 /* unsigned integer, like printf */
408 fprintf (fp, "%u", va_arg (arg, unsigned int));
409 break;
410
411 case 'l':
412 if (*fmt == 'd')
413 {
414 fprintf (fp, "%ld", va_arg (arg, long));
415 ++fmt;
416 break;
417 }
418 else if (*fmt == 'u')
419 {
420 fprintf (fp, "%lu", va_arg (arg, unsigned long));
421 ++fmt;
422 break;
423 }
424 /* Fall thru */
425
426 default:
427 fprintf (fp, "%%%c", fmt[-1]);
428 break;
429 }
430 }
431 }
432
433 if (is_warning && config.fatal_warnings)
434 config.make_executable = FALSE;
435
436 if (fatal)
437 xexit (1);
438 }
439
440 /* Format info message and print on stdout. */
441
442 /* (You would think this should be called just "info", but then you
443 would be hosed by LynxOS, which defines that name in its libc.) */
444
445 void
info_msg(const char * fmt,...)446 info_msg (const char *fmt, ...)
447 {
448 va_list arg;
449
450 va_start (arg, fmt);
451 vfinfo (stdout, fmt, arg, FALSE);
452 va_end (arg);
453 }
454
455 /* ('e' for error.) Format info message and print on stderr. */
456
457 void
einfo(const char * fmt,...)458 einfo (const char *fmt, ...)
459 {
460 va_list arg;
461
462 fflush (stdout);
463 va_start (arg, fmt);
464 vfinfo (stderr, fmt, arg, TRUE);
465 va_end (arg);
466 fflush (stderr);
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 if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
486 {
487 /* Stash info about --as-needed shared libraries. Print
488 later so they don't appear intermingled with archive
489 library info. */
490 struct asneeded_minfo *m = xmalloc (sizeof *m);
491
492 m->next = NULL;
493 m->soname = va_arg (arg, const char *);
494 m->ref = va_arg (arg, bfd *);
495 m->name = va_arg (arg, const char *);
496 *asneeded_list_tail = m;
497 asneeded_list_tail = &m->next;
498 }
499 else
500 vfinfo (config.map_file, fmt, arg, FALSE);
501 va_end (arg);
502 }
503 }
504
505 void
lfinfo(FILE * file,const char * fmt,...)506 lfinfo (FILE *file, const char *fmt, ...)
507 {
508 va_list arg;
509
510 va_start (arg, fmt);
511 vfinfo (file, fmt, arg, FALSE);
512 va_end (arg);
513 }
514
515 /* Functions to print the link map. */
516
517 void
print_space(void)518 print_space (void)
519 {
520 fprintf (config.map_file, " ");
521 }
522
523 void
print_nl(void)524 print_nl (void)
525 {
526 fprintf (config.map_file, "\n");
527 }
528
529 /* A more or less friendly abort message. In ld.h abort is defined to
530 call this function. */
531
532 void
ld_abort(const char * file,int line,const char * fn)533 ld_abort (const char *file, int line, const char *fn)
534 {
535 if (fn != NULL)
536 einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
537 file, line, fn);
538 else
539 einfo (_("%P: internal error: aborting at %s line %d\n"),
540 file, line);
541 einfo (_("%P%F: please report this bug\n"));
542 xexit (1);
543 }
544