OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [ldmisc.c] - Blame information for rev 299

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.