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   xmalloc_set_program_name (program_name);
 275
 276   bfd_init ();
 277
 278   while ((c = getopt_long (argc, argv, "aABCf:gnopPrst:uvV", long_options, (int *) 0)) != EOF)
 279     {
 280       switch (c)
 281         {
 282         case 'a':
 283           print_debug_syms = 1;
 284           break;
 285         case 'A':
 286         case 'o':
 287           filename_per_symbol = 1;
 288           break;
 289         case 'B':               /* For MIPS compatibility.  */
 290           set_output_format ("bsd");
 291           break;
 292         case 'C':
 293           do_demangle = 1;
 294           break;
 295         case 'f':
 296           set_output_format (optarg);
 297           break;
 298         case 'g':
 299           external_only = 1;
 300           break;
 301         case 'h':
 302           usage (stdout, 0);
 303         case 'n':
 304         case 'v':
 305           sort_numerically = 1;
 306           break;
 307         case 'p':
 308           no_sort = 1;
 309           break;
 310         case 'P':
 311           set_output_format ("posix");
 312           break;
 313         case 'r':
 314           reverse_sort = 1;
 315           break;
 316         case 's':
 317           print_armap = 1;
 318           break;
 319         case 't':
 320           set_print_radix (optarg);
 321           break;
 322         case 'u':
 323           undefined_only = 1;
 324           break;
 325         case 'V':
 326           show_version = 1;
 327           break;
 328
 329         case 200:               /* --target */
 330           target = optarg;
 331           break;
 332
 333         case 0:         /* A long option that just sets a flag.  */
 334           break;
 335
 336         default:
 337           usage (stderr, 1);
 338         }
 339     }
 340
 341   if (show_version)
 342     {
 343       printf ("GNU %s version %s\n", program_name, program_version);
 344       exit (0);
 345     }
 346
 347   /* OK, all options now parsed.  If no filename specified, do a.out.  */
 348   if (optind == argc)
 349     return !display_file ("a.out");
 350
 351   retval = 0;
 352
 353   if (argc - optind > 1)
 354     filename_per_file = 1;
 355
 356   /* We were given several filenames to do.  */
 357   while (optind < argc)
 358     {
 359       if (!display_file (argv[optind++]))
 360         retval++;
 361     }
 362
 363   exit (retval);
 364   return retval;
 365 }
 366 \f
 367 static void
 368 display_archive (file)
 369      bfd *file;
 370 {
 371   bfd *arfile = NULL;
 372   bfd *last_arfile = NULL;
 373   char **matching;
 374
 375   (*format->print_archive_filename) (bfd_get_filename (file));
 376
 377   if (print_armap)
 378     print_symdef_entry (file);
 379
 380   for (;;)
 381     {
 382       arfile = bfd_openr_next_archived_file (file, arfile);
 383
 384       if (arfile == NULL)
 385         {
 386           if (bfd_get_error () != bfd_error_no_more_archived_files)
 387             bfd_fatal (bfd_get_filename (file));
 388           break;
 389         }
 390
 391       if (bfd_check_format_matches (arfile, bfd_object, &matching))
 392         {
 393           (*format->print_archive_member) (bfd_get_filename (file),
 394                                            bfd_get_filename (arfile));
 395           display_rel_file (arfile, file);
 396         }
 397       else
 398         {
 399           bfd_nonfatal (bfd_get_filename (arfile));
 400           if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 401             {
 402               list_matching_formats (matching);
 403               free (matching);
 404             }
 405         }
 406
 407       if (last_arfile != NULL)
 408         bfd_close (last_arfile);
 409       last_arfile = arfile;
 410     }
 411
 412   if (last_arfile != NULL)
 413     bfd_close (last_arfile);
 414 }
 415
 416 static boolean
 417 display_file (filename)
 418      char *filename;
 419 {
 420   boolean retval = true;
 421   bfd *file;
 422   char **matching;
 423
 424   file = bfd_openr (filename, target);
 425   if (file == NULL)
 426     {
 427       bfd_nonfatal (filename);
 428       return false;
 429     }
 430
 431   if (bfd_check_format (file, bfd_archive))
 432     {
 433       display_archive (file);
 434     }
 435   else if (bfd_check_format_matches (file, bfd_object, &matching))
 436     {
 437       (*format->print_object_filename) (filename);
 438       display_rel_file (file, NULL);
 439     }
 440   else
 441     {
 442       bfd_nonfatal (filename);
 443       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 444         {
 445           list_matching_formats (matching);
 446           free (matching);
 447         }
 448       retval = false;
 449     }
 450
 451   if (bfd_close (file) == false)
 452     bfd_fatal (filename);
 453
 454   return retval;
 455 }
 456 \f
 457 /* Symbol-sorting predicates */
 458 #define valueof(x) ((x)->section->vma + (x)->value)
 459 int
 460 numeric_forward (x, y)
 461      CONST void *x;
 462      CONST void *y;
 463 {
 464   return (valueof (*(asymbol **) x) - valueof (*(asymbol **) y));
 465 }
 466
 467 int
 468 numeric_reverse (x, y)
 469      CONST void *x;
 470      CONST void *y;
 471 {
 472   return (valueof (*(asymbol **) y) - valueof (*(asymbol **) x));
 473 }
 474
 475 int
 476 non_numeric_forward (x, y)
 477      CONST void *x;
 478      CONST void *y;
 479 {
 480   CONST char *xn = (*(asymbol **) x)->name;
 481   CONST char *yn = (*(asymbol **) y)->name;
 482
 483   return ((xn == NULL) ? ((yn == NULL) ? 0 : -1) :
 484           ((yn == NULL) ? 1 : strcmp (xn, yn)));
 485 }
 486
 487 int
 488 non_numeric_reverse (x, y)
 489      CONST void *x;
 490      CONST void *y;
 491 {
 492   return -(non_numeric_forward (x, y));
 493 }
 494
 495 static int (*(sorters[2][2])) PARAMS ((CONST void *, CONST void *)) =
 496 {
 497   { non_numeric_forward, non_numeric_reverse },
 498   { numeric_forward, numeric_reverse }
 499 };
 500 \f
 501 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
 502
 503 static void
 504 display_rel_file (abfd, archive_bfd)
 505      bfd *abfd;
 506      bfd *archive_bfd;
 507 {
 508   long storage;
 509   asymbol **syms;
 510   long symcount = 0;
 511
 512   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 513     {
 514       printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
 515       return;
 516     }
 517
 518   storage = bfd_get_symtab_upper_bound (abfd);
 519   if (storage < 0)
 520     bfd_fatal (bfd_get_filename (abfd));
 521   if (storage == 0)
 522     {
 523     nosymz:
 524       fprintf (stderr, "%s: Symflags set but there are none?\n",
 525                bfd_get_filename (abfd));
 526       return;
 527     }
 528
 529   syms = (asymbol **) xmalloc (storage);
 530
 531   symcount = bfd_canonicalize_symtab (abfd, syms);
 532   if (symcount < 0)
 533     bfd_fatal (bfd_get_filename (abfd));
 534   if (symcount == 0)
 535     {
 536       free (syms);
 537       goto nosymz;
 538     }
 539
 540   /* Discard the symbols we don't want to print.
 541      It's OK to do this in place; we'll free the storage anyway
 542      (after printing).  */
 543
 544   symcount = filter_symbols (abfd, syms, symcount);
 545
 546   if (!no_sort)
 547     qsort ((char *) syms, symcount, sizeof (asymbol *),
 548            sorters[sort_numerically][reverse_sort]);
 549
 550   print_symbols (abfd, syms, symcount, archive_bfd);
 551   free (syms);
 552 }
 553 \f
 554 /* Choose which symbol entries to print;
 555    compact them downward to get rid of the rest.
 556    Return the number of symbols to be printed.  */
 557
 558 static unsigned int
 559 filter_symbols (abfd, syms, symcount)
 560      bfd *abfd;                 /* Unused.  */
 561      asymbol **syms;
 562      unsigned long symcount;
 563 {
 564   asymbol **from, **to;
 565   unsigned int src_count;
 566   unsigned int dst_count = 0;
 567   asymbol *sym;
 568
 569   for (from = to = syms, src_count = 0; src_count < symcount; src_count++)
 570     {
 571       int keep = 0;
 572       flagword flags = (from[src_count])->flags;
 573
 574       sym = from[src_count];
 575       if (undefined_only)
 576         keep = sym->section == &bfd_und_section;
 577       else if (external_only)
 578         keep = ((flags & BSF_GLOBAL)
 579                 || (sym->section == &bfd_und_section)
 580                 || (bfd_is_com_section (sym->section)));
 581       else
 582         keep = 1;
 583
 584       if (!print_debug_syms && ((flags & BSF_DEBUGGING) != 0))
 585         keep = 0;
 586
 587       if (keep)
 588         to[dst_count++] = from[src_count];
 589     }
 590
 591   return dst_count;
 592 }
 593 \f
 594 /* Print symbol name NAME, read from ABFD, with printf format FORMAT,
 595    demangling it if requested.  */
 596
 597 static void
 598 print_symname (format, name, abfd)
 599      char *format, *name;
 600      bfd *abfd;
 601 {
 602   if (do_demangle)
 603     {
 604       char *res;
 605
 606       /* In this mode, give a user-level view of the symbol name
 607          even if it's not mangled; strip off any leading
 608          underscore.  */
 609       if (bfd_get_symbol_leading_char (abfd) == name[0])
 610         name++;
 611
 612       res = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
 613       if (res)
 614         {
 615           printf (format, res);
 616           free (res);
 617           return;
 618         }
 619     }
 620
 621   printf (format, name);
 622 }
 623
 624 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
 625
 626 static void
 627 print_symbols (abfd, syms, symcount, archive_bfd)
 628      bfd *abfd;
 629      asymbol **syms;
 630      unsigned long symcount;
 631      bfd *archive_bfd;
 632 {
 633   asymbol **sym = syms, **end = syms + symcount;
 634   symbol_info syminfo;
 635
 636   for (; sym < end; ++sym)
 637     {
 638       (*format->print_symbol_filename) (archive_bfd, abfd);
 639
 640       if (undefined_only)
 641         {
 642           if ((*sym)->section == &bfd_und_section)
 643             {
 644               print_symname ("%s\n", (*sym)->name, abfd);
 645             }
 646         }
 647       else
 648         {
 649           asymbol *p = *sym;
 650           if (p)
 651             {
 652               bfd_get_symbol_info (abfd, p, &syminfo);
 653               (*format->print_symbol_info) (&syminfo, abfd);
 654               putchar ('\n');
 655             }
 656         }
 657     }
 658 }
 659 \f
 660 /* The following 3 groups of functions are called unconditionally,
 661    once at the start of processing each file of the appropriate type.
 662    They should check `filename_per_file' and `filename_per_symbol',
 663    as appropriate for their output format, to determine whether to
 664    print anything.  */
 665 \f
 666 /* Print the name of an object file given on the command line.  */
 667
 668 static void
 669 print_object_filename_bsd (filename)
 670      char *filename;
 671 {
 672   if (filename_per_file && !filename_per_symbol)
 673     printf ("\n%s:\n", filename);
 674 }
 675
 676 static void
 677 print_object_filename_sysv (filename)
 678      char *filename;
 679 {
 680   if (undefined_only)
 681     printf ("\n\nUndefined symbols from %s:\n\n", filename);
 682   else
 683     printf ("\n\nSymbols from %s:\n\n", filename);
 684   printf ("\
 685 Name                  Value   Class        Type         Size   Line  Section\n\n");
 686 }
 687
 688 static void
 689 print_object_filename_posix (filename)
 690      char *filename;
 691 {
 692   if (filename_per_file && !filename_per_symbol)
 693     printf ("%s:\n", filename);
 694 }
 695 \f
 696 /* Print the name of an archive file given on the command line.  */
 697
 698 static void
 699 print_archive_filename_bsd (filename)
 700      char *filename;
 701 {
 702   if (filename_per_file)
 703     printf ("\n%s:\n", filename);
 704 }
 705
 706 static void
 707 print_archive_filename_sysv (filename)
 708      char *filename;
 709 {
 710 }
 711
 712 static void
 713 print_archive_filename_posix (filename)
 714      char *filename;
 715 {
 716 }
 717 \f
 718 /* Print the name of an archive member file.  */
 719
 720 static void
 721 print_archive_member_bsd (archive, filename)
 722      char *archive;
 723      CONST char *filename;
 724 {
 725   if (!filename_per_symbol)
 726     printf ("\n%s:\n", filename);
 727 }
 728
 729 static void
 730 print_archive_member_sysv (archive, filename)
 731      char *archive;
 732      CONST char *filename;
 733 {
 734   if (undefined_only)
 735     printf ("\n\nUndefined symbols from %s[%s]:\n\n", archive, filename);
 736   else
 737     printf ("\n\nSymbols from %s[%s]:\n\n", archive, filename);
 738   printf ("\
 739 Name                  Value   Class        Type         Size   Line  Section\n\n");
 740 }
 741
 742 static void
 743 print_archive_member_posix (archive, filename)
 744      char *archive;
 745      CONST char *filename;
 746 {
 747   if (!filename_per_symbol)
 748     printf ("%s[%s]:\n", archive, filename);
 749 }
 750 \f
 751 /* Print the name of the file (and archive, if there is one)
 752    containing a symbol.  */
 753
 754 static void
 755 print_symbol_filename_bsd (archive_bfd, abfd)
 756      bfd *archive_bfd, *abfd;
 757 {
 758   if (filename_per_symbol)
 759     {
 760       if (archive_bfd)
 761         printf ("%s:", bfd_get_filename (archive_bfd));
 762       printf ("%s:", bfd_get_filename (abfd));
 763     }
 764 }
 765
 766 static void
 767 print_symbol_filename_sysv (archive_bfd, abfd)
 768      bfd *archive_bfd, *abfd;
 769 {
 770   if (filename_per_symbol)
 771     {
 772       if (archive_bfd)
 773         printf ("%s:", bfd_get_filename (archive_bfd));
 774       printf ("%s:", bfd_get_filename (abfd));
 775     }
 776 }
 777
 778 static void
 779 print_symbol_filename_posix (archive_bfd, abfd)
 780      bfd *archive_bfd, *abfd;
 781 {
 782   if (filename_per_symbol)
 783     {
 784       if (archive_bfd)
 785         printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
 786                 bfd_get_filename (abfd));
 787       else
 788         printf ("%s: ", bfd_get_filename (abfd));
 789     }
 790 }
 791 \f
 792 /* Print a line of information about a symbol.  */
 793
 794 static void
 795 print_symbol_info_bsd (info, abfd)
 796      symbol_info *info;
 797      bfd *abfd;
 798 {
 799   if (info->type == 'U')
 800     printf ("        ");
 801   else
 802     {
 803 #ifdef HOST_64_BIT
 804       printf (value_format, uint64_typeHIGH (info->value),
 805               uint64_typeLOW (info->value));
 806 #else
 807       printf (value_format, info->value);
 808 #endif
 809     }
 810   printf (" %c", info->type);
 811   if (info->type == '-')
 812     {
 813       /* A stab.  */
 814       printf (" ");
 815       printf (other_format, info->stab_other);
 816       printf (" ");
 817       printf (desc_format, info->stab_desc);
 818       printf (" %5s", info->stab_name);
 819     }
 820   print_symname (" %s", info->name, abfd);
 821 }
 822
 823 static void
 824 print_symbol_info_sysv (info, abfd)
 825      symbol_info *info;
 826      bfd *abfd;
 827 {
 828   print_symname ("%-20s|", info->name, abfd);   /* Name */
 829   if (info->type == 'U')
 830     printf ("        ");        /* Value */
 831   else
 832     {
 833 #ifdef HOST_64_BIT
 834       printf (value_format, uint64_typeHIGH (info->value),
 835               uint64_typeLOW (info->value));
 836 #else
 837       printf (value_format, info->value);
 838 #endif
 839     }
 840   printf ("|   %c  |", info->type);     /* Class */
 841   if (info->type == '-')
 842     {
 843       /* A stab.  */
 844       printf ("%18s|  ", info->stab_name);      /* (C) Type */
 845       printf (desc_format, info->stab_desc);    /* Size */
 846       printf ("|     |");       /* Line, Section */
 847     }
 848   else
 849     printf ("                  |      |     |");        /* Type, Size, Line, Section */
 850 }
 851
 852 static void
 853 print_symbol_info_posix (info, abfd)
 854      symbol_info *info;
 855      bfd *abfd;
 856 {
 857   print_symname ("%s ", info->name, abfd);
 858   printf ("%c ", info->type);
 859   if (info->type == 'U')
 860     printf ("        ");
 861   else
 862     {
 863 #ifdef HOST_64_BIT
 864       printf (value_format, uint64_typeHIGH (info->value),
 865               uint64_typeLOW (info->value));
 866 #else
 867       printf (value_format, info->value);
 868 #endif
 869     }
 870   /* POSIX.2 wants the symbol size printed here, when applicable;
 871      BFD currently doesn't provide it, so we take the easy way out by
 872      considering it to never be applicable.  */
 873 }
 874 \f
 875 static void
 876 print_symdef_entry (abfd)
 877      bfd *abfd;
 878 {
 879   symindex idx = BFD_NO_MORE_SYMBOLS;
 880   carsym *thesym;
 881   boolean everprinted = false;
 882
 883   for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
 884        idx != BFD_NO_MORE_SYMBOLS;
 885        idx = bfd_get_next_mapent (abfd, idx, &thesym))
 886     {
 887       bfd *elt;
 888       if (!everprinted)
 889         {
 890           printf ("\nArchive index:\n");
 891           everprinted = true;
 892         }
 893       elt = bfd_get_elt_at_index (abfd, idx);
 894       if (thesym->name != (char *) NULL)
 895         {
 896           printf ("%s in %s\n", thesym->name, bfd_get_filename (elt));
 897         }
 898     }
 899 }