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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [addr2line.c] - Blame information for rev 139

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

Line No. Rev Author Line
1 15 khays
/* addr2line.c -- convert addresses to line number and function name
2
   Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3
   2007, 2009  Free Software Foundation, Inc.
4
   Contributed by Ulrich Lauther <Ulrich.Lauther@mchp.siemens.de>
5
 
6
   This file is part of GNU Binutils.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3, or (at your option)
11
   any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
21
   MA 02110-1301, USA.  */
22
 
23
 
24
/* Derived from objdump.c and nm.c by Ulrich.Lauther@mchp.siemens.de
25
 
26
   Usage:
27
   addr2line [options] addr addr ...
28
   or
29
   addr2line [options]
30
 
31
   both forms write results to stdout, the second form reads addresses
32
   to be converted from stdin.  */
33
 
34
#include "sysdep.h"
35
#include "bfd.h"
36
#include "getopt.h"
37
#include "libiberty.h"
38
#include "demangle.h"
39
#include "bucomm.h"
40
#include "elf-bfd.h"
41
 
42
static bfd_boolean unwind_inlines;      /* -i, unwind inlined functions. */
43
static bfd_boolean with_addresses;      /* -a, show addresses.  */
44
static bfd_boolean with_functions;      /* -f, show function names.  */
45
static bfd_boolean do_demangle;         /* -C, demangle names.  */
46
static bfd_boolean pretty_print;        /* -p, print on one line.  */
47
static bfd_boolean base_names;          /* -s, strip directory names.  */
48
 
49
static int naddr;               /* Number of addresses to process.  */
50
static char **addr;             /* Hex addresses to process.  */
51
 
52
static asymbol **syms;          /* Symbol table.  */
53
 
54
static struct option long_options[] =
55
{
56
  {"addresses", no_argument, NULL, 'a'},
57
  {"basenames", no_argument, NULL, 's'},
58
  {"demangle", optional_argument, NULL, 'C'},
59
  {"exe", required_argument, NULL, 'e'},
60
  {"functions", no_argument, NULL, 'f'},
61
  {"inlines", no_argument, NULL, 'i'},
62
  {"pretty-print", no_argument, NULL, 'p'},
63
  {"section", required_argument, NULL, 'j'},
64
  {"target", required_argument, NULL, 'b'},
65
  {"help", no_argument, NULL, 'H'},
66
  {"version", no_argument, NULL, 'V'},
67
  {0, no_argument, 0, 0}
68
};
69
 
70
static void usage (FILE *, int);
71
static void slurp_symtab (bfd *);
72
static void find_address_in_section (bfd *, asection *, void *);
73
static void find_offset_in_section (bfd *, asection *);
74
static void translate_addresses (bfd *, asection *);
75
 
76
/* Print a usage message to STREAM and exit with STATUS.  */
77
 
78
static void
79
usage (FILE *stream, int status)
80
{
81
  fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
82
  fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
83
  fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
84
  fprintf (stream, _(" The options are:\n\
85
  @<file>                Read options from <file>\n\
86
  -a --addresses         Show addresses\n\
87
  -b --target=<bfdname>  Set the binary file format\n\
88
  -e --exe=<executable>  Set the input file name (default is a.out)\n\
89
  -i --inlines           Unwind inlined functions\n\
90
  -j --section=<name>    Read section-relative offsets instead of addresses\n\
91
  -p --pretty-print      Make the output easier to read for humans\n\
92
  -s --basenames         Strip directory names\n\
93
  -f --functions         Show function names\n\
94
  -C --demangle[=style]  Demangle function names\n\
95
  -h --help              Display this information\n\
96
  -v --version           Display the program's version\n\
97
\n"));
98
 
99
  list_supported_targets (program_name, stream);
100
  if (REPORT_BUGS_TO[0] && status == 0)
101
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
102
  exit (status);
103
}
104
 
105
/* Read in the symbol table.  */
106
 
107
static void
108
slurp_symtab (bfd *abfd)
109
{
110
  long storage;
111
  long symcount;
112
  bfd_boolean dynamic = FALSE;
113
 
114
  if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
115
    return;
116
 
117
  storage = bfd_get_symtab_upper_bound (abfd);
118
  if (storage == 0)
119
    {
120
      storage = bfd_get_dynamic_symtab_upper_bound (abfd);
121
      dynamic = TRUE;
122
    }
123
  if (storage < 0)
124
    bfd_fatal (bfd_get_filename (abfd));
125
 
126
  syms = (asymbol **) xmalloc (storage);
127
  if (dynamic)
128
    symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
129
  else
130
    symcount = bfd_canonicalize_symtab (abfd, syms);
131
  if (symcount < 0)
132
    bfd_fatal (bfd_get_filename (abfd));
133
}
134
 
135
/* These global variables are used to pass information between
136
   translate_addresses and find_address_in_section.  */
137
 
138
static bfd_vma pc;
139
static const char *filename;
140
static const char *functionname;
141
static unsigned int line;
142
static bfd_boolean found;
143
 
144
/* Look for an address in a section.  This is called via
145
   bfd_map_over_sections.  */
146
 
147
static void
148
find_address_in_section (bfd *abfd, asection *section,
149
                         void *data ATTRIBUTE_UNUSED)
150
{
151
  bfd_vma vma;
152
  bfd_size_type size;
153
 
154
  if (found)
155
    return;
156
 
157
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
158
    return;
159
 
160
  vma = bfd_get_section_vma (abfd, section);
161
  if (pc < vma)
162
    return;
163
 
164
  size = bfd_get_section_size (section);
165
  if (pc >= vma + size)
166
    return;
167
 
168
  found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
169
                                 &filename, &functionname, &line);
170
}
171
 
172
/* Look for an offset in a section.  This is directly called.  */
173
 
174
static void
175
find_offset_in_section (bfd *abfd, asection *section)
176
{
177
  bfd_size_type size;
178
 
179
  if (found)
180
    return;
181
 
182
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
183
    return;
184
 
185
  size = bfd_get_section_size (section);
186
  if (pc >= size)
187
    return;
188
 
189
  found = bfd_find_nearest_line (abfd, section, syms, pc,
190
                                 &filename, &functionname, &line);
191
}
192
 
193
/* Read hexadecimal addresses from stdin, translate into
194
   file_name:line_number and optionally function name.  */
195
 
196
static void
197
translate_addresses (bfd *abfd, asection *section)
198
{
199
  const struct elf_backend_data * bed;
200
 
201
  int read_stdin = (naddr == 0);
202
 
203
  for (;;)
204
    {
205
      if (read_stdin)
206
        {
207
          char addr_hex[100];
208
 
209
          if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
210
            break;
211
          pc = bfd_scan_vma (addr_hex, NULL, 16);
212
        }
213
      else
214
        {
215
          if (naddr <= 0)
216
            break;
217
          --naddr;
218
          pc = bfd_scan_vma (*addr++, NULL, 16);
219
        }
220
 
221
      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
222
          && (bed = get_elf_backend_data (abfd)) != NULL
223
          && bed->sign_extend_vma
224
          && (pc & (bfd_vma) 1 << (bed->s->arch_size - 1)))
225
        pc |= ((bfd_vma) -1) << bed->s->arch_size;
226
 
227
      if (with_addresses)
228
        {
229
          printf ("0x");
230
          bfd_printf_vma (abfd, pc);
231
 
232
          if (pretty_print)
233
            printf (": ");
234
          else
235
            printf ("\n");
236
        }
237
 
238
      found = FALSE;
239
      if (section)
240
        find_offset_in_section (abfd, section);
241
      else
242
        bfd_map_over_sections (abfd, find_address_in_section, NULL);
243
 
244
      if (! found)
245
        {
246
          if (with_functions)
247
            printf ("??\n");
248
          printf ("??:0\n");
249
        }
250
      else
251
        {
252
          while (1)
253
            {
254
              if (with_functions)
255
                {
256
                  const char *name;
257
                  char *alloc = NULL;
258
 
259
                  name = functionname;
260
                  if (name == NULL || *name == '\0')
261
                    name = "??";
262
                  else if (do_demangle)
263
                    {
264
                      alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
265
                      if (alloc != NULL)
266
                        name = alloc;
267
                    }
268
 
269
                  printf ("%s", name);
270
                  if (pretty_print)
271
                    printf (_(" at "));
272
                  else
273
                    printf ("\n");
274
 
275
                  if (alloc != NULL)
276
                    free (alloc);
277
                }
278
 
279
              if (base_names && filename != NULL)
280
                {
281
                  char *h;
282
 
283
                  h = strrchr (filename, '/');
284
                  if (h != NULL)
285
                    filename = h + 1;
286
                }
287
 
288
              printf ("%s:%u\n", filename ? filename : "??", line);
289
              if (!unwind_inlines)
290
                found = FALSE;
291
              else
292
                found = bfd_find_inliner_info (abfd, &filename, &functionname, &line);
293
              if (! found)
294
                break;
295
              if (pretty_print)
296
                printf (_(" (inlined by) "));
297
            }
298
        }
299
 
300
      /* fflush() is essential for using this command as a server
301
         child process that reads addresses from a pipe and responds
302
         with line number information, processing one address at a
303
         time.  */
304
      fflush (stdout);
305
    }
306
}
307
 
308
/* Process a file.  Returns an exit value for main().  */
309
 
310
static int
311
process_file (const char *file_name, const char *section_name,
312
              const char *target)
313
{
314
  bfd *abfd;
315
  asection *section;
316
  char **matching;
317
 
318
  if (get_file_size (file_name) < 1)
319
    return 1;
320
 
321
  abfd = bfd_openr (file_name, target);
322
  if (abfd == NULL)
323
    bfd_fatal (file_name);
324
 
325
  /* Decompress sections.  */
326
  abfd->flags |= BFD_DECOMPRESS;
327
 
328
  if (bfd_check_format (abfd, bfd_archive))
329
    fatal (_("%s: cannot get addresses from archive"), file_name);
330
 
331
  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
332
    {
333
      bfd_nonfatal (bfd_get_filename (abfd));
334
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
335
        {
336
          list_matching_formats (matching);
337
          free (matching);
338
        }
339
      xexit (1);
340
    }
341
 
342
  if (section_name != NULL)
343
    {
344
      section = bfd_get_section_by_name (abfd, section_name);
345
      if (section == NULL)
346
        fatal (_("%s: cannot find section %s"), file_name, section_name);
347
    }
348
  else
349
    section = NULL;
350
 
351
  slurp_symtab (abfd);
352
 
353
  translate_addresses (abfd, section);
354
 
355
  if (syms != NULL)
356
    {
357
      free (syms);
358
      syms = NULL;
359
    }
360
 
361
  bfd_close (abfd);
362
 
363
  return 0;
364
}
365
 
366
int
367
main (int argc, char **argv)
368
{
369
  const char *file_name;
370
  const char *section_name;
371
  char *target;
372
  int c;
373
 
374
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
375
  setlocale (LC_MESSAGES, "");
376
#endif
377
#if defined (HAVE_SETLOCALE)
378
  setlocale (LC_CTYPE, "");
379
#endif
380
  bindtextdomain (PACKAGE, LOCALEDIR);
381
  textdomain (PACKAGE);
382
 
383
  program_name = *argv;
384
  xmalloc_set_program_name (program_name);
385
 
386
  expandargv (&argc, &argv);
387
 
388
  bfd_init ();
389
  set_default_bfd_target ();
390
 
391
  file_name = NULL;
392
  section_name = NULL;
393
  target = NULL;
394
  while ((c = getopt_long (argc, argv, "ab:Ce:sfHhij:pVv", long_options, (int *) 0))
395
         != EOF)
396
    {
397
      switch (c)
398
        {
399
        case 0:
400
          break;                /* We've been given a long option.  */
401
        case 'a':
402
          with_addresses = TRUE;
403
          break;
404
        case 'b':
405
          target = optarg;
406
          break;
407
        case 'C':
408
          do_demangle = TRUE;
409
          if (optarg != NULL)
410
            {
411
              enum demangling_styles style;
412
 
413
              style = cplus_demangle_name_to_style (optarg);
414
              if (style == unknown_demangling)
415
                fatal (_("unknown demangling style `%s'"),
416
                       optarg);
417
 
418
              cplus_demangle_set_style (style);
419
            }
420
          break;
421
        case 'e':
422
          file_name = optarg;
423
          break;
424
        case 's':
425
          base_names = TRUE;
426
          break;
427
        case 'f':
428
          with_functions = TRUE;
429
          break;
430
        case 'p':
431
          pretty_print = TRUE;
432
          break;
433
        case 'v':
434
        case 'V':
435
          print_version ("addr2line");
436
          break;
437
        case 'h':
438
        case 'H':
439
          usage (stdout, 0);
440
          break;
441
        case 'i':
442
          unwind_inlines = TRUE;
443
          break;
444
        case 'j':
445
          section_name = optarg;
446
          break;
447
        default:
448
          usage (stderr, 1);
449
          break;
450
        }
451
    }
452
 
453
  if (file_name == NULL)
454
    file_name = "a.out";
455
 
456
  addr = argv + optind;
457
  naddr = argc - optind;
458
 
459
  return process_file (file_name, section_name, target);
460
}

powered by: WebSVN 2.1.0

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