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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [binutils/] [addr2line.c] - Blame information for rev 832

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

Line No. Rev Author Line
1 38 julius
/* addr2line.c -- convert addresses to line number and function name
2
   Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007
3
   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
 
41
static bfd_boolean unwind_inlines;      /* -i, unwind inlined functions. */
42
static bfd_boolean with_functions;      /* -f, show function names.  */
43
static bfd_boolean do_demangle;         /* -C, demangle names.  */
44
static bfd_boolean base_names;          /* -s, strip directory names.  */
45
 
46
static int naddr;               /* Number of addresses to process.  */
47
static char **addr;             /* Hex addresses to process.  */
48
 
49
static asymbol **syms;          /* Symbol table.  */
50
 
51
static struct option long_options[] =
52
{
53
  {"basenames", no_argument, NULL, 's'},
54
  {"demangle", optional_argument, NULL, 'C'},
55
  {"exe", required_argument, NULL, 'e'},
56
  {"functions", no_argument, NULL, 'f'},
57
  {"inlines", no_argument, NULL, 'i'},
58
  {"section", required_argument, NULL, 'j'},
59
  {"target", required_argument, NULL, 'b'},
60
  {"help", no_argument, NULL, 'H'},
61
  {"version", no_argument, NULL, 'V'},
62
  {0, no_argument, 0, 0}
63
};
64
 
65
static void usage (FILE *, int);
66
static void slurp_symtab (bfd *);
67
static void find_address_in_section (bfd *, asection *, void *);
68
static void find_offset_in_section (bfd *, asection *);
69
static void translate_addresses (bfd *, asection *);
70
 
71
/* Print a usage message to STREAM and exit with STATUS.  */
72
 
73
static void
74
usage (FILE *stream, int status)
75
{
76
  fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
77
  fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
78
  fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
79
  fprintf (stream, _(" The options are:\n\
80
  @<file>                Read options from <file>\n\
81
  -b --target=<bfdname>  Set the binary file format\n\
82
  -e --exe=<executable>  Set the input file name (default is a.out)\n\
83
  -i --inlines           Unwind inlined functions\n\
84
  -j --section=<name>    Read section-relative offsets instead of addresses\n\
85
  -s --basenames         Strip directory names\n\
86
  -f --functions         Show function names\n\
87
  -C --demangle[=style]  Demangle function names\n\
88
  -h --help              Display this information\n\
89
  -v --version           Display the program's version\n\
90
\n"));
91
 
92
  list_supported_targets (program_name, stream);
93
  if (REPORT_BUGS_TO[0] && status == 0)
94
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
95
  exit (status);
96
}
97
 
98
/* Read in the symbol table.  */
99
 
100
static void
101
slurp_symtab (bfd *abfd)
102
{
103
  long symcount;
104
  unsigned int size;
105
 
106
  if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
107
    return;
108
 
109
  symcount = bfd_read_minisymbols (abfd, FALSE, (void *) &syms, &size);
110
  if (symcount == 0)
111
    symcount = bfd_read_minisymbols (abfd, TRUE /* dynamic */, (void *) &syms, &size);
112
 
113
  if (symcount < 0)
114
    bfd_fatal (bfd_get_filename (abfd));
115
}
116
 
117
/* These global variables are used to pass information between
118
   translate_addresses and find_address_in_section.  */
119
 
120
static bfd_vma pc;
121
static const char *filename;
122
static const char *functionname;
123
static unsigned int line;
124
static bfd_boolean found;
125
 
126
/* Look for an address in a section.  This is called via
127
   bfd_map_over_sections.  */
128
 
129
static void
130
find_address_in_section (bfd *abfd, asection *section,
131
                         void *data ATTRIBUTE_UNUSED)
132
{
133
  bfd_vma vma;
134
  bfd_size_type size;
135
 
136
  if (found)
137
    return;
138
 
139
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
140
    return;
141
 
142
  vma = bfd_get_section_vma (abfd, section);
143
  if (pc < vma)
144
    return;
145
 
146
  size = bfd_get_section_size (section);
147
  if (pc >= vma + size)
148
    return;
149
 
150
  found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
151
                                 &filename, &functionname, &line);
152
}
153
 
154
/* Look for an offset in a section.  This is directly called.  */
155
 
156
static void
157
find_offset_in_section (bfd *abfd, asection *section)
158
{
159
  bfd_size_type size;
160
 
161
  if (found)
162
    return;
163
 
164
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
165
    return;
166
 
167
  size = bfd_get_section_size (section);
168
  if (pc >= size)
169
    return;
170
 
171
  found = bfd_find_nearest_line (abfd, section, syms, pc,
172
                                 &filename, &functionname, &line);
173
}
174
 
175
/* Read hexadecimal addresses from stdin, translate into
176
   file_name:line_number and optionally function name.  */
177
 
178
static void
179
translate_addresses (bfd *abfd, asection *section)
180
{
181
  int read_stdin = (naddr == 0);
182
 
183
  for (;;)
184
    {
185
      if (read_stdin)
186
        {
187
          char addr_hex[100];
188
 
189
          if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
190
            break;
191
          pc = bfd_scan_vma (addr_hex, NULL, 16);
192
        }
193
      else
194
        {
195
          if (naddr <= 0)
196
            break;
197
          --naddr;
198
          pc = bfd_scan_vma (*addr++, NULL, 16);
199
        }
200
 
201
      found = FALSE;
202
      if (section)
203
        find_offset_in_section (abfd, section);
204
      else
205
        bfd_map_over_sections (abfd, find_address_in_section, NULL);
206
 
207
      if (! found)
208
        {
209
          if (with_functions)
210
            printf ("??\n");
211
          printf ("??:0\n");
212
        }
213
      else
214
        {
215
          do {
216
            if (with_functions)
217
              {
218
                const char *name;
219
                char *alloc = NULL;
220
 
221
                name = functionname;
222
                if (name == NULL || *name == '\0')
223
                  name = "??";
224
                else if (do_demangle)
225
                  {
226
                    alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
227
                    if (alloc != NULL)
228
                      name = alloc;
229
                  }
230
 
231
                printf ("%s\n", name);
232
 
233
                if (alloc != NULL)
234
                  free (alloc);
235
              }
236
 
237
            if (base_names && filename != NULL)
238
              {
239
                char *h;
240
 
241
                h = strrchr (filename, '/');
242
                if (h != NULL)
243
                  filename = h + 1;
244
              }
245
 
246
            printf ("%s:%u\n", filename ? filename : "??", line);
247
            if (!unwind_inlines)
248
              found = FALSE;
249
            else
250
              found = bfd_find_inliner_info (abfd, &filename, &functionname, &line);
251
          } while (found);
252
 
253
        }
254
 
255
      /* fflush() is essential for using this command as a server
256
         child process that reads addresses from a pipe and responds
257
         with line number information, processing one address at a
258
         time.  */
259
      fflush (stdout);
260
    }
261
}
262
 
263
/* Process a file.  Returns an exit value for main().  */
264
 
265
static int
266
process_file (const char *file_name, const char *section_name,
267
              const char *target)
268
{
269
  bfd *abfd;
270
  asection *section;
271
  char **matching;
272
 
273
  if (get_file_size (file_name) < 1)
274
    return 1;
275
 
276
  abfd = bfd_openr (file_name, target);
277
  if (abfd == NULL)
278
    bfd_fatal (file_name);
279
 
280
  if (bfd_check_format (abfd, bfd_archive))
281
    fatal (_("%s: cannot get addresses from archive"), file_name);
282
 
283
  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
284
    {
285
      bfd_nonfatal (bfd_get_filename (abfd));
286
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
287
        {
288
          list_matching_formats (matching);
289
          free (matching);
290
        }
291
      xexit (1);
292
    }
293
 
294
  if (section_name != NULL)
295
    {
296
      section = bfd_get_section_by_name (abfd, section_name);
297
      if (section == NULL)
298
        fatal (_("%s: cannot find section %s"), file_name, section_name);
299
    }
300
  else
301
    section = NULL;
302
 
303
  slurp_symtab (abfd);
304
 
305
  translate_addresses (abfd, section);
306
 
307
  if (syms != NULL)
308
    {
309
      free (syms);
310
      syms = NULL;
311
    }
312
 
313
  bfd_close (abfd);
314
 
315
  return 0;
316
}
317
 
318
int
319
main (int argc, char **argv)
320
{
321
  const char *file_name;
322
  const char *section_name;
323
  char *target;
324
  int c;
325
 
326
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
327
  setlocale (LC_MESSAGES, "");
328
#endif
329
#if defined (HAVE_SETLOCALE)
330
  setlocale (LC_CTYPE, "");
331
#endif
332
  bindtextdomain (PACKAGE, LOCALEDIR);
333
  textdomain (PACKAGE);
334
 
335
  program_name = *argv;
336
  xmalloc_set_program_name (program_name);
337
 
338
  expandargv (&argc, &argv);
339
 
340
  bfd_init ();
341
  set_default_bfd_target ();
342
 
343
  file_name = NULL;
344
  section_name = NULL;
345
  target = NULL;
346
  while ((c = getopt_long (argc, argv, "b:Ce:sfHhij:Vv", long_options, (int *) 0))
347
         != EOF)
348
    {
349
      switch (c)
350
        {
351
        case 0:
352
          break;                /* We've been given a long option.  */
353
        case 'b':
354
          target = optarg;
355
          break;
356
        case 'C':
357
          do_demangle = TRUE;
358
          if (optarg != NULL)
359
            {
360
              enum demangling_styles style;
361
 
362
              style = cplus_demangle_name_to_style (optarg);
363
              if (style == unknown_demangling)
364
                fatal (_("unknown demangling style `%s'"),
365
                       optarg);
366
 
367
              cplus_demangle_set_style (style);
368
            }
369
          break;
370
        case 'e':
371
          file_name = optarg;
372
          break;
373
        case 's':
374
          base_names = TRUE;
375
          break;
376
        case 'f':
377
          with_functions = TRUE;
378
          break;
379
        case 'v':
380
        case 'V':
381
          print_version ("addr2line");
382
          break;
383
        case 'h':
384
        case 'H':
385
          usage (stdout, 0);
386
          break;
387
        case 'i':
388
          unwind_inlines = TRUE;
389
          break;
390
        case 'j':
391
          section_name = optarg;
392
          break;
393
        default:
394
          usage (stderr, 1);
395
          break;
396
        }
397
    }
398
 
399
  if (file_name == NULL)
400
    file_name = "a.out";
401
 
402
  addr = argv + optind;
403
  naddr = argc - optind;
404
 
405
  return process_file (file_name, section_name, target);
406
}

powered by: WebSVN 2.1.0

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