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_rs6000
 394 #define ARCH_sh
 395 #define ARCH_sparc
 396 #define ARCH_z8k
 397 #endif
 398
 399 void
 400 disassemble_data (abfd)
 401      bfd *abfd;
 402 {
 403   bfd_byte *data = NULL;
 404   bfd_arch_info_type *info;
 405   bfd_size_type datasize = 0;
 406   bfd_size_type i;
 407   unsigned int (*print) ()= 0; /* Old style */
 408   disassembler_ftype disassemble = 0; /* New style */
 409   enum bfd_architecture a;
 410   struct disassemble_info disasm_info;
 411   struct objdump_disasm_info aux;
 412
 413   int prevline;
 414   CONST char *prev_function = "";
 415
 416   asection *section;
 417
 418   /* Replace symbol section relative values with abs values */
 419   boolean done_dot = false;
 420
 421   INIT_DISASSEMBLE_INFO(disasm_info, stdout);
 422   disasm_info.application_data = (PTR) &aux;
 423   aux.abfd = abfd;
 424   disasm_info.print_address_func = objdump_print_address;
 425
 426   for (i = 0; i < symcount; i++)
 427     {
 428       syms[i]->value += syms[i]->section->vma;
 429     }
 430
 431   symcount = remove_useless_symbols (syms, symcount);
 432
 433   /* Sort the symbols into section and symbol order */
 434   (void) qsort (syms, symcount, sizeof (asymbol *), comp);
 435
 436   if (machine != (char *) NULL)
 437     {
 438       info = bfd_scan_arch (machine);
 439       if (info == 0)
 440         {
 441           fprintf (stderr, "%s: Can't use supplied machine %s\n",
 442                    program_name,
 443                    machine);
 444           exit (1);
 445         }
 446       abfd->arch_info = info;
 447     }
 448
 449   /* See if we can disassemble using bfd */
 450
 451   if (abfd->arch_info->disassemble)
 452     {
 453       print = abfd->arch_info->disassemble;
 454     }
 455   else
 456     {
 457       a = bfd_get_arch (abfd);
 458       switch (a)
 459         {
 460           /* If you add a case to this table, also add it to the
 461              ARCH_all definition right above this function.  */
 462 #ifdef ARCH_a29k
 463         case bfd_arch_a29k:
 464           /* As far as I know we only handle big-endian 29k objects.  */
 465           disassemble = print_insn_big_a29k;
 466           break;
 467 #endif
 468 #ifdef ARCH_alpha
 469         case bfd_arch_alpha:
 470           disassemble = print_insn_alpha;
 471           break;
 472 #endif
 473 #ifdef ARCH_h8300
 474         case bfd_arch_h8300:
 475           if (bfd_get_mach(abfd) == bfd_mach_h8300h)
 476            disassemble = print_insn_h8300h;
 477           else
 478            disassemble = print_insn_h8300;
 479           break;
 480 #endif
 481 #ifdef ARCH_h8500
 482         case bfd_arch_h8500:
 483           disassemble = print_insn_h8500;
 484           break;
 485 #endif
 486 #ifdef ARCH_hppa
 487         case bfd_arch_hppa:
 488           disassemble = print_insn_hppa;
 489           break;
 490 #endif
 491 #ifdef ARCH_i386
 492         case bfd_arch_i386:
 493           disassemble = print_insn_i386;
 494           break;
 495 #endif
 496 #ifdef ARCH_i960
 497         case bfd_arch_i960:
 498           disassemble = print_insn_i960;
 499           break;
 500 #endif
 501 #ifdef ARCH_m68k
 502         case bfd_arch_m68k:
 503           disassemble = print_insn_m68k;
 504           break;
 505 #endif
 506 #ifdef ARCH_m88k
 507         case bfd_arch_m88k:
 508           disassemble = print_insn_m88k;
 509           break;
 510 #endif
 511 #ifdef ARCH_mips
 512         case bfd_arch_mips:
 513           if (abfd->xvec->byteorder_big_p)
 514             disassemble = print_insn_big_mips;
 515           else
 516             disassemble = print_insn_little_mips;
 517           break;
 518 #endif
 519 #ifdef ARCH_rs6000:
 520         case bfd_arch_rs6000:
 521           disassemble = print_insn_rs6000;
 522           break;
 523 #endif
 524 #ifdef ARCH_sh
 525         case bfd_arch_sh:
 526           disassemble = print_insn_sh;
 527           break;
 528 #endif
 529 #ifdef ARCH_sparc
 530         case bfd_arch_sparc:
 531           disassemble = print_insn_sparc;
 532           break;
 533 #endif
 534 #ifdef ARCH_z8k
 535         case bfd_arch_z8k:
 536           if (bfd_get_mach(abfd) == bfd_mach_z8001)
 537            disassemble = print_insn_z8001;
 538           else
 539            disassemble = print_insn_z8002;
 540           break;
 541 #endif
 542         default:
 543           fprintf (stderr, "%s: Can't disassemble for architecture %s\n",
 544                    program_name,
 545                    bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
 546           exit (1);
 547         }
 548
 549     }
 550
 551   for (section = abfd->sections;
 552        section != (asection *) NULL;
 553        section = section->next)
 554     {
 555       aux.sec = section;
 556
 557       if ((section->flags & SEC_LOAD)
 558           && (only == (char *) NULL || strcmp (only, section->name) == 0))
 559         {
 560           printf ("Disassembly of section %s:\n", section->name);
 561
 562           if (bfd_get_section_size_before_reloc (section) == 0)
 563             continue;
 564
 565           data = (bfd_byte *) xmalloc ((size_t) bfd_get_section_size_before_reloc (section));
 566
 567           datasize = bfd_get_section_size_before_reloc (section);
 568
 569           bfd_get_section_contents (abfd, section, data, 0, bfd_get_section_size_before_reloc (section));
 570
 571           disasm_info.buffer = data;
 572           disasm_info.buffer_vma = section->vma;
 573           disasm_info.buffer_length =
 574             bfd_get_section_size_before_reloc (section);
 575           i = 0;
 576           while (i < disasm_info.buffer_length)
 577             {
 578               if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 0 &&
 579                   data[i + 3] == 0)
 580                 {
 581                   if (done_dot == false)
 582                     {
 583                       printf ("...\n");
 584                       done_dot = true;
 585                     }
 586                   i += 4;
 587                 }
 588               else
 589                 {
 590                   done_dot = false;
 591                   if (with_line_numbers)
 592                     {
 593                       CONST char *filename;
 594                       CONST char *functionname;
 595                       unsigned int line;
 596
 597                       if (bfd_find_nearest_line (abfd,
 598                                                  section,
 599                                                  syms,
 600                                                  section->vma + i,
 601                                                  &filename,
 602                                                  &functionname,
 603                                                  &line))
 604                         {
 605                           if (functionname && *functionname
 606                               && strcmp(functionname, prev_function))
 607                             {
 608                               printf ("%s():\n", functionname);
 609                               prev_function = functionname;
 610                             }
 611                           if (!filename)
 612                             filename = "???";
 613                           if (line && line != prevline)
 614                             {
 615                               printf ("%s:%u\n", filename, line);
 616                               prevline = line;
 617                             }
 618                         }
 619                     }
 620                   objdump_print_address (section->vma + i, &disasm_info);
 621                   printf (" ");
 622
 623                   if (disassemble) /* New style */
 624                     {
 625                       int bytes = (*disassemble)(section->vma + i,
 626                                                  &disasm_info);
 627                       if (bytes < 0)
 628                         break;
 629                       i += bytes;
 630                     }
 631                   else /* Old style */
 632                     i += print (section->vma + i,
 633                                 data + i,
 634                                 stdout);
 635                   putchar ('\n');
 636                 }
 637             }
 638           free (data);
 639         }
 640     }
 641 }
 642 \f
 643
 644 /* Define a table of stab values and print-strings.  We wish the initializer
 645    could be a direct-mapped table, but instead we build one the first
 646    time we need it.  */
 647
 648 char **stab_name;
 649
 650 struct stab_print {
 651   int value;
 652   char *string;
 653 };
 654
 655 struct stab_print stab_print[] = {
 656 #define __define_stab(NAME, CODE, STRING) {CODE, STRING},
 657 #include "aout/stab.def"
 658 #undef __define_stab
 659   {0, ""}
 660 };
 661
 662 void dump_stabs_1 ();
 663
 664 /* This dumps the stabs section from object files that have a section that
 665    uses Sun stabs encoding.  It has to use some hooks into BFD because
 666    string table sections are not normally visible to BFD callers.  */
 667
 668 void
 669 dump_stabs (abfd)
 670      bfd *abfd;
 671 {
 672   int i;
 673
 674   /* Allocate and initialize stab name array if first time.  */
 675   if (stab_name == NULL)
 676     {
 677       stab_name = (char **) xmalloc (256 * sizeof(char *));
 678       /* Clear the array. */
 679       for (i = 0; i < 256; i++)
 680         stab_name[i] = NULL;
 681       /* Fill in the defined stabs. */
 682       for (i = 0; *stab_print[i].string; i++)
 683         stab_name[stab_print[i].value] = stab_print[i].string;
 684     }
 685
 686   dump_stabs_1 (abfd, ".stab", ".stabstr");
 687   dump_stabs_1 (abfd, ".stab.excl", ".stab.exclstr");
 688   dump_stabs_1 (abfd, ".stab.index", ".stab.indexstr");
 689   dump_stabs_1 (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
 690 }
 691
 692 void
 693 dump_stabs_1 (abfd, name1, name2)
 694      bfd *abfd;
 695      char *name1;               /* Section name of .stab */
 696      char *name2;               /* Section name of its string section */
 697 {
 698   Elf_Internal_Shdr *stab_hdr, *stabstr_hdr;
 699   asection *stabsect, *stabstrsect;
 700   char *strtab;
 701   struct internal_nlist *stabs, *stabs_end;
 702   int i;
 703   int stab_size, stabstr_size;
 704   unsigned file_string_table_offset, next_file_string_table_offset;
 705   int is_elf = (0 == strncmp ("elf", abfd->xvec->name, 3));
 706
 707   if (is_elf)
 708     {
 709       stab_hdr = bfd_elf_find_section (abfd, name1);
 710     }
 711   else
 712     {
 713       stabsect = bfd_get_section_by_name (abfd, name1);
 714     }
 715
 716   if (is_elf ? (0 == stab_hdr) : (0 == stabsect))
 717     {
 718       printf ("No %s section present.\n\n", name1);
 719       return;
 720     }
 721
 722   if (is_elf)
 723     {
 724       stabstr_hdr = bfd_elf_find_section (abfd, name2);
 725     }
 726   else
 727     {
 728       stabstrsect = bfd_get_section_by_name (abfd, name2);
 729     }
 730
 731   if (is_elf ? (0 == stabstr_hdr) : (0 == stabstrsect))
 732     {
 733       fprintf (stderr, "%s: %s has no %s section.\n", program_name,
 734                abfd->filename, name2);
 735       return;
 736     }
 737
 738   stab_size    = (is_elf ? stab_hdr   ->sh_size : bfd_section_size (abfd, stabsect));
 739   stabstr_size = (is_elf ? stabstr_hdr->sh_size : bfd_section_size (abfd, stabstrsect));
 740
 741   stabs  = (struct internal_nlist *) xmalloc (stab_size);
 742   strtab = (char *) xmalloc (stabstr_size);
 743   stabs_end = (struct internal_nlist *) (stab_size + (char *) stabs);
 744
 745   if (is_elf)
 746     {
 747       if (bfd_seek (abfd, stab_hdr->sh_offset, SEEK_SET) < 0 ||
 748           stab_size != bfd_read ((PTR) stabs, stab_size, 1, abfd))
 749         {
 750           fprintf (stderr, "%s: reading %s section of %s failed.\n",
 751                    program_name, name1,
 752                    abfd->filename);
 753           return;
 754         }
 755     }
 756   else
 757     {
 758       bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size);
 759     }
 760
 761   if (is_elf)
 762     {
 763       if (bfd_seek (abfd, stabstr_hdr->sh_offset, SEEK_SET) < 0 ||
 764           stabstr_size != bfd_read ((PTR) strtab, stabstr_size, 1, abfd))
 765         {
 766           fprintf (stderr, "%s: reading %s section of %s failed.\n",
 767                    program_name, name2,
 768                    abfd->filename);
 769           return;
 770         }
 771     }
 772   else
 773     {
 774       bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0, stabstr_size);
 775     }
 776
 777 #define SWAP_SYMBOL(symp, abfd) \
 778   { \
 779     (symp)->n_strx = bfd_h_get_32(abfd,                 \
 780                                 (unsigned char *)&(symp)->n_strx);      \
 781     (symp)->n_desc = bfd_h_get_16 (abfd,                        \
 782                                 (unsigned char *)&(symp)->n_desc);      \
 783     (symp)->n_value = bfd_h_get_32 (abfd,                       \
 784                                 (unsigned char *)&(symp)->n_value);     \
 785   }
 786
 787   printf ("Contents of %s section:\n\n", name1);
 788   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
 789
 790   file_string_table_offset = 0;
 791   next_file_string_table_offset = 0;
 792
 793   /* Loop through all symbols and print them.
 794
 795      We start the index at -1 because there is a dummy symbol on
 796      the front of stabs-in-{coff,elf} sections that supplies sizes. */
 797
 798   for (i = -1; stabs < stabs_end; stabs++, i++)
 799     {
 800       SWAP_SYMBOL (stabs, abfd);
 801       printf ("\n%-6d ", i);
 802       /* Print either the stab name, or, if unnamed, print its number
 803          again (makes consistent formatting for tools like awk). */
 804       if (stab_name[stabs->n_type])
 805         printf ("%-6s", stab_name[stabs->n_type]);
 806       else
 807         printf ("%-6d", i);
 808       printf (" %-6d %-6d ", stabs->n_other, stabs->n_desc);
 809       printf_vma (stabs->n_value);
 810       printf (" %-6lu", stabs->n_strx);
 811
 812       /* Symbols with type == 0 (N_UNDF) specify the length of the
 813          string table associated with this file.  We use that info
 814          to know how to relocate the *next* file's string table indices.  */
 815
 816       if (stabs->n_type == N_UNDF)
 817         {
 818           file_string_table_offset = next_file_string_table_offset;
 819           next_file_string_table_offset += stabs->n_value;
 820         }
 821       else
 822         {
 823           /* Now, using the possibly updated string table offset, print the
 824              string (if any) associated with this symbol.  */
 825
 826           if ((stabs->n_strx + file_string_table_offset) < stabstr_size)
 827             printf (" %s", &strtab[stabs->n_strx + file_string_table_offset]);
 828           else
 829             printf (" *");
 830         }
 831     }
 832   printf ("\n\n");
 833 }
 834
 835 static void
 836 display_bfd (abfd)
 837      bfd *abfd;
 838 {
 839
 840   if (!bfd_check_format (abfd, bfd_object))
 841     {
 842       fprintf (stderr, "%s:%s: %s\n", program_name, abfd->filename,
 843                bfd_errmsg (bfd_error));
 844       return;
 845     }
 846   printf ("\n%s:     file format %s\n", abfd->filename, abfd->xvec->name);
 847   if (dump_ar_hdrs)
 848     print_arelt_descr (stdout, abfd, true);
 849
 850   if (dump_file_header)
 851     {
 852       char *comma = "";
 853
 854       printf ("architecture: %s, ",
 855               bfd_printable_arch_mach (bfd_get_arch (abfd),
 856                                        bfd_get_mach (abfd)));
 857       printf ("flags 0x%08x:\n", abfd->flags);
 858
 859 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
 860       PF (HAS_RELOC, "HAS_RELOC");
 861       PF (EXEC_P, "EXEC_P");
 862       PF (HAS_LINENO, "HAS_LINENO");
 863       PF (HAS_DEBUG, "HAS_DEBUG");
 864       PF (HAS_SYMS, "HAS_SYMS");
 865       PF (HAS_LOCALS, "HAS_LOCALS");
 866       PF (DYNAMIC, "DYNAMIC");
 867       PF (WP_TEXT, "WP_TEXT");
 868       PF (D_PAGED, "D_PAGED");
 869       PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
 870       printf ("\nstart address 0x");
 871       printf_vma (abfd->start_address);
 872     }
 873   printf ("\n");
 874
 875   if (dump_section_headers)
 876     dump_headers (abfd);
 877   if (dump_symtab || dump_reloc_info || disassemble)
 878     {
 879       syms = slurp_symtab (abfd);
 880     }
 881   if (dump_symtab)
 882     dump_symbols (abfd);
 883   if (dump_stab_section_info)
 884     dump_stabs (abfd);
 885   if (dump_reloc_info)
 886     dump_relocs (abfd);
 887   if (dump_section_contents)
 888     dump_data (abfd);
 889   /* Note that disassemble_data re-orders the syms table, but that is
 890      safe - as long as it is done last! */
 891   if (disassemble)
 892     disassemble_data (abfd);
 893 }
 894
 895 static void
 896 display_file (filename, target)
 897      char *filename;
 898      char *target;
 899 {
 900   bfd *file, *arfile = (bfd *) NULL;
 901
 902   file = bfd_openr (filename, target);
 903   if (file == NULL)
 904     {
 905       fprintf (stderr, "%s: ", program_name);
 906       bfd_perror (filename);
 907       return;
 908     }
 909
 910   if (bfd_check_format (file, bfd_archive) == true)
 911     {
 912       printf ("In archive %s:\n", bfd_get_filename (file));
 913       for (;;)
 914         {
 915           bfd_error = no_error;
 916
 917           arfile = bfd_openr_next_archived_file (file, arfile);
 918           if (arfile == NULL)
 919             {
 920               if (bfd_error != no_more_archived_files)
 921                 {
 922                   fprintf (stderr, "%s: ", program_name);
 923                   bfd_perror (bfd_get_filename (file));
 924                 }
 925               return;
 926             }
 927
 928           display_bfd (arfile);
 929           /* Don't close the archive elements; we need them for next_archive */
 930         }
 931     }
 932   else
 933     display_bfd (file);
 934
 935   bfd_close (file);
 936 }
 937 \f
 938 /* Actually display the various requested regions */
 939
 940 static void
 941 dump_data (abfd)
 942      bfd *abfd;
 943 {
 944   asection *section;
 945   bfd_byte *data = 0;
 946   bfd_size_type datasize = 0;
 947   bfd_size_type i;
 948
 949   for (section = abfd->sections; section != NULL; section =
 950        section->next)
 951     {
 952       int onaline = 16;
 953
 954       if (only == (char *) NULL ||
 955           strcmp (only, section->name) == 0)
 956         {
 957           if (section->flags & SEC_HAS_CONTENTS)
 958             {
 959               printf ("Contents of section %s:\n", section->name);
 960
 961               if (bfd_section_size (abfd, section) == 0)
 962                 continue;
 963               data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
 964               datasize = bfd_section_size (abfd, section);
 965
 966
 967               bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
 968
 969               for (i = 0; i < bfd_section_size (abfd, section); i += onaline)
 970                 {
 971                   bfd_size_type j;
 972
 973                   printf (" %04lx ", (unsigned long int) (i + section->vma));
 974                   for (j = i; j < i + onaline; j++)
 975                     {
 976                       if (j < bfd_section_size (abfd, section))
 977                         printf ("%02x", (unsigned) (data[j]));
 978                       else
 979                         printf ("  ");
 980                       if ((j & 3) == 3)
 981                         printf (" ");
 982                     }
 983
 984                   printf (" ");
 985                   for (j = i; j < i + onaline; j++)
 986                     {
 987                       if (j >= bfd_section_size (abfd, section))
 988                         printf (" ");
 989                       else
 990                         printf ("%c", isprint (data[j]) ? data[j] : '.');
 991                     }
 992                   putchar ('\n');
 993                 }
 994               free (data);
 995             }
 996         }
 997     }
 998 }
 999
1000 /* Should perhaps share code and display with nm? */
1001 static void
1002 dump_symbols (abfd)
1003      bfd *abfd;
1004 {
1005
1006   unsigned int count;
1007   asymbol **current = syms;
1008
1009   printf ("SYMBOL TABLE:\n");
1010
1011   for (count = 0; count < symcount; count++)
1012     {
1013
1014       if (*current)
1015         {
1016           bfd *cur_bfd = bfd_asymbol_bfd(*current);
1017           if (cur_bfd)
1018             {
1019               bfd_print_symbol (cur_bfd,
1020                                 stdout,
1021                                 *current, bfd_print_symbol_all);
1022               printf ("\n");
1023             }
1024
1025         }
1026       current++;
1027     }
1028   printf ("\n");
1029   printf ("\n");
1030 }
1031
1032 static void
1033 dump_relocs (abfd)
1034      bfd *abfd;
1035 {
1036   arelent **relpp;
1037   unsigned int relcount;
1038   asection *a;
1039
1040   for (a = abfd->sections; a != (asection *) NULL; a = a->next)
1041     {
1042       if (a == &bfd_abs_section)
1043         continue;
1044       if (a == &bfd_und_section)
1045         continue;
1046       if (bfd_is_com_section (a))
1047         continue;
1048
1049       if (only)
1050         {
1051           if (strcmp (only, a->name))
1052             continue;
1053         }
1054       else if ((a->flags & SEC_RELOC) == 0)
1055         continue;
1056
1057       printf ("RELOCATION RECORDS FOR [%s]:", a->name);
1058
1059       if (bfd_get_reloc_upper_bound (abfd, a) == 0)
1060         {
1061           printf (" (none)\n\n");
1062         }
1063       else
1064         {
1065           arelent **p;
1066
1067           relpp = (arelent **) xmalloc (bfd_get_reloc_upper_bound (abfd, a));
1068           /* Note that this must be done *before* we sort the syms table. */
1069           relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
1070           if (relcount == 0)
1071             {
1072               printf (" (none)\n\n");
1073             }
1074           else
1075             {
1076               printf ("\n");
1077               /* Get column headers lined up reasonably.  */
1078               {
1079                 static int width;
1080                 if (width == 0)
1081                   {
1082                     char buf[30];
1083                     sprintf_vma (buf, (bfd_vma) -1);
1084                     width = strlen (buf) - 7;
1085                   }
1086                 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
1087               }
1088
1089               for (p = relpp; relcount && *p != (arelent *) NULL; p++,
1090                    relcount--)
1091                 {
1092                   arelent *q = *p;
1093                   CONST char *sym_name;
1094                   CONST char *section_name;
1095
1096                   if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
1097                     {
1098                       sym_name = (*(q->sym_ptr_ptr))->name;
1099                       section_name = (*(q->sym_ptr_ptr))->section->name;
1100                     }
1101                   else
1102                     {
1103                       sym_name = NULL;
1104                       section_name = NULL;
1105                     }
1106                   if (sym_name)
1107                     {
1108                       printf_vma (q->address);
1109                       printf (" %-16s  %s",
1110                               q->howto->name,
1111                               sym_name);
1112                     }
1113                   else
1114                     {
1115                       if (section_name == (CONST char *) NULL)
1116                         section_name = "*unknown*";
1117                       printf_vma (q->address);
1118                       printf (" %-16s  [%s]",
1119                               q->howto->name,
1120                               section_name);
1121                     }
1122                   if (q->addend)
1123                     {
1124                       printf ("+0x");
1125                       printf_vma (q->addend);
1126                     }
1127                   printf ("\n");
1128                 }
1129               printf ("\n\n");
1130               free (relpp);
1131             }
1132         }
1133
1134     }
1135 }
1136
1137 #ifdef unix
1138 #define _DUMMY_NAME_ "/dev/null"
1139 #else
1140 #define _DUMMY_NAME_ "##dummy"
1141 #endif
1142 static void
1143 DEFUN (display_info_table, (first, last),
1144        int first AND int last)
1145 {
1146   unsigned int i, j;
1147   extern bfd_target *target_vector[];
1148
1149   printf ("\n%12s", " ");
1150   for (i = first; i++ < last && target_vector[i];)
1151     printf ("%s ", target_vector[i]->name);
1152   printf ("\n");
1153
1154   for (j = (int) bfd_arch_obscure + 1; (int) j < (int) bfd_arch_last; j++)
1155     if (strcmp (bfd_printable_arch_mach (j, 0), "UNKNOWN!") != 0)
1156       {
1157         printf ("%11s ", bfd_printable_arch_mach (j, 0));
1158         for (i = first; i++ < last && target_vector[i];)
1159           {
1160             bfd_target *p = target_vector[i];
1161             bfd *abfd = bfd_openw (_DUMMY_NAME_, p->name);
1162             int l = strlen (p->name);
1163             int ok;
1164             bfd_set_format (abfd, bfd_object);
1165             ok = bfd_set_arch_mach (abfd, j, 0);
1166
1167             if (ok)
1168               printf ("%s ", p->name);
1169             else
1170               {
1171                 while (l--)
1172                   printf ("%c", ok ? '*' : '-');
1173                 printf (" ");
1174               }
1175           }
1176         printf ("\n");
1177       }
1178 }
1179
1180 static void
1181 DEFUN_VOID (display_info)
1182 {
1183   char *colum;
1184   unsigned int i, j, columns;
1185   extern bfd_target *target_vector[];
1186   extern char *getenv ();
1187
1188   printf ("BFD header file version %s\n", BFD_VERSION);
1189   for (i = 0; target_vector[i]; i++)
1190     {
1191       bfd_target *p = target_vector[i];
1192       bfd *abfd = bfd_openw (_DUMMY_NAME_, p->name);
1193       bfd_set_format (abfd, bfd_object);
1194       printf ("%s\n (header %s, data %s)\n", p->name,
1195               p->header_byteorder_big_p ? "big endian" : "little endian",
1196               p->byteorder_big_p ? "big endian" : "little endian");
1197       for (j = (int) bfd_arch_obscure + 1; j < (int) bfd_arch_last; j++)
1198         if (bfd_set_arch_mach (abfd, (enum bfd_architecture) j, 0))
1199           printf ("  %s\n",
1200                   bfd_printable_arch_mach ((enum bfd_architecture) j, 0));
1201     }
1202   columns = 0;
1203   if ((colum = getenv ("COLUMNS")) != (char *) NULL)
1204     columns = atoi (colum);
1205   if (!columns)
1206     columns = 80;
1207   for (i = 0; target_vector[i];)
1208     {
1209       int old;
1210       old = i;
1211       for (j = 12; target_vector[i] && j < columns; i++)
1212         j += strlen (target_vector[i]->name) + 1;
1213       i--;
1214       if (old == i)
1215         break;
1216       display_info_table (old, i);
1217     }
1218 }
1219
1220 /** main and like trivia */
1221 int
1222 main (argc, argv)
1223      int argc;
1224      char **argv;
1225 {
1226   int c;
1227   extern int optind;
1228   extern char *optarg;
1229   char *target = default_target;
1230   boolean seenflag = false;
1231
1232   bfd_init ();
1233   program_name = *argv;
1234
1235   while ((c = getopt_long (argc, argv, "ib:m:Vdlfahrtxsj:", long_options,
1236                            (int *) 0))
1237          != EOF)
1238     {
1239       seenflag = true;
1240       switch (c)
1241         {
1242         case 0:
1243           break;                /* we've been given a long option */
1244         case 'm':
1245           machine = optarg;
1246           break;
1247         case 'j':
1248           only = optarg;
1249           break;
1250         case 'l':
1251           with_line_numbers = 1;
1252           break;
1253         case 'b':
1254           target = optarg;
1255           break;
1256         case 'f':
1257           dump_file_header = true;
1258           break;
1259         case 'i':
1260           formats_info = true;
1261           break;
1262         case 'x':
1263           dump_symtab = 1;
1264           dump_reloc_info = 1;
1265           dump_file_header = true;
1266           dump_ar_hdrs = 1;
1267           dump_section_headers = 1;
1268           break;
1269         case 't':
1270           dump_symtab = 1;
1271           break;
1272         case 'd':
1273           disassemble = true;
1274           break;
1275         case 's':
1276           dump_section_contents = 1;
1277           break;
1278         case 'r':
1279           dump_reloc_info = 1;
1280           break;
1281         case 'a':
1282           dump_ar_hdrs = 1;
1283           break;
1284         case 'h':
1285           dump_section_headers = 1;
1286           break;
1287         case 'H':
1288           usage (stdout, 0);
1289         case 'V':
1290           show_version = 1;
1291           break;
1292         default:
1293           usage (stderr, 1);
1294         }
1295     }
1296
1297   if (show_version)
1298     {
1299       printf ("GNU %s version %s\n", program_name, program_version);
1300       exit (0);
1301     }
1302
1303   if (seenflag == false)
1304     usage (stderr, 1);
1305
1306   if (formats_info)
1307     {
1308       display_info ();
1309     }
1310   else
1311     {
1312       if (optind == argc)
1313         display_file ("a.out", target);
1314       else
1315         for (; optind < argc;)
1316           display_file (argv[optind++], target);
1317     }
1318   return 0;
1319 }