← Back to branch summary

~ubuntu-branches/ubuntu/utopic/binutils-arm64-cross/utopic

« back to all changes in this revision

Viewing changes to binutils-2.23.52.20130611/binutils/addr2line.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-06-20 17:38:09 UTC
  • Revision ID: package-import@ubuntu.com-20130620173809-app8lzgvymy5fg6c
Tags: 0.7
Build-depend on binutils-source (>= 2.23.52.20130620-1~).

Show diffs side-by-side

added added

removed removed

Lines of Context:
binutils-2.23.52.20130611/binutils/addr2line.c
 
1
/* 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
  /* If there are no symbols left after canonicalization and
 
135
     we have not tried the dynamic symbols then give them a go.  */
 
136
  if (symcount == 0
 
137
      && ! dynamic
 
138
      && (storage = bfd_get_dynamic_symtab_upper_bound (abfd)) > 0)
 
139
    {
 
140
      free (syms);
 
141
      syms = xmalloc (storage);
 
142
      symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 
143
    }
 
144
}
 
145
 
 
146
/* These global variables are used to pass information between
 
147
   translate_addresses and find_address_in_section.  */
 
148
 
 
149
static bfd_vma pc;
 
150
static const char *filename;
 
151
static const char *functionname;
 
152
static unsigned int line;
 
153
static unsigned int discriminator;
 
154
static bfd_boolean found;
 
155
 
 
156
/* Look for an address in a section.  This is called via
 
157
   bfd_map_over_sections.  */
 
158
 
 
159
static void
 
160
find_address_in_section (bfd *abfd, asection *section,
 
161
                         void *data ATTRIBUTE_UNUSED)
 
162
{
 
163
  bfd_vma vma;
 
164
  bfd_size_type size;
 
165
 
 
166
  if (found)
 
167
    return;
 
168
 
 
169
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
 
170
    return;
 
171
 
 
172
  vma = bfd_get_section_vma (abfd, section);
 
173
  if (pc < vma)
 
174
    return;
 
175
 
 
176
  size = bfd_get_section_size (section);
 
177
  if (pc >= vma + size)
 
178
    return;
 
179
 
 
180
  found = bfd_find_nearest_line_discriminator (abfd, section, syms, pc - vma,
 
181
                                               &filename, &functionname,
 
182
                                               &line, &discriminator);
 
183
}
 
184
 
 
185
/* Look for an offset in a section.  This is directly called.  */
 
186
 
 
187
static void
 
188
find_offset_in_section (bfd *abfd, asection *section)
 
189
{
 
190
  bfd_size_type size;
 
191
 
 
192
  if (found)
 
193
    return;
 
194
 
 
195
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
 
196
    return;
 
197
 
 
198
  size = bfd_get_section_size (section);
 
199
  if (pc >= size)
 
200
    return;
 
201
 
 
202
  found = bfd_find_nearest_line_discriminator (abfd, section, syms, pc,
 
203
                                               &filename, &functionname,
 
204
                                               &line, &discriminator);
 
205
}
 
206
 
 
207
/* Read hexadecimal addresses from stdin, translate into
 
208
   file_name:line_number and optionally function name.  */
 
209
 
 
210
static void
 
211
translate_addresses (bfd *abfd, asection *section)
 
212
{
 
213
  int read_stdin = (naddr == 0);
 
214
 
 
215
  for (;;)
 
216
    {
 
217
      if (read_stdin)
 
218
        {
 
219
          char addr_hex[100];
 
220
 
 
221
          if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
 
222
            break;
 
223
          pc = bfd_scan_vma (addr_hex, NULL, 16);
 
224
        }
 
225
      else
 
226
        {
 
227
          if (naddr <= 0)
 
228
            break;
 
229
          --naddr;
 
230
          pc = bfd_scan_vma (*addr++, NULL, 16);
 
231
        }
 
232
 
 
233
      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 
234
        {
 
235
          const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 
236
          bfd_vma sign = (bfd_vma) 1 << (bed->s->arch_size - 1);
 
237
 
 
238
          pc &= (sign << 1) - 1;
 
239
          if (bed->sign_extend_vma)
 
240
            pc = (pc ^ sign) - sign;
 
241
        }
 
242
 
 
243
      if (with_addresses)
 
244
        {
 
245
          printf ("0x");
 
246
          bfd_printf_vma (abfd, pc);
 
247
 
 
248
          if (pretty_print)
 
249
            printf (": ");
 
250
          else
 
251
            printf ("\n");
 
252
        }
 
253
 
 
254
      found = FALSE;
 
255
      if (section)
 
256
        find_offset_in_section (abfd, section);
 
257
      else
 
258
        bfd_map_over_sections (abfd, find_address_in_section, NULL);
 
259
 
 
260
      if (! found)
 
261
        {
 
262
          if (with_functions)
 
263
            {
 
264
              if (pretty_print)
 
265
                printf ("?? ");
 
266
              else
 
267
                printf ("??\n");
 
268
            }
 
269
          printf ("??:0\n");
 
270
        }
 
271
      else
 
272
        {
 
273
          while (1)
 
274
            {
 
275
              if (with_functions)
 
276
                {
 
277
                  const char *name;
 
278
                  char *alloc = NULL;
 
279
 
 
280
                  name = functionname;
 
281
                  if (name == NULL || *name == '\0')
 
282
                    name = "??";
 
283
                  else if (do_demangle)
 
284
                    {
 
285
                      alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
 
286
                      if (alloc != NULL)
 
287
                        name = alloc;
 
288
                    }
 
289
 
 
290
                  printf ("%s", name);
 
291
                  if (pretty_print)
 
292
                    /* Note for translators:  This printf is used to join the
 
293
                       function name just printed above to the line number/
 
294
                       file name pair that is about to be printed below.  Eg:
 
295
 
 
296
                         foo at 123:bar.c  */
 
297
                    printf (_(" at "));
 
298
                  else
 
299
                    printf ("\n");
 
300
 
 
301
                  if (alloc != NULL)
 
302
                    free (alloc);
 
303
                }
 
304
 
 
305
              if (base_names && filename != NULL)
 
306
                {
 
307
                  char *h;
 
308
 
 
309
                  h = strrchr (filename, '/');
 
310
                  if (h != NULL)
 
311
                    filename = h + 1;
 
312
                }
 
313
 
 
314
              printf ("%s:", filename ? filename : "??");
 
315
              if (line != 0)
 
316
                {
 
317
                  if (discriminator != 0)
 
318
                    printf ("%u (discriminator %u)\n", line, discriminator);
 
319
                  else
 
320
                    printf ("%u\n", line);
 
321
                }
 
322
              else
 
323
                printf ("?\n");
 
324
              if (!unwind_inlines)
 
325
                found = FALSE;
 
326
              else
 
327
                found = bfd_find_inliner_info (abfd, &filename, &functionname,
 
328
                                               &line);
 
329
              if (! found)
 
330
                break;
 
331
              if (pretty_print)
 
332
                /* Note for translators: This printf is used to join the
 
333
                   line number/file name pair that has just been printed with
 
334
                   the line number/file name pair that is going to be printed
 
335
                   by the next iteration of the while loop.  Eg:
 
336
 
 
337
                     123:bar.c (inlined by) 456:main.c  */
 
338
                printf (_(" (inlined by) "));
 
339
            }
 
340
        }
 
341
 
 
342
      /* fflush() is essential for using this command as a server
 
343
         child process that reads addresses from a pipe and responds
 
344
         with line number information, processing one address at a
 
345
         time.  */
 
346
      fflush (stdout);
 
347
    }
 
348
}
 
349
 
 
350
/* Process a file.  Returns an exit value for main().  */
 
351
 
 
352
static int
 
353
process_file (const char *file_name, const char *section_name,
 
354
              const char *target)
 
355
{
 
356
  bfd *abfd;
 
357
  asection *section;
 
358
  char **matching;
 
359
 
 
360
  if (get_file_size (file_name) < 1)
 
361
    return 1;
 
362
 
 
363
  abfd = bfd_openr (file_name, target);
 
364
  if (abfd == NULL)
 
365
    bfd_fatal (file_name);
 
366
 
 
367
  /* Decompress sections.  */
 
368
  abfd->flags |= BFD_DECOMPRESS;
 
369
 
 
370
  if (bfd_check_format (abfd, bfd_archive))
 
371
    fatal (_("%s: cannot get addresses from archive"), file_name);
 
372
 
 
373
  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
 
374
    {
 
375
      bfd_nonfatal (bfd_get_filename (abfd));
 
376
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 
377
        {
 
378
          list_matching_formats (matching);
 
379
          free (matching);
 
380
        }
 
381
      xexit (1);
 
382
    }
 
383
 
 
384
  if (section_name != NULL)
 
385
    {
 
386
      section = bfd_get_section_by_name (abfd, section_name);
 
387
      if (section == NULL)
 
388
        fatal (_("%s: cannot find section %s"), file_name, section_name);
 
389
    }
 
390
  else
 
391
    section = NULL;
 
392
 
 
393
  slurp_symtab (abfd);
 
394
 
 
395
  translate_addresses (abfd, section);
 
396
 
 
397
  if (syms != NULL)
 
398
    {
 
399
      free (syms);
 
400
      syms = NULL;
 
401
    }
 
402
 
 
403
  bfd_close (abfd);
 
404
 
 
405
  return 0;
 
406
}
 
407
 
 
408
int
 
409
main (int argc, char **argv)
 
410
{
 
411
  const char *file_name;
 
412
  const char *section_name;
 
413
  char *target;
 
414
  int c;
 
415
 
 
416
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 
417
  setlocale (LC_MESSAGES, "");
 
418
#endif
 
419
#if defined (HAVE_SETLOCALE)
 
420
  setlocale (LC_CTYPE, "");
 
421
#endif
 
422
  bindtextdomain (PACKAGE, LOCALEDIR);
 
423
  textdomain (PACKAGE);
 
424
 
 
425
  program_name = *argv;
 
426
  xmalloc_set_program_name (program_name);
 
427
 
 
428
  expandargv (&argc, &argv);
 
429
 
 
430
  bfd_init ();
 
431
  set_default_bfd_target ();
 
432
 
 
433
  file_name = NULL;
 
434
  section_name = NULL;
 
435
  target = NULL;
 
436
  while ((c = getopt_long (argc, argv, "ab:Ce:sfHhij:pVv", long_options, (int *) 0))
 
437
         != EOF)
 
438
    {
 
439
      switch (c)
 
440
        {
 
441
        case 0:
 
442
          break;                /* We've been given a long option.  */
 
443
        case 'a':
 
444
          with_addresses = TRUE;
 
445
          break;
 
446
        case 'b':
 
447
          target = optarg;
 
448
          break;
 
449
        case 'C':
 
450
          do_demangle = TRUE;
 
451
          if (optarg != NULL)
 
452
            {
 
453
              enum demangling_styles style;
 
454
 
 
455
              style = cplus_demangle_name_to_style (optarg);
 
456
              if (style == unknown_demangling)
 
457
                fatal (_("unknown demangling style `%s'"),
 
458
                       optarg);
 
459
 
 
460
              cplus_demangle_set_style (style);
 
461
            }
 
462
          break;
 
463
        case 'e':
 
464
          file_name = optarg;
 
465
          break;
 
466
        case 's':
 
467
          base_names = TRUE;
 
468
          break;
 
469
        case 'f':
 
470
          with_functions = TRUE;
 
471
          break;
 
472
        case 'p':
 
473
          pretty_print = TRUE;
 
474
          break;
 
475
        case 'v':
 
476
        case 'V':
 
477
          print_version ("addr2line");
 
478
          break;
 
479
        case 'h':
 
480
        case 'H':
 
481
          usage (stdout, 0);
 
482
          break;
 
483
        case 'i':
 
484
          unwind_inlines = TRUE;
 
485
          break;
 
486
        case 'j':
 
487
          section_name = optarg;
 
488
          break;
 
489
        default:
 
490
          usage (stderr, 1);
 
491
          break;
 
492
        }
 
493
    }
 
494
 
 
495
  if (file_name == NULL)
 
496
    file_name = "a.out";
 
497
 
 
498
  addr = argv + optind;
 
499
  naddr = argc - optind;
 
500
 
 
501
  return process_file (file_name, section_name, target);
 
502
}