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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [nm.c] - Blame information for rev 272

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

Line No. Rev Author Line
1 15 khays
/* nm.c -- Describe symbol table of a rel file.
2
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 166 khays
   2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
4 15 khays
   Free Software Foundation, Inc.
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 of the License, or
11
   (at your option) 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, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21
   02110-1301, USA.  */
22
 
23
#include "sysdep.h"
24
#include "bfd.h"
25
#include "progress.h"
26
#include "getopt.h"
27
#include "aout/stab_gnu.h"
28
#include "aout/ranlib.h"
29
#include "demangle.h"
30
#include "libiberty.h"
31
#include "elf-bfd.h"
32
#include "elf/common.h"
33
#include "bucomm.h"
34
#include "plugin.h"
35
 
36
/* When sorting by size, we use this structure to hold the size and a
37
   pointer to the minisymbol.  */
38
 
39
struct size_sym
40
{
41
  const void *minisym;
42
  bfd_vma size;
43
};
44
 
45
/* When fetching relocs, we use this structure to pass information to
46
   get_relocs.  */
47
 
48
struct get_relocs_info
49
{
50
  asection **secs;
51
  arelent ***relocs;
52
  long *relcount;
53
  asymbol **syms;
54
};
55
 
56
struct extended_symbol_info
57
{
58
  symbol_info *sinfo;
59
  bfd_vma ssize;
60
  elf_symbol_type *elfinfo;
61
  /* FIXME: We should add more fields for Type, Line, Section.  */
62
};
63
#define SYM_NAME(sym)        (sym->sinfo->name)
64
#define SYM_VALUE(sym)       (sym->sinfo->value)
65
#define SYM_TYPE(sym)        (sym->sinfo->type)
66
#define SYM_STAB_NAME(sym)   (sym->sinfo->stab_name)
67
#define SYM_STAB_DESC(sym)   (sym->sinfo->stab_desc)
68
#define SYM_STAB_OTHER(sym)  (sym->sinfo->stab_other)
69
#define SYM_SIZE(sym) \
70
  (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
71
 
72
/* The output formatting functions.  */
73
static void print_object_filename_bsd (char *);
74
static void print_object_filename_sysv (char *);
75
static void print_object_filename_posix (char *);
76
static void print_archive_filename_bsd (char *);
77
static void print_archive_filename_sysv (char *);
78
static void print_archive_filename_posix (char *);
79
static void print_archive_member_bsd (char *, const char *);
80
static void print_archive_member_sysv (char *, const char *);
81
static void print_archive_member_posix (char *, const char *);
82
static void print_symbol_filename_bsd (bfd *, bfd *);
83
static void print_symbol_filename_sysv (bfd *, bfd *);
84
static void print_symbol_filename_posix (bfd *, bfd *);
85
static void print_value (bfd *, bfd_vma);
86
static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
87
static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
88
static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
89
 
90
/* Support for different output formats.  */
91
struct output_fns
92
  {
93
    /* Print the name of an object file given on the command line.  */
94
    void (*print_object_filename) (char *);
95
 
96
    /* Print the name of an archive file given on the command line.  */
97
    void (*print_archive_filename) (char *);
98
 
99
    /* Print the name of an archive member file.  */
100
    void (*print_archive_member) (char *, const char *);
101
 
102
    /* Print the name of the file (and archive, if there is one)
103
       containing a symbol.  */
104
    void (*print_symbol_filename) (bfd *, bfd *);
105
 
106
    /* Print a line of information about a symbol.  */
107
    void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
108
  };
109
 
110
static struct output_fns formats[] =
111
{
112
  {print_object_filename_bsd,
113
   print_archive_filename_bsd,
114
   print_archive_member_bsd,
115
   print_symbol_filename_bsd,
116
   print_symbol_info_bsd},
117
  {print_object_filename_sysv,
118
   print_archive_filename_sysv,
119
   print_archive_member_sysv,
120
   print_symbol_filename_sysv,
121
   print_symbol_info_sysv},
122
  {print_object_filename_posix,
123
   print_archive_filename_posix,
124
   print_archive_member_posix,
125
   print_symbol_filename_posix,
126
   print_symbol_info_posix}
127
};
128
 
129
/* Indices in `formats'.  */
130
#define FORMAT_BSD 0
131
#define FORMAT_SYSV 1
132
#define FORMAT_POSIX 2
133
#define FORMAT_DEFAULT FORMAT_BSD
134
 
135
/* The output format to use.  */
136
static struct output_fns *format = &formats[FORMAT_DEFAULT];
137
 
138
/* Command options.  */
139
 
140
static int do_demangle = 0;      /* Pretty print C++ symbol names.  */
141
static int external_only = 0;    /* Print external symbols only.  */
142
static int defined_only = 0;     /* Print defined symbols only.  */
143
static int no_sort = 0;          /* Don't sort; print syms in order found.  */
144
static int print_debug_syms = 0;/* Print debugger-only symbols too.  */
145
static int print_armap = 0;      /* Describe __.SYMDEF data in archive files.  */
146
static int print_size = 0;       /* Print size of defined symbols.  */
147
static int reverse_sort = 0;     /* Sort in downward(alpha or numeric) order.  */
148
static int sort_numerically = 0;/* Sort in numeric rather than alpha order.  */
149
static int sort_by_size = 0;     /* Sort by size of symbol.  */
150
static int undefined_only = 0;   /* Print undefined symbols only.  */
151
static int dynamic = 0;          /* Print dynamic symbols.  */
152
static int show_version = 0;     /* Show the version number.  */
153
static int show_stats = 0;       /* Show statistics.  */
154
static int show_synthetic = 0;   /* Display synthesized symbols too.  */
155
static int line_numbers = 0;     /* Print line numbers for symbols.  */
156
static int allow_special_symbols = 0;  /* Allow special symbols.  */
157
 
158
/* When to print the names of files.  Not mutually exclusive in SYSV format.  */
159
static int filename_per_file = 0;        /* Once per file, on its own line.  */
160
static int filename_per_symbol = 0;      /* Once per symbol, at start of line.  */
161
 
162
/* Print formats for printing a symbol value.  */
163
static char value_format_32bit[] = "%08lx";
164
#if BFD_HOST_64BIT_LONG
165
static char value_format_64bit[] = "%016lx";
166
#elif BFD_HOST_64BIT_LONG_LONG
167
#ifndef __MSVCRT__
168
static char value_format_64bit[] = "%016llx";
169
#else
170
static char value_format_64bit[] = "%016I64x";
171
#endif
172
#endif
173
static int print_width = 0;
174
static int print_radix = 16;
175
/* Print formats for printing stab info.  */
176
static char other_format[] = "%02x";
177
static char desc_format[] = "%04x";
178
 
179
static char *target = NULL;
180
static char *plugin_target = NULL;
181
 
182
/* Used to cache the line numbers for a BFD.  */
183
static bfd *lineno_cache_bfd;
184
static bfd *lineno_cache_rel_bfd;
185
 
186
#define OPTION_TARGET 200
187 166 khays
#define OPTION_PLUGIN (OPTION_TARGET + 1)
188
#define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
189 15 khays
 
190
static struct option long_options[] =
191
{
192
  {"debug-syms", no_argument, &print_debug_syms, 1},
193
  {"demangle", optional_argument, 0, 'C'},
194
  {"dynamic", no_argument, &dynamic, 1},
195
  {"extern-only", no_argument, &external_only, 1},
196
  {"format", required_argument, 0, 'f'},
197
  {"help", no_argument, 0, 'h'},
198
  {"line-numbers", no_argument, 0, 'l'},
199
  {"no-cplus", no_argument, &do_demangle, 0},  /* Linux compatibility.  */
200
  {"no-demangle", no_argument, &do_demangle, 0},
201 166 khays
  {"no-sort", no_argument, 0, 'p'},
202
  {"numeric-sort", no_argument, 0, 'n'},
203 15 khays
  {"plugin", required_argument, 0, OPTION_PLUGIN},
204
  {"portability", no_argument, 0, 'P'},
205
  {"print-armap", no_argument, &print_armap, 1},
206
  {"print-file-name", no_argument, 0, 'o'},
207
  {"print-size", no_argument, 0, 'S'},
208
  {"radix", required_argument, 0, 't'},
209
  {"reverse-sort", no_argument, &reverse_sort, 1},
210 166 khays
  {"size-sort", no_argument, 0, OPTION_SIZE_SORT},
211 15 khays
  {"special-syms", no_argument, &allow_special_symbols, 1},
212
  {"stats", no_argument, &show_stats, 1},
213
  {"synthetic", no_argument, &show_synthetic, 1},
214
  {"target", required_argument, 0, OPTION_TARGET},
215
  {"defined-only", no_argument, &defined_only, 1},
216
  {"undefined-only", no_argument, &undefined_only, 1},
217
  {"version", no_argument, &show_version, 1},
218
  {0, no_argument, 0, 0}
219
};
220
 
221
/* Some error-reporting functions.  */
222
 
223
static void
224
usage (FILE *stream, int status)
225
{
226
  fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
227
  fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
228
  fprintf (stream, _(" The options are:\n\
229
  -a, --debug-syms       Display debugger-only symbols\n\
230
  -A, --print-file-name  Print name of the input file before every symbol\n\
231
  -B                     Same as --format=bsd\n\
232
  -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
233
                          The STYLE, if specified, can be `auto' (the default),\n\
234
                          `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
235
                          or `gnat'\n\
236
      --no-demangle      Do not demangle low-level symbol names\n\
237
  -D, --dynamic          Display dynamic symbols instead of normal symbols\n\
238
      --defined-only     Display only defined symbols\n\
239
  -e                     (ignored)\n\
240
  -f, --format=FORMAT    Use the output format FORMAT.  FORMAT can be `bsd',\n\
241
                           `sysv' or `posix'.  The default is `bsd'\n\
242
  -g, --extern-only      Display only external symbols\n\
243
  -l, --line-numbers     Use debugging information to find a filename and\n\
244
                           line number for each symbol\n\
245
  -n, --numeric-sort     Sort symbols numerically by address\n\
246
  -o                     Same as -A\n\
247
  -p, --no-sort          Do not sort the symbols\n\
248
  -P, --portability      Same as --format=posix\n\
249
  -r, --reverse-sort     Reverse the sense of the sort\n"));
250
#if BFD_SUPPORTS_PLUGINS
251
  fprintf (stream, _("\
252
      --plugin NAME      Load the specified plugin\n"));
253
#endif
254
  fprintf (stream, _("\
255
  -S, --print-size       Print size of defined symbols\n\
256
  -s, --print-armap      Include index for symbols from archive members\n\
257
      --size-sort        Sort symbols by size\n\
258
      --special-syms     Include special symbols in the output\n\
259
      --synthetic        Display synthetic symbols as well\n\
260
  -t, --radix=RADIX      Use RADIX for printing symbol values\n\
261
      --target=BFDNAME   Specify the target object format as BFDNAME\n\
262
  -u, --undefined-only   Display only undefined symbols\n\
263
  -X 32_64               (ignored)\n\
264
  @FILE                  Read options from FILE\n\
265
  -h, --help             Display this information\n\
266
  -V, --version          Display this program's version number\n\
267
\n"));
268
  list_supported_targets (program_name, stream);
269
  if (REPORT_BUGS_TO[0] && status == 0)
270
    fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
271
  exit (status);
272
}
273
 
274
/* Set the radix for the symbol value and size according to RADIX.  */
275
 
276
static void
277
set_print_radix (char *radix)
278
{
279
  switch (*radix)
280
    {
281
    case 'x':
282
      break;
283
    case 'd':
284
    case 'o':
285
      if (*radix == 'd')
286
        print_radix = 10;
287
      else
288
        print_radix = 8;
289
      value_format_32bit[4] = *radix;
290
#if BFD_HOST_64BIT_LONG
291
      value_format_64bit[5] = *radix;
292
#elif BFD_HOST_64BIT_LONG_LONG
293
#ifndef __MSVCRT__
294
      value_format_64bit[6] = *radix;
295
#else
296
      value_format_64bit[7] = *radix;
297
#endif
298
#endif
299
      other_format[3] = desc_format[3] = *radix;
300
      break;
301
    default:
302
      fatal (_("%s: invalid radix"), radix);
303
    }
304
}
305
 
306
static void
307
set_output_format (char *f)
308
{
309
  int i;
310
 
311
  switch (*f)
312
    {
313
    case 'b':
314
    case 'B':
315
      i = FORMAT_BSD;
316
      break;
317
    case 'p':
318
    case 'P':
319
      i = FORMAT_POSIX;
320
      break;
321
    case 's':
322
    case 'S':
323
      i = FORMAT_SYSV;
324
      break;
325
    default:
326
      fatal (_("%s: invalid output format"), f);
327
    }
328
  format = &formats[i];
329
}
330
 
331
static const char *
332
get_symbol_type (unsigned int type)
333
{
334
  static char buff [32];
335
 
336
  switch (type)
337
    {
338
    case STT_NOTYPE:   return "NOTYPE";
339
    case STT_OBJECT:   return "OBJECT";
340
    case STT_FUNC:     return "FUNC";
341
    case STT_SECTION:  return "SECTION";
342
    case STT_FILE:     return "FILE";
343
    case STT_COMMON:   return "COMMON";
344
    case STT_TLS:      return "TLS";
345
    default:
346
      if (type >= STT_LOPROC && type <= STT_HIPROC)
347
        sprintf (buff, _("<processor specific>: %d"), type);
348
      else if (type >= STT_LOOS && type <= STT_HIOS)
349
        sprintf (buff, _("<OS specific>: %d"), type);
350
      else
351
        sprintf (buff, _("<unknown>: %d"), type);
352
      return buff;
353
    }
354
}
355
 
356
/* Print symbol name NAME, read from ABFD, with printf format FORM,
357
   demangling it if requested.  */
358
 
359
static void
360
print_symname (const char *form, const char *name, bfd *abfd)
361
{
362
  if (do_demangle && *name)
363
    {
364
      char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
365
 
366
      if (res != NULL)
367
        {
368
          printf (form, res);
369
          free (res);
370
          return;
371
        }
372
    }
373
 
374
  printf (form, name);
375
}
376
 
377
static void
378
print_symdef_entry (bfd *abfd)
379
{
380
  symindex idx = BFD_NO_MORE_SYMBOLS;
381
  carsym *thesym;
382
  bfd_boolean everprinted = FALSE;
383
 
384
  for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
385
       idx != BFD_NO_MORE_SYMBOLS;
386
       idx = bfd_get_next_mapent (abfd, idx, &thesym))
387
    {
388
      bfd *elt;
389
      if (!everprinted)
390
        {
391
          printf (_("\nArchive index:\n"));
392
          everprinted = TRUE;
393
        }
394
      elt = bfd_get_elt_at_index (abfd, idx);
395
      if (elt == NULL)
396
        bfd_fatal ("bfd_get_elt_at_index");
397
      if (thesym->name != (char *) NULL)
398
        {
399
          print_symname ("%s", thesym->name, abfd);
400
          printf (" in %s\n", bfd_get_filename (elt));
401
        }
402
    }
403
}
404
 
405
/* Choose which symbol entries to print;
406
   compact them downward to get rid of the rest.
407
   Return the number of symbols to be printed.  */
408
 
409
static long
410
filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
411
                long symcount, unsigned int size)
412
{
413
  bfd_byte *from, *fromend, *to;
414
  asymbol *store;
415
 
416
  store = bfd_make_empty_symbol (abfd);
417
  if (store == NULL)
418
    bfd_fatal (bfd_get_filename (abfd));
419
 
420
  from = (bfd_byte *) minisyms;
421
  fromend = from + symcount * size;
422
  to = (bfd_byte *) minisyms;
423
 
424
  for (; from < fromend; from += size)
425
    {
426
      int keep = 0;
427
      asymbol *sym;
428
 
429
      PROGRESS (1);
430
 
431
      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
432
      if (sym == NULL)
433
        bfd_fatal (bfd_get_filename (abfd));
434
 
435
      if (undefined_only)
436
        keep = bfd_is_und_section (sym->section);
437
      else if (external_only)
438
        keep = ((sym->flags & BSF_GLOBAL) != 0
439
                || (sym->flags & BSF_WEAK) != 0
440
                /* PR binutls/12753: Unique symbols are global too.  */
441
                || (sym->flags & BSF_GNU_UNIQUE) != 0
442
                || bfd_is_und_section (sym->section)
443
                || bfd_is_com_section (sym->section));
444
      else
445
        keep = 1;
446
 
447
      if (keep
448
          && ! print_debug_syms
449
          && (sym->flags & BSF_DEBUGGING) != 0)
450
        keep = 0;
451
 
452
      if (keep
453
          && sort_by_size
454
          && (bfd_is_abs_section (sym->section)
455
              || bfd_is_und_section (sym->section)))
456
        keep = 0;
457
 
458
      if (keep
459
          && defined_only)
460
        {
461
          if (bfd_is_und_section (sym->section))
462
            keep = 0;
463
        }
464
 
465
      if (keep
466
          && bfd_is_target_special_symbol (abfd, sym)
467
          && ! allow_special_symbols)
468
        keep = 0;
469
 
470
      if (keep)
471
        {
472
          if (to != from)
473
            memcpy (to, from, size);
474
          to += size;
475
        }
476
    }
477
 
478
  return (to - (bfd_byte *) minisyms) / size;
479
}
480
 
481
/* These globals are used to pass information into the sorting
482
   routines.  */
483
static bfd *sort_bfd;
484
static bfd_boolean sort_dynamic;
485
static asymbol *sort_x;
486
static asymbol *sort_y;
487
 
488
/* Symbol-sorting predicates */
489
#define valueof(x) ((x)->section->vma + (x)->value)
490
 
491
/* Numeric sorts.  Undefined symbols are always considered "less than"
492
   defined symbols with zero values.  Common symbols are not treated
493
   specially -- i.e., their sizes are used as their "values".  */
494
 
495
static int
496
non_numeric_forward (const void *P_x, const void *P_y)
497
{
498
  asymbol *x, *y;
499
  const char *xn, *yn;
500
 
501
  x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
502
  y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
503
  if (x == NULL || y == NULL)
504
    bfd_fatal (bfd_get_filename (sort_bfd));
505
 
506
  xn = bfd_asymbol_name (x);
507
  yn = bfd_asymbol_name (y);
508
 
509
  if (yn == NULL)
510
    return xn != NULL;
511
  if (xn == NULL)
512
    return -1;
513
 
514
#ifdef HAVE_STRCOLL
515
  /* Solaris 2.5 has a bug in strcoll.
516
     strcoll returns invalid values when confronted with empty strings.  */
517
  if (*yn == '\0')
518
    return *xn != '\0';
519
  if (*xn == '\0')
520
    return -1;
521
 
522
  return strcoll (xn, yn);
523
#else
524
  return strcmp (xn, yn);
525
#endif
526
}
527
 
528
static int
529
non_numeric_reverse (const void *x, const void *y)
530
{
531
  return - non_numeric_forward (x, y);
532
}
533
 
534
static int
535
numeric_forward (const void *P_x, const void *P_y)
536
{
537
  asymbol *x, *y;
538
  asection *xs, *ys;
539
 
540
  x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
541
  y =  bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
542
  if (x == NULL || y == NULL)
543
    bfd_fatal (bfd_get_filename (sort_bfd));
544
 
545
  xs = bfd_get_section (x);
546
  ys = bfd_get_section (y);
547
 
548
  if (bfd_is_und_section (xs))
549
    {
550
      if (! bfd_is_und_section (ys))
551
        return -1;
552
    }
553
  else if (bfd_is_und_section (ys))
554
    return 1;
555
  else if (valueof (x) != valueof (y))
556
    return valueof (x) < valueof (y) ? -1 : 1;
557
 
558
  return non_numeric_forward (P_x, P_y);
559
}
560
 
561
static int
562
numeric_reverse (const void *x, const void *y)
563
{
564
  return - numeric_forward (x, y);
565
}
566
 
567
static int (*(sorters[2][2])) (const void *, const void *) =
568
{
569
  { non_numeric_forward, non_numeric_reverse },
570
  { numeric_forward, numeric_reverse }
571
};
572
 
573
/* This sort routine is used by sort_symbols_by_size.  It is similar
574
   to numeric_forward, but when symbols have the same value it sorts
575
   by section VMA.  This simplifies the sort_symbols_by_size code
576
   which handles symbols at the end of sections.  Also, this routine
577
   tries to sort file names before other symbols with the same value.
578
   That will make the file name have a zero size, which will make
579
   sort_symbols_by_size choose the non file name symbol, leading to
580
   more meaningful output.  For similar reasons, this code sorts
581
   gnu_compiled_* and gcc2_compiled before other symbols with the same
582
   value.  */
583
 
584
static int
585
size_forward1 (const void *P_x, const void *P_y)
586
{
587
  asymbol *x, *y;
588
  asection *xs, *ys;
589
  const char *xn, *yn;
590
  size_t xnl, ynl;
591
  int xf, yf;
592
 
593
  x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
594
  y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
595
  if (x == NULL || y == NULL)
596
    bfd_fatal (bfd_get_filename (sort_bfd));
597
 
598
  xs = bfd_get_section (x);
599
  ys = bfd_get_section (y);
600
 
601
  if (bfd_is_und_section (xs))
602
    abort ();
603
  if (bfd_is_und_section (ys))
604
    abort ();
605
 
606
  if (valueof (x) != valueof (y))
607
    return valueof (x) < valueof (y) ? -1 : 1;
608
 
609
  if (xs->vma != ys->vma)
610
    return xs->vma < ys->vma ? -1 : 1;
611
 
612
  xn = bfd_asymbol_name (x);
613
  yn = bfd_asymbol_name (y);
614
  xnl = strlen (xn);
615
  ynl = strlen (yn);
616
 
617
  /* The symbols gnu_compiled and gcc2_compiled convey even less
618
     information than the file name, so sort them out first.  */
619
 
620
  xf = (strstr (xn, "gnu_compiled") != NULL
621
        || strstr (xn, "gcc2_compiled") != NULL);
622
  yf = (strstr (yn, "gnu_compiled") != NULL
623
        || strstr (yn, "gcc2_compiled") != NULL);
624
 
625
  if (xf && ! yf)
626
    return -1;
627
  if (! xf && yf)
628
    return 1;
629
 
630
  /* We use a heuristic for the file name.  It may not work on non
631
     Unix systems, but it doesn't really matter; the only difference
632
     is precisely which symbol names get printed.  */
633
 
634
#define file_symbol(s, sn, snl)                 \
635
  (((s)->flags & BSF_FILE) != 0                  \
636
   || ((sn)[(snl) - 2] == '.'                   \
637
       && ((sn)[(snl) - 1] == 'o'               \
638
           || (sn)[(snl) - 1] == 'a')))
639
 
640
  xf = file_symbol (x, xn, xnl);
641
  yf = file_symbol (y, yn, ynl);
642
 
643
  if (xf && ! yf)
644
    return -1;
645
  if (! xf && yf)
646
    return 1;
647
 
648
  return non_numeric_forward (P_x, P_y);
649
}
650
 
651
/* This sort routine is used by sort_symbols_by_size.  It is sorting
652
   an array of size_sym structures into size order.  */
653
 
654
static int
655
size_forward2 (const void *P_x, const void *P_y)
656
{
657
  const struct size_sym *x = (const struct size_sym *) P_x;
658
  const struct size_sym *y = (const struct size_sym *) P_y;
659
 
660
  if (x->size < y->size)
661
    return reverse_sort ? 1 : -1;
662
  else if (x->size > y->size)
663
    return reverse_sort ? -1 : 1;
664
  else
665
    return sorters[0][reverse_sort] (x->minisym, y->minisym);
666
}
667
 
668
/* Sort the symbols by size.  ELF provides a size but for other formats
669
   we have to make a guess by assuming that the difference between the
670
   address of a symbol and the address of the next higher symbol is the
671
   size.  */
672
 
673
static long
674
sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
675
                      long symcount, unsigned int size,
676
                      struct size_sym **symsizesp)
677
{
678
  struct size_sym *symsizes;
679
  bfd_byte *from, *fromend;
680
  asymbol *sym = NULL;
681
  asymbol *store_sym, *store_next;
682
 
683
  qsort (minisyms, symcount, size, size_forward1);
684
 
685
  /* We are going to return a special set of symbols and sizes to
686
     print.  */
687
  symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
688
  *symsizesp = symsizes;
689
 
690
  /* Note that filter_symbols has already removed all absolute and
691
     undefined symbols.  Here we remove all symbols whose size winds
692
     up as zero.  */
693
  from = (bfd_byte *) minisyms;
694
  fromend = from + symcount * size;
695
 
696
  store_sym = sort_x;
697
  store_next = sort_y;
698
 
699
  if (from < fromend)
700
    {
701
      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
702
                                      store_sym);
703
      if (sym == NULL)
704
        bfd_fatal (bfd_get_filename (abfd));
705
    }
706
 
707
  for (; from < fromend; from += size)
708
    {
709
      asymbol *next;
710
      asection *sec;
711
      bfd_vma sz;
712
      asymbol *temp;
713
 
714
      if (from + size < fromend)
715
        {
716
          next = bfd_minisymbol_to_symbol (abfd,
717
                                           is_dynamic,
718
                                           (const void *) (from + size),
719
                                           store_next);
720
          if (next == NULL)
721
            bfd_fatal (bfd_get_filename (abfd));
722
        }
723
      else
724
        next = NULL;
725
 
726
      sec = bfd_get_section (sym);
727
 
728
      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
729
        sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
730
      else if (bfd_is_com_section (sec))
731
        sz = sym->value;
732
      else
733
        {
734
          if (from + size < fromend
735
              && sec == bfd_get_section (next))
736
            sz = valueof (next) - valueof (sym);
737
          else
738
            sz = (bfd_get_section_vma (abfd, sec)
739
                  + bfd_section_size (abfd, sec)
740
                  - valueof (sym));
741
        }
742
 
743
      if (sz != 0)
744
        {
745
          symsizes->minisym = (const void *) from;
746
          symsizes->size = sz;
747
          ++symsizes;
748
        }
749
 
750
      sym = next;
751
 
752
      temp = store_sym;
753
      store_sym = store_next;
754
      store_next = temp;
755
    }
756
 
757
  symcount = symsizes - *symsizesp;
758
 
759
  /* We must now sort again by size.  */
760
  qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
761
 
762
  return symcount;
763
}
764
 
765
/* This function is used to get the relocs for a particular section.
766
   It is called via bfd_map_over_sections.  */
767
 
768
static void
769
get_relocs (bfd *abfd, asection *sec, void *dataarg)
770
{
771
  struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
772
 
773
  *data->secs = sec;
774
 
775
  if ((sec->flags & SEC_RELOC) == 0)
776
    {
777
      *data->relocs = NULL;
778
      *data->relcount = 0;
779
    }
780
  else
781
    {
782
      long relsize;
783
 
784
      relsize = bfd_get_reloc_upper_bound (abfd, sec);
785
      if (relsize < 0)
786
        bfd_fatal (bfd_get_filename (abfd));
787
 
788
      *data->relocs = (arelent **) xmalloc (relsize);
789
      *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
790
                                                data->syms);
791
      if (*data->relcount < 0)
792
        bfd_fatal (bfd_get_filename (abfd));
793
    }
794
 
795
  ++data->secs;
796
  ++data->relocs;
797
  ++data->relcount;
798
}
799
 
800
/* Print a single symbol.  */
801
 
802
static void
803
print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
804
{
805
  symbol_info syminfo;
806
  struct extended_symbol_info info;
807
 
808
  PROGRESS (1);
809
 
810
  format->print_symbol_filename (archive_bfd, abfd);
811
 
812
  bfd_get_symbol_info (abfd, sym, &syminfo);
813
  info.sinfo = &syminfo;
814
  info.ssize = ssize;
815
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
816
    info.elfinfo = (elf_symbol_type *) sym;
817
  else
818
    info.elfinfo = NULL;
819
  format->print_symbol_info (&info, abfd);
820
 
821
  if (line_numbers)
822
    {
823
      static asymbol **syms;
824
      static long symcount;
825
      const char *filename, *functionname;
826
      unsigned int lineno;
827
 
828
      /* We need to get the canonical symbols in order to call
829
         bfd_find_nearest_line.  This is inefficient, but, then, you
830
         don't have to use --line-numbers.  */
831
      if (abfd != lineno_cache_bfd && syms != NULL)
832
        {
833
          free (syms);
834
          syms = NULL;
835
        }
836
      if (syms == NULL)
837
        {
838
          long symsize;
839
 
840
          symsize = bfd_get_symtab_upper_bound (abfd);
841
          if (symsize < 0)
842
            bfd_fatal (bfd_get_filename (abfd));
843
          syms = (asymbol **) xmalloc (symsize);
844
          symcount = bfd_canonicalize_symtab (abfd, syms);
845
          if (symcount < 0)
846
            bfd_fatal (bfd_get_filename (abfd));
847
          lineno_cache_bfd = abfd;
848
        }
849
 
850
      if (bfd_is_und_section (bfd_get_section (sym)))
851
        {
852
          static asection **secs;
853
          static arelent ***relocs;
854
          static long *relcount;
855
          static unsigned int seccount;
856
          unsigned int i;
857
          const char *symname;
858
 
859
          /* For an undefined symbol, we try to find a reloc for the
860
             symbol, and print the line number of the reloc.  */
861
          if (abfd != lineno_cache_rel_bfd && relocs != NULL)
862
            {
863
              for (i = 0; i < seccount; i++)
864
                if (relocs[i] != NULL)
865
                  free (relocs[i]);
866
              free (secs);
867
              free (relocs);
868
              free (relcount);
869
              secs = NULL;
870
              relocs = NULL;
871
              relcount = NULL;
872
            }
873
 
874
          if (relocs == NULL)
875
            {
876
              struct get_relocs_info rinfo;
877
 
878
              seccount = bfd_count_sections (abfd);
879
 
880
              secs = (asection **) xmalloc (seccount * sizeof *secs);
881
              relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
882
              relcount = (long *) xmalloc (seccount * sizeof *relcount);
883
 
884
              rinfo.secs = secs;
885
              rinfo.relocs = relocs;
886
              rinfo.relcount = relcount;
887
              rinfo.syms = syms;
888
              bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
889
              lineno_cache_rel_bfd = abfd;
890
            }
891
 
892
          symname = bfd_asymbol_name (sym);
893
          for (i = 0; i < seccount; i++)
894
            {
895
              long j;
896
 
897
              for (j = 0; j < relcount[i]; j++)
898
                {
899
                  arelent *r;
900
 
901
                  r = relocs[i][j];
902
                  if (r->sym_ptr_ptr != NULL
903
                      && (*r->sym_ptr_ptr)->section == sym->section
904
                      && (*r->sym_ptr_ptr)->value == sym->value
905
                      && strcmp (symname,
906
                                 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
907
                      && bfd_find_nearest_line (abfd, secs[i], syms,
908
                                                r->address, &filename,
909
                                                &functionname, &lineno)
910
                      && filename != NULL)
911
                    {
912
                      /* We only print the first one we find.  */
913
                      printf ("\t%s:%u", filename, lineno);
914
                      i = seccount;
915
                      break;
916
                    }
917
                }
918
            }
919
        }
920
      else if (bfd_get_section (sym)->owner == abfd)
921
        {
922
          if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
923
               || bfd_find_nearest_line (abfd, bfd_get_section (sym),
924
                                         syms, sym->value, &filename,
925
                                         &functionname, &lineno))
926
              && filename != NULL
927
              && lineno != 0)
928
            printf ("\t%s:%u", filename, lineno);
929
        }
930
    }
931
 
932
  putchar ('\n');
933
}
934
 
935
/* Print the symbols when sorting by size.  */
936
 
937
static void
938
print_size_symbols (bfd *abfd, bfd_boolean is_dynamic,
939
                    struct size_sym *symsizes, long symcount,
940
                    bfd *archive_bfd)
941
{
942
  asymbol *store;
943
  struct size_sym *from, *fromend;
944
 
945
  store = bfd_make_empty_symbol (abfd);
946
  if (store == NULL)
947
    bfd_fatal (bfd_get_filename (abfd));
948
 
949
  from = symsizes;
950
  fromend = from + symcount;
951
  for (; from < fromend; from++)
952
    {
953
      asymbol *sym;
954
      bfd_vma ssize;
955
 
956
      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
957
      if (sym == NULL)
958
        bfd_fatal (bfd_get_filename (abfd));
959
 
960
      /* For elf we have already computed the correct symbol size.  */
961
      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
962
        ssize = from->size;
963
      else
964
        ssize = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
965
 
966
      print_symbol (abfd, sym, ssize, archive_bfd);
967
    }
968
}
969
 
970
 
971
/* Print the symbols.  If ARCHIVE_BFD is non-NULL, it is the archive
972
   containing ABFD.  */
973
 
974
static void
975
print_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms, long symcount,
976
               unsigned int size, bfd *archive_bfd)
977
{
978
  asymbol *store;
979
  bfd_byte *from, *fromend;
980
 
981
  store = bfd_make_empty_symbol (abfd);
982
  if (store == NULL)
983
    bfd_fatal (bfd_get_filename (abfd));
984
 
985
  from = (bfd_byte *) minisyms;
986
  fromend = from + symcount * size;
987
  for (; from < fromend; from += size)
988
    {
989
      asymbol *sym;
990
 
991
      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
992
      if (sym == NULL)
993
        bfd_fatal (bfd_get_filename (abfd));
994
 
995
      print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
996
    }
997
}
998
 
999
/* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
1000
 
1001
static void
1002
display_rel_file (bfd *abfd, bfd *archive_bfd)
1003
{
1004
  long symcount;
1005
  void *minisyms;
1006
  unsigned int size;
1007
  struct size_sym *symsizes;
1008
 
1009
  if (! dynamic)
1010
    {
1011
      if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1012
        {
1013
          non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1014
          return;
1015
        }
1016
    }
1017
 
1018
  symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1019
  if (symcount < 0)
1020
    bfd_fatal (bfd_get_filename (abfd));
1021
 
1022
  if (symcount == 0)
1023
    {
1024
      non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1025
      return;
1026
    }
1027
 
1028
  if (show_synthetic && size == sizeof (asymbol *))
1029
    {
1030
      asymbol *synthsyms;
1031
      long synth_count;
1032
      asymbol **static_syms = NULL;
1033
      asymbol **dyn_syms = NULL;
1034
      long static_count = 0;
1035
      long dyn_count = 0;
1036
 
1037
      if (dynamic)
1038
        {
1039
          dyn_count = symcount;
1040
          dyn_syms = (asymbol **) minisyms;
1041
        }
1042
      else
1043
        {
1044
          long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1045
 
1046
          static_count = symcount;
1047
          static_syms = (asymbol **) minisyms;
1048
 
1049
          if (storage > 0)
1050
            {
1051
              dyn_syms = (asymbol **) xmalloc (storage);
1052
              dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1053
              if (dyn_count < 0)
1054
                bfd_fatal (bfd_get_filename (abfd));
1055
            }
1056
        }
1057
      synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1058
                                              dyn_count, dyn_syms, &synthsyms);
1059
      if (synth_count > 0)
1060
        {
1061
          asymbol **symp;
1062
          void *new_mini;
1063
          long i;
1064
 
1065
          new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1066
          symp = (asymbol **) new_mini;
1067
          memcpy (symp, minisyms, symcount * sizeof (*symp));
1068
          symp += symcount;
1069
          for (i = 0; i < synth_count; i++)
1070
            *symp++ = synthsyms + i;
1071
          *symp = 0;
1072
          minisyms = new_mini;
1073
          symcount += synth_count;
1074
        }
1075
    }
1076
 
1077
  /* Discard the symbols we don't want to print.
1078
     It's OK to do this in place; we'll free the storage anyway
1079
     (after printing).  */
1080
 
1081
  symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1082
 
1083
  symsizes = NULL;
1084
  if (! no_sort)
1085
    {
1086
      sort_bfd = abfd;
1087
      sort_dynamic = dynamic;
1088
      sort_x = bfd_make_empty_symbol (abfd);
1089
      sort_y = bfd_make_empty_symbol (abfd);
1090
      if (sort_x == NULL || sort_y == NULL)
1091
        bfd_fatal (bfd_get_filename (abfd));
1092
 
1093
      if (! sort_by_size)
1094
        qsort (minisyms, symcount, size,
1095
               sorters[sort_numerically][reverse_sort]);
1096
      else
1097
        symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1098
                                         size, &symsizes);
1099
    }
1100
 
1101
  if (! sort_by_size)
1102
    print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1103
  else
1104
    print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1105
 
1106
  free (minisyms);
1107
  free (symsizes);
1108
}
1109
 
1110
static void
1111
set_print_width (bfd *file)
1112
{
1113
  print_width = bfd_get_arch_size (file);
1114
 
1115
  if (print_width == -1)
1116
    {
1117
      /* PR binutils/4292
1118
         Guess the target's bitsize based on its name.
1119
         We assume here than any 64-bit format will include
1120
         "64" somewhere in its name.  The only known exception
1121
         is the MMO object file format.  */
1122
      if (strstr (bfd_get_target (file), "64") != NULL
1123
          || strcmp (bfd_get_target (file), "mmo") == 0)
1124
        print_width = 64;
1125
      else
1126
        print_width = 32;
1127
    }
1128
}
1129
 
1130
static void
1131
display_archive (bfd *file)
1132
{
1133
  bfd *arfile = NULL;
1134
  bfd *last_arfile = NULL;
1135
  char **matching;
1136
 
1137
  format->print_archive_filename (bfd_get_filename (file));
1138
 
1139
  if (print_armap)
1140
    print_symdef_entry (file);
1141
 
1142
  for (;;)
1143
    {
1144
      PROGRESS (1);
1145
 
1146
      arfile = bfd_openr_next_archived_file (file, arfile);
1147
 
1148
      if (arfile == NULL)
1149
        {
1150
          if (bfd_get_error () != bfd_error_no_more_archived_files)
1151
            bfd_fatal (bfd_get_filename (file));
1152
          break;
1153
        }
1154
 
1155
      if (bfd_check_format_matches (arfile, bfd_object, &matching))
1156
        {
1157
          set_print_width (arfile);
1158
          format->print_archive_member (bfd_get_filename (file),
1159
                                        bfd_get_filename (arfile));
1160
          display_rel_file (arfile, file);
1161
        }
1162
      else
1163
        {
1164
          bfd_nonfatal (bfd_get_filename (arfile));
1165
          if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1166
            {
1167
              list_matching_formats (matching);
1168
              free (matching);
1169
            }
1170
        }
1171
 
1172
      if (last_arfile != NULL)
1173
        {
1174
          bfd_close (last_arfile);
1175
          lineno_cache_bfd = NULL;
1176
          lineno_cache_rel_bfd = NULL;
1177
        }
1178
      last_arfile = arfile;
1179
    }
1180
 
1181
  if (last_arfile != NULL)
1182
    {
1183
      bfd_close (last_arfile);
1184
      lineno_cache_bfd = NULL;
1185
      lineno_cache_rel_bfd = NULL;
1186
    }
1187
}
1188
 
1189
static bfd_boolean
1190
display_file (char *filename)
1191
{
1192
  bfd_boolean retval = TRUE;
1193
  bfd *file;
1194
  char **matching;
1195
 
1196
  if (get_file_size (filename) < 1)
1197
    return FALSE;
1198
 
1199
  file = bfd_openr (filename, target ? target : plugin_target);
1200
  if (file == NULL)
1201
    {
1202
      bfd_nonfatal (filename);
1203
      return FALSE;
1204
    }
1205
 
1206 161 khays
  /* If printing line numbers, decompress the debug sections.  */
1207
  if (line_numbers)
1208
    file->flags |= BFD_DECOMPRESS;
1209
 
1210 15 khays
  if (bfd_check_format (file, bfd_archive))
1211
    {
1212
      display_archive (file);
1213
    }
1214
  else if (bfd_check_format_matches (file, bfd_object, &matching))
1215
    {
1216
      set_print_width (file);
1217
      format->print_object_filename (filename);
1218
      display_rel_file (file, NULL);
1219
    }
1220
  else
1221
    {
1222
      bfd_nonfatal (filename);
1223
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1224
        {
1225
          list_matching_formats (matching);
1226
          free (matching);
1227
        }
1228
      retval = FALSE;
1229
    }
1230
 
1231
  if (!bfd_close (file))
1232
    bfd_fatal (filename);
1233
 
1234
  lineno_cache_bfd = NULL;
1235
  lineno_cache_rel_bfd = NULL;
1236
 
1237
  return retval;
1238
}
1239
 
1240
/* The following 3 groups of functions are called unconditionally,
1241
   once at the start of processing each file of the appropriate type.
1242
   They should check `filename_per_file' and `filename_per_symbol',
1243
   as appropriate for their output format, to determine whether to
1244
   print anything.  */
1245
 
1246
/* Print the name of an object file given on the command line.  */
1247
 
1248
static void
1249
print_object_filename_bsd (char *filename)
1250
{
1251
  if (filename_per_file && !filename_per_symbol)
1252
    printf ("\n%s:\n", filename);
1253
}
1254
 
1255
static void
1256
print_object_filename_sysv (char *filename)
1257
{
1258
  if (undefined_only)
1259
    printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1260
  else
1261
    printf (_("\n\nSymbols from %s:\n\n"), filename);
1262
  if (print_width == 32)
1263
    printf (_("\
1264
Name                  Value   Class        Type         Size     Line  Section\n\n"));
1265
  else
1266
    printf (_("\
1267
Name                  Value           Class        Type         Size             Line  Section\n\n"));
1268
}
1269
 
1270
static void
1271
print_object_filename_posix (char *filename)
1272
{
1273
  if (filename_per_file && !filename_per_symbol)
1274
    printf ("%s:\n", filename);
1275
}
1276
 
1277
/* Print the name of an archive file given on the command line.  */
1278
 
1279
static void
1280
print_archive_filename_bsd (char *filename)
1281
{
1282
  if (filename_per_file)
1283
    printf ("\n%s:\n", filename);
1284
}
1285
 
1286
static void
1287
print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1288
{
1289
}
1290
 
1291
static void
1292
print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1293
{
1294
}
1295
 
1296
/* Print the name of an archive member file.  */
1297
 
1298
static void
1299
print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1300
                          const char *filename)
1301
{
1302
  if (!filename_per_symbol)
1303
    printf ("\n%s:\n", filename);
1304
}
1305
 
1306
static void
1307
print_archive_member_sysv (char *archive, const char *filename)
1308
{
1309
  if (undefined_only)
1310
    printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1311
  else
1312
    printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1313
  if (print_width == 32)
1314
    printf (_("\
1315
Name                  Value   Class        Type         Size     Line  Section\n\n"));
1316
  else
1317
    printf (_("\
1318
Name                  Value           Class        Type         Size             Line  Section\n\n"));
1319
}
1320
 
1321
static void
1322
print_archive_member_posix (char *archive, const char *filename)
1323
{
1324
  if (!filename_per_symbol)
1325
    printf ("%s[%s]:\n", archive, filename);
1326
}
1327
 
1328
/* Print the name of the file (and archive, if there is one)
1329
   containing a symbol.  */
1330
 
1331
static void
1332
print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1333
{
1334
  if (filename_per_symbol)
1335
    {
1336
      if (archive_bfd)
1337
        printf ("%s:", bfd_get_filename (archive_bfd));
1338
      printf ("%s:", bfd_get_filename (abfd));
1339
    }
1340
}
1341
 
1342
static void
1343
print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1344
{
1345
  if (filename_per_symbol)
1346
    {
1347
      if (archive_bfd)
1348
        printf ("%s:", bfd_get_filename (archive_bfd));
1349
      printf ("%s:", bfd_get_filename (abfd));
1350
    }
1351
}
1352
 
1353
static void
1354
print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1355
{
1356
  if (filename_per_symbol)
1357
    {
1358
      if (archive_bfd)
1359
        printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1360
                bfd_get_filename (abfd));
1361
      else
1362
        printf ("%s: ", bfd_get_filename (abfd));
1363
    }
1364
}
1365
 
1366
/* Print a symbol value.  */
1367
 
1368
static void
1369
print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1370
{
1371
  switch (print_width)
1372
    {
1373
    case 32:
1374
      printf (value_format_32bit, (unsigned long) val);
1375
      break;
1376
 
1377
    case 64:
1378
#if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1379
      printf (value_format_64bit, val);
1380
#else
1381
      /* We have a 64 bit value to print, but the host is only 32 bit.  */
1382
      if (print_radix == 16)
1383
        bfd_fprintf_vma (abfd, stdout, val);
1384
      else
1385
        {
1386
          char buf[30];
1387
          char *s;
1388
 
1389
          s = buf + sizeof buf;
1390
          *--s = '\0';
1391
          while (val > 0)
1392
            {
1393
              *--s = (val % print_radix) + '0';
1394
              val /= print_radix;
1395
            }
1396
          while ((buf + sizeof buf - 1) - s < 16)
1397
            *--s = '0';
1398
          printf ("%s", s);
1399
        }
1400
#endif
1401
      break;
1402
 
1403
    default:
1404
      fatal (_("Print width has not been initialized (%d)"), print_width);
1405
      break;
1406
    }
1407
}
1408
 
1409
/* Print a line of information about a symbol.  */
1410
 
1411
static void
1412
print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1413
{
1414
  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1415
    {
1416
      if (print_width == 64)
1417
        printf ("        ");
1418
      printf ("        ");
1419
    }
1420
  else
1421
    {
1422
      /* Normally we print the value of the symbol.  If we are printing the
1423
         size or sorting by size then we print its size, except for the
1424
         (weird) special case where both flags are defined, in which case we
1425
         print both values.  This conforms to documented behaviour.  */
1426
      if (sort_by_size && !print_size)
1427
        print_value (abfd, SYM_SIZE (info));
1428
      else
1429
        print_value (abfd, SYM_VALUE (info));
1430
 
1431
      if (print_size && SYM_SIZE (info))
1432
        {
1433
          printf (" ");
1434
          print_value (abfd, SYM_SIZE (info));
1435
        }
1436
    }
1437
 
1438
  printf (" %c", SYM_TYPE (info));
1439
 
1440
  if (SYM_TYPE (info) == '-')
1441
    {
1442
      /* A stab.  */
1443
      printf (" ");
1444
      printf (other_format, SYM_STAB_OTHER (info));
1445
      printf (" ");
1446
      printf (desc_format, SYM_STAB_DESC (info));
1447
      printf (" %5s", SYM_STAB_NAME (info));
1448
    }
1449
  print_symname (" %s", SYM_NAME (info), abfd);
1450
}
1451
 
1452
static void
1453
print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1454
{
1455
  print_symname ("%-20s|", SYM_NAME (info), abfd);
1456
 
1457
  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1458
    {
1459
      if (print_width == 32)
1460
        printf ("        ");
1461
      else
1462
        printf ("                ");
1463
    }
1464
  else
1465
    print_value (abfd, SYM_VALUE (info));
1466
 
1467
  printf ("|   %c  |", SYM_TYPE (info));
1468
 
1469
  if (SYM_TYPE (info) == '-')
1470
    {
1471
      /* A stab.  */
1472
      printf ("%18s|  ", SYM_STAB_NAME (info));         /* (C) Type.  */
1473
      printf (desc_format, SYM_STAB_DESC (info));       /* Size.  */
1474
      printf ("|     |");                               /* Line, Section.  */
1475
    }
1476
  else
1477
    {
1478
      /* Type, Size, Line, Section */
1479
      if (info->elfinfo)
1480
        printf ("%18s|",
1481
                get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1482
      else
1483
        printf ("                  |");
1484
 
1485
      if (SYM_SIZE (info))
1486
        print_value (abfd, SYM_SIZE (info));
1487
      else
1488
        {
1489
          if (print_width == 32)
1490
            printf ("        ");
1491
          else
1492
            printf ("                ");
1493
        }
1494
 
1495
      if (info->elfinfo)
1496
        printf("|     |%s", info->elfinfo->symbol.section->name);
1497
      else
1498
        printf("|     |");
1499
    }
1500
}
1501
 
1502
static void
1503
print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1504
{
1505
  print_symname ("%s ", SYM_NAME (info), abfd);
1506
  printf ("%c ", SYM_TYPE (info));
1507
 
1508
  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1509
    printf ("        ");
1510
  else
1511
    {
1512
      print_value (abfd, SYM_VALUE (info));
1513
      printf (" ");
1514
      if (SYM_SIZE (info))
1515
        print_value (abfd, SYM_SIZE (info));
1516
    }
1517
}
1518
 
1519
int
1520
main (int argc, char **argv)
1521
{
1522
  int c;
1523
  int retval;
1524
 
1525
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1526
  setlocale (LC_MESSAGES, "");
1527
#endif
1528
#if defined (HAVE_SETLOCALE)
1529
  setlocale (LC_CTYPE, "");
1530
  setlocale (LC_COLLATE, "");
1531
#endif
1532
  bindtextdomain (PACKAGE, LOCALEDIR);
1533
  textdomain (PACKAGE);
1534
 
1535
  program_name = *argv;
1536
  xmalloc_set_program_name (program_name);
1537
#if BFD_SUPPORTS_PLUGINS
1538
  bfd_plugin_set_program_name (program_name);
1539
#endif
1540
 
1541
  START_PROGRESS (program_name, 0);
1542
 
1543
  expandargv (&argc, &argv);
1544
 
1545
  bfd_init ();
1546
  set_default_bfd_target ();
1547
 
1548
  while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1549
                           long_options, (int *) 0)) != EOF)
1550
    {
1551
      switch (c)
1552
        {
1553
        case 'a':
1554
          print_debug_syms = 1;
1555
          break;
1556
        case 'A':
1557
        case 'o':
1558
          filename_per_symbol = 1;
1559
          break;
1560
        case 'B':               /* For MIPS compatibility.  */
1561
          set_output_format ("bsd");
1562
          break;
1563
        case 'C':
1564
          do_demangle = 1;
1565
          if (optarg != NULL)
1566
            {
1567
              enum demangling_styles style;
1568
 
1569
              style = cplus_demangle_name_to_style (optarg);
1570
              if (style == unknown_demangling)
1571
                fatal (_("unknown demangling style `%s'"),
1572
                       optarg);
1573
 
1574
              cplus_demangle_set_style (style);
1575
            }
1576
          break;
1577
        case 'D':
1578
          dynamic = 1;
1579
          break;
1580
        case 'e':
1581
          /* Ignored for HP/UX compatibility.  */
1582
          break;
1583
        case 'f':
1584
          set_output_format (optarg);
1585
          break;
1586
        case 'g':
1587
          external_only = 1;
1588
          break;
1589
        case 'H':
1590
        case 'h':
1591
          usage (stdout, 0);
1592
        case 'l':
1593
          line_numbers = 1;
1594
          break;
1595
        case 'n':
1596
        case 'v':
1597 166 khays
          no_sort = 0;
1598 15 khays
          sort_numerically = 1;
1599 166 khays
          sort_by_size = 0;
1600 15 khays
          break;
1601
        case 'p':
1602
          no_sort = 1;
1603 166 khays
          sort_numerically = 0;
1604
          sort_by_size = 0;
1605 15 khays
          break;
1606 166 khays
        case OPTION_SIZE_SORT:
1607
          no_sort = 0;
1608
          sort_numerically = 0;
1609
          sort_by_size = 1;
1610
          break;
1611 15 khays
        case 'P':
1612
          set_output_format ("posix");
1613
          break;
1614
        case 'r':
1615
          reverse_sort = 1;
1616
          break;
1617
        case 's':
1618
          print_armap = 1;
1619
          break;
1620
        case 'S':
1621
          print_size = 1;
1622
          break;
1623
        case 't':
1624
          set_print_radix (optarg);
1625
          break;
1626
        case 'u':
1627
          undefined_only = 1;
1628
          break;
1629
        case 'V':
1630
          show_version = 1;
1631
          break;
1632
        case 'X':
1633
          /* Ignored for (partial) AIX compatibility.  On AIX, the
1634
             argument has values 32, 64, or 32_64, and specifies that
1635
             only 32-bit, only 64-bit, or both kinds of objects should
1636
             be examined.  The default is 32.  So plain AIX nm on a
1637
             library archive with both kinds of objects will ignore
1638
             the 64-bit ones.  For GNU nm, the default is and always
1639
             has been -X 32_64, and other options are not supported.  */
1640
          if (strcmp (optarg, "32_64") != 0)
1641
            fatal (_("Only -X 32_64 is supported"));
1642
          break;
1643
 
1644
        case OPTION_TARGET:     /* --target */
1645
          target = optarg;
1646
          break;
1647
 
1648
        case OPTION_PLUGIN:     /* --plugin */
1649
#if BFD_SUPPORTS_PLUGINS
1650
          plugin_target = "plugin";
1651
          bfd_plugin_set_plugin (optarg);
1652
#else
1653
          fatal (_("sorry - this program has been built without plugin support\n"));
1654
#endif
1655
          break;
1656
 
1657
        case 0:          /* A long option that just sets a flag.  */
1658
          break;
1659
 
1660
        default:
1661
          usage (stderr, 1);
1662
        }
1663
    }
1664
 
1665
  if (show_version)
1666
    print_version ("nm");
1667
 
1668
  if (sort_by_size && undefined_only)
1669
    {
1670
      non_fatal (_("Using the --size-sort and --undefined-only options together"));
1671
      non_fatal (_("will produce no output, since undefined symbols have no size."));
1672
      return 0;
1673
    }
1674
 
1675
  /* OK, all options now parsed.  If no filename specified, do a.out.  */
1676
  if (optind == argc)
1677
    return !display_file ("a.out");
1678
 
1679
  retval = 0;
1680
 
1681
  if (argc - optind > 1)
1682
    filename_per_file = 1;
1683
 
1684
  /* We were given several filenames to do.  */
1685
  while (optind < argc)
1686
    {
1687
      PROGRESS (1);
1688
      if (!display_file (argv[optind++]))
1689
        retval++;
1690
    }
1691
 
1692
  END_PROGRESS (program_name);
1693
 
1694
#ifdef HAVE_SBRK
1695
  if (show_stats)
1696
    {
1697
      char *lim = (char *) sbrk (0);
1698
 
1699
      non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
1700
    }
1701
#endif
1702
 
1703
  exit (retval);
1704
  return retval;
1705
}

powered by: WebSVN 2.1.0

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