binutils/nm.c

   1 /* nm.c -- Describe symbol table of a rel file.
   2    Copyright 1991, 92, 93, 94 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "bucomm.h"
  23 #include "getopt.h"
  24 #include "aout/stab_gnu.h"
  25 #include "aout/ranlib.h"
  26 #include "demangle.h"
  27
  28 static boolean
  29 display_file PARAMS ((char *filename));
  30
  31 static void
  32 display_rel_file PARAMS ((bfd * file, bfd * archive));
  33
  34 static unsigned int
  35 filter_symbols PARAMS ((bfd * file, asymbol ** syms, unsigned long symcount));
  36
  37 static void
  38 print_symbols PARAMS ((bfd * file, asymbol ** syms, unsigned long symcount,
  39                        bfd * archive));
  40
  41 static void
  42 print_symdef_entry PARAMS ((bfd * abfd));
  43
  44
  45 /* The output formatting functions.  */
  46
  47 static void
  48 print_object_filename_bsd PARAMS ((char *filename));
  49
  50 static void
  51 print_object_filename_sysv PARAMS ((char *filename));
  52
  53 static void
  54 print_object_filename_posix PARAMS ((char *filename));
  55
  56
  57 static void
  58 print_archive_filename_bsd PARAMS ((char *filename));
  59
  60 static void
  61 print_archive_filename_sysv PARAMS ((char *filename));
  62
  63 static void
  64 print_archive_filename_posix PARAMS ((char *filename));
  65
  66
  67 static void
  68 print_archive_member_bsd PARAMS ((char *archive, CONST char *filename));
  69
  70 static void
  71 print_archive_member_sysv PARAMS ((char *archive, CONST char *filename));
  72
  73 static void
  74 print_archive_member_posix PARAMS ((char *archive, CONST char *filename));
  75
  76
  77 static void
  78 print_symbol_filename_bsd PARAMS ((bfd * archive_bfd, bfd * abfd));
  79
  80 static void
  81 print_symbol_filename_sysv PARAMS ((bfd * archive_bfd, bfd * abfd));
  82
  83 static void
  84 print_symbol_filename_posix PARAMS ((bfd * archive_bfd, bfd * abfd));
  85
  86
  87 static void
  88 print_symbol_info_bsd PARAMS ((symbol_info * info, bfd * abfd));
  89
  90 static void
  91 print_symbol_info_sysv PARAMS ((symbol_info * info, bfd * abfd));
  92
  93 static void
  94 print_symbol_info_posix PARAMS ((symbol_info * info, bfd * abfd));
  95
  96
  97 /* Support for different output formats.  */
  98 struct output_fns
  99   {
 100     /* Print the name of an object file given on the command line.  */
 101     void (*print_object_filename) PARAMS ((char *filename));
 102
 103     /* Print the name of an archive file given on the command line.  */
 104     void (*print_archive_filename) PARAMS ((char *filename));
 105
 106     /* Print the name of an archive member file.  */
 107     void (*print_archive_member) PARAMS ((char *archive, CONST char *filename));
 108
 109     /* Print the name of the file (and archive, if there is one)
 110        containing a symbol.  */
 111     void (*print_symbol_filename) PARAMS ((bfd * archive_bfd, bfd * abfd));
 112
 113     /* Print a line of information about a symbol.  */
 114     void (*print_symbol_info) PARAMS ((symbol_info * info, bfd * abfd));
 115   };
 116 static struct output_fns formats[] =
 117 {
 118   {print_object_filename_bsd,
 119    print_archive_filename_bsd,
 120    print_archive_member_bsd,
 121    print_symbol_filename_bsd,
 122    print_symbol_info_bsd},
 123   {print_object_filename_sysv,
 124    print_archive_filename_sysv,
 125    print_archive_member_sysv,
 126    print_symbol_filename_sysv,
 127    print_symbol_info_sysv},
 128   {print_object_filename_posix,
 129    print_archive_filename_posix,
 130    print_archive_member_posix,
 131    print_symbol_filename_posix,
 132    print_symbol_info_posix}
 133 };
 134
 135 /* Indices in `formats'.  */
 136 #define FORMAT_BSD 0
 137 #define FORMAT_SYSV 1
 138 #define FORMAT_POSIX 2
 139 #define FORMAT_DEFAULT FORMAT_BSD
 140
 141 /* The output format to use.  */
 142 static struct output_fns *format = &formats[FORMAT_DEFAULT];
 143
 144
 145 /* Command options.  */
 146
 147 static int do_demangle = 0;     /* Pretty print C++ symbol names.  */
 148 static int external_only = 0;   /* print external symbols only */
 149 static int no_sort = 0;         /* don't sort; print syms in order found */
 150 static int print_debug_syms = 0;        /* print debugger-only symbols too */
 151 static int print_armap = 0;     /* describe __.SYMDEF data in archive files.  */
 152 static int reverse_sort = 0;    /* sort in downward(alpha or numeric) order */
 153 static int sort_numerically = 0;        /* sort in numeric rather than alpha order */
 154 static int undefined_only = 0;  /* print undefined symbols only */
 155 static int show_version = 0;    /* show the version number */
 156
 157 /* When to print the names of files.  Not mutually exclusive in SYSV format.  */
 158 static int filename_per_file = 0;       /* Once per file, on its own line.  */
 159 static int filename_per_symbol = 0;     /* Once per symbol, at start of line.  */
 160
 161 /* Print formats for printing a symbol value.  */
 162 #ifdef  HOST_64_BIT
 163 static char value_format[] = "%08x%08x";
 164 #else
 165 static char value_format[] = "%08lx";
 166 #endif
 167 /* Print formats for printing stab info.  */
 168 static char other_format[] = "%02x";
 169 static char desc_format[] = "%04x";
 170
 171 /* IMPORT */
 172 extern char *program_name;
 173 extern char *program_version;
 174 extern char *target;
 175 extern int print_version;
 176
 177 static struct option long_options[] =
 178 {
 179   {"debug-syms", no_argument, &print_debug_syms, 1},
 180   {"demangle", no_argument, &do_demangle, 1},
 181   {"extern-only", no_argument, &external_only, 1},
 182   {"format", required_argument, 0, 'f'},
 183   {"help", no_argument, 0, 'h'},
 184   {"no-sort", no_argument, &no_sort, 1},
 185   {"numeric-sort", no_argument, &sort_numerically, 1},
 186   {"portability", no_argument, 0, 'P'},
 187   {"print-armap", no_argument, &print_armap, 1},
 188   {"print-file-name", no_argument, 0, 'o'},
 189   {"radix", required_argument, 0, 't'},
 190   {"reverse-sort", no_argument, &reverse_sort, 1},
 191   {"target", required_argument, 0, 200},
 192   {"undefined-only", no_argument, &undefined_only, 1},
 193   {"version", no_argument, &show_version, 1},
 194   {0, no_argument, 0, 0}
 195 };
 196 \f
 197 /* Some error-reporting functions */
 198
 199 void
 200 usage (stream, status)
 201      FILE *stream;
 202      int status;
 203 {
 204   fprintf (stream, "\
 205 Usage: %s [-aABCgnopPrsuvV] [-t radix] [--radix=radix] [--target=bfdname]\n\
 206        [--debug-syms] [--extern-only] [--print-armap] [--print-file-name]\n\
 207        [--numeric-sort] [--no-sort] [--reverse-sort] [--undefined-only]\n\
 208        [--portability] [-f {bsd,sysv,posix}] [--format={bsd,sysv,posix}]\n\
 209        [--demangle] [--version] [--help] [file...]\n",
 210            program_name);
 211   exit (status);
 212 }
 213
 214 /* Set the radix for the symbol value and size according to RADIX.  */
 215
 216 void
 217 set_print_radix (radix)
 218      char *radix;
 219 {
 220   switch (*radix)
 221     {
 222     case 'd':
 223     case 'o':
 224     case 'x':
 225 #ifdef  HOST_64_BIT
 226       value_format[3] = value_format[7] = *radix;
 227 #else
 228       value_format[4] = *radix;
 229 #endif
 230       other_format[3] = desc_format[3] = *radix;
 231       break;
 232     default:
 233       fprintf (stderr, "%s: %s: invalid radix\n", program_name, radix);
 234       exit (1);
 235     }
 236 }
 237
 238 void
 239 set_output_format (f)
 240      char *f;
 241 {
 242   int i;
 243
 244   switch (*f)
 245     {
 246     case 'b':
 247     case 'B':
 248       i = FORMAT_BSD;
 249       break;
 250     case 'p':
 251     case 'P':
 252       i = FORMAT_POSIX;
 253       break;
 254     case 's':
 255     case 'S':
 256       i = FORMAT_SYSV;
 257       break;
 258     default:
 259       fprintf (stderr, "%s: %s: invalid output format\n", program_name, f);
 260       exit (1);
 261     }
 262   format = &formats[i];
 263 }
 264 \f
 265 int
 266 main (argc, argv)
 267      int argc;
 268      char **argv;
 269 {
 270   int c;
 271   int retval;
 272
 273   program_name = *argv;
 274
 275   bfd_init ();
 276
 277   while ((c = getopt_long (argc, argv, "aABCf:gnopPrst:uvV", long_options, (int *) 0)) != EOF)
 278     {
 279       switch (c)
 280         {
 281         case 'a':
 282           print_debug_syms = 1;
 283           break;
 284         case 'A':
 285         case 'o':
 286           filename_per_symbol = 1;
 287           break;
 288         case 'B':               /* For MIPS compatibility.  */
 289           set_output_format ("bsd");
 290           break;
 291         case 'C':
 292           do_demangle = 1;
 293           break;
 294         case 'f':
 295           set_output_format (optarg);
 296           break;
 297         case 'g':
 298           external_only = 1;
 299           break;
 300         case 'h':
 301           usage (stdout, 0);
 302         case 'n':
 303         case 'v':
 304           sort_numerically = 1;
 305           break;
 306         case 'p':
 307           no_sort = 1;
 308           break;
 309         case 'P':
 310           set_output_format ("posix");
 311           break;
 312         case 'r':
 313           reverse_sort = 1;
 314           break;
 315         case 's':
 316           print_armap = 1;
 317           break;
 318         case 't':
 319           set_print_radix (optarg);
 320           break;
 321         case 'u':
 322           undefined_only = 1;
 323           break;
 324         case 'V':
 325           show_version = 1;
 326           break;
 327
 328         case 200:               /* --target */
 329           target = optarg;
 330           break;
 331
 332         case 0:         /* A long option that just sets a flag.  */
 333           break;
 334
 335         default:
 336           usage (stderr, 1);
 337         }
 338     }
 339
 340   if (show_version)
 341     {
 342       printf ("GNU %s version %s\n", program_name, program_version);
 343       exit (0);
 344     }
 345
 346   /* OK, all options now parsed.  If no filename specified, do a.out.  */
 347   if (optind == argc)
 348     return !display_file ("a.out");
 349
 350   retval = 0;
 351
 352   if (argc - optind > 1)
 353     filename_per_file = 1;
 354
 355   /* We were given several filenames to do.  */
 356   while (optind < argc)
 357     {
 358       if (!display_file (argv[optind++]))
 359         retval++;
 360     }
 361
 362   exit (retval);
 363   return retval;
 364 }
 365 \f
 366 static void
 367 display_archive (file)
 368      bfd *file;
 369 {
 370   bfd *arfile = NULL;
 371   char **matching;
 372
 373   (*format->print_archive_filename) (bfd_get_filename (file));
 374
 375   if (print_armap)
 376     print_symdef_entry (file);
 377
 378   for (;;)
 379     {
 380       arfile = bfd_openr_next_archived_file (file, arfile);
 381
 382       if (arfile == NULL)
 383         {
 384           if (bfd_error != no_more_archived_files)
 385             bfd_fatal (bfd_get_filename (file));
 386           break;
 387         }
 388
 389       if (bfd_check_format_matches (arfile, bfd_object, &matching))
 390         {
 391           (*format->print_archive_member) (bfd_get_filename (file),
 392                                            bfd_get_filename (arfile));
 393           display_rel_file (arfile, file);
 394         }
 395       else
 396         {
 397           bfd_nonfatal (bfd_get_filename (arfile));
 398           if (bfd_error == file_ambiguously_recognized)
 399             {
 400               list_matching_formats (matching);
 401               free (matching);
 402             }
 403         }
 404     }
 405 }
 406
 407 static boolean
 408 display_file (filename)
 409      char *filename;
 410 {
 411   boolean retval = true;
 412   bfd *file;
 413   char **matching;
 414
 415   file = bfd_openr (filename, target);
 416   if (file == NULL)
 417     {
 418       bfd_nonfatal (filename);
 419       return false;
 420     }
 421
 422   if (bfd_check_format (file, bfd_archive))
 423     {
 424       display_archive (file);
 425     }
 426   else if (bfd_check_format_matches (file, bfd_object, &matching))
 427     {
 428       (*format->print_object_filename) (filename);
 429       display_rel_file (file, NULL);
 430     }
 431   else
 432     {
 433       bfd_nonfatal (filename);
 434       if (bfd_error == file_ambiguously_recognized)
 435         {
 436           list_matching_formats (matching);
 437           free (matching);
 438         }
 439       retval = false;
 440     }
 441
 442   if (bfd_close (file) == false)
 443     bfd_fatal (filename);
 444
 445   return retval;
 446 }
 447 \f
 448 /* Symbol-sorting predicates */
 449 #define valueof(x) ((x)->section->vma + (x)->value)
 450 int
 451 numeric_forward (x, y)
 452      CONST void *x;
 453      CONST void *y;
 454 {
 455   return (valueof (*(asymbol **) x) - valueof (*(asymbol **) y));
 456 }
 457
 458 int
 459 numeric_reverse (x, y)
 460      CONST void *x;
 461      CONST void *y;
 462 {
 463   return (valueof (*(asymbol **) y) - valueof (*(asymbol **) x));
 464 }
 465
 466 int
 467 non_numeric_forward (x, y)
 468      CONST void *x;
 469      CONST void *y;
 470 {
 471   CONST char *xn = (*(asymbol **) x)->name;
 472   CONST char *yn = (*(asymbol **) y)->name;
 473
 474   return ((xn == NULL) ? ((yn == NULL) ? 0 : -1) :
 475           ((yn == NULL) ? 1 : strcmp (xn, yn)));
 476 }
 477
 478 int
 479 non_numeric_reverse (x, y)
 480      CONST void *x;
 481      CONST void *y;
 482 {
 483   return -(non_numeric_forward (x, y));
 484 }
 485
 486 static int (*(sorters[2][2])) PARAMS ((CONST void *, CONST void *)) =
 487 {
 488   { non_numeric_forward, non_numeric_reverse },
 489   { numeric_forward, numeric_reverse }
 490 };
 491 \f
 492 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
 493
 494 static void
 495 display_rel_file (abfd, archive_bfd)
 496      bfd *abfd;
 497      bfd *archive_bfd;
 498 {
 499   unsigned int storage;
 500   asymbol **syms;
 501   unsigned int symcount = 0;
 502
 503   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 504     {
 505       printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
 506       return;
 507     }
 508
 509   storage = get_symtab_upper_bound (abfd);
 510   if (storage == 0)
 511     {
 512     nosymz:
 513       fprintf (stderr, "%s: Symflags set but there are none?\n",
 514                bfd_get_filename (abfd));
 515       return;
 516     }
 517
 518   syms = (asymbol **) xmalloc (storage);
 519
 520   symcount = bfd_canonicalize_symtab (abfd, syms);
 521   if (symcount == 0)
 522     {
 523       free (syms);
 524       goto nosymz;
 525     }
 526
 527   /* Discard the symbols we don't want to print.
 528      It's OK to do this in place; we'll free the storage anyway
 529      (after printing).  */
 530
 531   symcount = filter_symbols (abfd, syms, symcount);
 532
 533   if (!no_sort)
 534     qsort ((char *) syms, symcount, sizeof (asymbol *),
 535            sorters[sort_numerically][reverse_sort]);
 536
 537   print_symbols (abfd, syms, symcount, archive_bfd);
 538   free (syms);
 539 }
 540 \f
 541 /* Choose which symbol entries to print;
 542    compact them downward to get rid of the rest.
 543    Return the number of symbols to be printed.  */
 544
 545 static unsigned int
 546 filter_symbols (abfd, syms, symcount)
 547      bfd *abfd;                 /* Unused.  */
 548      asymbol **syms;
 549      unsigned long symcount;
 550 {
 551   asymbol **from, **to;
 552   unsigned int src_count;
 553   unsigned int dst_count = 0;
 554   asymbol *sym;
 555
 556   for (from = to = syms, src_count = 0; src_count < symcount; src_count++)
 557     {
 558       int keep = 0;
 559       flagword flags = (from[src_count])->flags;
 560
 561       sym = from[src_count];
 562       if (undefined_only)
 563         keep = sym->section == &bfd_und_section;
 564       else if (external_only)
 565         keep = ((flags & BSF_GLOBAL)
 566                 || (sym->section == &bfd_und_section)
 567                 || (bfd_is_com_section (sym->section)));
 568       else
 569         keep = 1;
 570
 571       if (!print_debug_syms && ((flags & BSF_DEBUGGING) != 0))
 572         keep = 0;
 573
 574       if (keep)
 575         to[dst_count++] = from[src_count];
 576     }
 577
 578   return dst_count;
 579 }
 580 \f
 581 /* Print symbol name NAME, read from ABFD, with printf format FORMAT,
 582    demangling it if requested.  */
 583
 584 static void
 585 print_symname (format, name, abfd)
 586      char *format, *name;
 587      bfd *abfd;
 588 {
 589   if (do_demangle)
 590     {
 591       char *res;
 592
 593       /* In this mode, give a user-level view of the symbol name
 594          even if it's not mangled; strip off any leading
 595          underscore.  */
 596       if (bfd_get_symbol_leading_char (abfd) == name[0])
 597         name++;
 598
 599       res = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
 600       if (res)
 601         {
 602           printf (format, res);
 603           free (res);
 604           return;
 605         }
 606     }
 607
 608   printf (format, name);
 609 }
 610
 611 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
 612
 613 static void
 614 print_symbols (abfd, syms, symcount, archive_bfd)
 615      bfd *abfd;
 616      asymbol **syms;
 617      unsigned long symcount;
 618      bfd *archive_bfd;
 619 {
 620   asymbol **sym = syms, **end = syms + symcount;
 621   symbol_info syminfo;
 622
 623   for (; sym < end; ++sym)
 624     {
 625       (*format->print_symbol_filename) (archive_bfd, abfd);
 626
 627       if (undefined_only)
 628         {
 629           if ((*sym)->section == &bfd_und_section)
 630             {
 631               print_symname ("%s\n", (*sym)->name, abfd);
 632             }
 633         }
 634       else
 635         {
 636           asymbol *p = *sym;
 637           if (p)
 638             {
 639               bfd_get_symbol_info (abfd, p, &syminfo);
 640               (*format->print_symbol_info) (&syminfo, abfd);
 641               putchar ('\n');
 642             }
 643         }
 644     }
 645 }
 646 \f
 647 /* The following 3 groups of functions are called unconditionally,
 648    once at the start of processing each file of the appropriate type.
 649    They should check `filename_per_file' and `filename_per_symbol',
 650    as appropriate for their output format, to determine whether to
 651    print anything.  */
 652 \f
 653 /* Print the name of an object file given on the command line.  */
 654
 655 static void
 656 print_object_filename_bsd (filename)
 657      char *filename;
 658 {
 659   if (filename_per_file && !filename_per_symbol)
 660     printf ("\n%s:\n", filename);
 661 }
 662
 663 static void
 664 print_object_filename_sysv (filename)
 665      char *filename;
 666 {
 667   if (undefined_only)
 668     printf ("\n\nUndefined symbols from %s:\n\n", filename);
 669   else
 670     printf ("\n\nSymbols from %s:\n\n", filename);
 671   printf ("\
 672 Name                  Value   Class        Type         Size   Line  Section\n\n");
 673 }
 674
 675 static void
 676 print_object_filename_posix (filename)
 677      char *filename;
 678 {
 679   if (filename_per_file && !filename_per_symbol)
 680     printf ("%s:\n", filename);
 681 }
 682 \f
 683 /* Print the name of an archive file given on the command line.  */
 684
 685 static void
 686 print_archive_filename_bsd (filename)
 687      char *filename;
 688 {
 689   if (filename_per_file)
 690     printf ("\n%s:\n", filename);
 691 }
 692
 693 static void
 694 print_archive_filename_sysv (filename)
 695      char *filename;
 696 {
 697 }
 698
 699 static void
 700 print_archive_filename_posix (filename)
 701      char *filename;
 702 {
 703 }
 704 \f
 705 /* Print the name of an archive member file.  */
 706
 707 static void
 708 print_archive_member_bsd (archive, filename)
 709      char *archive;
 710      CONST char *filename;
 711 {
 712   if (!filename_per_symbol)
 713     printf ("\n%s:\n", filename);
 714 }
 715
 716 static void
 717 print_archive_member_sysv (archive, filename)
 718      char *archive;
 719      CONST char *filename;
 720 {
 721   if (undefined_only)
 722     printf ("\n\nUndefined symbols from %s[%s]:\n\n", archive, filename);
 723   else
 724     printf ("\n\nSymbols from %s[%s]:\n\n", archive, filename);
 725   printf ("\
 726 Name                  Value   Class        Type         Size   Line  Section\n\n");
 727 }
 728
 729 static void
 730 print_archive_member_posix (archive, filename)
 731      char *archive;
 732      CONST char *filename;
 733 {
 734   if (!filename_per_symbol)
 735     printf ("%s[%s]:\n", archive, filename);
 736 }
 737 \f
 738 /* Print the name of the file (and archive, if there is one)
 739    containing a symbol.  */
 740
 741 static void
 742 print_symbol_filename_bsd (archive_bfd, abfd)
 743      bfd *archive_bfd, *abfd;
 744 {
 745   if (filename_per_symbol)
 746     {
 747       if (archive_bfd)
 748         printf ("%s:", bfd_get_filename (archive_bfd));
 749       printf ("%s:", bfd_get_filename (abfd));
 750     }
 751 }
 752
 753 static void
 754 print_symbol_filename_sysv (archive_bfd, abfd)
 755      bfd *archive_bfd, *abfd;
 756 {
 757   if (filename_per_symbol)
 758     {
 759       if (archive_bfd)
 760         printf ("%s:", bfd_get_filename (archive_bfd));
 761       printf ("%s:", bfd_get_filename (abfd));
 762     }
 763 }
 764
 765 static void
 766 print_symbol_filename_posix (archive_bfd, abfd)
 767      bfd *archive_bfd, *abfd;
 768 {
 769   if (filename_per_symbol)
 770     {
 771       if (archive_bfd)
 772         printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
 773                 bfd_get_filename (abfd));
 774       else
 775         printf ("%s: ", bfd_get_filename (abfd));
 776     }
 777 }
 778 \f
 779 /* Print a line of information about a symbol.  */
 780
 781 static void
 782 print_symbol_info_bsd (info, abfd)
 783      symbol_info *info;
 784      bfd *abfd;
 785 {
 786   if (info->type == 'U')
 787     printf ("        ");
 788   else
 789     {
 790 #ifdef HOST_64_BIT
 791       printf (value_format, uint64_typeHIGH (info->value),
 792               uint64_typeLOW (info->value));
 793 #else
 794       printf (value_format, info->value);
 795 #endif
 796     }
 797   printf (" %c", info->type);
 798   if (info->type == '-')
 799     {
 800       /* A stab.  */
 801       printf (" ");
 802       printf (other_format, info->stab_other);
 803       printf (" ");
 804       printf (desc_format, info->stab_desc);
 805       printf (" %5s", info->stab_name);
 806     }
 807   print_symname (" %s", info->name, abfd);
 808 }
 809
 810 static void
 811 print_symbol_info_sysv (info, abfd)
 812      symbol_info *info;
 813      bfd *abfd;
 814 {
 815   print_symname ("%-20s|", info->name, abfd);   /* Name */
 816   if (info->type == 'U')
 817     printf ("        ");        /* Value */
 818   else
 819     {
 820 #ifdef HOST_64_BIT
 821       printf (value_format, uint64_typeHIGH (info->value),
 822               uint64_typeLOW (info->value));
 823 #else
 824       printf (value_format, info->value);
 825 #endif
 826     }
 827   printf ("|   %c  |", info->type);     /* Class */
 828   if (info->type == '-')
 829     {
 830       /* A stab.  */
 831       printf ("%18s|  ", info->stab_name);      /* (C) Type */
 832       printf (desc_format, info->stab_desc);    /* Size */
 833       printf ("|     |");       /* Line, Section */
 834     }
 835   else
 836     printf ("                  |      |     |");        /* Type, Size, Line, Section */
 837 }
 838
 839 static void
 840 print_symbol_info_posix (info, abfd)
 841      symbol_info *info;
 842      bfd *abfd;
 843 {
 844   print_symname ("%s ", info->name, abfd);
 845   printf ("%c ", info->type);
 846   if (info->type == 'U')
 847     printf ("        ");
 848   else
 849     {
 850 #ifdef HOST_64_BIT
 851       printf (value_format, uint64_typeHIGH (info->value),
 852               uint64_typeLOW (info->value));
 853 #else
 854       printf (value_format, info->value);
 855 #endif
 856     }
 857   /* POSIX.2 wants the symbol size printed here, when applicable;
 858      BFD currently doesn't provide it, so we take the easy way out by
 859      considering it to never be applicable.  */
 860 }
 861 \f
 862 static void
 863 print_symdef_entry (abfd)
 864      bfd *abfd;
 865 {
 866   symindex idx = BFD_NO_MORE_SYMBOLS;
 867   carsym *thesym;
 868   boolean everprinted = false;
 869
 870   for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
 871        idx != BFD_NO_MORE_SYMBOLS;
 872        idx = bfd_get_next_mapent (abfd, idx, &thesym))
 873     {
 874       bfd *elt;
 875       if (!everprinted)
 876         {
 877           printf ("\nArchive index:\n");
 878           everprinted = true;
 879         }
 880       elt = bfd_get_elt_at_index (abfd, idx);
 881       if (thesym->name != (char *) NULL)
 882         {
 883           printf ("%s in %s\n", thesym->name, bfd_get_filename (elt));
 884         }
 885     }
 886 }