binutils/objdump.c

   1 /* objdump.c -- dump information about an object file.
   2    Copyright 1990, 1991, 1992, 1993 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, or (at your option)
   9 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "getopt.h"
  23 #include "bucomm.h"
  24 #include <stdio.h>
  25 #include <ctype.h>
  26 #include "dis-asm.h"
  27
  28 /* Internal headers for the ELF .stab-dump code - sorry.  */
  29 #define BYTES_IN_WORD   32
  30 #include "aout/aout64.h"
  31 #include "elf/internal.h"
  32 extern Elf_Internal_Shdr *bfd_elf_find_section();
  33
  34 #ifndef FPRINTF_ALREADY_DECLARED
  35 extern int fprintf PARAMS ((FILE *, CONST char *, ...));
  36 #endif
  37
  38 char *default_target = NULL;    /* default at runtime */
  39
  40 extern char *program_version;
  41
  42 int show_version = 0;           /* show the version number */
  43 int dump_section_contents;      /* -s */
  44 int dump_section_headers;       /* -h */
  45 boolean dump_file_header;       /* -f */
  46 int dump_symtab;                /* -t */
  47 int dump_reloc_info;            /* -r */
  48 int dump_ar_hdrs;               /* -a */
  49 int with_line_numbers;          /* -l */
  50 int dump_stab_section_info;     /* --stabs */
  51 boolean disassemble;            /* -d */
  52 boolean formats_info;           /* -i */
  53 char *only;                     /* -j secname */
  54
  55 struct objdump_disasm_info {
  56   bfd *abfd;
  57   asection *sec;
  58 };
  59
  60 char *machine = (char *) NULL;
  61 asymbol **syms;
  62
  63 unsigned int storage;
  64
  65 unsigned int symcount = 0;
  66
  67 /* Forward declarations.  */
  68
  69 static void
  70 display_file PARAMS ((char *filename, char *target));
  71
  72 static void
  73 dump_data PARAMS ((bfd *abfd));
  74
  75 static void
  76 dump_relocs PARAMS ((bfd *abfd));
  77
  78 static void
  79 dump_symbols PARAMS ((bfd *abfd));
  80
  81 static void
  82 display_bfd PARAMS ((bfd *abfd));
  83 \f
  84 void
  85 usage (stream, status)
  86      FILE *stream;
  87      int status;
  88 {
  89   fprintf (stream, "\
  90 Usage: %s [-ahifdrtxsl] [-b bfdname] [-m machine] [-j section-name]\n\
  91        [--archive-headers] [--target=bfdname] [--disassemble] [--file-headers]\n\
  92        [--section-headers] [--headers] [--info] [--section=section-name]\n\
  93        [--line-numbers] [--architecture=machine] [--reloc] [--full-contents]\n\
  94        [--stabs] [--syms] [--all-headers] [--version] [--help] objfile...\n\
  95 at least one option besides -l (--line-numbers) must be given\n",
  96            program_name);
  97   exit (status);
  98 }
  99
 100 static struct option long_options[]=
 101 {
 102   {"all-headers", no_argument, NULL, 'x'},
 103   {"architecture", required_argument, NULL, 'm'},
 104   {"archive-headers", no_argument, NULL, 'a'},
 105   {"disassemble", no_argument, NULL, 'd'},
 106   {"file-headers", no_argument, NULL, 'f'},
 107   {"full-contents", no_argument, NULL, 's'},
 108   {"headers", no_argument, NULL, 'h'},
 109   {"help", no_argument, NULL, 'H'},
 110   {"info", no_argument, NULL, 'i'},
 111   {"line-numbers", no_argument, NULL, 'l'},
 112   {"reloc", no_argument, NULL, 'r'},
 113   {"section", required_argument, NULL, 'j'},
 114   {"section-headers", no_argument, NULL, 'h'},
 115   {"stabs", no_argument, &dump_stab_section_info, 1},
 116   {"syms", no_argument, NULL, 't'},
 117   {"target", required_argument, NULL, 'b'},
 118   {"version", no_argument, &show_version,    1},
 119   {0, no_argument, 0, 0}
 120 };
 121
 122
 123 static void
 124 dump_headers (abfd)
 125      bfd *abfd;
 126 {
 127   asection *section;
 128
 129   for (section = abfd->sections;
 130        section != (asection *) NULL;
 131        section = section->next)
 132     {
 133       char *comma = "";
 134
 135 #define PF(x,y) \
 136         if (section->flags & x) {  printf("%s%s",comma,y); comma = ", "; }
 137
 138
 139       printf ("SECTION %d [%s]\t: size %08x",
 140               section->index,
 141               section->name,
 142               (unsigned) bfd_get_section_size_before_reloc (section));
 143       printf (" vma ");
 144       printf_vma (section->vma);
 145       printf (" align 2**%u\n ",
 146               section->alignment_power);
 147       PF (SEC_ALLOC, "ALLOC");
 148       PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
 149       PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT");
 150       PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA");
 151       PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS");
 152       PF (SEC_LOAD, "LOAD");
 153       PF (SEC_RELOC, "RELOC");
 154 #ifdef SEC_BALIGN
 155       PF (SEC_BALIGN, "BALIGN");
 156 #endif
 157       PF (SEC_READONLY, "READONLY");
 158       PF (SEC_CODE, "CODE");
 159       PF (SEC_DATA, "DATA");
 160       PF (SEC_ROM, "ROM");
 161       PF (SEC_DEBUGGING, "DEBUGGING");
 162       printf ("\n");
 163 #undef PF
 164     }
 165 }
 166
 167 static asymbol **
 168 DEFUN (slurp_symtab, (abfd),
 169        bfd * abfd)
 170 {
 171   asymbol **sy = (asymbol **) NULL;
 172
 173   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 174     {
 175       (void) printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
 176       return (NULL);
 177     }
 178
 179   storage = get_symtab_upper_bound (abfd);
 180   if (storage)
 181     {
 182       sy = (asymbol **) xmalloc (storage);
 183     }
 184   symcount = bfd_canonicalize_symtab (abfd, sy);
 185   if (symcount <= 0)
 186     {
 187       fprintf (stderr, "%s: Bad symbol table in \"%s\".\n",
 188                program_name, bfd_get_filename (abfd));
 189       exit (1);
 190     }
 191   return sy;
 192 }
 193
 194 /* Filter out (in place) symbols that are useless for dis-assemble.
 195    Return count of useful symbols. */
 196
 197 int remove_useless_symbols (syms, count)
 198      asymbol **syms;
 199      int count;
 200 {
 201   register asymbol **in_ptr = syms;
 202   register asymbol **out_ptr = syms;
 203
 204   while ( --count >= 0 )
 205     {
 206       asymbol *sym = *in_ptr++;
 207
 208       if (sym->name == NULL || sym->name[0] == '\0')
 209         continue;
 210       if (sym->flags & (BSF_DEBUGGING))
 211         continue;
 212       if (sym->section == &bfd_und_section
 213           || bfd_is_com_section (sym->section))
 214         continue;
 215
 216       *out_ptr++ = sym;
 217     }
 218   return out_ptr - syms;
 219 }
 220
 221
 222 /* Sort symbols into value order */
 223 static int
 224 comp (ap, bp)
 225      PTR ap;
 226      PTR bp;
 227 {
 228   asymbol *a = *(asymbol **)ap;
 229   asymbol *b = *(asymbol **)bp;
 230
 231   if (a->value > b->value)
 232     return 1;
 233   else if (a->value < b->value)
 234     return -1;
 235
 236   if (a->section > b->section)
 237     return 1;
 238   else if (a->section < b->section)
 239     return -1;
 240   return 0;
 241 }
 242
 243 /* Print the supplied address symbolically if possible */
 244 void
 245 objdump_print_address (vma, info)
 246      bfd_vma vma;
 247      struct disassemble_info *info;
 248 {
 249   /* Perform a binary search looking for the closest symbol to
 250      the required value.  */
 251   /* @@ For relocateable files, should filter out symbols belonging to
 252      the wrong section.  Unfortunately, not enough information is supplied
 253      to this routine to determine the correct section in all cases.  */
 254   /* @@ Would it speed things up to cache the last two symbols returned,
 255      and maybe their address ranges?  For many processors, only one memory
 256      operand can be present at a time, so the 2-entry cache wouldn't be
 257      constantly churned by code doing heavy memory accesses.  */
 258
 259   unsigned int min = 0;
 260   unsigned int max = symcount;
 261
 262   unsigned int thisplace = 1;
 263   unsigned int oldthisplace;
 264
 265   int vardiff;
 266
 267   fprintf_vma (info->stream, vma);
 268
 269   if (symcount > 0)
 270     {
 271       while (true)
 272         {
 273           asymbol *sym; asection *sym_sec;
 274           oldthisplace = thisplace;
 275           thisplace = (max + min) / 2;
 276           if (thisplace == oldthisplace)
 277             break;
 278           sym = syms[thisplace];
 279           vardiff = sym->value - vma;
 280           sym_sec = sym->section;
 281
 282           if (vardiff > 0)
 283             max = thisplace;
 284           else if (vardiff < 0)
 285             min = thisplace;
 286           else
 287             goto found;
 288         }
 289       /* We've run out of places to look, print the symbol before this one
 290          see if this or the symbol before describes this location the best */
 291
 292       if (thisplace != 0)
 293         {
 294           if (syms[thisplace - 1]->value - vma >
 295               syms[thisplace]->value - vma)
 296             {
 297               /* Previous symbol is in correct section and is closer */
 298               thisplace--;
 299             }
 300         }
 301
 302     found:
 303       {
 304         bfd_vma val = syms[thisplace]->value;
 305         int i;
 306         if (syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
 307           for (i = thisplace - 1; i >= 0; i--)
 308             {
 309               if (syms[i]->value == val
 310                   && (!(syms[i]->flags & (BSF_LOCAL|BSF_DEBUGGING))
 311                       || ((syms[thisplace]->flags & BSF_DEBUGGING)
 312                           && !(syms[i]->flags & BSF_DEBUGGING))))
 313                 {
 314                   thisplace = i;
 315                   break;
 316                 }
 317             }
 318         if (syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
 319           for (i = thisplace + 1; i < symcount; i++)
 320             {
 321               if (syms[i]->value == val
 322                   && (!(syms[i]->flags & (BSF_LOCAL|BSF_DEBUGGING))
 323                       || ((syms[thisplace]->flags & BSF_DEBUGGING)
 324                           && !(syms[i]->flags & BSF_DEBUGGING))))
 325                 {
 326                   thisplace = i;
 327                   break;
 328                 }
 329             }
 330       }
 331       {
 332         /* If the file is relocateable, and the symbol could be from this
 333            section, prefer a symbol from this section over symbols from
 334            others, even if the other symbol's value might be closer.
 335
 336            Note that this may be wrong for some symbol references if the
 337            sections have overlapping memory ranges, but in that case there's
 338            no way to tell what's desired without looking at the relocation
 339            table.  */
 340         struct objdump_disasm_info *aux;
 341         int i;
 342
 343         aux = (struct objdump_disasm_info *) info->application_data;
 344         if (aux->abfd->flags & HAS_RELOC
 345             && vma >= bfd_get_section_vma (aux->abfd, aux->sec)
 346             && vma < (bfd_get_section_vma (aux->abfd, aux->sec)
 347                       + bfd_get_section_size_before_reloc (aux->sec))
 348             && syms[thisplace]->section != aux->sec)
 349           {
 350             for (i = thisplace + 1; i < symcount; i++)
 351               if (syms[i]->value != syms[thisplace]->value)
 352                 break;
 353             while (--i >= 0)
 354               if (syms[i]->section == aux->sec)
 355                 {
 356                   thisplace = i;
 357                   break;
 358                 }
 359           }
 360       }
 361       fprintf (info->stream, " <%s", syms[thisplace]->name);
 362       if (syms[thisplace]->value > vma)
 363         {
 364           char buf[30], *p = buf;
 365           sprintf_vma (buf, syms[thisplace]->value - vma);
 366           while (*p == '0')
 367             p++;
 368           fprintf (info->stream, "-%s", p);
 369         }
 370       else if (vma > syms[thisplace]->value)
 371         {
 372           char buf[30], *p = buf;
 373           sprintf_vma (buf, vma - syms[thisplace]->value);
 374           while (*p == '0')
 375             p++;
 376           fprintf (info->stream, "+%s", p);
 377         }
 378       fprintf (info->stream, ">");
 379     }
 380 }
 381
 382 #ifdef ARCH_all
 383 #define ARCH_a29k
 384 #define ARCH_alpha
 385 #define ARCH_h8300
 386 #define ARCH_h8500
 387 #define ARCH_hppa
 388 #define ARCH_i386
 389 #define ARCH_i960
 390 #define ARCH_m68k
 391 #define ARCH_m88k
 392 #define ARCH_mips
 393 #define ARCH_sh
 394 #define ARCH_sparc
 395 #define ARCH_z8k
 396 #endif
 397
 398 void
 399 disassemble_data (abfd)
 400      bfd *abfd;
 401 {
 402   bfd_byte *data = NULL;
 403   bfd_arch_info_type *info;
 404   bfd_size_type datasize = 0;
 405   bfd_size_type i;
 406   unsigned int (*print) ()= 0; /* Old style */
 407   disassembler_ftype disassemble = 0; /* New style */
 408   enum bfd_architecture a;
 409   struct disassemble_info disasm_info;
 410   struct objdump_disasm_info aux;
 411
 412   int prevline;
 413   CONST char *prev_function = "";
 414
 415   asection *section;
 416
 417   /* Replace symbol section relative values with abs values */
 418   boolean done_dot = false;
 419
 420   INIT_DISASSEMBLE_INFO(disasm_info, stdout);
 421   disasm_info.application_data = (PTR) &aux;
 422   aux.abfd = abfd;
 423   disasm_info.print_address_func = objdump_print_address;
 424
 425   for (i = 0; i < symcount; i++)
 426     {
 427       syms[i]->value += syms[i]->section->vma;
 428     }
 429
 430   symcount = remove_useless_symbols (syms, symcount);
 431
 432   /* Sort the symbols into section and symbol order */
 433   (void) qsort (syms, symcount, sizeof (asymbol *), comp);
 434
 435   if (machine != (char *) NULL)
 436     {
 437       info = bfd_scan_arch (machine);
 438       if (info == 0)
 439         {
 440           fprintf (stderr, "%s: Can't use supplied machine %s\n",
 441                    program_name,
 442                    machine);
 443           exit (1);
 444         }
 445       abfd->arch_info = info;
 446     }
 447
 448   /* See if we can disassemble using bfd */
 449
 450   if (abfd->arch_info->disassemble)
 451     {
 452       print = abfd->arch_info->disassemble;
 453     }
 454   else
 455     {
 456       a = bfd_get_arch (abfd);
 457       switch (a)
 458         {
 459           /* If you add a case to this table, also add it to the
 460              ARCH_all definition right above this function.  */
 461 #ifdef ARCH_a29k
 462         case bfd_arch_a29k:
 463           /* As far as I know we only handle big-endian 29k objects.  */
 464           disassemble = print_insn_big_a29k;
 465           break;
 466 #endif
 467 #ifdef ARCH_alpha
 468         case bfd_arch_alpha:
 469           disassemble = print_insn_alpha;
 470           break;
 471 #endif
 472 #ifdef ARCH_h8300
 473         case bfd_arch_h8300:
 474           if (bfd_get_mach(abfd) == bfd_mach_h8300h)
 475            disassemble = print_insn_h8300h;
 476           else
 477            disassemble = print_insn_h8300;
 478           break;
 479 #endif
 480 #ifdef ARCH_h8500
 481         case bfd_arch_h8500:
 482           disassemble = print_insn_h8500;
 483           break;
 484 #endif
 485 #ifdef ARCH_hppa
 486         case bfd_arch_hppa:
 487           disassemble = print_insn_hppa;
 488           break;
 489 #endif
 490 #ifdef ARCH_i386
 491         case bfd_arch_i386:
 492           disassemble = print_insn_i386;
 493           break;
 494 #endif
 495 #ifdef ARCH_i960
 496         case bfd_arch_i960:
 497           disassemble = print_insn_i960;
 498           break;
 499 #endif
 500 #ifdef ARCH_m68k
 501         case bfd_arch_m68k:
 502           disassemble = print_insn_m68k;
 503           break;
 504 #endif
 505 #ifdef ARCH_m88k
 506         case bfd_arch_m88k:
 507           disassemble = print_insn_m88k;
 508           break;
 509 #endif
 510 #ifdef ARCH_mips
 511         case bfd_arch_mips:
 512           if (abfd->xvec->byteorder_big_p)
 513             disassemble = print_insn_big_mips;
 514           else
 515             disassemble = print_insn_little_mips;
 516           break;
 517 #endif
 518 #ifdef ARCH_sh
 519         case bfd_arch_sh:
 520           disassemble = print_insn_sh;
 521           break;
 522 #endif
 523 #ifdef ARCH_sparc
 524         case bfd_arch_sparc:
 525           disassemble = print_insn_sparc;
 526           break;
 527 #endif
 528 #ifdef ARCH_z8k
 529         case bfd_arch_z8k:
 530           if (bfd_get_mach(abfd) == bfd_mach_z8001)
 531            disassemble = print_insn_z8001;
 532           else
 533            disassemble = print_insn_z8002;
 534           break;
 535 #endif
 536         default:
 537           fprintf (stderr, "%s: Can't disassemble for architecture %s\n",
 538                    program_name,
 539                    bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
 540           exit (1);
 541         }
 542
 543     }
 544
 545   for (section = abfd->sections;
 546        section != (asection *) NULL;
 547        section = section->next)
 548     {
 549       aux.sec = section;
 550
 551       if ((section->flags & SEC_LOAD)
 552           && (only == (char *) NULL || strcmp (only, section->name) == 0))
 553         {
 554           printf ("Disassembly of section %s:\n", section->name);
 555
 556           if (bfd_get_section_size_before_reloc (section) == 0)
 557             continue;
 558
 559           data = (bfd_byte *) xmalloc ((size_t) bfd_get_section_size_before_reloc (section));
 560
 561           datasize = bfd_get_section_size_before_reloc (section);
 562
 563           bfd_get_section_contents (abfd, section, data, 0, bfd_get_section_size_before_reloc (section));
 564
 565           disasm_info.buffer = data;
 566           disasm_info.buffer_vma = section->vma;
 567           disasm_info.buffer_length =
 568             bfd_get_section_size_before_reloc (section);
 569           i = 0;
 570           while (i < disasm_info.buffer_length)
 571             {
 572               if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 0 &&
 573                   data[i + 3] == 0)
 574                 {
 575                   if (done_dot == false)
 576                     {
 577                       printf ("...\n");
 578                       done_dot = true;
 579                     }
 580                   i += 4;
 581                 }
 582               else
 583                 {
 584                   done_dot = false;
 585                   if (with_line_numbers)
 586                     {
 587                       CONST char *filename;
 588                       CONST char *functionname;
 589                       unsigned int line;
 590
 591                       if (bfd_find_nearest_line (abfd,
 592                                                  section,
 593                                                  syms,
 594                                                  section->vma + i,
 595                                                  &filename,
 596                                                  &functionname,
 597                                                  &line))
 598                         {
 599                           if (functionname && *functionname
 600                               && strcmp(functionname, prev_function))
 601                             {
 602                               printf ("%s():\n", functionname);
 603                               prev_function = functionname;
 604                             }
 605                           if (!filename)
 606                             filename = "???";
 607                           if (line && line != prevline)
 608                             {
 609                               printf ("%s:%u\n", filename, line);
 610                               prevline = line;
 611                             }
 612                         }
 613                     }
 614                   objdump_print_address (section->vma + i, &disasm_info);
 615                   printf (" ");
 616
 617                   if (disassemble) /* New style */
 618                     {
 619                       int bytes = (*disassemble)(section->vma + i,
 620                                                  &disasm_info);
 621                       if (bytes < 0)
 622                         break;
 623                       i += bytes;
 624                     }
 625                   else /* Old style */
 626                     i += print (section->vma + i,
 627                                 data + i,
 628                                 stdout);
 629                   putchar ('\n');
 630                 }
 631             }
 632           free (data);
 633         }
 634     }
 635 }
 636 \f
 637
 638 /* Define a table of stab values and print-strings.  We wish the initializer
 639    could be a direct-mapped table, but instead we build one the first
 640    time we need it.  */
 641
 642 #define STAB_STRING_LENGTH      6
 643
 644 char stab_name[256][STAB_STRING_LENGTH];
 645
 646 struct stab_print {
 647   int value;
 648   char string[STAB_STRING_LENGTH];
 649 };
 650
 651 struct stab_print stab_print[] = {
 652 #define __define_stab(NAME, CODE, STRING) {CODE, STRING},
 653 #include "aout/stab.def"
 654 #undef __define_stab
 655   {0, ""}
 656 };
 657
 658 void dump_stabs_1 ();
 659
 660 /* This dumps the stabs section from object files that have a section that
 661    uses Sun stabs encoding.  It has to use some hooks into BFD because
 662    string table sections are not normally visible to BFD callers.  */
 663
 664 void
 665 dump_stabs (abfd)
 666      bfd *abfd;
 667 {
 668   int i;
 669
 670   /* Initialize stab name array if first time.  */
 671   if (stab_name[0][0] == 0)
 672     {
 673       /* Fill in numeric values for all possible strings.  */
 674       for (i = 0; i < 256; i++)
 675         {
 676           sprintf (stab_name[i], "%d", i);
 677         }
 678       for (i = 0; stab_print[i].string[0]; i++)
 679         strcpy (stab_name[stab_print[i].value], stab_print[i].string);
 680     }
 681
 682   dump_stabs_1 (abfd, ".stab", ".stabstr");
 683   dump_stabs_1 (abfd, ".stab.excl", ".stab.exclstr");
 684   dump_stabs_1 (abfd, ".stab.index", ".stab.indexstr");
 685   dump_stabs_1 (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
 686 }
 687
 688 void
 689 dump_stabs_1 (abfd, name1, name2)
 690      bfd *abfd;
 691      char *name1;               /* Section name of .stab */
 692      char *name2;               /* Section name of its string section */
 693 {
 694   Elf_Internal_Shdr *stab_hdr, *stabstr_hdr;
 695   asection *stabsect, *stabstrsect;
 696   char *strtab;
 697   struct internal_nlist *stabs, *stabs_end;
 698   int i;
 699   int stab_size, stabstr_size;
 700   unsigned file_string_table_offset, next_file_string_table_offset;
 701   int is_elf = (0 == strncmp ("elf", abfd->xvec->name, 3));
 702
 703   if (is_elf)
 704     {
 705       stab_hdr = bfd_elf_find_section (abfd, name1);
 706     }
 707   else
 708     {
 709       stabsect = bfd_get_section_by_name (abfd, name1);
 710     }
 711
 712   if (is_elf ? (0 == stab_hdr) : (0 == stabsect))
 713     {
 714       printf ("No %s section present.\n\n", name1);
 715       return;
 716     }
 717
 718   if (is_elf)
 719     {
 720       stabstr_hdr = bfd_elf_find_section (abfd, name2);
 721     }
 722   else
 723     {
 724       stabstrsect = bfd_get_section_by_name (abfd, name2);
 725     }
 726
 727   if (is_elf ? (0 == stabstr_hdr) : (0 == stabstrsect))
 728     {
 729       fprintf (stderr, "%s: %s has no %s section.\n", program_name,
 730                abfd->filename, name2);
 731       return;
 732     }
 733
 734   stab_size    = (is_elf ? stab_hdr   ->sh_size : bfd_section_size (abfd, stabsect));
 735   stabstr_size = (is_elf ? stabstr_hdr->sh_size : bfd_section_size (abfd, stabstrsect));
 736
 737   stabs  = (struct internal_nlist *) xmalloc (stab_size);
 738   strtab = (char *) xmalloc (stabstr_size);
 739   stabs_end = (struct internal_nlist *) (stab_size + (char *) stabs);
 740
 741   if (is_elf)
 742     {
 743       if (bfd_seek (abfd, stab_hdr->sh_offset, SEEK_SET) < 0 ||
 744           stab_size != bfd_read ((PTR) stabs, stab_size, 1, abfd))
 745         {
 746           fprintf (stderr, "%s: reading %s section of %s failed.\n",
 747                    program_name, name1,
 748                    abfd->filename);
 749           return;
 750         }
 751     }
 752   else
 753     {
 754       bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size);
 755     }
 756
 757   if (is_elf)
 758     {
 759       if (bfd_seek (abfd, stabstr_hdr->sh_offset, SEEK_SET) < 0 ||
 760           stabstr_size != bfd_read ((PTR) strtab, stabstr_size, 1, abfd))
 761         {
 762           fprintf (stderr, "%s: reading %s section of %s failed.\n",
 763                    program_name, name2,
 764                    abfd->filename);
 765           return;
 766         }
 767     }
 768   else
 769     {
 770       bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0, stabstr_size);
 771     }
 772
 773 #define SWAP_SYMBOL(symp, abfd) \
 774   { \
 775     (symp)->n_strx = bfd_h_get_32(abfd,                 \
 776                                 (unsigned char *)&(symp)->n_strx);      \
 777     (symp)->n_desc = bfd_h_get_16 (abfd,                        \
 778                                 (unsigned char *)&(symp)->n_desc);      \
 779     (symp)->n_value = bfd_h_get_32 (abfd,                       \
 780                                 (unsigned char *)&(symp)->n_value);     \
 781   }
 782
 783   printf ("Contents of %s section:\n\n", name1);
 784   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
 785
 786   file_string_table_offset = 0;
 787   next_file_string_table_offset = 0;
 788
 789   /* Loop through all symbols and print them.
 790
 791      We start the index at -1 because there is a dummy symbol on
 792      the front of stabs-in-{coff,elf} sections that supplies sizes. */
 793
 794   for (i = -1; stabs < stabs_end; stabs++, i++)
 795     {
 796       SWAP_SYMBOL (stabs, abfd);
 797       printf ("\n%-6d %-6s %-6d %-6d ", i,
 798               stab_name [stabs->n_type],
 799               stabs->n_other, stabs->n_desc);
 800       printf_vma (stabs->n_value);
 801       printf (" %-6lu", stabs->n_strx);
 802
 803       /* Symbols with type == 0 (N_UNDF) specify the length of the
 804          string table associated with this file.  We use that info
 805          to know how to relocate the *next* file's string table indices.  */
 806
 807       if (stabs->n_type == N_UNDF)
 808         {
 809           file_string_table_offset = next_file_string_table_offset;
 810           next_file_string_table_offset += stabs->n_value;
 811         }
 812       else
 813         {
 814           /* Now, using the possibly updated string table offset, print the
 815              string (if any) associated with this symbol.  */
 816
 817           if ((stabs->n_strx + file_string_table_offset) < stabstr_size)
 818             printf (" %s", &strtab[stabs->n_strx + file_string_table_offset]);
 819           else
 820             printf (" *");
 821         }
 822     }
 823   printf ("\n\n");
 824 }
 825
 826 static void
 827 display_bfd (abfd)
 828      bfd *abfd;
 829 {
 830
 831   if (!bfd_check_format (abfd, bfd_object))
 832     {
 833       fprintf (stderr, "%s:%s: %s\n", program_name, abfd->filename,
 834                bfd_errmsg (bfd_error));
 835       return;
 836     }
 837   printf ("\n%s:     file format %s\n", abfd->filename, abfd->xvec->name);
 838   if (dump_ar_hdrs)
 839     print_arelt_descr (stdout, abfd, true);
 840
 841   if (dump_file_header)
 842     {
 843       char *comma = "";
 844
 845       printf ("architecture: %s, ",
 846               bfd_printable_arch_mach (bfd_get_arch (abfd),
 847                                        bfd_get_mach (abfd)));
 848       printf ("flags 0x%08x:\n", abfd->flags);
 849
 850 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
 851       PF (HAS_RELOC, "HAS_RELOC");
 852       PF (EXEC_P, "EXEC_P");
 853       PF (HAS_LINENO, "HAS_LINENO");
 854       PF (HAS_DEBUG, "HAS_DEBUG");
 855       PF (HAS_SYMS, "HAS_SYMS");
 856       PF (HAS_LOCALS, "HAS_LOCALS");
 857       PF (DYNAMIC, "DYNAMIC");
 858       PF (WP_TEXT, "WP_TEXT");
 859       PF (D_PAGED, "D_PAGED");
 860       PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
 861       printf ("\nstart address 0x");
 862       printf_vma (abfd->start_address);
 863     }
 864   printf ("\n");
 865
 866   if (dump_section_headers)
 867     dump_headers (abfd);
 868   if (dump_symtab || dump_reloc_info || disassemble)
 869     {
 870       syms = slurp_symtab (abfd);
 871     }
 872   if (dump_symtab)
 873     dump_symbols (abfd);
 874   if (dump_stab_section_info)
 875     dump_stabs (abfd);
 876   if (dump_reloc_info)
 877     dump_relocs (abfd);
 878   if (dump_section_contents)
 879     dump_data (abfd);
 880   /* Note that disassemble_data re-orders the syms table, but that is
 881      safe - as long as it is done last! */
 882   if (disassemble)
 883     disassemble_data (abfd);
 884 }
 885
 886 static void
 887 display_file (filename, target)
 888      char *filename;
 889      char *target;
 890 {
 891   bfd *file, *arfile = (bfd *) NULL;
 892
 893   file = bfd_openr (filename, target);
 894   if (file == NULL)
 895     {
 896       fprintf (stderr, "%s: ", program_name);
 897       bfd_perror (filename);
 898       return;
 899     }
 900
 901   if (bfd_check_format (file, bfd_archive) == true)
 902     {
 903       printf ("In archive %s:\n", bfd_get_filename (file));
 904       for (;;)
 905         {
 906           bfd_error = no_error;
 907
 908           arfile = bfd_openr_next_archived_file (file, arfile);
 909           if (arfile == NULL)
 910             {
 911               if (bfd_error != no_more_archived_files)
 912                 {
 913                   fprintf (stderr, "%s: ", program_name);
 914                   bfd_perror (bfd_get_filename (file));
 915                 }
 916               return;
 917             }
 918
 919           display_bfd (arfile);
 920           /* Don't close the archive elements; we need them for next_archive */
 921         }
 922     }
 923   else
 924     display_bfd (file);
 925
 926   bfd_close (file);
 927 }
 928 \f
 929 /* Actually display the various requested regions */
 930
 931 static void
 932 dump_data (abfd)
 933      bfd *abfd;
 934 {
 935   asection *section;
 936   bfd_byte *data = 0;
 937   bfd_size_type datasize = 0;
 938   bfd_size_type i;
 939
 940   for (section = abfd->sections; section != NULL; section =
 941        section->next)
 942     {
 943       int onaline = 16;
 944
 945       if (only == (char *) NULL ||
 946           strcmp (only, section->name) == 0)
 947         {
 948           if (section->flags & SEC_HAS_CONTENTS)
 949             {
 950               printf ("Contents of section %s:\n", section->name);
 951
 952               if (bfd_section_size (abfd, section) == 0)
 953                 continue;
 954               data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
 955               datasize = bfd_section_size (abfd, section);
 956
 957
 958               bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
 959
 960               for (i = 0; i < bfd_section_size (abfd, section); i += onaline)
 961                 {
 962                   bfd_size_type j;
 963
 964                   printf (" %04lx ", (unsigned long int) (i + section->vma));
 965                   for (j = i; j < i + onaline; j++)
 966                     {
 967                       if (j < bfd_section_size (abfd, section))
 968                         printf ("%02x", (unsigned) (data[j]));
 969                       else
 970                         printf ("  ");
 971                       if ((j & 3) == 3)
 972                         printf (" ");
 973                     }
 974
 975                   printf (" ");
 976                   for (j = i; j < i + onaline; j++)
 977                     {
 978                       if (j >= bfd_section_size (abfd, section))
 979                         printf (" ");
 980                       else
 981                         printf ("%c", isprint (data[j]) ? data[j] : '.');
 982                     }
 983                   putchar ('\n');
 984                 }
 985               free (data);
 986             }
 987         }
 988     }
 989 }
 990
 991 /* Should perhaps share code and display with nm? */
 992 static void
 993 dump_symbols (abfd)
 994      bfd *abfd;
 995 {
 996
 997   unsigned int count;
 998   asymbol **current = syms;
 999
1000   printf ("SYMBOL TABLE:\n");
1001
1002   for (count = 0; count < symcount; count++)
1003     {
1004
1005       if (*current)
1006         {
1007           bfd *cur_bfd = bfd_asymbol_bfd(*current);
1008           if (cur_bfd)
1009             {
1010               bfd_print_symbol (cur_bfd,
1011                                 stdout,
1012                                 *current, bfd_print_symbol_all);
1013               printf ("\n");
1014             }
1015
1016         }
1017       current++;
1018     }
1019   printf ("\n");
1020   printf ("\n");
1021 }
1022
1023 static void
1024 dump_relocs (abfd)
1025      bfd *abfd;
1026 {
1027   arelent **relpp;
1028   unsigned int relcount;
1029   asection *a;
1030
1031   for (a = abfd->sections; a != (asection *) NULL; a = a->next)
1032     {
1033       if (a == &bfd_abs_section)
1034         continue;
1035       if (a == &bfd_und_section)
1036         continue;
1037       if (bfd_is_com_section (a))
1038         continue;
1039
1040       if (only)
1041         {
1042           if (strcmp (only, a->name))
1043             continue;
1044         }
1045       else if ((a->flags & SEC_RELOC) == 0)
1046         continue;
1047
1048       printf ("RELOCATION RECORDS FOR [%s]:", a->name);
1049
1050       if (bfd_get_reloc_upper_bound (abfd, a) == 0)
1051         {
1052           printf (" (none)\n\n");
1053         }
1054       else
1055         {
1056           arelent **p;
1057
1058           relpp = (arelent **) xmalloc (bfd_get_reloc_upper_bound (abfd, a));
1059           /* Note that this must be done *before* we sort the syms table. */
1060           relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
1061           if (relcount == 0)
1062             {
1063               printf (" (none)\n\n");
1064             }
1065           else
1066             {
1067               printf ("\n");
1068               /* Get column headers lined up reasonably.  */
1069               {
1070                 static int width;
1071                 if (width == 0)
1072                   {
1073                     char buf[30];
1074                     sprintf_vma (buf, (bfd_vma) -1);
1075                     width = strlen (buf) - 7;
1076                   }
1077                 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
1078               }
1079
1080               for (p = relpp; relcount && *p != (arelent *) NULL; p++,
1081                    relcount--)
1082                 {
1083                   arelent *q = *p;
1084                   CONST char *sym_name;
1085                   CONST char *section_name;
1086
1087                   if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
1088                     {
1089                       sym_name = (*(q->sym_ptr_ptr))->name;
1090                       section_name = (*(q->sym_ptr_ptr))->section->name;
1091                     }
1092                   else
1093                     {
1094                       sym_name = NULL;
1095                       section_name = NULL;
1096                     }
1097                   if (sym_name)
1098                     {
1099                       printf_vma (q->address);
1100                       printf (" %-16s  %s",
1101                               q->howto->name,
1102                               sym_name);
1103                     }
1104                   else
1105                     {
1106                       if (section_name == (CONST char *) NULL)
1107                         section_name = "*unknown*";
1108                       printf_vma (q->address);
1109                       printf (" %-16s  [%s]",
1110                               q->howto->name,
1111                               section_name);
1112                     }
1113                   if (q->addend)
1114                     {
1115                       printf ("+0x");
1116                       printf_vma (q->addend);
1117                     }
1118                   printf ("\n");
1119                 }
1120               printf ("\n\n");
1121               free (relpp);
1122             }
1123         }
1124
1125     }
1126 }
1127
1128 #ifdef unix
1129 #define _DUMMY_NAME_ "/dev/null"
1130 #else
1131 #define _DUMMY_NAME_ "##dummy"
1132 #endif
1133 static void
1134 DEFUN (display_info_table, (first, last),
1135        int first AND int last)
1136 {
1137   unsigned int i, j;
1138   extern bfd_target *target_vector[];
1139
1140   printf ("\n%12s", " ");
1141   for (i = first; i++ < last && target_vector[i];)
1142     printf ("%s ", target_vector[i]->name);
1143   printf ("\n");
1144
1145   for (j = (int) bfd_arch_obscure + 1; (int) j < (int) bfd_arch_last; j++)
1146     if (strcmp (bfd_printable_arch_mach (j, 0), "UNKNOWN!") != 0)
1147       {
1148         printf ("%11s ", bfd_printable_arch_mach (j, 0));
1149         for (i = first; i++ < last && target_vector[i];)
1150           {
1151             bfd_target *p = target_vector[i];
1152             bfd *abfd = bfd_openw (_DUMMY_NAME_, p->name);
1153             int l = strlen (p->name);
1154             int ok;
1155             bfd_set_format (abfd, bfd_object);
1156             ok = bfd_set_arch_mach (abfd, j, 0);
1157
1158             if (ok)
1159               printf ("%s ", p->name);
1160             else
1161               {
1162                 while (l--)
1163                   printf ("%c", ok ? '*' : '-');
1164                 printf (" ");
1165               }
1166           }
1167         printf ("\n");
1168       }
1169 }
1170
1171 static void
1172 DEFUN_VOID (display_info)
1173 {
1174   char *colum;
1175   unsigned int i, j, columns;
1176   extern bfd_target *target_vector[];
1177   extern char *getenv ();
1178
1179   printf ("BFD header file version %s\n", BFD_VERSION);
1180   for (i = 0; target_vector[i]; i++)
1181     {
1182       bfd_target *p = target_vector[i];
1183       bfd *abfd = bfd_openw (_DUMMY_NAME_, p->name);
1184       bfd_set_format (abfd, bfd_object);
1185       printf ("%s\n (header %s, data %s)\n", p->name,
1186               p->header_byteorder_big_p ? "big endian" : "little endian",
1187               p->byteorder_big_p ? "big endian" : "little endian");
1188       for (j = (int) bfd_arch_obscure + 1; j < (int) bfd_arch_last; j++)
1189         if (bfd_set_arch_mach (abfd, (enum bfd_architecture) j, 0))
1190           printf ("  %s\n",
1191                   bfd_printable_arch_mach ((enum bfd_architecture) j, 0));
1192     }
1193   columns = 0;
1194   if ((colum = getenv ("COLUMNS")) != (char *) NULL)
1195     columns = atoi (colum);
1196   if (!columns)
1197     columns = 80;
1198   for (i = 0; target_vector[i];)
1199     {
1200       int old;
1201       old = i;
1202       for (j = 12; target_vector[i] && j < columns; i++)
1203         j += strlen (target_vector[i]->name) + 1;
1204       i--;
1205       if (old == i)
1206         break;
1207       display_info_table (old, i);
1208     }
1209 }
1210
1211 /** main and like trivia */
1212 int
1213 main (argc, argv)
1214      int argc;
1215      char **argv;
1216 {
1217   int c;
1218   extern int optind;
1219   extern char *optarg;
1220   char *target = default_target;
1221   boolean seenflag = false;
1222
1223   bfd_init ();
1224   program_name = *argv;
1225
1226   while ((c = getopt_long (argc, argv, "ib:m:Vdlfahrtxsj:", long_options,
1227                            (int *) 0))
1228          != EOF)
1229     {
1230       seenflag = true;
1231       switch (c)
1232         {
1233         case 0:
1234           break;                /* we've been given a long option */
1235         case 'm':
1236           machine = optarg;
1237           break;
1238         case 'j':
1239           only = optarg;
1240           break;
1241         case 'l':
1242           with_line_numbers = 1;
1243           break;
1244         case 'b':
1245           target = optarg;
1246           break;
1247         case 'f':
1248           dump_file_header = true;
1249           break;
1250         case 'i':
1251           formats_info = true;
1252           break;
1253         case 'x':
1254           dump_symtab = 1;
1255           dump_reloc_info = 1;
1256           dump_file_header = true;
1257           dump_ar_hdrs = 1;
1258           dump_section_headers = 1;
1259           break;
1260         case 't':
1261           dump_symtab = 1;
1262           break;
1263         case 'd':
1264           disassemble = true;
1265           break;
1266         case 's':
1267           dump_section_contents = 1;
1268           break;
1269         case 'r':
1270           dump_reloc_info = 1;
1271           break;
1272         case 'a':
1273           dump_ar_hdrs = 1;
1274           break;
1275         case 'h':
1276           dump_section_headers = 1;
1277           break;
1278         case 'H':
1279           usage (stdout, 0);
1280         case 'V':
1281           show_version = 1;
1282           break;
1283         default:
1284           usage (stderr, 1);
1285         }
1286     }
1287
1288   if (show_version)
1289     {
1290       printf ("GNU %s version %s\n", program_name, program_version);
1291       exit (0);
1292     }
1293
1294   if (seenflag == false)
1295     usage (stderr, 1);
1296
1297   if (formats_info)
1298     {
1299       display_info ();
1300     }
1301   else
1302     {
1303       if (optind == argc)
1304         display_file ("a.out", target);
1305       else
1306         for (; optind < argc;)
1307           display_file (argv[optind++], target);
1308     }
1309   return 0;
1310 }