binutils/nm.c

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