binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   4
   5    Originally developed by Eric Youngdale <eric@andante.jic.com>
   6    Modifications by Nick Clifton <nickc@redhat.com>
   7
   8    This file is part of GNU Binutils.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  23    02110-1301, USA.  */
  24 \f
  25 /* The difference between readelf and objdump:
  26
  27   Both programs are capable of displaying the contents of ELF format files,
  28   so why does the binutils project have two file dumpers ?
  29
  30   The reason is that objdump sees an ELF file through a BFD filter of the
  31   world; if BFD has a bug where, say, it disagrees about a machine constant
  32   in e_flags, then the odds are good that it will remain internally
  33   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  34   GAS sees it the BFD way.  There was need for a tool to go find out what
  35   the file actually says.
  36
  37   This is why the readelf program does not link against the BFD library - it
  38   exists as an independent program to help verify the correct working of BFD.
  39
  40   There is also the case that readelf can provide more information about an
  41   ELF file than is provided by objdump.  In particular it can display DWARF
  42   debugging information which (at the moment) objdump cannot.  */
  43 \f
  44 #include <assert.h>
  45 #include <sys/types.h>
  46 #include <sys/stat.h>
  47 #include <stdio.h>
  48 #include <time.h>
  49
  50 #if __GNUC__ >= 2
  51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  52    as this will allow us to read in and parse 64bit and 32bit ELF files.
  53    Only do this if we believe that the compiler can support a 64 bit
  54    data type.  For now we only rely on GCC being able to do this.  */
  55 #define BFD64
  56 #endif
  57
  58 #include "bfd.h"
  59
  60 #include "elf/common.h"
  61 #include "elf/external.h"
  62 #include "elf/internal.h"
  63 #include "elf/dwarf2.h"
  64
  65 /* The following headers use the elf/reloc-macros.h file to
  66    automatically generate relocation recognition functions
  67    such as elf_mips_reloc_type()  */
  68
  69 #define RELOC_MACROS_GEN_FUNC
  70
  71 #include "elf/alpha.h"
  72 #include "elf/arc.h"
  73 #include "elf/arm.h"
  74 #include "elf/avr.h"
  75 #include "elf/cris.h"
  76 #include "elf/d10v.h"
  77 #include "elf/d30v.h"
  78 #include "elf/dlx.h"
  79 #include "elf/fr30.h"
  80 #include "elf/frv.h"
  81 #include "elf/h8.h"
  82 #include "elf/hppa.h"
  83 #include "elf/i386.h"
  84 #include "elf/i370.h"
  85 #include "elf/i860.h"
  86 #include "elf/i960.h"
  87 #include "elf/ia64.h"
  88 #include "elf/ip2k.h"
  89 #include "elf/m32r.h"
  90 #include "elf/m68k.h"
  91 #include "elf/m68hc11.h"
  92 #include "elf/mcore.h"
  93 #include "elf/mips.h"
  94 #include "elf/mmix.h"
  95 #include "elf/mn10200.h"
  96 #include "elf/mn10300.h"
  97 #include "elf/ms1.h"
  98 #include "elf/msp430.h"
  99 #include "elf/or32.h"
 100 #include "elf/pj.h"
 101 #include "elf/ppc.h"
 102 #include "elf/ppc64.h"
 103 #include "elf/s390.h"
 104 #include "elf/sh.h"
 105 #include "elf/sparc.h"
 106 #include "elf/v850.h"
 107 #include "elf/vax.h"
 108 #include "elf/x86-64.h"
 109 #include "elf/xstormy16.h"
 110 #include "elf/crx.h"
 111 #include "elf/iq2000.h"
 112 #include "elf/xtensa.h"
 113
 114 #include "aout/ar.h"
 115
 116 #include "bucomm.h"
 117 #include "getopt.h"
 118 #include "libiberty.h"
 119
 120 char *program_name = "readelf";
 121 static long archive_file_offset;
 122 static unsigned long archive_file_size;
 123 static unsigned long dynamic_addr;
 124 static bfd_size_type dynamic_size;
 125 static unsigned int dynamic_nent;
 126 static char *dynamic_strings;
 127 static unsigned long dynamic_strings_length;
 128 static char *string_table;
 129 static unsigned long string_table_length;
 130 static unsigned long num_dynamic_syms;
 131 static Elf_Internal_Sym *dynamic_symbols;
 132 static Elf_Internal_Syminfo *dynamic_syminfo;
 133 static unsigned long dynamic_syminfo_offset;
 134 static unsigned int dynamic_syminfo_nent;
 135 static char program_interpreter[64];
 136 static bfd_vma dynamic_info[DT_JMPREL + 1];
 137 static bfd_vma version_info[16];
 138 static Elf_Internal_Ehdr elf_header;
 139 static Elf_Internal_Shdr *section_headers;
 140 static Elf_Internal_Phdr *program_headers;
 141 static Elf_Internal_Dyn *dynamic_section;
 142 static Elf_Internal_Shdr *symtab_shndx_hdr;
 143 static int show_name;
 144 static int do_dynamic;
 145 static int do_syms;
 146 static int do_reloc;
 147 static int do_sections;
 148 static int do_section_groups;
 149 static int do_full_section_name;
 150 static int do_segments;
 151 static int do_unwind;
 152 static int do_using_dynamic;
 153 static int do_header;
 154 static int do_dump;
 155 static int do_version;
 156 static int do_wide;
 157 static int do_histogram;
 158 static int do_debugging;
 159 static int do_debug_info;
 160 static int do_debug_abbrevs;
 161 static int do_debug_lines;
 162 static int do_debug_pubnames;
 163 static int do_debug_aranges;
 164 static int do_debug_ranges;
 165 static int do_debug_frames;
 166 static int do_debug_frames_interp;
 167 static int do_debug_macinfo;
 168 static int do_debug_str;
 169 static int do_debug_loc;
 170 static int do_arch;
 171 static int do_notes;
 172 static int is_32bit_elf;
 173 static int have_frame_base;
 174 static int need_base_address;
 175 static bfd_vma eh_addr_size;
 176
 177 struct group_list
 178 {
 179   struct group_list *next;
 180   unsigned int section_index;
 181 };
 182
 183 struct group
 184 {
 185   struct group_list *root;
 186   unsigned int group_index;
 187 };
 188
 189 static size_t group_count;
 190 static struct group *section_groups;
 191 static struct group **section_headers_groups;
 192
 193 /* A dynamic array of flags indicating for which sections a hex dump
 194    has been requested (via the -x switch) and/or a disassembly dump
 195    (via the -i switch).  */
 196 char *cmdline_dump_sects = NULL;
 197 unsigned num_cmdline_dump_sects = 0;
 198
 199 /* A dynamic array of flags indicating for which sections a dump of
 200    some kind has been requested.  It is reset on a per-object file
 201    basis and then initialised from the cmdline_dump_sects array and
 202    the results of interpreting the -w switch.  */
 203 char *dump_sects = NULL;
 204 unsigned int num_dump_sects = 0;
 205
 206 #define HEX_DUMP        (1 << 0)
 207 #define DISASS_DUMP     (1 << 1)
 208 #define DEBUG_DUMP      (1 << 2)
 209
 210 /* How to rpint a vma value.  */
 211 typedef enum print_mode
 212 {
 213   HEX,
 214   DEC,
 215   DEC_5,
 216   UNSIGNED,
 217   PREFIX_HEX,
 218   FULL_HEX,
 219   LONG_HEX
 220 }
 221 print_mode;
 222
 223 static bfd_vma (*byte_get) (unsigned char *, int);
 224 static void (*byte_put) (unsigned char *, bfd_vma, int);
 225
 226 #define UNKNOWN -1
 227
 228 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
 229                          ((X)->sh_name >= string_table_length \
 230                           ? "<corrupt>" : string_table + (X)->sh_name))
 231
 232 /* Given st_shndx I, map to section_headers index.  */
 233 #define SECTION_HEADER_INDEX(I)                         \
 234   ((I) < SHN_LORESERVE                                  \
 235    ? (I)                                                \
 236    : ((I) <= SHN_HIRESERVE                              \
 237       ? 0                                               \
 238       : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
 239
 240 /* Reverse of the above.  */
 241 #define SECTION_HEADER_NUM(N)                           \
 242   ((N) < SHN_LORESERVE                                  \
 243    ? (N)                                                \
 244    : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
 245
 246 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
 247
 248 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 249
 250 #define BYTE_GET(field) byte_get (field, sizeof (field))
 251
 252 #define NUM_ELEM(array)         (sizeof (array) / sizeof ((array)[0]))
 253
 254 #define GET_ELF_SYMBOLS(file, section)                  \
 255   (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
 256    : get_64bit_elf_symbols (file, section))
 257
 258 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 259 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 260    already been called and verified that the string exists.  */
 261 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 262
 263 /* This is just a bit of syntatic sugar.  */
 264 #define streq(a,b)      (strcmp ((a), (b)) == 0)
 265 #define strneq(a,b,n)   (strncmp ((a), (b), (n)) == 0)
 266 \f
 267 static void
 268 error (const char *message, ...)
 269 {
 270   va_list args;
 271
 272   va_start (args, message);
 273   fprintf (stderr, _("%s: Error: "), program_name);
 274   vfprintf (stderr, message, args);
 275   va_end (args);
 276 }
 277
 278 static void
 279 warn (const char *message, ...)
 280 {
 281   va_list args;
 282
 283   va_start (args, message);
 284   fprintf (stderr, _("%s: Warning: "), program_name);
 285   vfprintf (stderr, message, args);
 286   va_end (args);
 287 }
 288
 289 static void *
 290 get_data (void *var, FILE *file, long offset, size_t size, const char *reason)
 291 {
 292   void *mvar;
 293
 294   if (size == 0)
 295     return NULL;
 296
 297   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 298     {
 299       error (_("Unable to seek to 0x%x for %s\n"),
 300              archive_file_offset + offset, reason);
 301       return NULL;
 302     }
 303
 304   mvar = var;
 305   if (mvar == NULL)
 306     {
 307       mvar = malloc (size);
 308
 309       if (mvar == NULL)
 310         {
 311           error (_("Out of memory allocating 0x%x bytes for %s\n"),
 312                  size, reason);
 313           return NULL;
 314         }
 315     }
 316
 317   if (fread (mvar, size, 1, file) != 1)
 318     {
 319       error (_("Unable to read in 0x%x bytes of %s\n"), size, reason);
 320       if (mvar != var)
 321         free (mvar);
 322       return NULL;
 323     }
 324
 325   return mvar;
 326 }
 327
 328 static bfd_vma
 329 byte_get_little_endian (unsigned char *field, int size)
 330 {
 331   switch (size)
 332     {
 333     case 1:
 334       return *field;
 335
 336     case 2:
 337       return  ((unsigned int) (field[0]))
 338         |    (((unsigned int) (field[1])) << 8);
 339
 340 #ifndef BFD64
 341     case 8:
 342       /* We want to extract data from an 8 byte wide field and
 343          place it into a 4 byte wide field.  Since this is a little
 344          endian source we can just use the 4 byte extraction code.  */
 345       /* Fall through.  */
 346 #endif
 347     case 4:
 348       return  ((unsigned long) (field[0]))
 349         |    (((unsigned long) (field[1])) << 8)
 350         |    (((unsigned long) (field[2])) << 16)
 351         |    (((unsigned long) (field[3])) << 24);
 352
 353 #ifdef BFD64
 354     case 8:
 355       return  ((bfd_vma) (field[0]))
 356         |    (((bfd_vma) (field[1])) << 8)
 357         |    (((bfd_vma) (field[2])) << 16)
 358         |    (((bfd_vma) (field[3])) << 24)
 359         |    (((bfd_vma) (field[4])) << 32)
 360         |    (((bfd_vma) (field[5])) << 40)
 361         |    (((bfd_vma) (field[6])) << 48)
 362         |    (((bfd_vma) (field[7])) << 56);
 363 #endif
 364     default:
 365       error (_("Unhandled data length: %d\n"), size);
 366       abort ();
 367     }
 368 }
 369
 370 static bfd_vma
 371 byte_get_signed (unsigned char *field, int size)
 372 {
 373   bfd_vma x = byte_get (field, size);
 374
 375   switch (size)
 376     {
 377     case 1:
 378       return (x ^ 0x80) - 0x80;
 379     case 2:
 380       return (x ^ 0x8000) - 0x8000;
 381     case 4:
 382       return (x ^ 0x80000000) - 0x80000000;
 383     case 8:
 384       return x;
 385     default:
 386       abort ();
 387     }
 388 }
 389
 390 static void
 391 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
 392 {
 393   switch (size)
 394     {
 395     case 8:
 396       field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
 397       field[6] = ((value >> 24) >> 24) & 0xff;
 398       field[5] = ((value >> 24) >> 16) & 0xff;
 399       field[4] = ((value >> 24) >> 8) & 0xff;
 400       /* Fall through.  */
 401     case 4:
 402       field[3] = (value >> 24) & 0xff;
 403       field[2] = (value >> 16) & 0xff;
 404       /* Fall through.  */
 405     case 2:
 406       field[1] = (value >> 8) & 0xff;
 407       /* Fall through.  */
 408     case 1:
 409       field[0] = value & 0xff;
 410       break;
 411
 412     default:
 413       error (_("Unhandled data length: %d\n"), size);
 414       abort ();
 415     }
 416 }
 417
 418 #if defined BFD64 && !BFD_HOST_64BIT_LONG
 419 static int
 420 print_dec_vma (bfd_vma vma, int is_signed)
 421 {
 422   char buf[40];
 423   char *bufp = buf;
 424   int nc = 0;
 425
 426   if (is_signed && (bfd_signed_vma) vma < 0)
 427     {
 428       vma = -vma;
 429       putchar ('-');
 430       nc = 1;
 431     }
 432
 433   do
 434     {
 435       *bufp++ = '0' + vma % 10;
 436       vma /= 10;
 437     }
 438   while (vma != 0);
 439   nc += bufp - buf;
 440
 441   while (bufp > buf)
 442     putchar (*--bufp);
 443   return nc;
 444 }
 445
 446 static int
 447 print_hex_vma (bfd_vma vma)
 448 {
 449   char buf[32];
 450   char *bufp = buf;
 451   int nc;
 452
 453   do
 454     {
 455       char digit = '0' + (vma & 0x0f);
 456       if (digit > '9')
 457         digit += 'a' - '0' - 10;
 458       *bufp++ = digit;
 459       vma >>= 4;
 460     }
 461   while (vma != 0);
 462   nc = bufp - buf;
 463
 464   while (bufp > buf)
 465     putchar (*--bufp);
 466   return nc;
 467 }
 468 #endif
 469
 470 /* Print a VMA value.  */
 471 static int
 472 print_vma (bfd_vma vma, print_mode mode)
 473 {
 474 #ifdef BFD64
 475   if (is_32bit_elf)
 476 #endif
 477     {
 478       switch (mode)
 479         {
 480         case FULL_HEX:
 481           return printf ("0x%8.8lx", (unsigned long) vma);
 482
 483         case LONG_HEX:
 484           return printf ("%8.8lx", (unsigned long) vma);
 485
 486         case DEC_5:
 487           if (vma <= 99999)
 488             return printf ("%5ld", (long) vma);
 489           /* Drop through.  */
 490
 491         case PREFIX_HEX:
 492           return printf ("0x%lx", (unsigned long) vma);
 493
 494         case HEX:
 495           return printf ("%lx", (unsigned long) vma);
 496
 497         case DEC:
 498           return printf ("%ld", (unsigned long) vma);
 499
 500         case UNSIGNED:
 501           return printf ("%lu", (unsigned long) vma);
 502         }
 503     }
 504 #ifdef BFD64
 505   else
 506     {
 507       int nc = 0;
 508
 509       switch (mode)
 510         {
 511         case FULL_HEX:
 512           nc = printf ("0x");
 513           /* Drop through.  */
 514
 515         case LONG_HEX:
 516           printf_vma (vma);
 517           return nc + 16;
 518
 519         case PREFIX_HEX:
 520           nc = printf ("0x");
 521           /* Drop through.  */
 522
 523         case HEX:
 524 #if BFD_HOST_64BIT_LONG
 525           return nc + printf ("%lx", vma);
 526 #else
 527           return nc + print_hex_vma (vma);
 528 #endif
 529
 530         case DEC:
 531 #if BFD_HOST_64BIT_LONG
 532           return printf ("%ld", vma);
 533 #else
 534           return print_dec_vma (vma, 1);
 535 #endif
 536
 537         case DEC_5:
 538 #if BFD_HOST_64BIT_LONG
 539           if (vma <= 99999)
 540             return printf ("%5ld", vma);
 541           else
 542             return printf ("%#lx", vma);
 543 #else
 544           if (vma <= 99999)
 545             return printf ("%5ld", _bfd_int64_low (vma));
 546           else
 547             return print_hex_vma (vma);
 548 #endif
 549
 550         case UNSIGNED:
 551 #if BFD_HOST_64BIT_LONG
 552           return printf ("%lu", vma);
 553 #else
 554           return print_dec_vma (vma, 0);
 555 #endif
 556         }
 557     }
 558 #endif
 559   return 0;
 560 }
 561
 562 /* Display a symbol on stdout.  If do_wide is not true then
 563    format the symbol to be at most WIDTH characters,
 564    truncating as necessary.  If WIDTH is negative then
 565    format the string to be exactly - WIDTH characters,
 566    truncating or padding as necessary.  */
 567
 568 static void
 569 print_symbol (int width, const char *symbol)
 570 {
 571   if (do_wide)
 572     printf ("%s", symbol);
 573   else if (width < 0)
 574     printf ("%-*.*s", width, width, symbol);
 575   else
 576     printf ("%-.*s", width, symbol);
 577 }
 578
 579 static bfd_vma
 580 byte_get_big_endian (unsigned char *field, int size)
 581 {
 582   switch (size)
 583     {
 584     case 1:
 585       return *field;
 586
 587     case 2:
 588       return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
 589
 590 #ifndef BFD64
 591     case 8:
 592       /* Although we are extracing data from an 8 byte wide field,
 593          we are returning only 4 bytes of data.  */
 594       field += 4;
 595       /* Fall thru */
 596 #endif
 597     case 4:
 598       return ((unsigned long) (field[3]))
 599         |   (((unsigned long) (field[2])) << 8)
 600         |   (((unsigned long) (field[1])) << 16)
 601         |   (((unsigned long) (field[0])) << 24);
 602
 603 #ifdef BFD64
 604     case 8:
 605       return ((bfd_vma) (field[7]))
 606         |   (((bfd_vma) (field[6])) << 8)
 607         |   (((bfd_vma) (field[5])) << 16)
 608         |   (((bfd_vma) (field[4])) << 24)
 609         |   (((bfd_vma) (field[3])) << 32)
 610         |   (((bfd_vma) (field[2])) << 40)
 611         |   (((bfd_vma) (field[1])) << 48)
 612         |   (((bfd_vma) (field[0])) << 56);
 613 #endif
 614
 615     default:
 616       error (_("Unhandled data length: %d\n"), size);
 617       abort ();
 618     }
 619 }
 620
 621 static void
 622 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
 623 {
 624   switch (size)
 625     {
 626     case 8:
 627       field[7] = value & 0xff;
 628       field[6] = (value >> 8) & 0xff;
 629       field[5] = (value >> 16) & 0xff;
 630       field[4] = (value >> 24) & 0xff;
 631       value >>= 16;
 632       value >>= 16;
 633       /* Fall through.  */
 634     case 4:
 635       field[3] = value & 0xff;
 636       field[2] = (value >> 8) & 0xff;
 637       value >>= 16;
 638       /* Fall through.  */
 639     case 2:
 640       field[1] = value & 0xff;
 641       value >>= 8;
 642       /* Fall through.  */
 643     case 1:
 644       field[0] = value & 0xff;
 645       break;
 646
 647     default:
 648       error (_("Unhandled data length: %d\n"), size);
 649       abort ();
 650     }
 651 }
 652
 653 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 654
 655 static Elf_Internal_Shdr *
 656 find_section (const char *name)
 657 {
 658   unsigned int i;
 659
 660   for (i = 0; i < elf_header.e_shnum; i++)
 661     if (streq (SECTION_NAME (section_headers + i), name))
 662       return section_headers + i;
 663
 664   return NULL;
 665 }
 666
 667 /* Guess the relocation size commonly used by the specific machines.  */
 668
 669 static int
 670 guess_is_rela (unsigned long e_machine)
 671 {
 672   switch (e_machine)
 673     {
 674       /* Targets that use REL relocations.  */
 675     case EM_ARM:
 676     case EM_386:
 677     case EM_486:
 678     case EM_960:
 679     case EM_DLX:
 680     case EM_OPENRISC:
 681     case EM_OR32:
 682     case EM_CYGNUS_M32R:
 683     case EM_D10V:
 684     case EM_CYGNUS_D10V:
 685     case EM_MIPS:
 686     case EM_MIPS_RS3_LE:
 687       return FALSE;
 688
 689       /* Targets that use RELA relocations.  */
 690     case EM_68K:
 691     case EM_H8_300:
 692     case EM_H8_300H:
 693     case EM_H8S:
 694     case EM_SPARC32PLUS:
 695     case EM_SPARCV9:
 696     case EM_SPARC:
 697     case EM_PPC:
 698     case EM_PPC64:
 699     case EM_V850:
 700     case EM_CYGNUS_V850:
 701     case EM_D30V:
 702     case EM_CYGNUS_D30V:
 703     case EM_MN10200:
 704     case EM_CYGNUS_MN10200:
 705     case EM_MN10300:
 706     case EM_CYGNUS_MN10300:
 707     case EM_FR30:
 708     case EM_CYGNUS_FR30:
 709     case EM_CYGNUS_FRV:
 710     case EM_SH:
 711     case EM_ALPHA:
 712     case EM_MCORE:
 713     case EM_IA_64:
 714     case EM_AVR:
 715     case EM_AVR_OLD:
 716     case EM_CRIS:
 717     case EM_860:
 718     case EM_X86_64:
 719     case EM_S390:
 720     case EM_S390_OLD:
 721     case EM_MMIX:
 722     case EM_MSP430:
 723     case EM_MSP430_OLD:
 724     case EM_XSTORMY16:
 725     case EM_CRX:
 726     case EM_VAX:
 727     case EM_IP2K:
 728     case EM_IP2K_OLD:
 729     case EM_IQ2000:
 730     case EM_XTENSA:
 731     case EM_XTENSA_OLD:
 732     case EM_M32R:
 733     case EM_MS1:
 734       return TRUE;
 735
 736     case EM_MMA:
 737     case EM_PCP:
 738     case EM_NCPU:
 739     case EM_NDR1:
 740     case EM_STARCORE:
 741     case EM_ME16:
 742     case EM_ST100:
 743     case EM_TINYJ:
 744     case EM_FX66:
 745     case EM_ST9PLUS:
 746     case EM_ST7:
 747     case EM_68HC16:
 748     case EM_68HC11:
 749     case EM_68HC08:
 750     case EM_68HC05:
 751     case EM_SVX:
 752     case EM_ST19:
 753     default:
 754       warn (_("Don't know about relocations on this machine architecture\n"));
 755       return FALSE;
 756     }
 757 }
 758
 759 static int
 760 slurp_rela_relocs (FILE *file,
 761                    unsigned long rel_offset,
 762                    unsigned long rel_size,
 763                    Elf_Internal_Rela **relasp,
 764                    unsigned long *nrelasp)
 765 {
 766   Elf_Internal_Rela *relas;
 767   unsigned long nrelas;
 768   unsigned int i;
 769
 770   if (is_32bit_elf)
 771     {
 772       Elf32_External_Rela *erelas;
 773
 774       erelas = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
 775       if (!erelas)
 776         return 0;
 777
 778       nrelas = rel_size / sizeof (Elf32_External_Rela);
 779
 780       relas = malloc (nrelas * sizeof (Elf_Internal_Rela));
 781
 782       if (relas == NULL)
 783         {
 784           error (_("out of memory parsing relocs"));
 785           return 0;
 786         }
 787
 788       for (i = 0; i < nrelas; i++)
 789         {
 790           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 791           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 792           relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
 793         }
 794
 795       free (erelas);
 796     }
 797   else
 798     {
 799       Elf64_External_Rela *erelas;
 800
 801       erelas = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
 802       if (!erelas)
 803         return 0;
 804
 805       nrelas = rel_size / sizeof (Elf64_External_Rela);
 806
 807       relas = malloc (nrelas * sizeof (Elf_Internal_Rela));
 808
 809       if (relas == NULL)
 810         {
 811           error (_("out of memory parsing relocs"));
 812           return 0;
 813         }
 814
 815       for (i = 0; i < nrelas; i++)
 816         {
 817           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 818           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 819           relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
 820         }
 821
 822       free (erelas);
 823     }
 824   *relasp = relas;
 825   *nrelasp = nrelas;
 826   return 1;
 827 }
 828
 829 static int
 830 slurp_rel_relocs (FILE *file,
 831                   unsigned long rel_offset,
 832                   unsigned long rel_size,
 833                   Elf_Internal_Rela **relsp,
 834                   unsigned long *nrelsp)
 835 {
 836   Elf_Internal_Rela *rels;
 837   unsigned long nrels;
 838   unsigned int i;
 839
 840   if (is_32bit_elf)
 841     {
 842       Elf32_External_Rel *erels;
 843
 844       erels = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
 845       if (!erels)
 846         return 0;
 847
 848       nrels = rel_size / sizeof (Elf32_External_Rel);
 849
 850       rels = malloc (nrels * sizeof (Elf_Internal_Rela));
 851
 852       if (rels == NULL)
 853         {
 854           error (_("out of memory parsing relocs"));
 855           return 0;
 856         }
 857
 858       for (i = 0; i < nrels; i++)
 859         {
 860           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 861           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 862           rels[i].r_addend = 0;
 863         }
 864
 865       free (erels);
 866     }
 867   else
 868     {
 869       Elf64_External_Rel *erels;
 870
 871       erels = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
 872       if (!erels)
 873         return 0;
 874
 875       nrels = rel_size / sizeof (Elf64_External_Rel);
 876
 877       rels = malloc (nrels * sizeof (Elf_Internal_Rela));
 878
 879       if (rels == NULL)
 880         {
 881           error (_("out of memory parsing relocs"));
 882           return 0;
 883         }
 884
 885       for (i = 0; i < nrels; i++)
 886         {
 887           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 888           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 889           rels[i].r_addend = 0;
 890         }
 891
 892       free (erels);
 893     }
 894   *relsp = rels;
 895   *nrelsp = nrels;
 896   return 1;
 897 }
 898
 899 /* Display the contents of the relocation data found at the specified
 900    offset.  */
 901
 902 static int
 903 dump_relocations (FILE *file,
 904                   unsigned long rel_offset,
 905                   unsigned long rel_size,
 906                   Elf_Internal_Sym *symtab,
 907                   unsigned long nsyms,
 908                   char *strtab,
 909                   unsigned long strtablen,
 910                   int is_rela)
 911 {
 912   unsigned int i;
 913   Elf_Internal_Rela *rels;
 914
 915
 916   if (is_rela == UNKNOWN)
 917     is_rela = guess_is_rela (elf_header.e_machine);
 918
 919   if (is_rela)
 920     {
 921       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 922         return 0;
 923     }
 924   else
 925     {
 926       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 927         return 0;
 928     }
 929
 930   if (is_32bit_elf)
 931     {
 932       if (is_rela)
 933         {
 934           if (do_wide)
 935             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 936           else
 937             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 938         }
 939       else
 940         {
 941           if (do_wide)
 942             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 943           else
 944             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 945         }
 946     }
 947   else
 948     {
 949       if (is_rela)
 950         {
 951           if (do_wide)
 952             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 953           else
 954             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 955         }
 956       else
 957         {
 958           if (do_wide)
 959             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 960           else
 961             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 962         }
 963     }
 964
 965   for (i = 0; i < rel_size; i++)
 966     {
 967       const char *rtype;
 968       const char *rtype2 = NULL;
 969       const char *rtype3 = NULL;
 970       bfd_vma offset;
 971       bfd_vma info;
 972       bfd_vma symtab_index;
 973       bfd_vma type;
 974       bfd_vma type2 = 0;
 975       bfd_vma type3 = 0;
 976
 977       offset = rels[i].r_offset;
 978       info   = rels[i].r_info;
 979
 980       if (is_32bit_elf)
 981         {
 982           type         = ELF32_R_TYPE (info);
 983           symtab_index = ELF32_R_SYM  (info);
 984         }
 985       else
 986         {
 987           /* The #ifdef BFD64 below is to prevent a compile time warning.
 988              We know that if we do not have a 64 bit data type that we
 989              will never execute this code anyway.  */
 990 #ifdef BFD64
 991           if (elf_header.e_machine == EM_MIPS)
 992             {
 993               /* In little-endian objects, r_info isn't really a 64-bit
 994                  little-endian value: it has a 32-bit little-endian
 995                  symbol index followed by four individual byte fields.
 996                  Reorder INFO accordingly.  */
 997               if (elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 998                 info = (((info & 0xffffffff) << 32)
 999                         | ((info >> 56) & 0xff)
1000                         | ((info >> 40) & 0xff00)
1001                         | ((info >> 24) & 0xff0000)
1002                         | ((info >> 8) & 0xff000000));
1003               type  = ELF64_MIPS_R_TYPE (info);
1004               type2 = ELF64_MIPS_R_TYPE2 (info);
1005               type3 = ELF64_MIPS_R_TYPE3 (info);
1006             }
1007           else if (elf_header.e_machine == EM_SPARCV9)
1008             type = ELF64_R_TYPE_ID (info);
1009           else
1010             type = ELF64_R_TYPE (info);
1011
1012           symtab_index = ELF64_R_SYM  (info);
1013 #endif
1014         }
1015
1016       if (is_32bit_elf)
1017         {
1018 #ifdef _bfd_int64_low
1019           printf ("%8.8lx  %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
1020 #else
1021           printf ("%8.8lx  %8.8lx ", offset, info);
1022 #endif
1023         }
1024       else
1025         {
1026 #ifdef _bfd_int64_low
1027           printf (do_wide
1028                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1029                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1030                   _bfd_int64_high (offset),
1031                   _bfd_int64_low (offset),
1032                   _bfd_int64_high (info),
1033                   _bfd_int64_low (info));
1034 #else
1035           printf (do_wide
1036                   ? "%16.16lx  %16.16lx "
1037                   : "%12.12lx  %12.12lx ",
1038                   offset, info);
1039 #endif
1040         }
1041
1042       switch (elf_header.e_machine)
1043         {
1044         default:
1045           rtype = NULL;
1046           break;
1047
1048         case EM_M32R:
1049         case EM_CYGNUS_M32R:
1050           rtype = elf_m32r_reloc_type (type);
1051           break;
1052
1053         case EM_386:
1054         case EM_486:
1055           rtype = elf_i386_reloc_type (type);
1056           break;
1057
1058         case EM_68HC11:
1059         case EM_68HC12:
1060           rtype = elf_m68hc11_reloc_type (type);
1061           break;
1062
1063         case EM_68K:
1064           rtype = elf_m68k_reloc_type (type);
1065           break;
1066
1067         case EM_960:
1068           rtype = elf_i960_reloc_type (type);
1069           break;
1070
1071         case EM_AVR:
1072         case EM_AVR_OLD:
1073           rtype = elf_avr_reloc_type (type);
1074           break;
1075
1076         case EM_OLD_SPARCV9:
1077         case EM_SPARC32PLUS:
1078         case EM_SPARCV9:
1079         case EM_SPARC:
1080           rtype = elf_sparc_reloc_type (type);
1081           break;
1082
1083         case EM_V850:
1084         case EM_CYGNUS_V850:
1085           rtype = v850_reloc_type (type);
1086           break;
1087
1088         case EM_D10V:
1089         case EM_CYGNUS_D10V:
1090           rtype = elf_d10v_reloc_type (type);
1091           break;
1092
1093         case EM_D30V:
1094         case EM_CYGNUS_D30V:
1095           rtype = elf_d30v_reloc_type (type);
1096           break;
1097
1098         case EM_DLX:
1099           rtype = elf_dlx_reloc_type (type);
1100           break;
1101
1102         case EM_SH:
1103           rtype = elf_sh_reloc_type (type);
1104           break;
1105
1106         case EM_MN10300:
1107         case EM_CYGNUS_MN10300:
1108           rtype = elf_mn10300_reloc_type (type);
1109           break;
1110
1111         case EM_MN10200:
1112         case EM_CYGNUS_MN10200:
1113           rtype = elf_mn10200_reloc_type (type);
1114           break;
1115
1116         case EM_FR30:
1117         case EM_CYGNUS_FR30:
1118           rtype = elf_fr30_reloc_type (type);
1119           break;
1120
1121         case EM_CYGNUS_FRV:
1122           rtype = elf_frv_reloc_type (type);
1123           break;
1124
1125         case EM_MCORE:
1126           rtype = elf_mcore_reloc_type (type);
1127           break;
1128
1129         case EM_MMIX:
1130           rtype = elf_mmix_reloc_type (type);
1131           break;
1132
1133         case EM_MSP430:
1134         case EM_MSP430_OLD:
1135           rtype = elf_msp430_reloc_type (type);
1136           break;
1137
1138         case EM_PPC:
1139           rtype = elf_ppc_reloc_type (type);
1140           break;
1141
1142         case EM_PPC64:
1143           rtype = elf_ppc64_reloc_type (type);
1144           break;
1145
1146         case EM_MIPS:
1147         case EM_MIPS_RS3_LE:
1148           rtype = elf_mips_reloc_type (type);
1149           if (!is_32bit_elf)
1150             {
1151               rtype2 = elf_mips_reloc_type (type2);
1152               rtype3 = elf_mips_reloc_type (type3);
1153             }
1154           break;
1155
1156         case EM_ALPHA:
1157           rtype = elf_alpha_reloc_type (type);
1158           break;
1159
1160         case EM_ARM:
1161           rtype = elf_arm_reloc_type (type);
1162           break;
1163
1164         case EM_ARC:
1165           rtype = elf_arc_reloc_type (type);
1166           break;
1167
1168         case EM_PARISC:
1169           rtype = elf_hppa_reloc_type (type);
1170           break;
1171
1172         case EM_H8_300:
1173         case EM_H8_300H:
1174         case EM_H8S:
1175           rtype = elf_h8_reloc_type (type);
1176           break;
1177
1178         case EM_OPENRISC:
1179         case EM_OR32:
1180           rtype = elf_or32_reloc_type (type);
1181           break;
1182
1183         case EM_PJ:
1184         case EM_PJ_OLD:
1185           rtype = elf_pj_reloc_type (type);
1186           break;
1187         case EM_IA_64:
1188           rtype = elf_ia64_reloc_type (type);
1189           break;
1190
1191         case EM_CRIS:
1192           rtype = elf_cris_reloc_type (type);
1193           break;
1194
1195         case EM_860:
1196           rtype = elf_i860_reloc_type (type);
1197           break;
1198
1199         case EM_X86_64:
1200           rtype = elf_x86_64_reloc_type (type);
1201           break;
1202
1203         case EM_S370:
1204           rtype = i370_reloc_type (type);
1205           break;
1206
1207         case EM_S390_OLD:
1208         case EM_S390:
1209           rtype = elf_s390_reloc_type (type);
1210           break;
1211
1212         case EM_XSTORMY16:
1213           rtype = elf_xstormy16_reloc_type (type);
1214           break;
1215
1216         case EM_CRX:
1217           rtype = elf_crx_reloc_type (type);
1218           break;
1219
1220         case EM_VAX:
1221           rtype = elf_vax_reloc_type (type);
1222           break;
1223
1224         case EM_IP2K:
1225         case EM_IP2K_OLD:
1226           rtype = elf_ip2k_reloc_type (type);
1227           break;
1228
1229         case EM_IQ2000:
1230           rtype = elf_iq2000_reloc_type (type);
1231           break;
1232
1233         case EM_XTENSA_OLD:
1234         case EM_XTENSA:
1235           rtype = elf_xtensa_reloc_type (type);
1236           break;
1237
1238         case EM_MS1:
1239           rtype = elf_ms1_reloc_type (type);
1240           break;
1241         }
1242
1243       if (rtype == NULL)
1244 #ifdef _bfd_int64_low
1245         printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1246 #else
1247         printf (_("unrecognized: %-7lx"), type);
1248 #endif
1249       else
1250         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1251
1252       if (elf_header.e_machine == EM_ALPHA
1253           && streq (rtype, "R_ALPHA_LITUSE")
1254           && is_rela)
1255         {
1256           switch (rels[i].r_addend)
1257             {
1258             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1259             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1260             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1261             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1262             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1263             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1264             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1265             default: rtype = NULL;
1266             }
1267           if (rtype)
1268             printf (" (%s)", rtype);
1269           else
1270             {
1271               putchar (' ');
1272               printf (_("<unknown addend: %lx>"),
1273                       (unsigned long) rels[i].r_addend);
1274             }
1275         }
1276       else if (symtab_index)
1277         {
1278           if (symtab == NULL || symtab_index >= nsyms)
1279             printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1280           else
1281             {
1282               Elf_Internal_Sym *psym;
1283
1284               psym = symtab + symtab_index;
1285
1286               printf (" ");
1287               print_vma (psym->st_value, LONG_HEX);
1288               printf (is_32bit_elf ? "   " : " ");
1289
1290               if (psym->st_name == 0)
1291                 {
1292                   const char *sec_name = "<null>";
1293                   char name_buf[40];
1294
1295                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1296                     {
1297                       bfd_vma sec_index = (bfd_vma) -1;
1298
1299                       if (psym->st_shndx < SHN_LORESERVE)
1300                         sec_index = psym->st_shndx;
1301                       else if (psym->st_shndx > SHN_HIRESERVE)
1302                         sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1303                                                       - SHN_LORESERVE);
1304
1305                       if (sec_index != (bfd_vma) -1)
1306                         sec_name = SECTION_NAME (section_headers + sec_index);
1307                       else if (psym->st_shndx == SHN_ABS)
1308                         sec_name = "ABS";
1309                       else if (psym->st_shndx == SHN_COMMON)
1310                         sec_name = "COMMON";
1311                       else if (elf_header.e_machine == EM_IA_64
1312                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1313                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1314                         sec_name = "ANSI_COM";
1315                       else
1316                         {
1317                           sprintf (name_buf, "<section 0x%x>",
1318                                    (unsigned int) psym->st_shndx);
1319                           sec_name = name_buf;
1320                         }
1321                     }
1322                   print_symbol (22, sec_name);
1323                 }
1324               else if (strtab == NULL)
1325                 printf (_("<string table index: %3ld>"), psym->st_name);
1326               else if (psym->st_name > strtablen)
1327                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1328               else
1329                 print_symbol (22, strtab + psym->st_name);
1330
1331               if (is_rela)
1332                 printf (" + %lx", (unsigned long) rels[i].r_addend);
1333             }
1334         }
1335       else if (is_rela)
1336         {
1337           printf ("%*c", is_32bit_elf ?
1338                   (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1339           print_vma (rels[i].r_addend, LONG_HEX);
1340         }
1341
1342       if (elf_header.e_machine == EM_SPARCV9 && streq (rtype, "R_SPARC_OLO10"))
1343         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1344
1345       putchar ('\n');
1346
1347       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1348         {
1349           printf ("                    Type2: ");
1350
1351           if (rtype2 == NULL)
1352 #ifdef _bfd_int64_low
1353             printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1354 #else
1355             printf (_("unrecognized: %-7lx"), type2);
1356 #endif
1357           else
1358             printf ("%-17.17s", rtype2);
1359
1360           printf ("\n                    Type3: ");
1361
1362           if (rtype3 == NULL)
1363 #ifdef _bfd_int64_low
1364             printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1365 #else
1366             printf (_("unrecognized: %-7lx"), type3);
1367 #endif
1368           else
1369             printf ("%-17.17s", rtype3);
1370
1371           putchar ('\n');
1372         }
1373     }
1374
1375   free (rels);
1376
1377   return 1;
1378 }
1379
1380 static const char *
1381 get_mips_dynamic_type (unsigned long type)
1382 {
1383   switch (type)
1384     {
1385     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1386     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1387     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1388     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1389     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1390     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1391     case DT_MIPS_MSYM: return "MIPS_MSYM";
1392     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1393     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1394     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1395     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1396     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1397     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1398     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1399     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1400     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1401     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1402     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1403     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1404     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1405     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1406     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1407     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1408     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1409     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1410     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1411     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1412     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1413     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1414     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1415     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1416     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1417     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1418     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1419     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1420     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1421     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1422     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1423     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1424     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1425     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1426     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1427     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1428     default:
1429       return NULL;
1430     }
1431 }
1432
1433 static const char *
1434 get_sparc64_dynamic_type (unsigned long type)
1435 {
1436   switch (type)
1437     {
1438     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1439     default:
1440       return NULL;
1441     }
1442 }
1443
1444 static const char *
1445 get_ppc_dynamic_type (unsigned long type)
1446 {
1447   switch (type)
1448     {
1449     case DT_PPC_GOT: return "PPC_GOT";
1450     default:
1451       return NULL;
1452     }
1453 }
1454
1455 static const char *
1456 get_ppc64_dynamic_type (unsigned long type)
1457 {
1458   switch (type)
1459     {
1460     case DT_PPC64_GLINK: return "PPC64_GLINK";
1461     case DT_PPC64_OPD:   return "PPC64_OPD";
1462     case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1463     default:
1464       return NULL;
1465     }
1466 }
1467
1468 static const char *
1469 get_parisc_dynamic_type (unsigned long type)
1470 {
1471   switch (type)
1472     {
1473     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1474     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1475     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1476     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1477     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1478     case DT_HP_PREINIT:         return "HP_PREINIT";
1479     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1480     case DT_HP_NEEDED:          return "HP_NEEDED";
1481     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1482     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1483     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1484     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1485     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1486     default:
1487       return NULL;
1488     }
1489 }
1490
1491 static const char *
1492 get_ia64_dynamic_type (unsigned long type)
1493 {
1494   switch (type)
1495     {
1496     case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1497     default:
1498       return NULL;
1499     }
1500 }
1501
1502 static const char *
1503 get_alpha_dynamic_type (unsigned long type)
1504 {
1505   switch (type)
1506     {
1507     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1508     default:
1509       return NULL;
1510     }
1511 }
1512
1513 static const char *
1514 get_dynamic_type (unsigned long type)
1515 {
1516   static char buff[64];
1517
1518   switch (type)
1519     {
1520     case DT_NULL:       return "NULL";
1521     case DT_NEEDED:     return "NEEDED";
1522     case DT_PLTRELSZ:   return "PLTRELSZ";
1523     case DT_PLTGOT:     return "PLTGOT";
1524     case DT_HASH:       return "HASH";
1525     case DT_STRTAB:     return "STRTAB";
1526     case DT_SYMTAB:     return "SYMTAB";
1527     case DT_RELA:       return "RELA";
1528     case DT_RELASZ:     return "RELASZ";
1529     case DT_RELAENT:    return "RELAENT";
1530     case DT_STRSZ:      return "STRSZ";
1531     case DT_SYMENT:     return "SYMENT";
1532     case DT_INIT:       return "INIT";
1533     case DT_FINI:       return "FINI";
1534     case DT_SONAME:     return "SONAME";
1535     case DT_RPATH:      return "RPATH";
1536     case DT_SYMBOLIC:   return "SYMBOLIC";
1537     case DT_REL:        return "REL";
1538     case DT_RELSZ:      return "RELSZ";
1539     case DT_RELENT:     return "RELENT";
1540     case DT_PLTREL:     return "PLTREL";
1541     case DT_DEBUG:      return "DEBUG";
1542     case DT_TEXTREL:    return "TEXTREL";
1543     case DT_JMPREL:     return "JMPREL";
1544     case DT_BIND_NOW:   return "BIND_NOW";
1545     case DT_INIT_ARRAY: return "INIT_ARRAY";
1546     case DT_FINI_ARRAY: return "FINI_ARRAY";
1547     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1548     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1549     case DT_RUNPATH:    return "RUNPATH";
1550     case DT_FLAGS:      return "FLAGS";
1551
1552     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1553     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1554
1555     case DT_CHECKSUM:   return "CHECKSUM";
1556     case DT_PLTPADSZ:   return "PLTPADSZ";
1557     case DT_MOVEENT:    return "MOVEENT";
1558     case DT_MOVESZ:     return "MOVESZ";
1559     case DT_FEATURE:    return "FEATURE";
1560     case DT_POSFLAG_1:  return "POSFLAG_1";
1561     case DT_SYMINSZ:    return "SYMINSZ";
1562     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1563
1564     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1565     case DT_CONFIG:     return "CONFIG";
1566     case DT_DEPAUDIT:   return "DEPAUDIT";
1567     case DT_AUDIT:      return "AUDIT";
1568     case DT_PLTPAD:     return "PLTPAD";
1569     case DT_MOVETAB:    return "MOVETAB";
1570     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1571
1572     case DT_VERSYM:     return "VERSYM";
1573
1574     case DT_RELACOUNT:  return "RELACOUNT";
1575     case DT_RELCOUNT:   return "RELCOUNT";
1576     case DT_FLAGS_1:    return "FLAGS_1";
1577     case DT_VERDEF:     return "VERDEF";
1578     case DT_VERDEFNUM:  return "VERDEFNUM";
1579     case DT_VERNEED:    return "VERNEED";
1580     case DT_VERNEEDNUM: return "VERNEEDNUM";
1581
1582     case DT_AUXILIARY:  return "AUXILIARY";
1583     case DT_USED:       return "USED";
1584     case DT_FILTER:     return "FILTER";
1585
1586     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1587     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1588     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1589     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1590     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1591
1592     default:
1593       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1594         {
1595           const char *result;
1596
1597           switch (elf_header.e_machine)
1598             {
1599             case EM_MIPS:
1600             case EM_MIPS_RS3_LE:
1601               result = get_mips_dynamic_type (type);
1602               break;
1603             case EM_SPARCV9:
1604               result = get_sparc64_dynamic_type (type);
1605               break;
1606             case EM_PPC:
1607               result = get_ppc_dynamic_type (type);
1608               break;
1609             case EM_PPC64:
1610               result = get_ppc64_dynamic_type (type);
1611               break;
1612             case EM_IA_64:
1613               result = get_ia64_dynamic_type (type);
1614               break;
1615             case EM_ALPHA:
1616               result = get_alpha_dynamic_type (type);
1617               break;
1618             default:
1619               result = NULL;
1620               break;
1621             }
1622
1623           if (result != NULL)
1624             return result;
1625
1626           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1627         }
1628       else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1629         {
1630           const char *result;
1631
1632           switch (elf_header.e_machine)
1633             {
1634             case EM_PARISC:
1635               result = get_parisc_dynamic_type (type);
1636               break;
1637             default:
1638               result = NULL;
1639               break;
1640             }
1641
1642           if (result != NULL)
1643             return result;
1644
1645           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1646                     type);
1647         }
1648       else
1649         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1650
1651       return buff;
1652     }
1653 }
1654
1655 static char *
1656 get_file_type (unsigned e_type)
1657 {
1658   static char buff[32];
1659
1660   switch (e_type)
1661     {
1662     case ET_NONE:       return _("NONE (None)");
1663     case ET_REL:        return _("REL (Relocatable file)");
1664     case ET_EXEC:       return _("EXEC (Executable file)");
1665     case ET_DYN:        return _("DYN (Shared object file)");
1666     case ET_CORE:       return _("CORE (Core file)");
1667
1668     default:
1669       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1670         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1671       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1672         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1673       else
1674         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1675       return buff;
1676     }
1677 }
1678
1679 static char *
1680 get_machine_name (unsigned e_machine)
1681 {
1682   static char buff[64]; /* XXX */
1683
1684   switch (e_machine)
1685     {
1686     case EM_NONE:               return _("None");
1687     case EM_M32:                return "WE32100";
1688     case EM_SPARC:              return "Sparc";
1689     case EM_386:                return "Intel 80386";
1690     case EM_68K:                return "MC68000";
1691     case EM_88K:                return "MC88000";
1692     case EM_486:                return "Intel 80486";
1693     case EM_860:                return "Intel 80860";
1694     case EM_MIPS:               return "MIPS R3000";
1695     case EM_S370:               return "IBM System/370";
1696     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1697     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1698     case EM_PARISC:             return "HPPA";
1699     case EM_PPC_OLD:            return "Power PC (old)";
1700     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1701     case EM_960:                return "Intel 90860";
1702     case EM_PPC:                return "PowerPC";
1703     case EM_PPC64:              return "PowerPC64";
1704     case EM_V800:               return "NEC V800";
1705     case EM_FR20:               return "Fujitsu FR20";
1706     case EM_RH32:               return "TRW RH32";
1707     case EM_MCORE:              return "MCORE";
1708     case EM_ARM:                return "ARM";
1709     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1710     case EM_SH:                 return "Renesas / SuperH SH";
1711     case EM_SPARCV9:            return "Sparc v9";
1712     case EM_TRICORE:            return "Siemens Tricore";
1713     case EM_ARC:                return "ARC";
1714     case EM_H8_300:             return "Renesas H8/300";
1715     case EM_H8_300H:            return "Renesas H8/300H";
1716     case EM_H8S:                return "Renesas H8S";
1717     case EM_H8_500:             return "Renesas H8/500";
1718     case EM_IA_64:              return "Intel IA-64";
1719     case EM_MIPS_X:             return "Stanford MIPS-X";
1720     case EM_COLDFIRE:           return "Motorola Coldfire";
1721     case EM_68HC12:             return "Motorola M68HC12";
1722     case EM_ALPHA:              return "Alpha";
1723     case EM_CYGNUS_D10V:
1724     case EM_D10V:               return "d10v";
1725     case EM_CYGNUS_D30V:
1726     case EM_D30V:               return "d30v";
1727     case EM_CYGNUS_M32R:
1728     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1729     case EM_CYGNUS_V850:
1730     case EM_V850:               return "NEC v850";
1731     case EM_CYGNUS_MN10300:
1732     case EM_MN10300:            return "mn10300";
1733     case EM_CYGNUS_MN10200:
1734     case EM_MN10200:            return "mn10200";
1735     case EM_CYGNUS_FR30:
1736     case EM_FR30:               return "Fujitsu FR30";
1737     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1738     case EM_PJ_OLD:
1739     case EM_PJ:                 return "picoJava";
1740     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1741     case EM_PCP:                return "Siemens PCP";
1742     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1743     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1744     case EM_STARCORE:           return "Motorola Star*Core processor";
1745     case EM_ME16:               return "Toyota ME16 processor";
1746     case EM_ST100:              return "STMicroelectronics ST100 processor";
1747     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1748     case EM_FX66:               return "Siemens FX66 microcontroller";
1749     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1750     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1751     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1752     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1753     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1754     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1755     case EM_SVX:                return "Silicon Graphics SVx";
1756     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1757     case EM_VAX:                return "Digital VAX";
1758     case EM_AVR_OLD:
1759     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1760     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1761     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1762     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
1763     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
1764     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
1765     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
1766     case EM_PRISM:              return "Vitesse Prism";
1767     case EM_X86_64:             return "Advanced Micro Devices X86-64";
1768     case EM_S390_OLD:
1769     case EM_S390:               return "IBM S/390";
1770     case EM_XSTORMY16:          return "Sanyo Xstormy16 CPU core";
1771     case EM_OPENRISC:
1772     case EM_OR32:               return "OpenRISC";
1773     case EM_CRX:                return "National Semiconductor CRX microprocessor";
1774     case EM_DLX:                return "OpenDLX";
1775     case EM_IP2K_OLD:
1776     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
1777     case EM_IQ2000:             return "Vitesse IQ2000";
1778     case EM_XTENSA_OLD:
1779     case EM_XTENSA:             return "Tensilica Xtensa Processor";
1780     case EM_MS1:                return "Morpho Techologies MS1 processor";
1781     default:
1782       snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_machine);
1783       return buff;
1784     }
1785 }
1786
1787 static void
1788 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1789 {
1790   unsigned eabi;
1791   int unknown = 0;
1792
1793   eabi = EF_ARM_EABI_VERSION (e_flags);
1794   e_flags &= ~ EF_ARM_EABIMASK;
1795
1796   /* Handle "generic" ARM flags.  */
1797   if (e_flags & EF_ARM_RELEXEC)
1798     {
1799       strcat (buf, ", relocatable executable");
1800       e_flags &= ~ EF_ARM_RELEXEC;
1801     }
1802
1803   if (e_flags & EF_ARM_HASENTRY)
1804     {
1805       strcat (buf, ", has entry point");
1806       e_flags &= ~ EF_ARM_HASENTRY;
1807     }
1808
1809   /* Now handle EABI specific flags.  */
1810   switch (eabi)
1811     {
1812     default:
1813       strcat (buf, ", <unrecognized EABI>");
1814       if (e_flags)
1815         unknown = 1;
1816       break;
1817
1818     case EF_ARM_EABI_VER1:
1819       strcat (buf, ", Version1 EABI");
1820       while (e_flags)
1821         {
1822           unsigned flag;
1823
1824           /* Process flags one bit at a time.  */
1825           flag = e_flags & - e_flags;
1826           e_flags &= ~ flag;
1827
1828           switch (flag)
1829             {
1830             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
1831               strcat (buf, ", sorted symbol tables");
1832               break;
1833
1834             default:
1835               unknown = 1;
1836               break;
1837             }
1838         }
1839       break;
1840
1841     case EF_ARM_EABI_VER2:
1842       strcat (buf, ", Version2 EABI");
1843       while (e_flags)
1844         {
1845           unsigned flag;
1846
1847           /* Process flags one bit at a time.  */
1848           flag = e_flags & - e_flags;
1849           e_flags &= ~ flag;
1850
1851           switch (flag)
1852             {
1853             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
1854               strcat (buf, ", sorted symbol tables");
1855               break;
1856
1857             case EF_ARM_DYNSYMSUSESEGIDX:
1858               strcat (buf, ", dynamic symbols use segment index");
1859               break;
1860
1861             case EF_ARM_MAPSYMSFIRST:
1862               strcat (buf, ", mapping symbols precede others");
1863               break;
1864
1865             default:
1866               unknown = 1;
1867               break;
1868             }
1869         }
1870       break;
1871
1872     case EF_ARM_EABI_VER3:
1873       strcat (buf, ", Version3 EABI");
1874       break;
1875
1876     case EF_ARM_EABI_VER4:
1877       strcat (buf, ", Version4 EABI");
1878       while (e_flags)
1879         {
1880           unsigned flag;
1881
1882           /* Process flags one bit at a time.  */
1883           flag = e_flags & - e_flags;
1884           e_flags &= ~ flag;
1885
1886           switch (flag)
1887             {
1888             case EF_ARM_BE8:
1889               strcat (buf, ", BE8");
1890               break;
1891
1892             case EF_ARM_LE8:
1893               strcat (buf, ", LE8");
1894               break;
1895
1896             default:
1897               unknown = 1;
1898               break;
1899             }
1900         }
1901       break;
1902
1903     case EF_ARM_EABI_UNKNOWN:
1904       strcat (buf, ", GNU EABI");
1905       while (e_flags)
1906         {
1907           unsigned flag;
1908
1909           /* Process flags one bit at a time.  */
1910           flag = e_flags & - e_flags;
1911           e_flags &= ~ flag;
1912
1913           switch (flag)
1914             {
1915             case EF_ARM_INTERWORK:
1916               strcat (buf, ", interworking enabled");
1917               break;
1918
1919             case EF_ARM_APCS_26:
1920               strcat (buf, ", uses APCS/26");
1921               break;
1922
1923             case EF_ARM_APCS_FLOAT:
1924               strcat (buf, ", uses APCS/float");
1925               break;
1926
1927             case EF_ARM_PIC:
1928               strcat (buf, ", position independent");
1929               break;
1930
1931             case EF_ARM_ALIGN8:
1932               strcat (buf, ", 8 bit structure alignment");
1933               break;
1934
1935             case EF_ARM_NEW_ABI:
1936               strcat (buf, ", uses new ABI");
1937               break;
1938
1939             case EF_ARM_OLD_ABI:
1940               strcat (buf, ", uses old ABI");
1941               break;
1942
1943             case EF_ARM_SOFT_FLOAT:
1944               strcat (buf, ", software FP");
1945               break;
1946
1947             case EF_ARM_VFP_FLOAT:
1948               strcat (buf, ", VFP");
1949               break;
1950
1951             case EF_ARM_MAVERICK_FLOAT:
1952               strcat (buf, ", Maverick FP");
1953               break;
1954
1955             default:
1956               unknown = 1;
1957               break;
1958             }
1959         }
1960     }
1961
1962   if (unknown)
1963     strcat (buf,", <unknown>");
1964 }
1965
1966 static char *
1967 get_machine_flags (unsigned e_flags, unsigned e_machine)
1968 {
1969   static char buf[1024];
1970
1971   buf[0] = '\0';
1972
1973   if (e_flags)
1974     {
1975       switch (e_machine)
1976         {
1977         default:
1978           break;
1979
1980         case EM_ARM:
1981           decode_ARM_machine_flags (e_flags, buf);
1982           break;
1983
1984         case EM_CYGNUS_FRV:
1985           switch (e_flags & EF_FRV_CPU_MASK)
1986             {
1987             case EF_FRV_CPU_GENERIC:
1988               break;
1989
1990             default:
1991               strcat (buf, ", fr???");
1992               break;
1993
1994             case EF_FRV_CPU_FR300:
1995               strcat (buf, ", fr300");
1996               break;
1997
1998             case EF_FRV_CPU_FR400:
1999               strcat (buf, ", fr400");
2000               break;
2001             case EF_FRV_CPU_FR405:
2002               strcat (buf, ", fr405");
2003               break;
2004
2005             case EF_FRV_CPU_FR450:
2006               strcat (buf, ", fr450");
2007               break;
2008
2009             case EF_FRV_CPU_FR500:
2010               strcat (buf, ", fr500");
2011               break;
2012             case EF_FRV_CPU_FR550:
2013               strcat (buf, ", fr550");
2014               break;
2015
2016             case EF_FRV_CPU_SIMPLE:
2017               strcat (buf, ", simple");
2018               break;
2019             case EF_FRV_CPU_TOMCAT:
2020               strcat (buf, ", tomcat");
2021               break;
2022             }
2023           break;
2024
2025         case EM_68K:
2026           if (e_flags & EF_CPU32)
2027             strcat (buf, ", cpu32");
2028           if (e_flags & EF_M68000)
2029             strcat (buf, ", m68000");
2030           break;
2031
2032         case EM_PPC:
2033           if (e_flags & EF_PPC_EMB)
2034             strcat (buf, ", emb");
2035
2036           if (e_flags & EF_PPC_RELOCATABLE)
2037             strcat (buf, ", relocatable");
2038
2039           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2040             strcat (buf, ", relocatable-lib");
2041           break;
2042
2043         case EM_V850:
2044         case EM_CYGNUS_V850:
2045           switch (e_flags & EF_V850_ARCH)
2046             {
2047             case E_V850E1_ARCH:
2048               strcat (buf, ", v850e1");
2049               break;
2050             case E_V850E_ARCH:
2051               strcat (buf, ", v850e");
2052               break;
2053             case E_V850_ARCH:
2054               strcat (buf, ", v850");
2055               break;
2056             default:
2057               strcat (buf, ", unknown v850 architecture variant");
2058               break;
2059             }
2060           break;
2061
2062         case EM_M32R:
2063         case EM_CYGNUS_M32R:
2064           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2065             strcat (buf, ", m32r");
2066
2067           break;
2068
2069         case EM_MIPS:
2070         case EM_MIPS_RS3_LE:
2071           if (e_flags & EF_MIPS_NOREORDER)
2072             strcat (buf, ", noreorder");
2073
2074           if (e_flags & EF_MIPS_PIC)
2075             strcat (buf, ", pic");
2076
2077           if (e_flags & EF_MIPS_CPIC)
2078             strcat (buf, ", cpic");
2079
2080           if (e_flags & EF_MIPS_UCODE)
2081             strcat (buf, ", ugen_reserved");
2082
2083           if (e_flags & EF_MIPS_ABI2)
2084             strcat (buf, ", abi2");
2085
2086           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2087             strcat (buf, ", odk first");
2088
2089           if (e_flags & EF_MIPS_32BITMODE)
2090             strcat (buf, ", 32bitmode");
2091
2092           switch ((e_flags & EF_MIPS_MACH))
2093             {
2094             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2095             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2096             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2097             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2098             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2099             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2100             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2101             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2102             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2103             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2104             case 0:
2105             /* We simply ignore the field in this case to avoid confusion:
2106                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2107                extension.  */
2108               break;
2109             default: strcat (buf, ", unknown CPU"); break;
2110             }
2111
2112           switch ((e_flags & EF_MIPS_ABI))
2113             {
2114             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2115             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2116             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2117             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2118             case 0:
2119             /* We simply ignore the field in this case to avoid confusion:
2120                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2121                This means it is likely to be an o32 file, but not for
2122                sure.  */
2123               break;
2124             default: strcat (buf, ", unknown ABI"); break;
2125             }
2126
2127           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2128             strcat (buf, ", mdmx");
2129
2130           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2131             strcat (buf, ", mips16");
2132
2133           switch ((e_flags & EF_MIPS_ARCH))
2134             {
2135             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2136             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2137             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2138             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2139             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2140             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2141             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2142             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2143             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2144             default: strcat (buf, ", unknown ISA"); break;
2145             }
2146
2147           break;
2148
2149         case EM_SH:
2150           switch ((e_flags & EF_SH_MACH_MASK))
2151             {
2152             case EF_SH1: strcat (buf, ", sh1"); break;
2153             case EF_SH2: strcat (buf, ", sh2"); break;
2154             case EF_SH3: strcat (buf, ", sh3"); break;
2155             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2156             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2157             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2158             case EF_SH3E: strcat (buf, ", sh3e"); break;
2159             case EF_SH4: strcat (buf, ", sh4"); break;
2160             case EF_SH5: strcat (buf, ", sh5"); break;
2161             case EF_SH2E: strcat (buf, ", sh2e"); break;
2162             case EF_SH4A: strcat (buf, ", sh4a"); break;
2163             case EF_SH2A: strcat (buf, ", sh2a"); break;
2164             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2165             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2166             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2167             default: strcat (buf, ", unknown ISA"); break;
2168             }
2169
2170           break;
2171
2172         case EM_SPARCV9:
2173           if (e_flags & EF_SPARC_32PLUS)
2174             strcat (buf, ", v8+");
2175
2176           if (e_flags & EF_SPARC_SUN_US1)
2177             strcat (buf, ", ultrasparcI");
2178
2179           if (e_flags & EF_SPARC_SUN_US3)
2180             strcat (buf, ", ultrasparcIII");
2181
2182           if (e_flags & EF_SPARC_HAL_R1)
2183             strcat (buf, ", halr1");
2184
2185           if (e_flags & EF_SPARC_LEDATA)
2186             strcat (buf, ", ledata");
2187
2188           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2189             strcat (buf, ", tso");
2190
2191           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2192             strcat (buf, ", pso");
2193
2194           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2195             strcat (buf, ", rmo");
2196           break;
2197
2198         case EM_PARISC:
2199           switch (e_flags & EF_PARISC_ARCH)
2200             {
2201             case EFA_PARISC_1_0:
2202               strcpy (buf, ", PA-RISC 1.0");
2203               break;
2204             case EFA_PARISC_1_1:
2205               strcpy (buf, ", PA-RISC 1.1");
2206               break;
2207             case EFA_PARISC_2_0:
2208               strcpy (buf, ", PA-RISC 2.0");
2209               break;
2210             default:
2211               break;
2212             }
2213           if (e_flags & EF_PARISC_TRAPNIL)
2214             strcat (buf, ", trapnil");
2215           if (e_flags & EF_PARISC_EXT)
2216             strcat (buf, ", ext");
2217           if (e_flags & EF_PARISC_LSB)
2218             strcat (buf, ", lsb");
2219           if (e_flags & EF_PARISC_WIDE)
2220             strcat (buf, ", wide");
2221           if (e_flags & EF_PARISC_NO_KABP)
2222             strcat (buf, ", no kabp");
2223           if (e_flags & EF_PARISC_LAZYSWAP)
2224             strcat (buf, ", lazyswap");
2225           break;
2226
2227         case EM_PJ:
2228         case EM_PJ_OLD:
2229           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2230             strcat (buf, ", new calling convention");
2231
2232           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2233             strcat (buf, ", gnu calling convention");
2234           break;
2235
2236         case EM_IA_64:
2237           if ((e_flags & EF_IA_64_ABI64))
2238             strcat (buf, ", 64-bit");
2239           else
2240             strcat (buf, ", 32-bit");
2241           if ((e_flags & EF_IA_64_REDUCEDFP))
2242             strcat (buf, ", reduced fp model");
2243           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2244             strcat (buf, ", no function descriptors, constant gp");
2245           else if ((e_flags & EF_IA_64_CONS_GP))
2246             strcat (buf, ", constant gp");
2247           if ((e_flags & EF_IA_64_ABSOLUTE))
2248             strcat (buf, ", absolute");
2249           break;
2250
2251         case EM_VAX:
2252           if ((e_flags & EF_VAX_NONPIC))
2253             strcat (buf, ", non-PIC");
2254           if ((e_flags & EF_VAX_DFLOAT))
2255             strcat (buf, ", D-Float");
2256           if ((e_flags & EF_VAX_GFLOAT))
2257             strcat (buf, ", G-Float");
2258           break;
2259         }
2260     }
2261
2262   return buf;
2263 }
2264
2265 static const char *
2266 get_osabi_name (unsigned int osabi)
2267 {
2268   static char buff[32];
2269
2270   switch (osabi)
2271     {
2272     case ELFOSABI_NONE:         return "UNIX - System V";
2273     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2274     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2275     case ELFOSABI_LINUX:        return "UNIX - Linux";
2276     case ELFOSABI_HURD:         return "GNU/Hurd";
2277     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2278     case ELFOSABI_AIX:          return "UNIX - AIX";
2279     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2280     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2281     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2282     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2283     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2284     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2285     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2286     case ELFOSABI_AROS:         return "Amiga Research OS";
2287     case ELFOSABI_STANDALONE:   return _("Standalone App");
2288     case ELFOSABI_ARM:          return "ARM";
2289     default:
2290       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2291       return buff;
2292     }
2293 }
2294
2295 static const char *
2296 get_arm_segment_type (unsigned long type)
2297 {
2298   switch (type)
2299     {
2300     case PT_ARM_EXIDX:
2301       return "EXIDX";
2302     default:
2303       break;
2304     }
2305
2306   return NULL;
2307 }
2308
2309 static const char *
2310 get_mips_segment_type (unsigned long type)
2311 {
2312   switch (type)
2313     {
2314     case PT_MIPS_REGINFO:
2315       return "REGINFO";
2316     case PT_MIPS_RTPROC:
2317       return "RTPROC";
2318     case PT_MIPS_OPTIONS:
2319       return "OPTIONS";
2320     default:
2321       break;
2322     }
2323
2324   return NULL;
2325 }
2326
2327 static const char *
2328 get_parisc_segment_type (unsigned long type)
2329 {
2330   switch (type)
2331     {
2332     case PT_HP_TLS:             return "HP_TLS";
2333     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2334     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2335     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2336     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2337     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2338     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2339     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2340     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2341     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2342     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2343     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2344     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2345     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2346     default:
2347       break;
2348     }
2349
2350   return NULL;
2351 }
2352
2353 static const char *
2354 get_ia64_segment_type (unsigned long type)
2355 {
2356   switch (type)
2357     {
2358     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2359     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2360     case PT_HP_TLS:             return "HP_TLS";
2361     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
2362     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
2363     case PT_IA_64_HP_STACK:     return "HP_STACK";
2364     default:
2365       break;
2366     }
2367
2368   return NULL;
2369 }
2370
2371 static const char *
2372 get_segment_type (unsigned long p_type)
2373 {
2374   static char buff[32];
2375
2376   switch (p_type)
2377     {
2378     case PT_NULL:       return "NULL";
2379     case PT_LOAD:       return "LOAD";
2380     case PT_DYNAMIC:    return "DYNAMIC";
2381     case PT_INTERP:     return "INTERP";
2382     case PT_NOTE:       return "NOTE";
2383     case PT_SHLIB:      return "SHLIB";
2384     case PT_PHDR:       return "PHDR";
2385     case PT_TLS:        return "TLS";
2386
2387     case PT_GNU_EH_FRAME:
2388                         return "GNU_EH_FRAME";
2389     case PT_GNU_STACK:  return "GNU_STACK";
2390     case PT_GNU_RELRO:  return "GNU_RELRO";
2391
2392     default:
2393       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2394         {
2395           const char *result;
2396
2397           switch (elf_header.e_machine)
2398             {
2399             case EM_ARM:
2400               result = get_arm_segment_type (p_type);
2401               break;
2402             case EM_MIPS:
2403             case EM_MIPS_RS3_LE:
2404               result = get_mips_segment_type (p_type);
2405               break;
2406             case EM_PARISC:
2407               result = get_parisc_segment_type (p_type);
2408               break;
2409             case EM_IA_64:
2410               result = get_ia64_segment_type (p_type);
2411               break;
2412             default:
2413               result = NULL;
2414               break;
2415             }
2416
2417           if (result != NULL)
2418             return result;
2419
2420           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2421         }
2422       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2423         {
2424           const char *result;
2425
2426           switch (elf_header.e_machine)
2427             {
2428             case EM_PARISC:
2429               result = get_parisc_segment_type (p_type);
2430               break;
2431             case EM_IA_64:
2432               result = get_ia64_segment_type (p_type);
2433               break;
2434             default:
2435               result = NULL;
2436               break;
2437             }
2438
2439           if (result != NULL)
2440             return result;
2441
2442           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2443         }
2444       else
2445         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2446
2447       return buff;
2448     }
2449 }
2450
2451 static const char *
2452 get_mips_section_type_name (unsigned int sh_type)
2453 {
2454   switch (sh_type)
2455     {
2456     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
2457     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
2458     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
2459     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
2460     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
2461     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
2462     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
2463     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
2464     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
2465     case SHT_MIPS_RELD:          return "MIPS_RELD";
2466     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
2467     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
2468     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
2469     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
2470     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
2471     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
2472     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
2473     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
2474     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
2475     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
2476     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
2477     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
2478     case SHT_MIPS_LINE:          return "MIPS_LINE";
2479     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
2480     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
2481     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
2482     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
2483     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
2484     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
2485     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
2486     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
2487     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
2488     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
2489     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
2490     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
2491     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
2492     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
2493     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
2494     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2495     default:
2496       break;
2497     }
2498   return NULL;
2499 }
2500
2501 static const char *
2502 get_parisc_section_type_name (unsigned int sh_type)
2503 {
2504   switch (sh_type)
2505     {
2506     case SHT_PARISC_EXT:        return "PARISC_EXT";
2507     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
2508     case SHT_PARISC_DOC:        return "PARISC_DOC";
2509     default:
2510       break;
2511     }
2512   return NULL;
2513 }
2514
2515 static const char *
2516 get_ia64_section_type_name (unsigned int sh_type)
2517 {
2518   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
2519   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2520     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2521
2522   switch (sh_type)
2523     {
2524     case SHT_IA_64_EXT:           return "IA_64_EXT";
2525     case SHT_IA_64_UNWIND:        return "IA_64_UNWIND";
2526     case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2527     default:
2528       break;
2529     }
2530   return NULL;
2531 }
2532
2533 static const char *
2534 get_x86_64_section_type_name (unsigned int sh_type)
2535 {
2536   switch (sh_type)
2537     {
2538     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
2539     default:
2540       break;
2541     }
2542   return NULL;
2543 }
2544
2545 static const char *
2546 get_arm_section_type_name (unsigned int sh_type)
2547 {
2548   switch (sh_type)
2549     {
2550     case SHT_ARM_EXIDX:
2551       return "ARM_EXIDX";
2552     default:
2553       break;
2554     }
2555   return NULL;
2556 }
2557
2558 static const char *
2559 get_section_type_name (unsigned int sh_type)
2560 {
2561   static char buff[32];
2562
2563   switch (sh_type)
2564     {
2565     case SHT_NULL:              return "NULL";
2566     case SHT_PROGBITS:          return "PROGBITS";
2567     case SHT_SYMTAB:            return "SYMTAB";
2568     case SHT_STRTAB:            return "STRTAB";
2569     case SHT_RELA:              return "RELA";
2570     case SHT_HASH:              return "HASH";
2571     case SHT_DYNAMIC:           return "DYNAMIC";
2572     case SHT_NOTE:              return "NOTE";
2573     case SHT_NOBITS:            return "NOBITS";
2574     case SHT_REL:               return "REL";
2575     case SHT_SHLIB:             return "SHLIB";
2576     case SHT_DYNSYM:            return "DYNSYM";
2577     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
2578     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
2579     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
2580     case SHT_GROUP:             return "GROUP";
2581     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
2582     case SHT_GNU_verdef:        return "VERDEF";
2583     case SHT_GNU_verneed:       return "VERNEED";
2584     case SHT_GNU_versym:        return "VERSYM";
2585     case 0x6ffffff0:            return "VERSYM";
2586     case 0x6ffffffc:            return "VERDEF";
2587     case 0x7ffffffd:            return "AUXILIARY";
2588     case 0x7fffffff:            return "FILTER";
2589     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
2590
2591     default:
2592       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2593         {
2594           const char *result;
2595
2596           switch (elf_header.e_machine)
2597             {
2598             case EM_MIPS:
2599             case EM_MIPS_RS3_LE:
2600               result = get_mips_section_type_name (sh_type);
2601               break;
2602             case EM_PARISC:
2603               result = get_parisc_section_type_name (sh_type);
2604               break;
2605             case EM_IA_64:
2606               result = get_ia64_section_type_name (sh_type);
2607               break;
2608             case EM_X86_64:
2609               result = get_x86_64_section_type_name (sh_type);
2610               break;
2611             case EM_ARM:
2612               result = get_arm_section_type_name (sh_type);
2613               break;
2614             default:
2615               result = NULL;
2616               break;
2617             }
2618
2619           if (result != NULL)
2620             return result;
2621
2622           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2623         }
2624       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2625         sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2626       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2627         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2628       else
2629         snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
2630
2631       return buff;
2632     }
2633 }
2634
2635 #define OPTION_DEBUG_DUMP       512
2636
2637 static struct option options[] =
2638 {
2639   {"all",              no_argument, 0, 'a'},
2640   {"file-header",      no_argument, 0, 'h'},
2641   {"program-headers",  no_argument, 0, 'l'},
2642   {"headers",          no_argument, 0, 'e'},
2643   {"histogram",        no_argument, 0, 'I'},
2644   {"segments",         no_argument, 0, 'l'},
2645   {"sections",         no_argument, 0, 'S'},
2646   {"section-headers",  no_argument, 0, 'S'},
2647   {"section-groups",   no_argument, 0, 'g'},
2648   {"full-section-name",no_argument, 0, 'N'},
2649   {"symbols",          no_argument, 0, 's'},
2650   {"syms",             no_argument, 0, 's'},
2651   {"relocs",           no_argument, 0, 'r'},
2652   {"notes",            no_argument, 0, 'n'},
2653   {"dynamic",          no_argument, 0, 'd'},
2654   {"arch-specific",    no_argument, 0, 'A'},
2655   {"version-info",     no_argument, 0, 'V'},
2656   {"use-dynamic",      no_argument, 0, 'D'},
2657   {"hex-dump",         required_argument, 0, 'x'},
2658   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
2659   {"unwind",           no_argument, 0, 'u'},
2660 #ifdef SUPPORT_DISASSEMBLY
2661   {"instruction-dump", required_argument, 0, 'i'},
2662 #endif
2663
2664   {"version",          no_argument, 0, 'v'},
2665   {"wide",             no_argument, 0, 'W'},
2666   {"help",             no_argument, 0, 'H'},
2667   {0,                  no_argument, 0, 0}
2668 };
2669
2670 static void
2671 usage (void)
2672 {
2673   fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2674   fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2675   fprintf (stdout, _(" Options are:\n\
2676   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2677   -h --file-header       Display the ELF file header\n\
2678   -l --program-headers   Display the program headers\n\
2679      --segments          An alias for --program-headers\n\
2680   -S --section-headers   Display the sections' header\n\
2681      --sections          An alias for --section-headers\n\
2682   -g --section-groups    Display the section groups\n\
2683   -N --full-section-name\n\
2684                          Display the full section name\n\
2685   -e --headers           Equivalent to: -h -l -S\n\
2686   -s --syms              Display the symbol table\n\
2687       --symbols          An alias for --syms\n\
2688   -n --notes             Display the core notes (if present)\n\
2689   -r --relocs            Display the relocations (if present)\n\
2690   -u --unwind            Display the unwind info (if present)\n\
2691   -d --dynamic           Display the dynamic section (if present)\n\
2692   -V --version-info      Display the version sections (if present)\n\
2693   -A --arch-specific     Display architecture specific information (if any).\n\
2694   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
2695   -x --hex-dump=<number> Dump the contents of section <number>\n\
2696   -w[liaprmfFsoR] or\n\
2697   --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2698                          Display the contents of DWARF2 debug sections\n"));
2699 #ifdef SUPPORT_DISASSEMBLY
2700   fprintf (stdout, _("\
2701   -i --instruction-dump=<number>\n\
2702                          Disassemble the contents of section <number>\n"));
2703 #endif
2704   fprintf (stdout, _("\
2705   -I --histogram         Display histogram of bucket list lengths\n\
2706   -W --wide              Allow output width to exceed 80 characters\n\
2707   -H --help              Display this information\n\
2708   -v --version           Display the version number of readelf\n"));
2709   fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2710
2711   exit (0);
2712 }
2713
2714 /* Record the fact that the user wants the contents of section number
2715    SECTION to be displayed using the method(s) encoded as flags bits
2716    in TYPE.  Note, TYPE can be zero if we are creating the array for
2717    the first time.  */
2718
2719 static void
2720 request_dump (unsigned int section, int type)
2721 {
2722   if (section >= num_dump_sects)
2723     {
2724       char *new_dump_sects;
2725
2726       new_dump_sects = calloc (section + 1, 1);
2727
2728       if (new_dump_sects == NULL)
2729         error (_("Out of memory allocating dump request table."));
2730       else
2731         {
2732           /* Copy current flag settings.  */
2733           memcpy (new_dump_sects, dump_sects, num_dump_sects);
2734
2735           free (dump_sects);
2736
2737           dump_sects = new_dump_sects;
2738           num_dump_sects = section + 1;
2739         }
2740     }
2741
2742   if (dump_sects)
2743     dump_sects[section] |= type;
2744
2745   return;
2746 }
2747
2748 static void
2749 parse_args (int argc, char **argv)
2750 {
2751   int c;
2752
2753   if (argc < 2)
2754     usage ();
2755
2756   while ((c = getopt_long
2757           (argc, argv, "ersuahnldSDAINgw::x:i:vVWH", options, NULL)) != EOF)
2758     {
2759       char *cp;
2760       int section;
2761
2762       switch (c)
2763         {
2764         case 0:
2765           /* Long options.  */
2766           break;
2767         case 'H':
2768           usage ();
2769           break;
2770
2771         case 'a':
2772           do_syms++;
2773           do_reloc++;
2774           do_unwind++;
2775           do_dynamic++;
2776           do_header++;
2777           do_sections++;
2778           do_section_groups++;
2779           do_segments++;
2780           do_version++;
2781           do_histogram++;
2782           do_arch++;
2783           do_notes++;
2784           break;
2785         case 'g':
2786           do_section_groups++;
2787           break;
2788         case 'N':
2789           do_full_section_name++;
2790           break;
2791         case 'e':
2792           do_header++;
2793           do_sections++;
2794           do_segments++;
2795           break;
2796         case 'A':
2797           do_arch++;
2798           break;
2799         case 'D':
2800           do_using_dynamic++;
2801           break;
2802         case 'r':
2803           do_reloc++;
2804           break;
2805         case 'u':
2806           do_unwind++;
2807           break;
2808         case 'h':
2809           do_header++;
2810           break;
2811         case 'l':
2812           do_segments++;
2813           break;
2814         case 's':
2815           do_syms++;
2816           break;
2817         case 'S':
2818           do_sections++;
2819           break;
2820         case 'd':
2821           do_dynamic++;
2822           break;
2823         case 'I':
2824           do_histogram++;
2825           break;
2826         case 'n':
2827           do_notes++;
2828           break;
2829         case 'x':
2830           do_dump++;
2831           section = strtoul (optarg, & cp, 0);
2832           if (! *cp && section >= 0)
2833             {
2834               request_dump (section, HEX_DUMP);
2835               break;
2836             }
2837           goto oops;
2838         case 'w':
2839           do_dump++;
2840           if (optarg == 0)
2841             do_debugging = 1;
2842           else
2843             {
2844               unsigned int index = 0;
2845
2846               do_debugging = 0;
2847
2848               while (optarg[index])
2849                 switch (optarg[index++])
2850                   {
2851                   case 'i':
2852                   case 'I':
2853                     do_debug_info = 1;
2854                     break;
2855
2856                   case 'a':
2857                   case 'A':
2858                     do_debug_abbrevs = 1;
2859                     break;
2860
2861                   case 'l':
2862                   case 'L':
2863                     do_debug_lines = 1;
2864                     break;
2865
2866                   case 'p':
2867                   case 'P':
2868                     do_debug_pubnames = 1;
2869                     break;
2870
2871                   case 'r':
2872                     do_debug_aranges = 1;
2873                     break;
2874
2875                   case 'R':
2876                     do_debug_ranges = 1;
2877                     break;
2878
2879                   case 'F':
2880                     do_debug_frames_interp = 1;
2881                   case 'f':
2882                     do_debug_frames = 1;
2883                     break;
2884
2885                   case 'm':
2886                   case 'M':
2887                     do_debug_macinfo = 1;
2888                     break;
2889
2890                   case 's':
2891                   case 'S':
2892                     do_debug_str = 1;
2893                     break;
2894
2895                   case 'o':
2896                   case 'O':
2897                     do_debug_loc = 1;
2898                     break;
2899
2900                   default:
2901                     warn (_("Unrecognized debug option '%s'\n"), optarg);
2902                     break;
2903                   }
2904             }
2905           break;
2906         case OPTION_DEBUG_DUMP:
2907           do_dump++;
2908           if (optarg == 0)
2909             do_debugging = 1;
2910           else
2911             {
2912               typedef struct
2913               {
2914                 const char * option;
2915                 int *        variable;
2916               }
2917               debug_dump_long_opts;
2918
2919               debug_dump_long_opts opts_table [] =
2920                 {
2921                   /* Please keep this table alpha- sorted.  */
2922                   { "Ranges", & do_debug_ranges },
2923                   { "abbrev", & do_debug_abbrevs },
2924                   { "aranges", & do_debug_aranges },
2925                   { "frames", & do_debug_frames },
2926                   { "frames-interp", & do_debug_frames_interp },
2927                   { "info", & do_debug_info },
2928                   { "line", & do_debug_lines },
2929                   { "loc",  & do_debug_loc },
2930                   { "macro", & do_debug_macinfo },
2931                   { "pubnames", & do_debug_pubnames },
2932                   /* This entry is for compatability
2933                      with earlier versions of readelf.  */
2934                   { "ranges", & do_debug_aranges },
2935                   { "str", & do_debug_str },
2936                   { NULL, NULL }
2937                 };
2938
2939               const char *p;
2940
2941               do_debugging = 0;
2942
2943               p = optarg;
2944               while (*p)
2945                 {
2946                   debug_dump_long_opts * entry;
2947
2948                   for (entry = opts_table; entry->option; entry++)
2949                     {
2950                       size_t len = strlen (entry->option);
2951
2952                       if (strneq (p, entry->option, len)
2953                           && (p[len] == ',' || p[len] == '\0'))
2954                         {
2955                           * entry->variable = 1;
2956
2957                           /* The --debug-dump=frames-interp option also
2958                              enables the --debug-dump=frames option.  */
2959                           if (do_debug_frames_interp)
2960                             do_debug_frames = 1;
2961
2962                           p += len;
2963                           break;
2964                         }
2965                     }
2966
2967                   if (entry->option == NULL)
2968                     {
2969                       warn (_("Unrecognized debug option '%s'\n"), p);
2970                       p = strchr (p, ',');
2971                       if (p == NULL)
2972                         break;
2973                     }
2974
2975                   if (*p == ',')
2976                     p++;
2977                 }
2978             }
2979           break;
2980 #ifdef SUPPORT_DISASSEMBLY
2981         case 'i':
2982           do_dump++;
2983           section = strtoul (optarg, & cp, 0);
2984           if (! *cp && section >= 0)
2985             {
2986               request_dump (section, DISASS_DUMP);
2987               break;
2988             }
2989           goto oops;
2990 #endif
2991         case 'v':
2992           print_version (program_name);
2993           break;
2994         case 'V':
2995           do_version++;
2996           break;
2997         case 'W':
2998           do_wide++;
2999           break;
3000         default:
3001         oops:
3002           /* xgettext:c-format */
3003           error (_("Invalid option '-%c'\n"), c);
3004           /* Drop through.  */
3005         case '?':
3006           usage ();
3007         }
3008     }
3009
3010   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3011       && !do_segments && !do_header && !do_dump && !do_version
3012       && !do_histogram && !do_debugging && !do_arch && !do_notes
3013       && !do_section_groups)
3014     usage ();
3015   else if (argc < 3)
3016     {
3017       warn (_("Nothing to do.\n"));
3018       usage ();
3019     }
3020 }
3021
3022 static const char *
3023 get_elf_class (unsigned int elf_class)
3024 {
3025   static char buff[32];
3026
3027   switch (elf_class)
3028     {
3029     case ELFCLASSNONE: return _("none");
3030     case ELFCLASS32:   return "ELF32";
3031     case ELFCLASS64:   return "ELF64";
3032     default:
3033       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3034       return buff;
3035     }
3036 }
3037
3038 static const char *
3039 get_data_encoding (unsigned int encoding)
3040 {
3041   static char buff[32];
3042
3043   switch (encoding)
3044     {
3045     case ELFDATANONE: return _("none");
3046     case ELFDATA2LSB: return _("2's complement, little endian");
3047     case ELFDATA2MSB: return _("2's complement, big endian");
3048     default:
3049       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3050       return buff;
3051     }
3052 }
3053
3054 /* Decode the data held in 'elf_header'.  */
3055
3056 static int
3057 process_file_header (void)
3058 {
3059   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3060       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3061       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3062       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3063     {
3064       error
3065         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3066       return 0;
3067     }
3068
3069   if (do_header)
3070     {
3071       int i;
3072
3073       printf (_("ELF Header:\n"));
3074       printf (_("  Magic:   "));
3075       for (i = 0; i < EI_NIDENT; i++)
3076         printf ("%2.2x ", elf_header.e_ident[i]);
3077       printf ("\n");
3078       printf (_("  Class:                             %s\n"),
3079               get_elf_class (elf_header.e_ident[EI_CLASS]));
3080       printf (_("  Data:                              %s\n"),
3081               get_data_encoding (elf_header.e_ident[EI_DATA]));
3082       printf (_("  Version:                           %d %s\n"),
3083               elf_header.e_ident[EI_VERSION],
3084               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3085                ? "(current)"
3086                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3087                   ? "<unknown: %lx>"
3088                   : "")));
3089       printf (_("  OS/ABI:                            %s\n"),
3090               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3091       printf (_("  ABI Version:                       %d\n"),
3092               elf_header.e_ident[EI_ABIVERSION]);
3093       printf (_("  Type:                              %s\n"),
3094               get_file_type (elf_header.e_type));
3095       printf (_("  Machine:                           %s\n"),
3096               get_machine_name (elf_header.e_machine));
3097       printf (_("  Version:                           0x%lx\n"),
3098               (unsigned long) elf_header.e_version);
3099
3100       printf (_("  Entry point address:               "));
3101       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3102       printf (_("\n  Start of program headers:          "));
3103       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3104       printf (_(" (bytes into file)\n  Start of section headers:          "));
3105       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3106       printf (_(" (bytes into file)\n"));
3107
3108       printf (_("  Flags:                             0x%lx%s\n"),
3109               (unsigned long) elf_header.e_flags,
3110               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3111       printf (_("  Size of this header:               %ld (bytes)\n"),
3112               (long) elf_header.e_ehsize);
3113       printf (_("  Size of program headers:           %ld (bytes)\n"),
3114               (long) elf_header.e_phentsize);
3115       printf (_("  Number of program headers:         %ld\n"),
3116               (long) elf_header.e_phnum);
3117       printf (_("  Size of section headers:           %ld (bytes)\n"),
3118               (long) elf_header.e_shentsize);
3119       printf (_("  Number of section headers:         %ld"),
3120               (long) elf_header.e_shnum);
3121       if (section_headers != NULL && elf_header.e_shnum == 0)
3122         printf (" (%ld)", (long) section_headers[0].sh_size);
3123       putc ('\n', stdout);
3124       printf (_("  Section header string table index: %ld"),
3125               (long) elf_header.e_shstrndx);
3126       if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
3127         printf (" (%ld)", (long) section_headers[0].sh_link);
3128       putc ('\n', stdout);
3129     }
3130
3131   if (section_headers != NULL)
3132     {
3133       if (elf_header.e_shnum == 0)
3134         elf_header.e_shnum = section_headers[0].sh_size;
3135       if (elf_header.e_shstrndx == SHN_XINDEX)
3136         elf_header.e_shstrndx = section_headers[0].sh_link;
3137       free (section_headers);
3138       section_headers = NULL;
3139     }
3140
3141   return 1;
3142 }
3143
3144
3145 static int
3146 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3147 {
3148   Elf32_External_Phdr *phdrs;
3149   Elf32_External_Phdr *external;
3150   Elf_Internal_Phdr *internal;
3151   unsigned int i;
3152
3153   phdrs = get_data (NULL, file, elf_header.e_phoff,
3154                     elf_header.e_phentsize * elf_header.e_phnum,
3155                     _("program headers"));
3156   if (!phdrs)
3157     return 0;
3158
3159   for (i = 0, internal = program_headers, external = phdrs;
3160        i < elf_header.e_phnum;
3161        i++, internal++, external++)
3162     {
3163       internal->p_type   = BYTE_GET (external->p_type);
3164       internal->p_offset = BYTE_GET (external->p_offset);
3165       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3166       internal->p_paddr  = BYTE_GET (external->p_paddr);
3167       internal->p_filesz = BYTE_GET (external->p_filesz);
3168       internal->p_memsz  = BYTE_GET (external->p_memsz);
3169       internal->p_flags  = BYTE_GET (external->p_flags);
3170       internal->p_align  = BYTE_GET (external->p_align);
3171     }
3172
3173   free (phdrs);
3174
3175   return 1;
3176 }
3177
3178 static int
3179 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3180 {
3181   Elf64_External_Phdr *phdrs;
3182   Elf64_External_Phdr *external;
3183   Elf_Internal_Phdr *internal;
3184   unsigned int i;
3185
3186   phdrs = get_data (NULL, file, elf_header.e_phoff,
3187                     elf_header.e_phentsize * elf_header.e_phnum,
3188                     _("program headers"));
3189   if (!phdrs)
3190     return 0;
3191
3192   for (i = 0, internal = program_headers, external = phdrs;
3193        i < elf_header.e_phnum;
3194        i++, internal++, external++)
3195     {
3196       internal->p_type   = BYTE_GET (external->p_type);
3197       internal->p_flags  = BYTE_GET (external->p_flags);
3198       internal->p_offset = BYTE_GET (external->p_offset);
3199       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3200       internal->p_paddr  = BYTE_GET (external->p_paddr);
3201       internal->p_filesz = BYTE_GET (external->p_filesz);
3202       internal->p_memsz  = BYTE_GET (external->p_memsz);
3203       internal->p_align  = BYTE_GET (external->p_align);
3204     }
3205
3206   free (phdrs);
3207
3208   return 1;
3209 }
3210
3211 /* Returns 1 if the program headers were read into `program_headers'.  */
3212
3213 static int
3214 get_program_headers (FILE *file)
3215 {
3216   Elf_Internal_Phdr *phdrs;
3217
3218   /* Check cache of prior read.  */
3219   if (program_headers != NULL)
3220     return 1;
3221
3222   phdrs = malloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3223
3224   if (phdrs == NULL)
3225     {
3226       error (_("Out of memory\n"));
3227       return 0;
3228     }
3229
3230   if (is_32bit_elf
3231       ? get_32bit_program_headers (file, phdrs)
3232       : get_64bit_program_headers (file, phdrs))
3233     {
3234       program_headers = phdrs;
3235       return 1;
3236     }
3237
3238   free (phdrs);
3239   return 0;
3240 }
3241
3242 /* Returns 1 if the program headers were loaded.  */
3243
3244 static int
3245 process_program_headers (FILE *file)
3246 {
3247   Elf_Internal_Phdr *segment;
3248   unsigned int i;
3249
3250   if (elf_header.e_phnum == 0)
3251     {
3252       if (do_segments)
3253         printf (_("\nThere are no program headers in this file.\n"));
3254       return 0;
3255     }
3256
3257   if (do_segments && !do_header)
3258     {
3259       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3260       printf (_("Entry point "));
3261       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3262       printf (_("\nThere are %d program headers, starting at offset "),
3263               elf_header.e_phnum);
3264       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3265       printf ("\n");
3266     }
3267
3268   if (! get_program_headers (file))
3269       return 0;
3270
3271   if (do_segments)
3272     {
3273       if (elf_header.e_phnum > 1)
3274         printf (_("\nProgram Headers:\n"));
3275       else
3276         printf (_("\nProgram Headers:\n"));
3277
3278       if (is_32bit_elf)
3279         printf
3280           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
3281       else if (do_wide)
3282         printf
3283           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
3284       else
3285         {
3286           printf
3287             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
3288           printf
3289             (_("                 FileSiz            MemSiz              Flags  Align\n"));
3290         }
3291     }
3292
3293   dynamic_addr = 0;
3294   dynamic_size = 0;
3295
3296   for (i = 0, segment = program_headers;
3297        i < elf_header.e_phnum;
3298        i++, segment++)
3299     {
3300       if (do_segments)
3301         {
3302           printf ("  %-14.14s ", get_segment_type (segment->p_type));
3303
3304           if (is_32bit_elf)
3305             {
3306               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3307               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3308               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3309               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3310               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3311               printf ("%c%c%c ",
3312                       (segment->p_flags & PF_R ? 'R' : ' '),
3313                       (segment->p_flags & PF_W ? 'W' : ' '),
3314                       (segment->p_flags & PF_X ? 'E' : ' '));
3315               printf ("%#lx", (unsigned long) segment->p_align);
3316             }
3317           else if (do_wide)
3318             {
3319               if ((unsigned long) segment->p_offset == segment->p_offset)
3320                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3321               else
3322                 {
3323                   print_vma (segment->p_offset, FULL_HEX);
3324                   putchar (' ');
3325                 }
3326
3327               print_vma (segment->p_vaddr, FULL_HEX);
3328               putchar (' ');
3329               print_vma (segment->p_paddr, FULL_HEX);
3330               putchar (' ');
3331
3332               if ((unsigned long) segment->p_filesz == segment->p_filesz)
3333                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3334               else
3335                 {
3336                   print_vma (segment->p_filesz, FULL_HEX);
3337                   putchar (' ');
3338                 }
3339
3340               if ((unsigned long) segment->p_memsz == segment->p_memsz)
3341                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3342               else
3343                 {
3344                   print_vma (segment->p_offset, FULL_HEX);
3345                 }
3346
3347               printf (" %c%c%c ",
3348                       (segment->p_flags & PF_R ? 'R' : ' '),
3349                       (segment->p_flags & PF_W ? 'W' : ' '),
3350                       (segment->p_flags & PF_X ? 'E' : ' '));
3351
3352               if ((unsigned long) segment->p_align == segment->p_align)
3353                 printf ("%#lx", (unsigned long) segment->p_align);
3354               else
3355                 {
3356                   print_vma (segment->p_align, PREFIX_HEX);
3357                 }
3358             }
3359           else
3360             {
3361               print_vma (segment->p_offset, FULL_HEX);
3362               putchar (' ');
3363               print_vma (segment->p_vaddr, FULL_HEX);
3364               putchar (' ');
3365               print_vma (segment->p_paddr, FULL_HEX);
3366               printf ("\n                 ");
3367               print_vma (segment->p_filesz, FULL_HEX);
3368               putchar (' ');
3369               print_vma (segment->p_memsz, FULL_HEX);
3370               printf ("  %c%c%c    ",
3371                       (segment->p_flags & PF_R ? 'R' : ' '),
3372                       (segment->p_flags & PF_W ? 'W' : ' '),
3373                       (segment->p_flags & PF_X ? 'E' : ' '));
3374               print_vma (segment->p_align, HEX);
3375             }
3376         }
3377
3378       switch (segment->p_type)
3379         {
3380         case PT_DYNAMIC:
3381           if (dynamic_addr)
3382             error (_("more than one dynamic segment\n"));
3383
3384           /* Try to locate the .dynamic section. If there is
3385              a section header table, we can easily locate it.  */
3386           if (section_headers != NULL)
3387             {
3388               Elf_Internal_Shdr *sec;
3389
3390               sec = find_section (".dynamic");
3391               if (sec == NULL || sec->sh_size == 0)
3392                 {
3393                   error (_("no .dynamic section in the dynamic segment"));
3394                   break;
3395                 }
3396
3397               dynamic_addr = sec->sh_offset;
3398               dynamic_size = sec->sh_size;
3399
3400               if (dynamic_addr < segment->p_offset
3401                   || dynamic_addr > segment->p_offset + segment->p_filesz)
3402                 warn (_("the .dynamic section is not contained within the dynamic segment"));
3403               else if (dynamic_addr > segment->p_offset)
3404                 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3405             }
3406           else
3407             {
3408               /* Otherwise, we can only assume that the .dynamic
3409                  section is the first section in the DYNAMIC segment.  */
3410               dynamic_addr = segment->p_offset;
3411               dynamic_size = segment->p_filesz;
3412             }
3413           break;
3414
3415         case PT_INTERP:
3416           if (fseek (file, archive_file_offset + (long) segment->p_offset,
3417                      SEEK_SET))
3418             error (_("Unable to find program interpreter name\n"));
3419           else
3420             {
3421               program_interpreter[0] = 0;
3422               fscanf (file, "%63s", program_interpreter);
3423
3424               if (do_segments)
3425                 printf (_("\n      [Requesting program interpreter: %s]"),
3426                     program_interpreter);
3427             }
3428           break;
3429         }
3430
3431       if (do_segments)
3432         putc ('\n', stdout);
3433     }
3434
3435   if (do_segments && section_headers != NULL)
3436     {
3437       printf (_("\n Section to Segment mapping:\n"));
3438       printf (_("  Segment Sections...\n"));
3439
3440       assert (string_table != NULL);
3441
3442       for (i = 0; i < elf_header.e_phnum; i++)
3443         {
3444           unsigned int j;
3445           Elf_Internal_Shdr *section;
3446
3447           segment = program_headers + i;
3448           section = section_headers;
3449
3450           printf ("   %2.2d     ", i);
3451
3452           for (j = 1; j < elf_header.e_shnum; j++, section++)
3453             {
3454               if (section->sh_size > 0
3455                   /* Compare allocated sections by VMA, unallocated
3456                      sections by file offset.  */
3457                   && (section->sh_flags & SHF_ALLOC
3458                       ? (section->sh_addr >= segment->p_vaddr
3459                          && section->sh_addr + section->sh_size
3460                          <= segment->p_vaddr + segment->p_memsz)
3461                       : ((bfd_vma) section->sh_offset >= segment->p_offset
3462                          && (section->sh_offset + section->sh_size
3463                              <= segment->p_offset + segment->p_filesz)))
3464                   /* .tbss is special.  It doesn't contribute memory space
3465                      to normal segments.  */
3466                   && (!((section->sh_flags & SHF_TLS) != 0
3467                         && section->sh_type == SHT_NOBITS)
3468                       || segment->p_type == PT_TLS))
3469                 printf ("%s ", SECTION_NAME (section));
3470             }
3471
3472           putc ('\n',stdout);
3473         }
3474     }
3475
3476   return 1;
3477 }
3478
3479
3480 /* Find the file offset corresponding to VMA by using the program headers.  */
3481
3482 static long
3483 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3484 {
3485   Elf_Internal_Phdr *seg;
3486
3487   if (! get_program_headers (file))
3488     {
3489       warn (_("Cannot interpret virtual addresses without program headers.\n"));
3490       return (long) vma;
3491     }
3492
3493   for (seg = program_headers;
3494        seg < program_headers + elf_header.e_phnum;
3495        ++seg)
3496     {
3497       if (seg->p_type != PT_LOAD)
3498         continue;
3499
3500       if (vma >= (seg->p_vaddr & -seg->p_align)
3501           && vma + size <= seg->p_vaddr + seg->p_filesz)
3502         return vma - seg->p_vaddr + seg->p_offset;
3503     }
3504
3505   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3506         (long) vma);
3507   return (long) vma;
3508 }
3509
3510
3511 static int
3512 get_32bit_section_headers (FILE *file, unsigned int num)
3513 {
3514   Elf32_External_Shdr *shdrs;
3515   Elf_Internal_Shdr *internal;
3516   unsigned int i;
3517
3518   shdrs = get_data (NULL, file, elf_header.e_shoff,
3519                     elf_header.e_shentsize * num, _("section headers"));
3520   if (!shdrs)
3521     return 0;
3522
3523   section_headers = malloc (num * sizeof (Elf_Internal_Shdr));
3524
3525   if (section_headers == NULL)
3526     {
3527       error (_("Out of memory\n"));
3528       return 0;
3529     }
3530
3531   for (i = 0, internal = section_headers;
3532        i < num;
3533        i++, internal++)
3534     {
3535       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3536       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3537       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3538       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3539       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3540       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3541       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3542       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3543       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3544       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3545     }
3546
3547   free (shdrs);
3548
3549   return 1;
3550 }
3551
3552 static int
3553 get_64bit_section_headers (FILE *file, unsigned int num)
3554 {
3555   Elf64_External_Shdr *shdrs;
3556   Elf_Internal_Shdr *internal;
3557   unsigned int i;
3558
3559   shdrs = get_data (NULL, file, elf_header.e_shoff,
3560                     elf_header.e_shentsize * num, _("section headers"));
3561   if (!shdrs)
3562     return 0;
3563
3564   section_headers = malloc (num * sizeof (Elf_Internal_Shdr));
3565
3566   if (section_headers == NULL)
3567     {
3568       error (_("Out of memory\n"));
3569       return 0;
3570     }
3571
3572   for (i = 0, internal = section_headers;
3573        i < num;
3574        i++, internal++)
3575     {
3576       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3577       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3578       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3579       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3580       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3581       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3582       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3583       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3584       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3585       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3586     }
3587
3588   free (shdrs);
3589
3590   return 1;
3591 }
3592
3593 static Elf_Internal_Sym *
3594 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3595 {
3596   unsigned long number;
3597   Elf32_External_Sym *esyms;
3598   Elf_External_Sym_Shndx *shndx;
3599   Elf_Internal_Sym *isyms;
3600   Elf_Internal_Sym *psym;
3601   unsigned int j;
3602
3603   esyms = get_data (NULL, file, section->sh_offset, section->sh_size,
3604                     _("symbols"));
3605   if (!esyms)
3606     return NULL;
3607
3608   shndx = NULL;
3609   if (symtab_shndx_hdr != NULL
3610       && (symtab_shndx_hdr->sh_link
3611           == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3612     {
3613       shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3614                         symtab_shndx_hdr->sh_size, _("symtab shndx"));
3615       if (!shndx)
3616         {
3617           free (esyms);
3618           return NULL;
3619         }
3620     }
3621
3622   number = section->sh_size / section->sh_entsize;
3623   isyms = malloc (number * sizeof (Elf_Internal_Sym));
3624
3625   if (isyms == NULL)
3626     {
3627       error (_("Out of memory\n"));
3628       if (shndx)
3629         free (shndx);
3630       free (esyms);
3631       return NULL;
3632     }
3633
3634   for (j = 0, psym = isyms;
3635        j < number;
3636        j++, psym++)
3637     {
3638       psym->st_name  = BYTE_GET (esyms[j].st_name);
3639       psym->st_value = BYTE_GET (esyms[j].st_value);
3640       psym->st_size  = BYTE_GET (esyms[j].st_size);
3641       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3642       if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3643         psym->st_shndx
3644           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3645       psym->st_info  = BYTE_GET (esyms[j].st_info);
3646       psym->st_other = BYTE_GET (esyms[j].st_other);
3647     }
3648
3649   if (shndx)
3650     free (shndx);
3651   free (esyms);
3652
3653   return isyms;
3654 }
3655
3656 static Elf_Internal_Sym *
3657 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3658 {
3659   unsigned long number;
3660   Elf64_External_Sym *esyms;
3661   Elf_External_Sym_Shndx *shndx;
3662   Elf_Internal_Sym *isyms;
3663   Elf_Internal_Sym *psym;
3664   unsigned int j;
3665
3666   esyms = get_data (NULL, file, section->sh_offset, section->sh_size,
3667                     _("symbols"));
3668   if (!esyms)
3669     return NULL;
3670
3671   shndx = NULL;
3672   if (symtab_shndx_hdr != NULL
3673       && (symtab_shndx_hdr->sh_link
3674           == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3675     {
3676       shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3677                         symtab_shndx_hdr->sh_size, _("symtab shndx"));
3678       if (!shndx)
3679         {
3680           free (esyms);
3681           return NULL;
3682         }
3683     }
3684
3685   number = section->sh_size / section->sh_entsize;
3686   isyms = malloc (number * sizeof (Elf_Internal_Sym));
3687
3688   if (isyms == NULL)
3689     {
3690       error (_("Out of memory\n"));
3691       if (shndx)
3692         free (shndx);
3693       free (esyms);
3694       return NULL;
3695     }
3696
3697   for (j = 0, psym = isyms;
3698        j < number;
3699        j++, psym++)
3700     {
3701       psym->st_name  = BYTE_GET (esyms[j].st_name);
3702       psym->st_info  = BYTE_GET (esyms[j].st_info);
3703       psym->st_other = BYTE_GET (esyms[j].st_other);
3704       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3705       if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3706         psym->st_shndx
3707           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3708       psym->st_value = BYTE_GET (esyms[j].st_value);
3709       psym->st_size  = BYTE_GET (esyms[j].st_size);
3710     }
3711
3712   if (shndx)
3713     free (shndx);
3714   free (esyms);
3715
3716   return isyms;
3717 }
3718
3719 static const char *
3720 get_elf_section_flags (bfd_vma sh_flags)
3721 {
3722   static char buff[33];
3723   char *p = buff;
3724
3725   while (sh_flags)
3726     {
3727       bfd_vma flag;
3728
3729       flag = sh_flags & - sh_flags;
3730       sh_flags &= ~ flag;
3731
3732       switch (flag)
3733         {
3734         case SHF_WRITE:            *p = 'W'; break;
3735         case SHF_ALLOC:            *p = 'A'; break;
3736         case SHF_EXECINSTR:        *p = 'X'; break;
3737         case SHF_MERGE:            *p = 'M'; break;
3738         case SHF_STRINGS:          *p = 'S'; break;
3739         case SHF_INFO_LINK:        *p = 'I'; break;
3740         case SHF_LINK_ORDER:       *p = 'L'; break;
3741         case SHF_OS_NONCONFORMING: *p = 'O'; break;
3742         case SHF_GROUP:            *p = 'G'; break;
3743         case SHF_TLS:              *p = 'T'; break;
3744
3745         default:
3746           if (flag & SHF_MASKOS)
3747             {
3748               *p = 'o';
3749               sh_flags &= ~ SHF_MASKOS;
3750             }
3751           else if (flag & SHF_MASKPROC)
3752             {
3753               *p = 'p';
3754               sh_flags &= ~ SHF_MASKPROC;
3755             }
3756           else
3757             *p = 'x';
3758           break;
3759         }
3760       p++;
3761     }
3762
3763   *p = '\0';
3764   return buff;
3765 }
3766
3767 static int
3768 process_section_headers (FILE *file)
3769 {
3770   Elf_Internal_Shdr *section;
3771   unsigned int i;
3772
3773   section_headers = NULL;
3774
3775   if (elf_header.e_shnum == 0)
3776     {
3777       if (do_sections)
3778         printf (_("\nThere are no sections in this file.\n"));
3779
3780       return 1;
3781     }
3782
3783   if (do_sections && !do_header)
3784     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3785             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3786
3787   if (is_32bit_elf)
3788     {
3789       if (! get_32bit_section_headers (file, elf_header.e_shnum))
3790         return 0;
3791     }
3792   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3793     return 0;
3794
3795   /* Read in the string table, so that we have names to display.  */
3796   section = SECTION_HEADER (elf_header.e_shstrndx);
3797
3798   if (section->sh_size != 0)
3799     {
3800       string_table = get_data (NULL, file, section->sh_offset,
3801                                section->sh_size, _("string table"));
3802
3803       if (string_table == NULL)
3804         return 0;
3805
3806       string_table_length = section->sh_size;
3807     }
3808
3809   /* Scan the sections for the dynamic symbol table
3810      and dynamic string table and debug sections.  */
3811   dynamic_symbols = NULL;
3812   dynamic_strings = NULL;
3813   dynamic_syminfo = NULL;
3814   symtab_shndx_hdr = NULL;
3815
3816   eh_addr_size = is_32bit_elf ? 4 : 8;
3817   switch (elf_header.e_machine)
3818     {
3819     case EM_MIPS:
3820     case EM_MIPS_RS3_LE:
3821       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3822          FDE addresses.  However, the ABI also has a semi-official ILP32
3823          variant for which the normal FDE address size rules apply.
3824
3825          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3826          section, where XX is the size of longs in bits.  Unfortunately,
3827          earlier compilers provided no way of distinguishing ILP32 objects
3828          from LP64 objects, so if there's any doubt, we should assume that
3829          the official LP64 form is being used.  */
3830       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
3831           && find_section (".gcc_compiled_long32") == NULL)
3832         eh_addr_size = 8;
3833       break;
3834     }
3835
3836   for (i = 0, section = section_headers;
3837        i < elf_header.e_shnum;
3838        i++, section++)
3839     {
3840       char *name = SECTION_NAME (section);
3841
3842       if (section->sh_type == SHT_DYNSYM)
3843         {
3844           if (dynamic_symbols != NULL)
3845             {
3846               error (_("File contains multiple dynamic symbol tables\n"));
3847               continue;
3848             }
3849
3850           num_dynamic_syms = section->sh_size / section->sh_entsize;
3851           dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3852         }
3853       else if (section->sh_type == SHT_STRTAB
3854                && streq (name, ".dynstr"))
3855         {
3856           if (dynamic_strings != NULL)
3857             {
3858               error (_("File contains multiple dynamic string tables\n"));
3859               continue;
3860             }
3861
3862           dynamic_strings = get_data (NULL, file, section->sh_offset,
3863                                       section->sh_size, _("dynamic strings"));
3864           dynamic_strings_length = section->sh_size;
3865         }
3866       else if (section->sh_type == SHT_SYMTAB_SHNDX)
3867         {
3868           if (symtab_shndx_hdr != NULL)
3869             {
3870               error (_("File contains multiple symtab shndx tables\n"));
3871               continue;
3872             }
3873           symtab_shndx_hdr = section;
3874         }
3875       else if ((do_debugging || do_debug_info || do_debug_abbrevs
3876                 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3877                 || do_debug_frames || do_debug_macinfo || do_debug_str
3878                 || do_debug_loc || do_debug_ranges)
3879                && strneq (name, ".debug_", 7))
3880         {
3881           name += 7;
3882
3883           if (do_debugging
3884               || (do_debug_info     && streq (name, "info"))
3885               || (do_debug_abbrevs  && streq (name, "abbrev"))
3886               || (do_debug_lines    && streq (name, "line"))
3887               || (do_debug_pubnames && streq (name, "pubnames"))
3888               || (do_debug_aranges  && streq (name, "aranges"))
3889               || (do_debug_ranges   && streq (name, "ranges"))
3890               || (do_debug_frames   && streq (name, "frame"))
3891               || (do_debug_macinfo  && streq (name, "macinfo"))
3892               || (do_debug_str      && streq (name, "str"))
3893               || (do_debug_loc      && streq (name, "loc"))
3894               )
3895             request_dump (i, DEBUG_DUMP);
3896         }
3897       /* linkonce section to be combined with .debug_info at link time.  */
3898       else if ((do_debugging || do_debug_info)
3899                && strneq (name, ".gnu.linkonce.wi.", 17))
3900         request_dump (i, DEBUG_DUMP);
3901       else if (do_debug_frames && streq (name, ".eh_frame"))
3902         request_dump (i, DEBUG_DUMP);
3903     }
3904
3905   if (! do_sections)
3906     return 1;
3907
3908   if (elf_header.e_shnum > 1)
3909     printf (_("\nSection Headers:\n"));
3910   else
3911     printf (_("\nSection Header:\n"));
3912
3913   if (is_32bit_elf)
3914     {
3915       if (do_full_section_name)
3916         {
3917           printf (_("  [Nr] Name\n"));
3918           printf (_("       Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
3919         }
3920       else
3921         printf
3922           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
3923     }
3924   else if (do_wide)
3925     {
3926       if (do_full_section_name)
3927         {
3928           printf (_("  [Nr] Name\n"));
3929           printf (_("       Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
3930         }
3931       else
3932         printf
3933           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
3934     }
3935   else
3936     {
3937       if (do_full_section_name)
3938         {
3939           printf (_("  [Nr] Name\n"));
3940           printf (_("       Flags             Type             Address           Offset\n"));
3941           printf (_("       Size              EntSize          Link     Info     Align\n"));
3942         }
3943       else
3944         {
3945           printf (_("  [Nr] Name              Type             Address           Offset\n"));
3946           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
3947         }
3948     }
3949
3950   for (i = 0, section = section_headers;
3951        i < elf_header.e_shnum;
3952        i++, section++)
3953     {
3954       if (do_full_section_name)
3955         {
3956           printf ("  [%2u] %s\n",
3957                   SECTION_HEADER_NUM (i),
3958                   SECTION_NAME (section));
3959           if (is_32bit_elf || do_wide)
3960             printf ("       %-15.15s ",
3961                     get_section_type_name (section->sh_type));
3962         }
3963       else
3964         printf ("  [%2u] %-17.17s %-15.15s ",
3965                 SECTION_HEADER_NUM (i),
3966                 SECTION_NAME (section),
3967                 get_section_type_name (section->sh_type));
3968
3969       if (is_32bit_elf)
3970         {
3971           print_vma (section->sh_addr, LONG_HEX);
3972
3973           printf ( " %6.6lx %6.6lx %2.2lx",
3974                    (unsigned long) section->sh_offset,
3975                    (unsigned long) section->sh_size,
3976                    (unsigned long) section->sh_entsize);
3977
3978           printf (" %3s ", get_elf_section_flags (section->sh_flags));
3979
3980           printf ("%2ld %3lu %2ld\n",
3981                   (unsigned long) section->sh_link,
3982                   (unsigned long) section->sh_info,
3983                   (unsigned long) section->sh_addralign);
3984         }
3985       else if (do_wide)
3986         {
3987           print_vma (section->sh_addr, LONG_HEX);
3988
3989           if ((long) section->sh_offset == section->sh_offset)
3990             printf (" %6.6lx", (unsigned long) section->sh_offset);
3991           else
3992             {
3993               putchar (' ');
3994               print_vma (section->sh_offset, LONG_HEX);
3995             }
3996
3997           if ((unsigned long) section->sh_size == section->sh_size)
3998             printf (" %6.6lx", (unsigned long) section->sh_size);
3999           else
4000             {
4001               putchar (' ');
4002               print_vma (section->sh_size, LONG_HEX);
4003             }
4004
4005           if ((unsigned long) section->sh_entsize == section->sh_entsize)
4006             printf (" %2.2lx", (unsigned long) section->sh_entsize);
4007           else
4008             {
4009               putchar (' ');
4010               print_vma (section->sh_entsize, LONG_HEX);
4011             }
4012
4013           printf (" %3s ", get_elf_section_flags (section->sh_flags));
4014
4015           printf ("%2ld %3lu ",
4016                   (unsigned long) section->sh_link,
4017                   (unsigned long) section->sh_info);
4018
4019           if ((unsigned long) section->sh_addralign == section->sh_addralign)
4020             printf ("%2ld\n", (unsigned long) section->sh_addralign);
4021           else
4022             {
4023               print_vma (section->sh_addralign, DEC);
4024               putchar ('\n');
4025             }
4026         }
4027       else if (do_full_section_name)
4028         {
4029           printf ("       %-15.15s   %-15.15s ",
4030                   get_elf_section_flags (section->sh_flags),
4031                   get_section_type_name (section->sh_type));
4032           putchar (' ');
4033           print_vma (section->sh_addr, LONG_HEX);
4034           if ((long) section->sh_offset == section->sh_offset)
4035             printf ("  %8.8lx", (unsigned long) section->sh_offset);
4036           else
4037             {
4038               printf ("  ");
4039               print_vma (section->sh_offset, LONG_HEX);
4040             }
4041           printf ("\n       ");
4042           print_vma (section->sh_size, LONG_HEX);
4043           printf ("  ");
4044           print_vma (section->sh_entsize, LONG_HEX);
4045
4046           printf ("   %2ld      %3lu        %ld\n",
4047                   (unsigned long) section->sh_link,
4048                   (unsigned long) section->sh_info,
4049                   (unsigned long) section->sh_addralign);
4050         }
4051       else
4052         {
4053           putchar (' ');
4054           print_vma (section->sh_addr, LONG_HEX);
4055           if ((long) section->sh_offset == section->sh_offset)
4056             printf ("  %8.8lx", (unsigned long) section->sh_offset);
4057           else
4058             {
4059               printf ("  ");
4060               print_vma (section->sh_offset, LONG_HEX);
4061             }
4062           printf ("\n       ");
4063           print_vma (section->sh_size, LONG_HEX);
4064           printf ("  ");
4065           print_vma (section->sh_entsize, LONG_HEX);
4066
4067           printf (" %3s ", get_elf_section_flags (section->sh_flags));
4068
4069           printf ("     %2ld   %3lu     %ld\n",
4070                   (unsigned long) section->sh_link,
4071                   (unsigned long) section->sh_info,
4072                   (unsigned long) section->sh_addralign);
4073         }
4074     }
4075
4076   printf (_("Key to Flags:\n\
4077   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4078   I (info), L (link order), G (group), x (unknown)\n\
4079   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4080
4081   return 1;
4082 }
4083
4084 static const char *
4085 get_group_flags (unsigned int flags)
4086 {
4087   static char buff[32];
4088   switch (flags)
4089     {
4090     case GRP_COMDAT:
4091       return "COMDAT";
4092
4093    default:
4094       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4095       break;
4096     }
4097   return buff;
4098 }
4099
4100 static int
4101 process_section_groups (FILE *file)
4102 {
4103   Elf_Internal_Shdr *section;
4104   unsigned int i;
4105   struct group *group;
4106   Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4107   Elf_Internal_Sym *symtab;
4108   char *strtab;
4109
4110   /* Don't process section groups unless needed.  */
4111   if (!do_unwind && !do_section_groups)
4112     return 1;
4113
4114   if (elf_header.e_shnum == 0)
4115     {
4116       if (do_section_groups)
4117         printf (_("\nThere are no sections in this file.\n"));
4118
4119       return 1;
4120     }
4121
4122   if (section_headers == NULL)
4123     {
4124       error (_("Section headers are not available!\n"));
4125       abort ();
4126     }
4127
4128   section_headers_groups = calloc (elf_header.e_shnum,
4129                                    sizeof (struct group *));
4130
4131   if (section_headers_groups == NULL)
4132     {
4133       error (_("Out of memory\n"));
4134       return 0;
4135     }
4136
4137   /* Scan the sections for the group section.  */
4138   group_count = 0;
4139   for (i = 0, section = section_headers;
4140        i < elf_header.e_shnum;
4141        i++, section++)
4142     if (section->sh_type == SHT_GROUP)
4143       group_count++;
4144
4145   if (group_count == 0)
4146     {
4147       if (do_section_groups)
4148         printf (_("\nThere are no section groups in this file.\n"));
4149
4150       return 1;
4151     }
4152
4153   section_groups = calloc (group_count, sizeof (struct group));
4154
4155   if (section_groups == NULL)
4156     {
4157       error (_("Out of memory\n"));
4158       return 0;
4159     }
4160
4161   symtab_sec = NULL;
4162   strtab_sec = NULL;
4163   symtab = NULL;
4164   strtab = NULL;
4165   for (i = 0, section = section_headers, group = section_groups;
4166        i < elf_header.e_shnum;
4167        i++, section++)
4168     {
4169       if (section->sh_type == SHT_GROUP)
4170         {
4171           char *name = SECTION_NAME (section);
4172           char *group_name;
4173           unsigned char *start, *indices;
4174           unsigned int entry, j, size;
4175           Elf_Internal_Shdr *sec;
4176           Elf_Internal_Sym *sym;
4177
4178           /* Get the symbol table.  */
4179           sec = SECTION_HEADER (section->sh_link);
4180           if (sec->sh_type != SHT_SYMTAB)
4181             {
4182               error (_("Bad sh_link in group section `%s'\n"), name);
4183               continue;
4184             }
4185
4186           if (symtab_sec != sec)
4187             {
4188               symtab_sec = sec;
4189               if (symtab)
4190                 free (symtab);
4191               symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4192             }
4193
4194           sym = symtab + section->sh_info;
4195
4196           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4197             {
4198               bfd_vma sec_index = SECTION_HEADER_INDEX (sym->st_shndx);
4199               if (sec_index == 0)
4200                 {
4201                   error (_("Bad sh_info in group section `%s'\n"), name);
4202                   continue;
4203                 }
4204
4205               group_name = SECTION_NAME (section_headers + sec_index);
4206               strtab = NULL;
4207             }
4208           else
4209             {
4210               /* Get the string table.  */
4211               sec = SECTION_HEADER (symtab_sec->sh_link);
4212               if (strtab_sec != sec)
4213                 {
4214                   strtab_sec = sec;
4215                   if (strtab)
4216                     free (strtab);
4217                   strtab = get_data (NULL, file, strtab_sec->sh_offset,
4218                                      strtab_sec->sh_size,
4219                                      _("string table"));
4220                 }
4221               group_name = strtab + sym->st_name;
4222             }
4223
4224           start = get_data (NULL, file, section->sh_offset,
4225                             section->sh_size, _("section data"));
4226
4227           indices = start;
4228           size = (section->sh_size / section->sh_entsize) - 1;
4229           entry = byte_get (indices, 4);
4230           indices += 4;
4231
4232           if (do_section_groups)
4233             {
4234               printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4235                       get_group_flags (entry), i, name, group_name, size);
4236
4237               printf (_("   [Index]    Name\n"));
4238             }
4239
4240           group->group_index = i;
4241
4242           for (j = 0; j < size; j++)
4243             {
4244               struct group_list *g;
4245
4246               entry = byte_get (indices, 4);
4247               indices += 4;
4248
4249               if (entry >= elf_header.e_shnum)
4250                 {
4251                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4252                          entry, i, elf_header.e_shnum - 1);
4253                   continue;
4254                 }
4255               else if (entry >= SHN_LORESERVE && entry <= SHN_HIRESERVE)
4256                 {
4257                   error (_("invalid section [%5u] in group section [%5u]\n"),
4258                          entry, i);
4259                   continue;
4260                 }
4261
4262               if (section_headers_groups [SECTION_HEADER_INDEX (entry)]
4263                   != NULL)
4264                 {
4265                   if (entry)
4266                     {
4267                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4268                              entry, i,
4269                              section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4270                       continue;
4271                     }
4272                   else
4273                     {
4274                       /* Intel C/C++ compiler may put section 0 in a
4275                          section group. We just warn it the first time
4276                          and ignore it afterwards.  */
4277                       static int warned = 0;
4278                       if (!warned)
4279                         {
4280                           error (_("section 0 in group section [%5u]\n"),
4281                                  section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4282                           warned++;
4283                         }
4284                     }
4285                 }
4286
4287               section_headers_groups [SECTION_HEADER_INDEX (entry)]
4288                 = group;
4289
4290               if (do_section_groups)
4291                 {
4292                   sec = SECTION_HEADER (entry);
4293                   printf ("   [%5u]   %s\n",
4294                           entry, SECTION_NAME (sec));
4295                 }
4296
4297               g = xmalloc (sizeof (struct group_list));
4298               g->section_index = entry;
4299               g->next = group->root;
4300               group->root = g;
4301             }
4302
4303           if (start)
4304             free (start);
4305
4306           group++;
4307         }
4308     }
4309
4310   if (symtab)
4311     free (symtab);
4312   if (strtab)
4313     free (strtab);
4314   return 1;
4315 }
4316
4317 static struct
4318 {
4319   const char *name;
4320   int reloc;
4321   int size;
4322   int rela;
4323 } dynamic_relocations [] =
4324 {
4325     { "REL", DT_REL, DT_RELSZ, FALSE },
4326     { "RELA", DT_RELA, DT_RELASZ, TRUE },
4327     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4328 };
4329
4330 /* Process the reloc section.  */
4331
4332 static int
4333 process_relocs (FILE *file)
4334 {
4335   unsigned long rel_size;
4336   unsigned long rel_offset;
4337
4338
4339   if (!do_reloc)
4340     return 1;
4341
4342   if (do_using_dynamic)
4343     {
4344       int is_rela;
4345       const char *name;
4346       int has_dynamic_reloc;
4347       unsigned int i;
4348
4349       has_dynamic_reloc = 0;
4350
4351       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4352         {
4353           is_rela = dynamic_relocations [i].rela;
4354           name = dynamic_relocations [i].name;
4355           rel_size = dynamic_info [dynamic_relocations [i].size];
4356           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4357
4358           has_dynamic_reloc |= rel_size;
4359
4360           if (is_rela == UNKNOWN)
4361             {
4362               if (dynamic_relocations [i].reloc == DT_JMPREL)
4363                 switch (dynamic_info[DT_PLTREL])
4364                   {
4365                   case DT_REL:
4366                     is_rela = FALSE;
4367                     break;
4368                   case DT_RELA:
4369                     is_rela = TRUE;
4370                     break;
4371                   }
4372             }
4373
4374           if (rel_size)
4375             {
4376               printf
4377                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4378                  name, rel_offset, rel_size);
4379
4380               dump_relocations (file,
4381                                 offset_from_vma (file, rel_offset, rel_size),
4382                                 rel_size,
4383                                 dynamic_symbols, num_dynamic_syms,
4384                                 dynamic_strings, dynamic_strings_length, is_rela);
4385             }
4386         }
4387
4388       if (! has_dynamic_reloc)
4389         printf (_("\nThere are no dynamic relocations in this file.\n"));
4390     }
4391   else
4392     {
4393       Elf_Internal_Shdr *section;
4394       unsigned long i;
4395       int found = 0;
4396
4397       for (i = 0, section = section_headers;
4398            i < elf_header.e_shnum;
4399            i++, section++)
4400         {
4401           if (   section->sh_type != SHT_RELA
4402               && section->sh_type != SHT_REL)
4403             continue;
4404
4405           rel_offset = section->sh_offset;
4406           rel_size   = section->sh_size;
4407
4408           if (rel_size)
4409             {
4410               Elf_Internal_Shdr *strsec;
4411               int is_rela;
4412
4413               printf (_("\nRelocation section "));
4414
4415               if (string_table == NULL)
4416                 printf ("%d", section->sh_name);
4417               else
4418                 printf (_("'%s'"), SECTION_NAME (section));
4419
4420               printf (_(" at offset 0x%lx contains %lu entries:\n"),
4421                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4422
4423               is_rela = section->sh_type == SHT_RELA;
4424
4425               if (section->sh_link)
4426                 {
4427                   Elf_Internal_Shdr *symsec;
4428                   Elf_Internal_Sym *symtab;
4429                   unsigned long nsyms;
4430                   unsigned long strtablen;
4431                   char *strtab = NULL;
4432
4433                   symsec = SECTION_HEADER (section->sh_link);
4434                   nsyms = symsec->sh_size / symsec->sh_entsize;
4435                   symtab = GET_ELF_SYMBOLS (file, symsec);
4436
4437                   if (symtab == NULL)
4438                     continue;
4439
4440                   strsec = SECTION_HEADER (symsec->sh_link);
4441
4442                   strtab = get_data (NULL, file, strsec->sh_offset,
4443                                      strsec->sh_size, _("string table"));
4444                   strtablen = strtab == NULL ? 0 : strsec->sh_size;
4445
4446                   dump_relocations (file, rel_offset, rel_size,
4447                                     symtab, nsyms, strtab, strtablen, is_rela);
4448                   if (strtab)
4449                     free (strtab);
4450                   free (symtab);
4451                 }
4452               else
4453                 dump_relocations (file, rel_offset, rel_size,
4454                                   NULL, 0, NULL, 0, is_rela);
4455
4456               found = 1;
4457             }
4458         }
4459
4460       if (! found)
4461         printf (_("\nThere are no relocations in this file.\n"));
4462     }
4463
4464   return 1;
4465 }
4466
4467 /* Process the unwind section.  */
4468
4469 #include "unwind-ia64.h"
4470
4471 /* An absolute address consists of a section and an offset.  If the
4472    section is NULL, the offset itself is the address, otherwise, the
4473    address equals to LOAD_ADDRESS(section) + offset.  */
4474
4475 struct absaddr
4476   {
4477     unsigned short section;
4478     bfd_vma offset;
4479   };
4480
4481 struct ia64_unw_aux_info
4482   {
4483     struct ia64_unw_table_entry
4484       {
4485         struct absaddr start;
4486         struct absaddr end;
4487         struct absaddr info;
4488       }
4489     *table;                     /* Unwind table.  */
4490     unsigned long table_len;    /* Length of unwind table.  */
4491     unsigned char *info;        /* Unwind info.  */
4492     unsigned long info_size;    /* Size of unwind info.  */
4493     bfd_vma info_addr;          /* starting address of unwind info.  */
4494     bfd_vma seg_base;           /* Starting address of segment.  */
4495     Elf_Internal_Sym *symtab;   /* The symbol table.  */
4496     unsigned long nsyms;        /* Number of symbols.  */
4497     char *strtab;               /* The string table.  */
4498     unsigned long strtab_size;  /* Size of string table.  */
4499   };
4500
4501 static void
4502 find_symbol_for_address (Elf_Internal_Sym *symtab,
4503                          unsigned long nsyms,
4504                          const char *strtab,
4505                          unsigned long strtab_size,
4506                          struct absaddr addr,
4507                          const char **symname,
4508                          bfd_vma *offset)
4509 {
4510   bfd_vma dist = 0x100000;
4511   Elf_Internal_Sym *sym, *best = NULL;
4512   unsigned long i;
4513
4514   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4515     {
4516       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4517           && sym->st_name != 0
4518           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4519           && addr.offset >= sym->st_value
4520           && addr.offset - sym->st_value < dist)
4521         {
4522           best = sym;
4523           dist = addr.offset - sym->st_value;
4524           if (!dist)
4525             break;
4526         }
4527     }
4528   if (best)
4529     {
4530       *symname = (best->st_name >= strtab_size
4531                   ? "<corrupt>" : strtab + best->st_name);
4532       *offset = dist;
4533       return;
4534     }
4535   *symname = NULL;
4536   *offset = addr.offset;
4537 }
4538
4539 static void
4540 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
4541 {
4542   struct ia64_unw_table_entry *tp;
4543   int in_body;
4544
4545   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4546     {
4547       bfd_vma stamp;
4548       bfd_vma offset;
4549       const unsigned char *dp;
4550       const unsigned char *head;
4551       const char *procname;
4552
4553       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4554                                aux->strtab_size, tp->start, &procname, &offset);
4555
4556       fputs ("\n<", stdout);
4557
4558       if (procname)
4559         {
4560           fputs (procname, stdout);
4561
4562           if (offset)
4563             printf ("+%lx", (unsigned long) offset);
4564         }
4565
4566       fputs (">: [", stdout);
4567       print_vma (tp->start.offset, PREFIX_HEX);
4568       fputc ('-', stdout);
4569       print_vma (tp->end.offset, PREFIX_HEX);
4570       printf ("], info at +0x%lx\n",
4571               (unsigned long) (tp->info.offset - aux->seg_base));
4572
4573       head = aux->info + (tp->info.offset - aux->info_addr);
4574       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4575
4576       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4577               (unsigned) UNW_VER (stamp),
4578               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4579               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4580               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4581               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4582
4583       if (UNW_VER (stamp) != 1)
4584         {
4585           printf ("\tUnknown version.\n");
4586           continue;
4587         }
4588
4589       in_body = 0;
4590       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4591         dp = unw_decode (dp, in_body, & in_body);
4592     }
4593 }
4594
4595 static int
4596 slurp_ia64_unwind_table (FILE *file,
4597                          struct ia64_unw_aux_info *aux,
4598                          Elf_Internal_Shdr *sec)
4599 {
4600   unsigned long size, nrelas, i;
4601   Elf_Internal_Phdr *seg;
4602   struct ia64_unw_table_entry *tep;
4603   Elf_Internal_Shdr *relsec;
4604   Elf_Internal_Rela *rela, *rp;
4605   unsigned char *table, *tp;
4606   Elf_Internal_Sym *sym;
4607   const char *relname;
4608
4609   /* First, find the starting address of the segment that includes
4610      this section: */
4611
4612   if (elf_header.e_phnum)
4613     {
4614       if (! get_program_headers (file))
4615           return 0;
4616
4617       for (seg = program_headers;
4618            seg < program_headers + elf_header.e_phnum;
4619            ++seg)
4620         {
4621           if (seg->p_type != PT_LOAD)
4622             continue;
4623
4624           if (sec->sh_addr >= seg->p_vaddr
4625               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4626             {
4627               aux->seg_base = seg->p_vaddr;
4628               break;
4629             }
4630         }
4631     }
4632
4633   /* Second, build the unwind table from the contents of the unwind section:  */
4634   size = sec->sh_size;
4635   table = get_data (NULL, file, sec->sh_offset, size, _("unwind table"));
4636   if (!table)
4637     return 0;
4638
4639   aux->table = xmalloc (size / (3 * eh_addr_size) * sizeof (aux->table[0]));
4640   tep = aux->table;
4641   for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
4642     {
4643       tep->start.section = SHN_UNDEF;
4644       tep->end.section   = SHN_UNDEF;
4645       tep->info.section  = SHN_UNDEF;
4646       if (is_32bit_elf)
4647         {
4648           tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
4649           tep->end.offset   = byte_get ((unsigned char *) tp + 4, 4);
4650           tep->info.offset  = byte_get ((unsigned char *) tp + 8, 4);
4651         }
4652       else
4653         {
4654           tep->start.offset = BYTE_GET ((unsigned char *) tp +  0);
4655           tep->end.offset   = BYTE_GET ((unsigned char *) tp +  8);
4656           tep->info.offset  = BYTE_GET ((unsigned char *) tp + 16);
4657         }
4658       tep->start.offset += aux->seg_base;
4659       tep->end.offset   += aux->seg_base;
4660       tep->info.offset  += aux->seg_base;
4661     }
4662   free (table);
4663
4664   /* Third, apply any relocations to the unwind table: */
4665
4666   for (relsec = section_headers;
4667        relsec < section_headers + elf_header.e_shnum;
4668        ++relsec)
4669     {
4670       if (relsec->sh_type != SHT_RELA
4671           || SECTION_HEADER (relsec->sh_info) != sec)
4672         continue;
4673
4674       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
4675                               & rela, & nrelas))
4676         return 0;
4677
4678       for (rp = rela; rp < rela + nrelas; ++rp)
4679         {
4680           if (is_32bit_elf)
4681             {
4682               relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
4683               sym = aux->symtab + ELF32_R_SYM (rp->r_info);
4684             }
4685           else
4686             {
4687               relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
4688               sym = aux->symtab + ELF64_R_SYM (rp->r_info);
4689             }
4690
4691           if (! strneq (relname, "R_IA64_SEGREL", 13))
4692             {
4693               warn (_("Skipping unexpected relocation type %s\n"), relname);
4694               continue;
4695             }
4696
4697           i = rp->r_offset / (3 * eh_addr_size);
4698
4699           switch (rp->r_offset/eh_addr_size % 3)
4700             {
4701             case 0:
4702               aux->table[i].start.section = sym->st_shndx;
4703               aux->table[i].start.offset += rp->r_addend + sym->st_value;
4704               break;
4705             case 1:
4706               aux->table[i].end.section   = sym->st_shndx;
4707               aux->table[i].end.offset   += rp->r_addend + sym->st_value;
4708               break;
4709             case 2:
4710               aux->table[i].info.section  = sym->st_shndx;
4711               aux->table[i].info.offset  += rp->r_addend + sym->st_value;
4712               break;
4713             default:
4714               break;
4715             }
4716         }
4717
4718       free (rela);
4719     }
4720
4721   aux->table_len = size / (3 * eh_addr_size);
4722   return 1;
4723 }
4724
4725 static int
4726 ia64_process_unwind (FILE *file)
4727 {
4728   Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4729   unsigned long i, unwcount = 0, unwstart = 0;
4730   struct ia64_unw_aux_info aux;
4731
4732   memset (& aux, 0, sizeof (aux));
4733
4734   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4735     {
4736       if (sec->sh_type == SHT_SYMTAB)
4737         {
4738           aux.nsyms = sec->sh_size / sec->sh_entsize;
4739           aux.symtab = GET_ELF_SYMBOLS (file, sec);
4740
4741           strsec = SECTION_HEADER (sec->sh_link);
4742           aux.strtab_size = strsec->sh_size;
4743           aux.strtab = get_data (NULL, file, strsec->sh_offset,
4744                                  aux.strtab_size, _("string table"));
4745         }
4746       else if (sec->sh_type == SHT_IA_64_UNWIND)
4747         unwcount++;
4748     }
4749
4750   if (!unwcount)
4751     printf (_("\nThere are no unwind sections in this file.\n"));
4752
4753   while (unwcount-- > 0)
4754     {
4755       char *suffix;
4756       size_t len, len2;
4757
4758       for (i = unwstart, sec = section_headers + unwstart;
4759            i < elf_header.e_shnum; ++i, ++sec)
4760         if (sec->sh_type == SHT_IA_64_UNWIND)
4761           {
4762             unwsec = sec;
4763             break;
4764           }
4765
4766       unwstart = i + 1;
4767       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4768
4769       if ((unwsec->sh_flags & SHF_GROUP) != 0)
4770         {
4771           /* We need to find which section group it is in.  */
4772           struct group_list *g = section_headers_groups [i]->root;
4773
4774           for (; g != NULL; g = g->next)
4775             {
4776               sec = SECTION_HEADER (g->section_index);
4777
4778               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
4779                 break;
4780             }
4781
4782           if (g == NULL)
4783             i = elf_header.e_shnum;
4784         }
4785       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
4786         {
4787           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
4788           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4789           suffix = SECTION_NAME (unwsec) + len;
4790           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4791                ++i, ++sec)
4792             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
4793                 && streq (SECTION_NAME (sec) + len2, suffix))
4794               break;
4795         }
4796       else
4797         {
4798           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4799              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
4800           len = sizeof (ELF_STRING_ia64_unwind) - 1;
4801           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4802           suffix = "";
4803           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
4804             suffix = SECTION_NAME (unwsec) + len;
4805           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4806                ++i, ++sec)
4807             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
4808                 && streq (SECTION_NAME (sec) + len2, suffix))
4809               break;
4810         }
4811
4812       if (i == elf_header.e_shnum)
4813         {
4814           printf (_("\nCould not find unwind info section for "));
4815
4816           if (string_table == NULL)
4817             printf ("%d", unwsec->sh_name);
4818           else
4819             printf (_("'%s'"), SECTION_NAME (unwsec));
4820         }
4821       else
4822         {
4823           aux.info_size = sec->sh_size;
4824           aux.info_addr = sec->sh_addr;
4825           aux.info = get_data (NULL, file, sec->sh_offset, aux.info_size,
4826                                _("unwind info"));
4827
4828           printf (_("\nUnwind section "));
4829
4830           if (string_table == NULL)
4831             printf ("%d", unwsec->sh_name);
4832           else
4833             printf (_("'%s'"), SECTION_NAME (unwsec));
4834
4835           printf (_(" at offset 0x%lx contains %lu entries:\n"),
4836                   (unsigned long) unwsec->sh_offset,
4837                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4838
4839           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4840
4841           if (aux.table_len > 0)
4842             dump_ia64_unwind (& aux);
4843
4844           if (aux.table)
4845             free ((char *) aux.table);
4846           if (aux.info)
4847             free ((char *) aux.info);
4848           aux.table = NULL;
4849           aux.info = NULL;
4850         }
4851     }
4852
4853   if (aux.symtab)
4854     free (aux.symtab);
4855   if (aux.strtab)
4856     free ((char *) aux.strtab);
4857
4858   return 1;
4859 }
4860
4861 struct hppa_unw_aux_info
4862   {
4863     struct hppa_unw_table_entry
4864       {
4865         struct absaddr start;
4866         struct absaddr end;
4867         unsigned int Cannot_unwind:1;                   /* 0 */
4868         unsigned int Millicode:1;                       /* 1 */
4869         unsigned int Millicode_save_sr0:1;              /* 2 */
4870         unsigned int Region_description:2;              /* 3..4 */
4871         unsigned int reserved1:1;                       /* 5 */
4872         unsigned int Entry_SR:1;                        /* 6 */
4873         unsigned int Entry_FR:4;     /* number saved */ /* 7..10 */
4874         unsigned int Entry_GR:5;     /* number saved */ /* 11..15 */
4875         unsigned int Args_stored:1;                     /* 16 */
4876         unsigned int Variable_Frame:1;                  /* 17 */
4877         unsigned int Separate_Package_Body:1;           /* 18 */
4878         unsigned int Frame_Extension_Millicode:1;       /* 19 */
4879         unsigned int Stack_Overflow_Check:1;            /* 20 */
4880         unsigned int Two_Instruction_SP_Increment:1;    /* 21 */
4881         unsigned int Ada_Region:1;                      /* 22 */
4882         unsigned int cxx_info:1;                        /* 23 */
4883         unsigned int cxx_try_catch:1;                   /* 24 */
4884         unsigned int sched_entry_seq:1;                 /* 25 */
4885         unsigned int reserved2:1;                       /* 26 */
4886         unsigned int Save_SP:1;                         /* 27 */
4887         unsigned int Save_RP:1;                         /* 28 */
4888         unsigned int Save_MRP_in_frame:1;               /* 29 */
4889         unsigned int extn_ptr_defined:1;                /* 30 */
4890         unsigned int Cleanup_defined:1;                 /* 31 */
4891
4892         unsigned int MPE_XL_interrupt_marker:1;         /* 0 */
4893         unsigned int HP_UX_interrupt_marker:1;          /* 1 */
4894         unsigned int Large_frame:1;                     /* 2 */
4895         unsigned int Pseudo_SP_Set:1;                   /* 3 */
4896         unsigned int reserved4:1;                       /* 4 */
4897         unsigned int Total_frame_size:27;               /* 5..31 */
4898       }
4899     *table;                     /* Unwind table.  */
4900     unsigned long table_len;    /* Length of unwind table.  */
4901     bfd_vma seg_base;           /* Starting address of segment.  */
4902     Elf_Internal_Sym *symtab;   /* The symbol table.  */
4903     unsigned long nsyms;        /* Number of symbols.  */
4904     char *strtab;               /* The string table.  */
4905     unsigned long strtab_size;  /* Size of string table.  */
4906   };
4907
4908 static void
4909 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
4910 {
4911   struct hppa_unw_table_entry *tp;
4912
4913   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4914     {
4915       bfd_vma offset;
4916       const char *procname;
4917
4918       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4919                                aux->strtab_size, tp->start, &procname,
4920                                &offset);
4921
4922       fputs ("\n<", stdout);
4923
4924       if (procname)
4925         {
4926           fputs (procname, stdout);
4927
4928           if (offset)
4929             printf ("+%lx", (unsigned long) offset);
4930         }
4931
4932       fputs (">: [", stdout);
4933       print_vma (tp->start.offset, PREFIX_HEX);
4934       fputc ('-', stdout);
4935       print_vma (tp->end.offset, PREFIX_HEX);
4936       printf ("]\n\t");
4937
4938 #define PF(_m) if (tp->_m) printf (#_m " ");
4939 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4940       PF(Cannot_unwind);
4941       PF(Millicode);
4942       PF(Millicode_save_sr0);
4943       /* PV(Region_description);  */
4944       PF(Entry_SR);
4945       PV(Entry_FR);
4946       PV(Entry_GR);
4947       PF(Args_stored);
4948       PF(Variable_Frame);
4949       PF(Separate_Package_Body);
4950       PF(Frame_Extension_Millicode);
4951       PF(Stack_Overflow_Check);
4952       PF(Two_Instruction_SP_Increment);
4953       PF(Ada_Region);
4954       PF(cxx_info);
4955       PF(cxx_try_catch);
4956       PF(sched_entry_seq);
4957       PF(Save_SP);
4958       PF(Save_RP);
4959       PF(Save_MRP_in_frame);
4960       PF(extn_ptr_defined);
4961       PF(Cleanup_defined);
4962       PF(MPE_XL_interrupt_marker);
4963       PF(HP_UX_interrupt_marker);
4964       PF(Large_frame);
4965       PF(Pseudo_SP_Set);
4966       PV(Total_frame_size);
4967 #undef PF
4968 #undef PV
4969     }
4970
4971   printf ("\n");
4972 }
4973
4974 static int
4975 slurp_hppa_unwind_table (FILE *file,
4976                          struct hppa_unw_aux_info *aux,
4977                          Elf_Internal_Shdr *sec)
4978 {
4979   unsigned long size, unw_ent_size, nrelas, i;
4980   Elf_Internal_Phdr *seg;
4981   struct hppa_unw_table_entry *tep;
4982   Elf_Internal_Shdr *relsec;
4983   Elf_Internal_Rela *rela, *rp;
4984   unsigned char *table, *tp;
4985   Elf_Internal_Sym *sym;
4986   const char *relname;
4987
4988   /* First, find the starting address of the segment that includes
4989      this section.  */
4990
4991   if (elf_header.e_phnum)
4992     {
4993       if (! get_program_headers (file))
4994         return 0;
4995
4996       for (seg = program_headers;
4997            seg < program_headers + elf_header.e_phnum;
4998            ++seg)
4999         {
5000           if (seg->p_type != PT_LOAD)
5001             continue;
5002
5003           if (sec->sh_addr >= seg->p_vaddr
5004               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5005             {
5006               aux->seg_base = seg->p_vaddr;
5007               break;
5008             }
5009         }
5010     }
5011
5012   /* Second, build the unwind table from the contents of the unwind
5013      section.  */
5014   size = sec->sh_size;
5015   table = get_data (NULL, file, sec->sh_offset, size, _("unwind table"));
5016   if (!table)
5017     return 0;
5018
5019   unw_ent_size = 2 * eh_addr_size + 8;
5020
5021   tep = aux->table = xmalloc (size / unw_ent_size * sizeof (aux->table[0]));
5022
5023   for (tp = table; tp < table + size; tp += (2 * eh_addr_size + 8), ++tep)
5024     {
5025       unsigned int tmp1, tmp2;
5026
5027       tep->start.section = SHN_UNDEF;
5028       tep->end.section   = SHN_UNDEF;
5029
5030       if (is_32bit_elf)
5031         {
5032           tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5033           tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5034           tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5035           tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5036         }
5037       else
5038         {
5039           tep->start.offset = BYTE_GET ((unsigned char *) tp + 0);
5040           tep->end.offset = BYTE_GET ((unsigned char *) tp + 8);
5041           tmp1 = byte_get ((unsigned char *) tp + 16, 4);
5042           tmp2 = byte_get ((unsigned char *) tp + 20, 4);
5043         }
5044
5045       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5046       tep->Millicode = (tmp1 >> 30) & 0x1;
5047       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5048       tep->Region_description = (tmp1 >> 27) & 0x3;
5049       tep->reserved1 = (tmp1 >> 26) & 0x1;
5050       tep->Entry_SR = (tmp1 >> 25) & 0x1;
5051       tep->Entry_FR = (tmp1 >> 21) & 0xf;
5052       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5053       tep->Args_stored = (tmp1 >> 15) & 0x1;
5054       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5055       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5056       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5057       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5058       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5059       tep->Ada_Region = (tmp1 >> 9) & 0x1;
5060       tep->cxx_info = (tmp1 >> 8) & 0x1;
5061       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5062       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5063       tep->reserved2 = (tmp1 >> 5) & 0x1;
5064       tep->Save_SP = (tmp1 >> 4) & 0x1;
5065       tep->Save_RP = (tmp1 >> 3) & 0x1;
5066       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5067       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5068       tep->Cleanup_defined = tmp1 & 0x1;
5069
5070       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5071       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5072       tep->Large_frame = (tmp2 >> 29) & 0x1;
5073       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5074       tep->reserved4 = (tmp2 >> 27) & 0x1;
5075       tep->Total_frame_size = tmp2 & 0x7ffffff;
5076
5077       tep->start.offset += aux->seg_base;
5078       tep->end.offset   += aux->seg_base;
5079     }
5080   free (table);
5081
5082   /* Third, apply any relocations to the unwind table.  */
5083
5084   for (relsec = section_headers;
5085        relsec < section_headers + elf_header.e_shnum;
5086        ++relsec)
5087     {
5088       if (relsec->sh_type != SHT_RELA
5089           || SECTION_HEADER (relsec->sh_info) != sec)
5090         continue;
5091
5092       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5093                               & rela, & nrelas))
5094         return 0;
5095
5096       for (rp = rela; rp < rela + nrelas; ++rp)
5097         {
5098           if (is_32bit_elf)
5099             {
5100               relname = elf_hppa_reloc_type (ELF32_R_TYPE (rp->r_info));
5101               sym = aux->symtab + ELF32_R_SYM (rp->r_info);
5102             }
5103           else
5104             {
5105               relname = elf_hppa_reloc_type (ELF64_R_TYPE (rp->r_info));
5106               sym = aux->symtab + ELF64_R_SYM (rp->r_info);
5107             }
5108
5109           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
5110           if (strncmp (relname, "R_PARISC_SEGREL", 15) != 0)
5111             {
5112               warn (_("Skipping unexpected relocation type %s\n"), relname);
5113               continue;
5114             }
5115
5116           i = rp->r_offset / unw_ent_size;
5117
5118           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5119             {
5120             case 0:
5121               aux->table[i].start.section = sym->st_shndx;
5122               aux->table[i].start.offset += sym->st_value + rp->r_addend;
5123               break;
5124             case 1:
5125               aux->table[i].end.section   = sym->st_shndx;
5126               aux->table[i].end.offset   += sym->st_value + rp->r_addend;
5127               break;
5128             default:
5129               break;
5130             }
5131         }
5132
5133       free (rela);
5134     }
5135
5136   aux->table_len = size / unw_ent_size;
5137
5138   return 1;
5139 }
5140
5141 static int
5142 hppa_process_unwind (FILE *file)
5143 {
5144   struct hppa_unw_aux_info aux;
5145   Elf_Internal_Shdr *unwsec = NULL;
5146   Elf_Internal_Shdr *strsec;
5147   Elf_Internal_Shdr *sec;
5148   unsigned long i;
5149
5150   memset (& aux, 0, sizeof (aux));
5151
5152   assert (string_table != NULL);
5153
5154   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5155     {
5156       if (sec->sh_type == SHT_SYMTAB)
5157         {
5158           aux.nsyms = sec->sh_size / sec->sh_entsize;
5159           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5160
5161           strsec = SECTION_HEADER (sec->sh_link);
5162           aux.strtab_size = strsec->sh_size;
5163           aux.strtab = get_data (NULL, file, strsec->sh_offset,
5164                                  aux.strtab_size, _("string table"));
5165         }
5166       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5167         unwsec = sec;
5168     }
5169
5170   if (!unwsec)
5171     printf (_("\nThere are no unwind sections in this file.\n"));
5172
5173   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5174     {
5175       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5176         {
5177           printf (_("\nUnwind section "));
5178           printf (_("'%s'"), SECTION_NAME (sec));
5179
5180           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5181                   (unsigned long) sec->sh_offset,
5182                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5183
5184           slurp_hppa_unwind_table (file, &aux, sec);
5185           if (aux.table_len > 0)
5186             dump_hppa_unwind (&aux);
5187
5188           if (aux.table)
5189             free ((char *) aux.table);
5190           aux.table = NULL;
5191         }
5192     }
5193
5194   if (aux.symtab)
5195     free (aux.symtab);
5196   if (aux.strtab)
5197     free ((char *) aux.strtab);
5198
5199   return 1;
5200 }
5201
5202 static int
5203 process_unwind (FILE *file)
5204 {
5205   struct unwind_handler {
5206     int machtype;
5207     int (*handler)(FILE *file);
5208   } handlers[] = {
5209     { EM_IA_64, ia64_process_unwind },
5210     { EM_PARISC, hppa_process_unwind },
5211     { 0, 0 }
5212   };
5213   int i;
5214
5215   if (!do_unwind)
5216     return 1;
5217
5218   for (i = 0; handlers[i].handler != NULL; i++)
5219     if (elf_header.e_machine == handlers[i].machtype)
5220       return handlers[i].handler (file);
5221
5222   printf (_("\nThere are no unwind sections in this file.\n"));
5223   return 1;
5224 }
5225
5226 static void
5227 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5228 {
5229   switch (entry->d_tag)
5230     {
5231     case DT_MIPS_FLAGS:
5232       if (entry->d_un.d_val == 0)
5233         printf ("NONE\n");
5234       else
5235         {
5236           static const char * opts[] =
5237           {
5238             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5239             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5240             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5241             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5242             "RLD_ORDER_SAFE"
5243           };
5244           unsigned int cnt;
5245           int first = 1;
5246           for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
5247             if (entry->d_un.d_val & (1 << cnt))
5248               {
5249                 printf ("%s%s", first ? "" : " ", opts[cnt]);
5250                 first = 0;
5251               }
5252           puts ("");
5253         }
5254       break;
5255
5256     case DT_MIPS_IVERSION:
5257       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5258         printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5259       else
5260         printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5261       break;
5262
5263     case DT_MIPS_TIME_STAMP:
5264       {
5265         char timebuf[20];
5266         struct tm *tmp;
5267
5268         time_t time = entry->d_un.d_val;
5269         tmp = gmtime (&time);
5270         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5271                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5272                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5273         printf ("Time Stamp: %s\n", timebuf);
5274       }
5275       break;
5276
5277     case DT_MIPS_RLD_VERSION:
5278     case DT_MIPS_LOCAL_GOTNO:
5279     case DT_MIPS_CONFLICTNO:
5280     case DT_MIPS_LIBLISTNO:
5281     case DT_MIPS_SYMTABNO:
5282     case DT_MIPS_UNREFEXTNO:
5283     case DT_MIPS_HIPAGENO:
5284     case DT_MIPS_DELTA_CLASS_NO:
5285     case DT_MIPS_DELTA_INSTANCE_NO:
5286     case DT_MIPS_DELTA_RELOC_NO:
5287     case DT_MIPS_DELTA_SYM_NO:
5288     case DT_MIPS_DELTA_CLASSSYM_NO:
5289     case DT_MIPS_COMPACT_SIZE:
5290       printf ("%ld\n", (long) entry->d_un.d_ptr);
5291       break;
5292
5293     default:
5294       printf ("%#lx\n", (long) entry->d_un.d_ptr);
5295     }
5296 }
5297
5298
5299 static void
5300 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5301 {
5302   switch (entry->d_tag)
5303     {
5304     case DT_HP_DLD_FLAGS:
5305       {
5306         static struct
5307         {
5308           long int bit;
5309           const char *str;
5310         }
5311         flags[] =
5312         {
5313           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5314           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5315           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5316           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5317           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5318           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5319           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5320           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5321           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5322           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5323           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
5324         };
5325         int first = 1;
5326         size_t cnt;
5327         bfd_vma val = entry->d_un.d_val;
5328
5329         for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
5330           if (val & flags[cnt].bit)
5331             {
5332               if (! first)
5333                 putchar (' ');
5334               fputs (flags[cnt].str, stdout);
5335               first = 0;
5336               val ^= flags[cnt].bit;
5337             }
5338
5339         if (val != 0 || first)
5340           {
5341             if (! first)
5342               putchar (' ');
5343             print_vma (val, HEX);
5344           }
5345       }
5346       break;
5347
5348     default:
5349       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5350       break;
5351     }
5352   putchar ('\n');
5353 }
5354
5355 static void
5356 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5357 {
5358   switch (entry->d_tag)
5359     {
5360     case DT_IA_64_PLT_RESERVE:
5361       /* First 3 slots reserved.  */
5362       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5363       printf (" -- ");
5364       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5365       break;
5366
5367     default:
5368       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5369       break;
5370     }
5371   putchar ('\n');
5372 }
5373
5374 static int
5375 get_32bit_dynamic_section (FILE *file)
5376 {
5377   Elf32_External_Dyn *edyn, *ext;
5378   Elf_Internal_Dyn *entry;
5379
5380   edyn = get_data (NULL, file, dynamic_addr, dynamic_size,
5381                    _("dynamic section"));
5382   if (!edyn)
5383     return 0;
5384
5385 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5386    might not have the luxury of section headers.  Look for the DT_NULL
5387    terminator to determine the number of entries.  */
5388   for (ext = edyn, dynamic_nent = 0;
5389        (char *) ext < (char *) edyn + dynamic_size;
5390        ext++)
5391     {
5392       dynamic_nent++;
5393       if (BYTE_GET (ext->d_tag) == DT_NULL)
5394         break;
5395     }
5396
5397   dynamic_section = malloc (dynamic_nent * sizeof (*entry));
5398   if (dynamic_section == NULL)
5399     {
5400       error (_("Out of memory\n"));
5401       free (edyn);
5402       return 0;
5403     }
5404
5405   for (ext = edyn, entry = dynamic_section;
5406        entry < dynamic_section + dynamic_nent;
5407        ext++, entry++)
5408     {
5409       entry->d_tag      = BYTE_GET (ext->d_tag);
5410       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5411     }
5412
5413   free (edyn);
5414
5415   return 1;
5416 }
5417
5418 static int
5419 get_64bit_dynamic_section (FILE *file)
5420 {
5421   Elf64_External_Dyn *edyn, *ext;
5422   Elf_Internal_Dyn *entry;
5423
5424   edyn = get_data (NULL, file, dynamic_addr, dynamic_size,
5425                    _("dynamic section"));
5426   if (!edyn)
5427     return 0;
5428
5429 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5430    might not have the luxury of section headers.  Look for the DT_NULL
5431    terminator to determine the number of entries.  */
5432   for (ext = edyn, dynamic_nent = 0;
5433        (char *) ext < (char *) edyn + dynamic_size;
5434        ext++)
5435     {
5436       dynamic_nent++;
5437       if (BYTE_GET (ext->d_tag) == DT_NULL)
5438         break;
5439     }
5440
5441   dynamic_section = malloc (dynamic_nent * sizeof (*entry));
5442   if (dynamic_section == NULL)
5443     {
5444       error (_("Out of memory\n"));
5445       free (edyn);
5446       return 0;
5447     }
5448
5449   for (ext = edyn, entry = dynamic_section;
5450        entry < dynamic_section + dynamic_nent;
5451        ext++, entry++)
5452     {
5453       entry->d_tag      = BYTE_GET (ext->d_tag);
5454       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5455     }
5456
5457   free (edyn);
5458
5459   return 1;
5460 }
5461
5462 static void
5463 print_dynamic_flags (bfd_vma flags)
5464 {
5465   int first = 1;
5466
5467   while (flags)
5468     {
5469       bfd_vma flag;
5470
5471       flag = flags & - flags;
5472       flags &= ~ flag;
5473
5474       if (first)
5475         first = 0;
5476       else
5477         putc (' ', stdout);
5478
5479       switch (flag)
5480         {
5481         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
5482         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
5483         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
5484         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
5485         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
5486         default:                fputs ("unknown", stdout); break;
5487         }
5488     }
5489   puts ("");
5490 }
5491
5492 /* Parse and display the contents of the dynamic section.  */
5493
5494 static int
5495 process_dynamic_section (FILE *file)
5496 {
5497   Elf_Internal_Dyn *entry;
5498
5499   if (dynamic_size == 0)
5500     {
5501       if (do_dynamic)
5502         printf (_("\nThere is no dynamic section in this file.\n"));
5503
5504       return 1;
5505     }
5506
5507   if (is_32bit_elf)
5508     {
5509       if (! get_32bit_dynamic_section (file))
5510         return 0;
5511     }
5512   else if (! get_64bit_dynamic_section (file))
5513     return 0;
5514
5515   /* Find the appropriate symbol table.  */
5516   if (dynamic_symbols == NULL)
5517     {
5518       for (entry = dynamic_section;
5519            entry < dynamic_section + dynamic_nent;
5520            ++entry)
5521         {
5522           Elf_Internal_Shdr section;
5523
5524           if (entry->d_tag != DT_SYMTAB)
5525             continue;
5526
5527           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5528
5529           /* Since we do not know how big the symbol table is,
5530              we default to reading in the entire file (!) and
5531              processing that.  This is overkill, I know, but it
5532              should work.  */
5533           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5534
5535           if (archive_file_offset != 0)
5536             section.sh_size = archive_file_size - section.sh_offset;
5537           else
5538             {
5539               if (fseek (file, 0, SEEK_END))
5540                 error (_("Unable to seek to end of file!"));
5541
5542               section.sh_size = ftell (file) - section.sh_offset;
5543             }
5544
5545           if (is_32bit_elf)
5546             section.sh_entsize = sizeof (Elf32_External_Sym);
5547           else
5548             section.sh_entsize = sizeof (Elf64_External_Sym);
5549
5550           num_dynamic_syms = section.sh_size / section.sh_entsize;
5551           if (num_dynamic_syms < 1)
5552             {
5553               error (_("Unable to determine the number of symbols to load\n"));
5554               continue;
5555             }
5556
5557           dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
5558         }
5559     }
5560
5561   /* Similarly find a string table.  */
5562   if (dynamic_strings == NULL)
5563     {
5564       for (entry = dynamic_section;
5565            entry < dynamic_section + dynamic_nent;
5566            ++entry)
5567         {
5568           unsigned long offset;
5569           long str_tab_len;
5570
5571           if (entry->d_tag != DT_STRTAB)
5572             continue;
5573
5574           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
5575
5576           /* Since we do not know how big the string table is,
5577              we default to reading in the entire file (!) and
5578              processing that.  This is overkill, I know, but it
5579              should work.  */
5580
5581           offset = offset_from_vma (file, entry->d_un.d_val, 0);
5582
5583           if (archive_file_offset != 0)
5584             str_tab_len = archive_file_size - offset;
5585           else
5586             {
5587               if (fseek (file, 0, SEEK_END))
5588                 error (_("Unable to seek to end of file\n"));
5589               str_tab_len = ftell (file) - offset;
5590             }
5591
5592           if (str_tab_len < 1)
5593             {
5594               error
5595                 (_("Unable to determine the length of the dynamic string table\n"));
5596               continue;
5597             }
5598
5599           dynamic_strings = get_data (NULL, file, offset, str_tab_len,
5600                                       _("dynamic string table"));
5601           dynamic_strings_length = str_tab_len;
5602           break;
5603         }
5604     }
5605
5606   /* And find the syminfo section if available.  */
5607   if (dynamic_syminfo == NULL)
5608     {
5609       unsigned long syminsz = 0;
5610
5611       for (entry = dynamic_section;
5612            entry < dynamic_section + dynamic_nent;
5613            ++entry)
5614         {
5615           if (entry->d_tag == DT_SYMINENT)
5616             {
5617               /* Note: these braces are necessary to avoid a syntax
5618                  error from the SunOS4 C compiler.  */
5619               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
5620             }
5621           else if (entry->d_tag == DT_SYMINSZ)
5622             syminsz = entry->d_un.d_val;
5623           else if (entry->d_tag == DT_SYMINFO)
5624             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
5625                                                       syminsz);
5626         }
5627
5628       if (dynamic_syminfo_offset != 0 && syminsz != 0)
5629         {
5630           Elf_External_Syminfo *extsyminfo, *extsym;
5631           Elf_Internal_Syminfo *syminfo;
5632
5633           /* There is a syminfo section.  Read the data.  */
5634           extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, syminsz,
5635                                  _("symbol information"));
5636           if (!extsyminfo)
5637             return 0;
5638
5639           dynamic_syminfo = malloc (syminsz);
5640           if (dynamic_syminfo == NULL)
5641             {
5642               error (_("Out of memory\n"));
5643               return 0;
5644             }
5645
5646           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
5647           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
5648                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
5649                ++syminfo, ++extsym)
5650             {
5651               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
5652               syminfo->si_flags = BYTE_GET (extsym->si_flags);
5653             }
5654
5655           free (extsyminfo);
5656         }
5657     }
5658
5659   if (do_dynamic && dynamic_addr)
5660     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5661             dynamic_addr, dynamic_nent);
5662   if (do_dynamic)
5663     printf (_("  Tag        Type                         Name/Value\n"));
5664
5665   for (entry = dynamic_section;
5666        entry < dynamic_section + dynamic_nent;
5667        entry++)
5668     {
5669       if (do_dynamic)
5670         {
5671           const char *dtype;
5672
5673           putchar (' ');
5674           print_vma (entry->d_tag, FULL_HEX);
5675           dtype = get_dynamic_type (entry->d_tag);
5676           printf (" (%s)%*s", dtype,
5677                   ((is_32bit_elf ? 27 : 19)
5678                    - (int) strlen (dtype)),
5679                   " ");
5680         }
5681
5682       switch (entry->d_tag)
5683         {
5684         case DT_FLAGS:
5685           if (do_dynamic)
5686             print_dynamic_flags (entry->d_un.d_val);
5687           break;
5688
5689         case DT_AUXILIARY:
5690         case DT_FILTER:
5691         case DT_CONFIG:
5692         case DT_DEPAUDIT:
5693         case DT_AUDIT:
5694           if (do_dynamic)
5695             {
5696               switch (entry->d_tag)
5697                 {
5698                 case DT_AUXILIARY:
5699                   printf (_("Auxiliary library"));
5700                   break;
5701
5702                 case DT_FILTER:
5703                   printf (_("Filter library"));
5704                   break;
5705
5706                 case DT_CONFIG:
5707                   printf (_("Configuration file"));
5708                   break;
5709
5710                 case DT_DEPAUDIT:
5711                   printf (_("Dependency audit library"));
5712                   break;
5713
5714                 case DT_AUDIT:
5715                   printf (_("Audit library"));
5716                   break;
5717                 }
5718
5719               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5720                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5721               else
5722                 {
5723                   printf (": ");
5724                   print_vma (entry->d_un.d_val, PREFIX_HEX);
5725                   putchar ('\n');
5726                 }
5727             }
5728           break;
5729
5730         case DT_FEATURE:
5731           if (do_dynamic)
5732             {
5733               printf (_("Flags:"));
5734
5735               if (entry->d_un.d_val == 0)
5736                 printf (_(" None\n"));
5737               else
5738                 {
5739                   unsigned long int val = entry->d_un.d_val;
5740
5741                   if (val & DTF_1_PARINIT)
5742                     {
5743                       printf (" PARINIT");
5744                       val ^= DTF_1_PARINIT;
5745                     }
5746                   if (val & DTF_1_CONFEXP)
5747                     {
5748                       printf (" CONFEXP");
5749                       val ^= DTF_1_CONFEXP;
5750                     }
5751                   if (val != 0)
5752                     printf (" %lx", val);
5753                   puts ("");
5754                 }
5755             }
5756           break;
5757
5758         case DT_POSFLAG_1:
5759           if (do_dynamic)
5760             {
5761               printf (_("Flags:"));
5762
5763               if (entry->d_un.d_val == 0)
5764                 printf (_(" None\n"));
5765               else
5766                 {
5767                   unsigned long int val = entry->d_un.d_val;
5768
5769                   if (val & DF_P1_LAZYLOAD)
5770                     {
5771                       printf (" LAZYLOAD");
5772                       val ^= DF_P1_LAZYLOAD;
5773                     }
5774                   if (val & DF_P1_GROUPPERM)
5775                     {
5776                       printf (" GROUPPERM");
5777                       val ^= DF_P1_GROUPPERM;
5778                     }
5779                   if (val != 0)
5780                     printf (" %lx", val);
5781                   puts ("");
5782                 }
5783             }
5784           break;
5785
5786         case DT_FLAGS_1:
5787           if (do_dynamic)
5788             {
5789               printf (_("Flags:"));
5790               if (entry->d_un.d_val == 0)
5791                 printf (_(" None\n"));
5792               else
5793                 {
5794                   unsigned long int val = entry->d_un.d_val;
5795
5796                   if (val & DF_1_NOW)
5797                     {
5798                       printf (" NOW");
5799                       val ^= DF_1_NOW;
5800                     }
5801                   if (val & DF_1_GLOBAL)
5802                     {
5803                       printf (" GLOBAL");
5804                       val ^= DF_1_GLOBAL;
5805                     }
5806                   if (val & DF_1_GROUP)
5807                     {
5808                       printf (" GROUP");
5809                       val ^= DF_1_GROUP;
5810                     }
5811                   if (val & DF_1_NODELETE)
5812                     {
5813                       printf (" NODELETE");
5814                       val ^= DF_1_NODELETE;
5815                     }
5816                   if (val & DF_1_LOADFLTR)
5817                     {
5818                       printf (" LOADFLTR");
5819                       val ^= DF_1_LOADFLTR;
5820                     }
5821                   if (val & DF_1_INITFIRST)
5822                     {
5823                       printf (" INITFIRST");
5824                       val ^= DF_1_INITFIRST;
5825                     }
5826                   if (val & DF_1_NOOPEN)
5827                     {
5828                       printf (" NOOPEN");
5829                       val ^= DF_1_NOOPEN;
5830                     }
5831                   if (val & DF_1_ORIGIN)
5832                     {
5833                       printf (" ORIGIN");
5834                       val ^= DF_1_ORIGIN;
5835                     }
5836                   if (val & DF_1_DIRECT)
5837                     {
5838                       printf (" DIRECT");
5839                       val ^= DF_1_DIRECT;
5840                     }
5841                   if (val & DF_1_TRANS)
5842                     {
5843                       printf (" TRANS");
5844                       val ^= DF_1_TRANS;
5845                     }
5846                   if (val & DF_1_INTERPOSE)
5847                     {
5848                       printf (" INTERPOSE");
5849                       val ^= DF_1_INTERPOSE;
5850                     }
5851                   if (val & DF_1_NODEFLIB)
5852                     {
5853                       printf (" NODEFLIB");
5854                       val ^= DF_1_NODEFLIB;
5855                     }
5856                   if (val & DF_1_NODUMP)
5857                     {
5858                       printf (" NODUMP");
5859                       val ^= DF_1_NODUMP;
5860                     }
5861                   if (val & DF_1_CONLFAT)
5862                     {
5863                       printf (" CONLFAT");
5864                       val ^= DF_1_CONLFAT;
5865                     }
5866                   if (val != 0)
5867                     printf (" %lx", val);
5868                   puts ("");
5869                 }
5870             }
5871           break;
5872
5873         case DT_PLTREL:
5874           dynamic_info[entry->d_tag] = entry->d_un.d_val;
5875           if (do_dynamic)
5876             puts (get_dynamic_type (entry->d_un.d_val));
5877           break;
5878
5879         case DT_NULL    :
5880         case DT_NEEDED  :
5881         case DT_PLTGOT  :
5882         case DT_HASH    :
5883         case DT_STRTAB  :
5884         case DT_SYMTAB  :
5885         case DT_RELA    :
5886         case DT_INIT    :
5887         case DT_FINI    :
5888         case DT_SONAME  :
5889         case DT_RPATH   :
5890         case DT_SYMBOLIC:
5891         case DT_REL     :
5892         case DT_DEBUG   :
5893         case DT_TEXTREL :
5894         case DT_JMPREL  :
5895         case DT_RUNPATH :
5896           dynamic_info[entry->d_tag] = entry->d_un.d_val;
5897
5898           if (do_dynamic)
5899             {
5900               char *name;
5901
5902               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5903                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
5904               else
5905                 name = NULL;
5906
5907               if (name)
5908                 {
5909                   switch (entry->d_tag)
5910                     {
5911                     case DT_NEEDED:
5912                       printf (_("Shared library: [%s]"), name);
5913
5914                       if (streq (name, program_interpreter))
5915                         printf (_(" program interpreter"));
5916                       break;
5917
5918                     case DT_SONAME:
5919                       printf (_("Library soname: [%s]"), name);
5920                       break;
5921
5922                     case DT_RPATH:
5923                       printf (_("Library rpath: [%s]"), name);
5924                       break;
5925
5926                     case DT_RUNPATH:
5927                       printf (_("Library runpath: [%s]"), name);
5928                       break;
5929
5930                     default:
5931                       print_vma (entry->d_un.d_val, PREFIX_HEX);
5932                       break;
5933                     }
5934                 }
5935               else
5936                 print_vma (entry->d_un.d_val, PREFIX_HEX);
5937
5938               putchar ('\n');
5939             }
5940           break;
5941
5942         case DT_PLTRELSZ:
5943         case DT_RELASZ  :
5944         case DT_STRSZ   :
5945         case DT_RELSZ   :
5946         case DT_RELAENT :
5947         case DT_SYMENT  :
5948         case DT_RELENT  :
5949           dynamic_info[entry->d_tag] = entry->d_un.d_val;
5950         case DT_PLTPADSZ:
5951         case DT_MOVEENT :
5952         case DT_MOVESZ  :
5953         case DT_INIT_ARRAYSZ:
5954         case DT_FINI_ARRAYSZ:
5955         case DT_GNU_CONFLICTSZ:
5956         case DT_GNU_LIBLISTSZ:
5957           if (do_dynamic)
5958             {
5959               print_vma (entry->d_un.d_val, UNSIGNED);
5960               printf (" (bytes)\n");
5961             }
5962           break;
5963
5964         case DT_VERDEFNUM:
5965         case DT_VERNEEDNUM:
5966         case DT_RELACOUNT:
5967         case DT_RELCOUNT:
5968           if (do_dynamic)
5969             {
5970               print_vma (entry->d_un.d_val, UNSIGNED);
5971               putchar ('\n');
5972             }
5973           break;
5974
5975         case DT_SYMINSZ:
5976         case DT_SYMINENT:
5977         case DT_SYMINFO:
5978         case DT_USED:
5979         case DT_INIT_ARRAY:
5980         case DT_FINI_ARRAY:
5981           if (do_dynamic)
5982             {
5983               if (entry->d_tag == DT_USED
5984                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
5985                 {
5986                   char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
5987
5988                   if (*name)
5989                     {
5990                       printf (_("Not needed object: [%s]\n"), name);
5991                       break;
5992                     }
5993                 }
5994
5995               print_vma (entry->d_un.d_val, PREFIX_HEX);
5996               putchar ('\n');
5997             }
5998           break;
5999
6000         case DT_BIND_NOW:
6001           /* The value of this entry is ignored.  */
6002           if (do_dynamic)
6003             putchar ('\n');
6004           break;
6005
6006         case DT_GNU_PRELINKED:
6007           if (do_dynamic)
6008             {
6009               struct tm *tmp;
6010               time_t time = entry->d_un.d_val;
6011
6012               tmp = gmtime (&time);
6013               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6014                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6015                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6016
6017             }
6018           break;
6019
6020         default:
6021           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6022             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6023               entry->d_un.d_val;
6024
6025           if (do_dynamic)
6026             {
6027               switch (elf_header.e_machine)
6028                 {
6029                 case EM_MIPS:
6030                 case EM_MIPS_RS3_LE:
6031                   dynamic_section_mips_val (entry);
6032                   break;
6033                 case EM_PARISC:
6034                   dynamic_section_parisc_val (entry);
6035                   break;
6036                 case EM_IA_64:
6037                   dynamic_section_ia64_val (entry);
6038                   break;
6039                 default:
6040                   print_vma (entry->d_un.d_val, PREFIX_HEX);
6041                   putchar ('\n');
6042                 }
6043             }
6044           break;
6045         }
6046     }
6047
6048   return 1;
6049 }
6050
6051 static char *
6052 get_ver_flags (unsigned int flags)
6053 {
6054   static char buff[32];
6055
6056   buff[0] = 0;
6057
6058   if (flags == 0)
6059     return _("none");
6060
6061   if (flags & VER_FLG_BASE)
6062     strcat (buff, "BASE ");
6063
6064   if (flags & VER_FLG_WEAK)
6065     {
6066       if (flags & VER_FLG_BASE)
6067         strcat (buff, "| ");
6068
6069       strcat (buff, "WEAK ");
6070     }
6071
6072   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6073     strcat (buff, "| <unknown>");
6074
6075   return buff;
6076 }
6077
6078 /* Display the contents of the version sections.  */
6079 static int
6080 process_version_sections (FILE *file)
6081 {
6082   Elf_Internal_Shdr *section;
6083   unsigned i;
6084   int found = 0;
6085
6086   if (! do_version)
6087     return 1;
6088
6089   for (i = 0, section = section_headers;
6090        i < elf_header.e_shnum;
6091        i++, section++)
6092     {
6093       switch (section->sh_type)
6094         {
6095         case SHT_GNU_verdef:
6096           {
6097             Elf_External_Verdef *edefs;
6098             unsigned int idx;
6099             unsigned int cnt;
6100
6101             found = 1;
6102
6103             printf
6104               (_("\nVersion definition section '%s' contains %ld entries:\n"),
6105                SECTION_NAME (section), section->sh_info);
6106
6107             printf (_("  Addr: 0x"));
6108             printf_vma (section->sh_addr);
6109             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
6110                     (unsigned long) section->sh_offset, section->sh_link,
6111                     SECTION_NAME (SECTION_HEADER (section->sh_link)));
6112
6113             edefs = get_data (NULL, file, section->sh_offset, section->sh_size,
6114                               _("version definition section"));
6115             if (!edefs)
6116               break;
6117
6118             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6119               {
6120                 char *vstart;
6121                 Elf_External_Verdef *edef;
6122                 Elf_Internal_Verdef ent;
6123                 Elf_External_Verdaux *eaux;
6124                 Elf_Internal_Verdaux aux;
6125                 int j;
6126                 int isum;
6127
6128                 vstart = ((char *) edefs) + idx;
6129
6130                 edef = (Elf_External_Verdef *) vstart;
6131
6132                 ent.vd_version = BYTE_GET (edef->vd_version);
6133                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
6134                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
6135                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
6136                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
6137                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
6138                 ent.vd_next    = BYTE_GET (edef->vd_next);
6139
6140                 printf (_("  %#06x: Rev: %d  Flags: %s"),
6141                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6142
6143                 printf (_("  Index: %d  Cnt: %d  "),
6144                         ent.vd_ndx, ent.vd_cnt);
6145
6146                 vstart += ent.vd_aux;
6147
6148                 eaux = (Elf_External_Verdaux *) vstart;
6149
6150                 aux.vda_name = BYTE_GET (eaux->vda_name);
6151                 aux.vda_next = BYTE_GET (eaux->vda_next);
6152
6153                 if (VALID_DYNAMIC_NAME (aux.vda_name))
6154                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6155                 else
6156                   printf (_("Name index: %ld\n"), aux.vda_name);
6157
6158                 isum = idx + ent.vd_aux;
6159
6160                 for (j = 1; j < ent.vd_cnt; j++)
6161                   {
6162                     isum   += aux.vda_next;
6163                     vstart += aux.vda_next;
6164
6165                     eaux = (Elf_External_Verdaux *) vstart;
6166
6167                     aux.vda_name = BYTE_GET (eaux->vda_name);
6168                     aux.vda_next = BYTE_GET (eaux->vda_next);
6169
6170                     if (VALID_DYNAMIC_NAME (aux.vda_name))
6171                       printf (_("  %#06x: Parent %d: %s\n"),
6172                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6173                     else
6174                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
6175                               isum, j, aux.vda_name);
6176                   }
6177
6178                 idx += ent.vd_next;
6179               }
6180
6181             free (edefs);
6182           }
6183           break;
6184
6185         case SHT_GNU_verneed:
6186           {
6187             Elf_External_Verneed *eneed;
6188             unsigned int idx;
6189             unsigned int cnt;
6190
6191             found = 1;
6192
6193             printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6194                     SECTION_NAME (section), section->sh_info);
6195
6196             printf (_(" Addr: 0x"));
6197             printf_vma (section->sh_addr);
6198             printf (_("  Offset: %#08lx  Link to section: %ld (%s)\n"),
6199                     (unsigned long) section->sh_offset, section->sh_link,
6200                     SECTION_NAME (SECTION_HEADER (section->sh_link)));
6201
6202             eneed = get_data (NULL, file, section->sh_offset, section->sh_size,
6203                               _("version need section"));
6204             if (!eneed)
6205               break;
6206
6207             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6208               {
6209                 Elf_External_Verneed *entry;
6210                 Elf_Internal_Verneed ent;
6211                 int j;
6212                 int isum;
6213                 char *vstart;
6214
6215                 vstart = ((char *) eneed) + idx;
6216
6217                 entry = (Elf_External_Verneed *) vstart;
6218
6219                 ent.vn_version = BYTE_GET (entry->vn_version);
6220                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
6221                 ent.vn_file    = BYTE_GET (entry->vn_file);
6222                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
6223                 ent.vn_next    = BYTE_GET (entry->vn_next);
6224
6225                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
6226
6227                 if (VALID_DYNAMIC_NAME (ent.vn_file))
6228                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6229                 else
6230                   printf (_("  File: %lx"), ent.vn_file);
6231
6232                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
6233
6234                 vstart += ent.vn_aux;
6235
6236                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6237                   {
6238                     Elf_External_Vernaux *eaux;
6239                     Elf_Internal_Vernaux aux;
6240
6241                     eaux = (Elf_External_Vernaux *) vstart;
6242
6243                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
6244                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
6245                     aux.vna_other = BYTE_GET (eaux->vna_other);
6246                     aux.vna_name  = BYTE_GET (eaux->vna_name);
6247                     aux.vna_next  = BYTE_GET (eaux->vna_next);
6248
6249                     if (VALID_DYNAMIC_NAME (aux.vna_name))
6250                       printf (_("  %#06x:   Name: %s"),
6251                               isum, GET_DYNAMIC_NAME (aux.vna_name));
6252                     else
6253                       printf (_("  %#06x:   Name index: %lx"),
6254                               isum, aux.vna_name);
6255
6256                     printf (_("  Flags: %s  Version: %d\n"),
6257                             get_ver_flags (aux.vna_flags), aux.vna_other);
6258
6259                     isum   += aux.vna_next;
6260                     vstart += aux.vna_next;
6261                   }
6262
6263                 idx += ent.vn_next;
6264               }
6265
6266             free (eneed);
6267           }
6268           break;
6269
6270         case SHT_GNU_versym:
6271           {
6272             Elf_Internal_Shdr *link_section;
6273             int total;
6274             int cnt;
6275             unsigned char *edata;
6276             unsigned short *data;
6277             char *strtab;
6278             Elf_Internal_Sym *symbols;
6279             Elf_Internal_Shdr *string_sec;
6280             long off;
6281
6282             link_section = SECTION_HEADER (section->sh_link);
6283             total = section->sh_size / section->sh_entsize;
6284
6285             found = 1;
6286
6287             symbols = GET_ELF_SYMBOLS (file, link_section);
6288
6289             string_sec = SECTION_HEADER (link_section->sh_link);
6290
6291             strtab = get_data (NULL, file, string_sec->sh_offset,
6292                                string_sec->sh_size, _("version string table"));
6293             if (!strtab)
6294               break;
6295
6296             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6297                     SECTION_NAME (section), total);
6298
6299             printf (_(" Addr: "));
6300             printf_vma (section->sh_addr);
6301             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
6302                     (unsigned long) section->sh_offset, section->sh_link,
6303                     SECTION_NAME (link_section));
6304
6305             off = offset_from_vma (file,
6306                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6307                                    total * sizeof (short));
6308             edata = get_data (NULL, file, off, total * sizeof (short),
6309                               _("version symbol data"));
6310             if (!edata)
6311               {
6312                 free (strtab);
6313                 break;
6314               }
6315
6316             data = malloc (total * sizeof (short));
6317
6318             for (cnt = total; cnt --;)
6319               data[cnt] = byte_get (edata + cnt * sizeof (short),
6320                                     sizeof (short));
6321
6322             free (edata);
6323
6324             for (cnt = 0; cnt < total; cnt += 4)
6325               {
6326                 int j, nn;
6327                 int check_def, check_need;
6328                 char *name;
6329
6330                 printf ("  %03x:", cnt);
6331
6332                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6333                   switch (data[cnt + j])
6334                     {
6335                     case 0:
6336                       fputs (_("   0 (*local*)    "), stdout);
6337                       break;
6338
6339                     case 1:
6340                       fputs (_("   1 (*global*)   "), stdout);
6341                       break;
6342
6343                     default:
6344                       nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6345                                    data[cnt + j] & 0x8000 ? 'h' : ' ');
6346
6347                       check_def = 1;
6348                       check_need = 1;
6349                       if (SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
6350                           != SHT_NOBITS)
6351                         {
6352                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6353                             check_def = 0;
6354                           else
6355                             check_need = 0;
6356                         }
6357
6358                       if (check_need
6359                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6360                         {
6361                           Elf_Internal_Verneed ivn;
6362                           unsigned long offset;
6363
6364                           offset = offset_from_vma
6365                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6366                              sizeof (Elf_External_Verneed));
6367
6368                           do
6369                             {
6370                               Elf_Internal_Vernaux ivna;
6371                               Elf_External_Verneed evn;
6372                               Elf_External_Vernaux evna;
6373                               unsigned long a_off;
6374
6375                               get_data (&evn, file, offset, sizeof (evn),
6376                                         _("version need"));
6377
6378                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
6379                               ivn.vn_next = BYTE_GET (evn.vn_next);
6380
6381                               a_off = offset + ivn.vn_aux;
6382
6383                               do
6384                                 {
6385                                   get_data (&evna, file, a_off, sizeof (evna),
6386                                             _("version need aux (2)"));
6387
6388                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
6389                                   ivna.vna_other = BYTE_GET (evna.vna_other);
6390
6391                                   a_off += ivna.vna_next;
6392                                 }
6393                               while (ivna.vna_other != data[cnt + j]
6394                                      && ivna.vna_next != 0);
6395
6396                               if (ivna.vna_other == data[cnt + j])
6397                                 {
6398                                   ivna.vna_name = BYTE_GET (evna.vna_name);
6399
6400                                   name = strtab + ivna.vna_name;
6401                                   nn += printf ("(%s%-*s",
6402                                                 name,
6403                                                 12 - (int) strlen (name),
6404                                                 ")");
6405                                   check_def = 0;
6406                                   break;
6407                                 }
6408
6409                               offset += ivn.vn_next;
6410                             }
6411                           while (ivn.vn_next);
6412                         }
6413
6414                       if (check_def && data[cnt + j] != 0x8001
6415                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6416                         {
6417                           Elf_Internal_Verdef ivd;
6418                           Elf_External_Verdef evd;
6419                           unsigned long offset;
6420
6421                           offset = offset_from_vma
6422                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6423                              sizeof evd);
6424
6425                           do
6426                             {
6427                               get_data (&evd, file, offset, sizeof (evd),
6428                                         _("version def"));
6429
6430                               ivd.vd_next = BYTE_GET (evd.vd_next);
6431                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
6432
6433                               offset += ivd.vd_next;
6434                             }
6435                           while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6436                                  && ivd.vd_next != 0);
6437
6438                           if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6439                             {
6440                               Elf_External_Verdaux evda;
6441                               Elf_Internal_Verdaux ivda;
6442
6443                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
6444
6445                               get_data (&evda, file,
6446                                         offset - ivd.vd_next + ivd.vd_aux,
6447                                         sizeof (evda), _("version def aux"));
6448
6449                               ivda.vda_name = BYTE_GET (evda.vda_name);
6450
6451                               name = strtab + ivda.vda_name;
6452                               nn += printf ("(%s%-*s",
6453                                             name,
6454                                             12 - (int) strlen (name),
6455                                             ")");
6456                             }
6457                         }
6458
6459                       if (nn < 18)
6460                         printf ("%*c", 18 - nn, ' ');
6461                     }
6462
6463                 putchar ('\n');
6464               }
6465
6466             free (data);
6467             free (strtab);
6468             free (symbols);
6469           }
6470           break;
6471
6472         default:
6473           break;
6474         }
6475     }
6476
6477   if (! found)
6478     printf (_("\nNo version information found in this file.\n"));
6479
6480   return 1;
6481 }
6482
6483 static const char *
6484 get_symbol_binding (unsigned int binding)
6485 {
6486   static char buff[32];
6487
6488   switch (binding)
6489     {
6490     case STB_LOCAL:     return "LOCAL";
6491     case STB_GLOBAL:    return "GLOBAL";
6492     case STB_WEAK:      return "WEAK";
6493     default:
6494       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6495         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6496                   binding);
6497       else if (binding >= STB_LOOS && binding <= STB_HIOS)
6498         snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6499       else
6500         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6501       return buff;
6502     }
6503 }
6504
6505 static const char *
6506 get_symbol_type (unsigned int type)
6507 {
6508   static char buff[32];
6509
6510   switch (type)
6511     {
6512     case STT_NOTYPE:    return "NOTYPE";
6513     case STT_OBJECT:    return "OBJECT";
6514     case STT_FUNC:      return "FUNC";
6515     case STT_SECTION:   return "SECTION";
6516     case STT_FILE:      return "FILE";
6517     case STT_COMMON:    return "COMMON";
6518     case STT_TLS:       return "TLS";
6519     default:
6520       if (type >= STT_LOPROC && type <= STT_HIPROC)
6521         {
6522           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
6523             return "THUMB_FUNC";
6524
6525           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
6526             return "REGISTER";
6527
6528           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
6529             return "PARISC_MILLI";
6530
6531           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
6532         }
6533       else if (type >= STT_LOOS && type <= STT_HIOS)
6534         {
6535           if (elf_header.e_machine == EM_PARISC)
6536             {
6537               if (type == STT_HP_OPAQUE)
6538                 return "HP_OPAQUE";
6539               if (type == STT_HP_STUB)
6540                 return "HP_STUB";
6541             }
6542
6543           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
6544         }
6545       else
6546         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
6547       return buff;
6548     }
6549 }
6550
6551 static const char *
6552 get_symbol_visibility (unsigned int visibility)
6553 {
6554   switch (visibility)
6555     {
6556     case STV_DEFAULT:   return "DEFAULT";
6557     case STV_INTERNAL:  return "INTERNAL";
6558     case STV_HIDDEN:    return "HIDDEN";
6559     case STV_PROTECTED: return "PROTECTED";
6560     default: abort ();
6561     }
6562 }
6563
6564 static const char *
6565 get_symbol_index_type (unsigned int type)
6566 {
6567   static char buff[32];
6568
6569   switch (type)
6570     {
6571     case SHN_UNDEF:     return "UND";
6572     case SHN_ABS:       return "ABS";
6573     case SHN_COMMON:    return "COM";
6574     default:
6575       if (type == SHN_IA_64_ANSI_COMMON
6576           && elf_header.e_machine == EM_IA_64
6577           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
6578         return "ANSI_COM";
6579       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
6580         sprintf (buff, "PRC[0x%04x]", type);
6581       else if (type >= SHN_LOOS && type <= SHN_HIOS)
6582         sprintf (buff, "OS [0x%04x]", type);
6583       else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
6584         sprintf (buff, "RSV[0x%04x]", type);
6585       else
6586         sprintf (buff, "%3d", type);
6587       break;
6588     }
6589
6590   return buff;
6591 }
6592
6593 static bfd_vma *
6594 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
6595 {
6596   unsigned char *e_data;
6597   bfd_vma *i_data;
6598
6599   e_data = malloc (number * ent_size);
6600
6601   if (e_data == NULL)
6602     {
6603       error (_("Out of memory\n"));
6604       return NULL;
6605     }
6606
6607   if (fread (e_data, ent_size, number, file) != number)
6608     {
6609       error (_("Unable to read in dynamic data\n"));
6610       return NULL;
6611     }
6612
6613   i_data = malloc (number * sizeof (*i_data));
6614
6615   if (i_data == NULL)
6616     {
6617       error (_("Out of memory\n"));
6618       free (e_data);
6619       return NULL;
6620     }
6621
6622   while (number--)
6623     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
6624
6625   free (e_data);
6626
6627   return i_data;
6628 }
6629
6630 /* Dump the symbol table.  */
6631 static int
6632 process_symbol_table (FILE *file)
6633 {
6634   Elf_Internal_Shdr *section;
6635   bfd_vma nbuckets = 0;
6636   bfd_vma nchains = 0;
6637   bfd_vma *buckets = NULL;
6638   bfd_vma *chains = NULL;
6639
6640   if (! do_syms && !do_histogram)
6641     return 1;
6642
6643   if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
6644                                 || do_histogram))
6645     {
6646       unsigned char nb[8];
6647       unsigned char nc[8];
6648       int hash_ent_size = 4;
6649
6650       if ((elf_header.e_machine == EM_ALPHA
6651            || elf_header.e_machine == EM_S390
6652            || elf_header.e_machine == EM_S390_OLD)
6653           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
6654         hash_ent_size = 8;
6655
6656       if (fseek (file,
6657                  (archive_file_offset
6658                   + offset_from_vma (file, dynamic_info[DT_HASH],
6659                                      sizeof nb + sizeof nc)),
6660                  SEEK_SET))
6661         {
6662           error (_("Unable to seek to start of dynamic information"));
6663           return 0;
6664         }
6665
6666       if (fread (nb, hash_ent_size, 1, file) != 1)
6667         {
6668           error (_("Failed to read in number of buckets\n"));
6669           return 0;
6670         }
6671
6672       if (fread (nc, hash_ent_size, 1, file) != 1)
6673         {
6674           error (_("Failed to read in number of chains\n"));
6675           return 0;
6676         }
6677
6678       nbuckets = byte_get (nb, hash_ent_size);
6679       nchains  = byte_get (nc, hash_ent_size);
6680
6681       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
6682       chains  = get_dynamic_data (file, nchains, hash_ent_size);
6683
6684       if (buckets == NULL || chains == NULL)
6685         return 0;
6686     }
6687
6688   if (do_syms
6689       && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
6690     {
6691       unsigned long hn;
6692       bfd_vma si;
6693
6694       printf (_("\nSymbol table for image:\n"));
6695       if (is_32bit_elf)
6696         printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
6697       else
6698         printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
6699
6700       for (hn = 0; hn < nbuckets; hn++)
6701         {
6702           if (! buckets[hn])
6703             continue;
6704
6705           for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
6706             {
6707               Elf_Internal_Sym *psym;
6708               int n;
6709
6710               psym = dynamic_symbols + si;
6711
6712               n = print_vma (si, DEC_5);
6713               if (n < 5)
6714                 fputs ("     " + n, stdout);
6715               printf (" %3lu: ", hn);
6716               print_vma (psym->st_value, LONG_HEX);
6717               putchar (' ');
6718               print_vma (psym->st_size, DEC_5);
6719
6720               printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
6721               printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
6722               printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6723               printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
6724               if (VALID_DYNAMIC_NAME (psym->st_name))
6725                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
6726               else
6727                 printf (" <corrupt: %14ld>", psym->st_name);
6728               putchar ('\n');
6729             }
6730         }
6731     }
6732   else if (do_syms && !do_using_dynamic)
6733     {
6734       unsigned int i;
6735
6736       for (i = 0, section = section_headers;
6737            i < elf_header.e_shnum;
6738            i++, section++)
6739         {
6740           unsigned int si;
6741           char *strtab;
6742           Elf_Internal_Sym *symtab;
6743           Elf_Internal_Sym *psym;
6744
6745
6746           if (   section->sh_type != SHT_SYMTAB
6747               && section->sh_type != SHT_DYNSYM)
6748             continue;
6749
6750           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6751                   SECTION_NAME (section),
6752                   (unsigned long) (section->sh_size / section->sh_entsize));
6753           if (is_32bit_elf)
6754             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
6755           else
6756             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
6757
6758           symtab = GET_ELF_SYMBOLS (file, section);
6759           if (symtab == NULL)
6760             continue;
6761
6762           if (section->sh_link == elf_header.e_shstrndx)
6763             strtab = string_table;
6764           else
6765             {
6766               Elf_Internal_Shdr *string_sec;
6767
6768               string_sec = SECTION_HEADER (section->sh_link);
6769
6770               strtab = get_data (NULL, file, string_sec->sh_offset,
6771                                  string_sec->sh_size, _("string table"));
6772             }
6773
6774           for (si = 0, psym = symtab;
6775                si < section->sh_size / section->sh_entsize;
6776                si++, psym++)
6777             {
6778               printf ("%6d: ", si);
6779               print_vma (psym->st_value, LONG_HEX);
6780               putchar (' ');
6781               print_vma (psym->st_size, DEC_5);
6782               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
6783               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
6784               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6785               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
6786               print_symbol (25, strtab + psym->st_name);
6787
6788               if (section->sh_type == SHT_DYNSYM &&
6789                   version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
6790                 {
6791                   unsigned char data[2];
6792                   unsigned short vers_data;
6793                   unsigned long offset;
6794                   int is_nobits;
6795                   int check_def;
6796
6797                   offset = offset_from_vma
6798                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6799                      sizeof data + si * sizeof (vers_data));
6800
6801                   get_data (&data, file, offset + si * sizeof (vers_data),
6802                             sizeof (data), _("version data"));
6803
6804                   vers_data = byte_get (data, 2);
6805
6806                   is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
6807                                == SHT_NOBITS);
6808
6809                   check_def = (psym->st_shndx != SHN_UNDEF);
6810
6811                   if ((vers_data & 0x8000) || vers_data > 1)
6812                     {
6813                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
6814                           && (is_nobits || ! check_def))
6815                         {
6816                           Elf_External_Verneed evn;
6817                           Elf_Internal_Verneed ivn;
6818                           Elf_Internal_Vernaux ivna;
6819
6820                           /* We must test both.  */
6821                           offset = offset_from_vma
6822                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6823                              sizeof evn);
6824
6825                           do
6826                             {
6827                               unsigned long vna_off;
6828
6829                               get_data (&evn, file, offset, sizeof (evn),
6830                                         _("version need"));
6831
6832                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
6833                               ivn.vn_next = BYTE_GET (evn.vn_next);
6834
6835                               vna_off = offset + ivn.vn_aux;
6836
6837                               do
6838                                 {
6839                                   Elf_External_Vernaux evna;
6840
6841                                   get_data (&evna, file, vna_off,
6842                                             sizeof (evna),
6843                                             _("version need aux (3)"));
6844
6845                                   ivna.vna_other = BYTE_GET (evna.vna_other);
6846                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
6847                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
6848
6849                                   vna_off += ivna.vna_next;
6850                                 }
6851                               while (ivna.vna_other != vers_data
6852                                      && ivna.vna_next != 0);
6853
6854                               if (ivna.vna_other == vers_data)
6855                                 break;
6856
6857                               offset += ivn.vn_next;
6858                             }
6859                           while (ivn.vn_next != 0);
6860
6861                           if (ivna.vna_other == vers_data)
6862                             {
6863                               printf ("@%s (%d)",
6864                                       strtab + ivna.vna_name, ivna.vna_other);
6865                               check_def = 0;
6866                             }
6867                           else if (! is_nobits)
6868                             error (_("bad dynamic symbol"));
6869                           else
6870                             check_def = 1;
6871                         }
6872
6873                       if (check_def)
6874                         {
6875                           if (vers_data != 0x8001
6876                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6877                             {
6878                               Elf_Internal_Verdef ivd;
6879                               Elf_Internal_Verdaux ivda;
6880                               Elf_External_Verdaux evda;
6881                               unsigned long offset;
6882
6883                               offset = offset_from_vma
6884                                 (file,
6885                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6886                                  sizeof (Elf_External_Verdef));
6887
6888                               do
6889                                 {
6890                                   Elf_External_Verdef evd;
6891
6892                                   get_data (&evd, file, offset, sizeof (evd),
6893                                             _("version def"));
6894
6895                                   ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
6896                                   ivd.vd_aux = BYTE_GET (evd.vd_aux);
6897                                   ivd.vd_next = BYTE_GET (evd.vd_next);
6898
6899                                   offset += ivd.vd_next;
6900                                 }
6901                               while (ivd.vd_ndx != (vers_data & 0x7fff)
6902                                      && ivd.vd_next != 0);
6903
6904                               offset -= ivd.vd_next;
6905                               offset += ivd.vd_aux;
6906
6907                               get_data (&evda, file, offset, sizeof (evda),
6908                                         _("version def aux"));
6909
6910                               ivda.vda_name = BYTE_GET (evda.vda_name);
6911
6912                               if (psym->st_name != ivda.vda_name)
6913                                 printf ((vers_data & 0x8000)
6914                                         ? "@%s" : "@@%s",
6915                                         strtab + ivda.vda_name);
6916                             }
6917                         }
6918                     }
6919                 }
6920
6921               putchar ('\n');
6922             }
6923
6924           free (symtab);
6925           if (strtab != string_table)
6926             free (strtab);
6927         }
6928     }
6929   else if (do_syms)
6930     printf
6931       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6932
6933   if (do_histogram && buckets != NULL)
6934     {
6935       unsigned long *lengths;
6936       unsigned long *counts;
6937       unsigned long hn;
6938       bfd_vma si;
6939       unsigned long maxlength = 0;
6940       unsigned long nzero_counts = 0;
6941       unsigned long nsyms = 0;
6942
6943       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6944               (unsigned long) nbuckets);
6945       printf (_(" Length  Number     %% of total  Coverage\n"));
6946
6947       lengths = calloc (nbuckets, sizeof (*lengths));
6948       if (lengths == NULL)
6949         {
6950           error (_("Out of memory"));
6951           return 0;
6952         }
6953       for (hn = 0; hn < nbuckets; ++hn)
6954         {
6955           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
6956             {
6957               ++nsyms;
6958               if (maxlength < ++lengths[hn])
6959                 ++maxlength;
6960             }
6961         }
6962
6963       counts = calloc (maxlength + 1, sizeof (*counts));
6964       if (counts == NULL)
6965         {
6966           error (_("Out of memory"));
6967           return 0;
6968         }
6969
6970       for (hn = 0; hn < nbuckets; ++hn)
6971         ++counts[lengths[hn]];
6972
6973       if (nbuckets > 0)
6974         {
6975           unsigned long i;
6976           printf ("      0  %-10lu (%5.1f%%)\n",
6977                   counts[0], (counts[0] * 100.0) / nbuckets);
6978           for (i = 1; i <= maxlength; ++i)
6979             {
6980               nzero_counts += counts[i] * i;
6981               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
6982                       i, counts[i], (counts[i] * 100.0) / nbuckets,
6983                       (nzero_counts * 100.0) / nsyms);
6984             }
6985         }
6986
6987       free (counts);
6988       free (lengths);
6989     }
6990
6991   if (buckets != NULL)
6992     {
6993       free (buckets);
6994       free (chains);
6995     }
6996
6997   return 1;
6998 }
6999
7000 static int
7001 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7002 {
7003   unsigned int i;
7004
7005   if (dynamic_syminfo == NULL
7006       || !do_dynamic)
7007     /* No syminfo, this is ok.  */
7008     return 1;
7009
7010   /* There better should be a dynamic symbol section.  */
7011   if (dynamic_symbols == NULL || dynamic_strings == NULL)
7012     return 0;
7013
7014   if (dynamic_addr)
7015     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7016             dynamic_syminfo_offset, dynamic_syminfo_nent);
7017
7018   printf (_(" Num: Name                           BoundTo     Flags\n"));
7019   for (i = 0; i < dynamic_syminfo_nent; ++i)
7020     {
7021       unsigned short int flags = dynamic_syminfo[i].si_flags;
7022
7023       printf ("%4d: ", i);
7024       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7025         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7026       else
7027         printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7028       putchar (' ');
7029
7030       switch (dynamic_syminfo[i].si_boundto)
7031         {
7032         case SYMINFO_BT_SELF:
7033           fputs ("SELF       ", stdout);
7034           break;
7035         case SYMINFO_BT_PARENT:
7036           fputs ("PARENT     ", stdout);
7037           break;
7038         default:
7039           if (dynamic_syminfo[i].si_boundto > 0
7040               && dynamic_syminfo[i].si_boundto < dynamic_nent
7041               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7042             {
7043               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7044               putchar (' ' );
7045             }
7046           else
7047             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7048           break;
7049         }
7050
7051       if (flags & SYMINFO_FLG_DIRECT)
7052         printf (" DIRECT");
7053       if (flags & SYMINFO_FLG_PASSTHRU)
7054         printf (" PASSTHRU");
7055       if (flags & SYMINFO_FLG_COPY)
7056         printf (" COPY");
7057       if (flags & SYMINFO_FLG_LAZYLOAD)
7058         printf (" LAZYLOAD");
7059
7060       puts ("");
7061     }
7062
7063   return 1;
7064 }
7065
7066 #ifdef SUPPORT_DISASSEMBLY
7067 static int
7068 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7069 {
7070   printf (_("\nAssembly dump of section %s\n"),
7071           SECTION_NAME (section));
7072
7073   /* XXX -- to be done --- XXX */
7074
7075   return 1;
7076 }
7077 #endif
7078
7079 static int
7080 dump_section (Elf_Internal_Shdr *section, FILE *file)
7081 {
7082   bfd_size_type bytes;
7083   bfd_vma addr;
7084   unsigned char *data;
7085   unsigned char *start;
7086
7087   bytes = section->sh_size;
7088
7089   if (bytes == 0 || section->sh_type == SHT_NOBITS)
7090     {
7091       printf (_("\nSection '%s' has no data to dump.\n"),
7092               SECTION_NAME (section));
7093       return 0;
7094     }
7095   else
7096     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7097
7098   addr = section->sh_addr;
7099
7100   start = get_data (NULL, file, section->sh_offset, bytes, _("section data"));
7101   if (!start)
7102     return 0;
7103
7104   data = start;
7105
7106   while (bytes)
7107     {
7108       int j;
7109       int k;
7110       int lbytes;
7111
7112       lbytes = (bytes > 16 ? 16 : bytes);
7113
7114       printf ("  0x%8.8lx ", (unsigned long) addr);
7115
7116       switch (elf_header.e_ident[EI_DATA])
7117         {
7118         default:
7119         case ELFDATA2LSB:
7120           for (j = 15; j >= 0; j --)
7121             {
7122               if (j < lbytes)
7123                 printf ("%2.2x", data[j]);
7124               else
7125                 printf ("  ");
7126
7127               if (!(j & 0x3))
7128                 printf (" ");
7129             }
7130           break;
7131
7132         case ELFDATA2MSB:
7133           for (j = 0; j < 16; j++)
7134             {
7135               if (j < lbytes)
7136                 printf ("%2.2x", data[j]);
7137               else
7138                 printf ("  ");
7139
7140               if ((j & 3) == 3)
7141                 printf (" ");
7142             }
7143           break;
7144         }
7145
7146       for (j = 0; j < lbytes; j++)
7147         {
7148           k = data[j];
7149           if (k >= ' ' && k < 0x7f)
7150             printf ("%c", k);
7151           else
7152             printf (".");
7153         }
7154
7155       putchar ('\n');
7156
7157       data  += lbytes;
7158       addr  += lbytes;
7159       bytes -= lbytes;
7160     }
7161
7162   free (start);
7163
7164   return 1;
7165 }
7166
7167
7168 static unsigned long int
7169 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
7170 {
7171   unsigned long int result = 0;
7172   unsigned int num_read = 0;
7173   unsigned int shift = 0;
7174   unsigned char byte;
7175
7176   do
7177     {
7178       byte = *data++;
7179       num_read++;
7180
7181       result |= ((unsigned long int) (byte & 0x7f)) << shift;
7182
7183       shift += 7;
7184
7185     }
7186   while (byte & 0x80);
7187
7188   if (length_return != NULL)
7189     *length_return = num_read;
7190
7191   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
7192     result |= -1L << shift;
7193
7194   return result;
7195 }
7196
7197 typedef struct State_Machine_Registers
7198 {
7199   unsigned long address;
7200   unsigned int file;
7201   unsigned int line;
7202   unsigned int column;
7203   int is_stmt;
7204   int basic_block;
7205   int end_sequence;
7206 /* This variable hold the number of the last entry seen
7207    in the File Table.  */
7208   unsigned int last_file_entry;
7209 } SMR;
7210
7211 static SMR state_machine_regs;
7212
7213 static void
7214 reset_state_machine (int is_stmt)
7215 {
7216   state_machine_regs.address = 0;
7217   state_machine_regs.file = 1;
7218   state_machine_regs.line = 1;
7219   state_machine_regs.column = 0;
7220   state_machine_regs.is_stmt = is_stmt;
7221   state_machine_regs.basic_block = 0;
7222   state_machine_regs.end_sequence = 0;
7223   state_machine_regs.last_file_entry = 0;
7224 }
7225
7226 /* Handled an extend line op.
7227    Returns the number of bytes read.  */
7228
7229 static int
7230 process_extended_line_op (unsigned char *data, int is_stmt, int pointer_size)
7231 {
7232   unsigned char op_code;
7233   unsigned int bytes_read;
7234   unsigned int len;
7235   unsigned char *name;
7236   unsigned long adr;
7237
7238   len = read_leb128 (data, & bytes_read, 0);
7239   data += bytes_read;
7240
7241   if (len == 0)
7242     {
7243       warn (_("badly formed extended line op encountered!\n"));
7244       return bytes_read;
7245     }
7246
7247   len += bytes_read;
7248   op_code = *data++;
7249
7250   printf (_("  Extended opcode %d: "), op_code);
7251
7252   switch (op_code)
7253     {
7254     case DW_LNE_end_sequence:
7255       printf (_("End of Sequence\n\n"));
7256       reset_state_machine (is_stmt);
7257       break;
7258
7259     case DW_LNE_set_address:
7260       adr = byte_get (data, pointer_size);
7261       printf (_("set Address to 0x%lx\n"), adr);
7262       state_machine_regs.address = adr;
7263       break;
7264
7265     case DW_LNE_define_file:
7266       printf (_("  define new File Table entry\n"));
7267       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
7268
7269       printf (_("   %d\t"), ++state_machine_regs.last_file_entry);
7270       name = data;
7271       data += strlen ((char *) data) + 1;
7272       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
7273       data += bytes_read;
7274       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
7275       data += bytes_read;
7276       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
7277       printf (_("%s\n\n"), name);
7278       break;
7279
7280     default:
7281       printf (_("UNKNOWN: length %d\n"), len - bytes_read);
7282       break;
7283     }
7284
7285   return len;
7286 }
7287
7288 static const char *debug_str_contents;
7289 static bfd_vma debug_str_size;
7290
7291 static void
7292 load_debug_str (FILE *file)
7293 {
7294   Elf_Internal_Shdr *sec;
7295
7296   /* If it is already loaded, do nothing.  */
7297   if (debug_str_contents != NULL)
7298     return;
7299
7300   /* Locate the .debug_str section.  */
7301   sec = find_section (".debug_str");
7302   if (sec == NULL)
7303     return;
7304
7305   debug_str_size = sec->sh_size;
7306
7307   debug_str_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
7308                                  _("debug_str section data"));
7309 }
7310
7311 static void
7312 free_debug_str (void)
7313 {
7314   if (debug_str_contents == NULL)
7315     return;
7316
7317   free ((char *) debug_str_contents);
7318   debug_str_contents = NULL;
7319   debug_str_size = 0;
7320 }
7321
7322 static const char *
7323 fetch_indirect_string (unsigned long offset)
7324 {
7325   if (debug_str_contents == NULL)
7326     return _("<no .debug_str section>");
7327
7328   if (offset > debug_str_size)
7329     {
7330       warn (_("DW_FORM_strp offset too big: %x\n"), offset);
7331       return _("<offset is too big>");
7332     }
7333
7334   return debug_str_contents + offset;
7335 }
7336
7337 static const char *debug_loc_contents;
7338 static bfd_vma debug_loc_size;
7339
7340 static void
7341 load_debug_loc (FILE *file)
7342 {
7343   Elf_Internal_Shdr *sec;
7344
7345   /* If it is already loaded, do nothing.  */
7346   if (debug_loc_contents != NULL)
7347     return;
7348
7349   /* Locate the .debug_loc section.  */
7350   sec = find_section (".debug_loc");
7351   if (sec == NULL)
7352     return;
7353
7354   debug_loc_size = sec->sh_size;
7355
7356   debug_loc_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
7357                                  _("debug_loc section data"));
7358 }
7359
7360 static void
7361 free_debug_loc (void)
7362 {
7363   if (debug_loc_contents == NULL)
7364     return;
7365
7366   free ((char *) debug_loc_contents);
7367   debug_loc_contents = NULL;
7368   debug_loc_size = 0;
7369 }
7370
7371 static const char *   debug_range_contents;
7372 static unsigned long  debug_range_size;
7373
7374 static void
7375 load_debug_range (FILE *file)
7376 {
7377   Elf_Internal_Shdr *sec;
7378
7379   /* If it is already loaded, do nothing.  */
7380   if (debug_range_contents != NULL)
7381     return;
7382
7383   /* Locate the .debug_ranges section.  */
7384   sec = find_section (".debug_ranges");
7385   if (sec == NULL)
7386     return;
7387
7388   debug_range_size = sec->sh_size;
7389
7390   debug_range_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
7391                                    _("debug_range section data"));
7392 }
7393
7394 static void
7395 free_debug_range (void)
7396 {
7397   if (debug_range_contents == NULL)
7398     return;
7399
7400   free ((char *) debug_range_contents);
7401   debug_range_contents = NULL;
7402   debug_range_size = 0;
7403 }
7404
7405 /* Apply addends of RELA relocations.  */
7406
7407 static int
7408 debug_apply_rela_addends (FILE *file,
7409                           Elf_Internal_Shdr *section,
7410                           int reloc_size,
7411                           unsigned char *sec_data,
7412                           unsigned char *start,
7413                           unsigned char *end)
7414 {
7415   Elf_Internal_Shdr *relsec;
7416
7417   if (end - start < reloc_size)
7418     return 1;
7419
7420   for (relsec = section_headers;
7421        relsec < section_headers + elf_header.e_shnum;
7422        ++relsec)
7423     {
7424       unsigned long nrelas;
7425       Elf_Internal_Rela *rela, *rp;
7426       Elf_Internal_Shdr *symsec;
7427       Elf_Internal_Sym *symtab;
7428       Elf_Internal_Sym *sym;
7429
7430       if (relsec->sh_type != SHT_RELA
7431           || SECTION_HEADER (relsec->sh_info) != section
7432           || relsec->sh_size == 0)
7433         continue;
7434
7435       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7436                               &rela, &nrelas))
7437         return 0;
7438
7439       symsec = SECTION_HEADER (relsec->sh_link);
7440       symtab = GET_ELF_SYMBOLS (file, symsec);
7441
7442       for (rp = rela; rp < rela + nrelas; ++rp)
7443         {
7444           unsigned char *loc;
7445
7446           if (rp->r_offset >= (bfd_vma) (start - sec_data)
7447               && rp->r_offset < (bfd_vma) (end - sec_data) - reloc_size)
7448             loc = sec_data + rp->r_offset;
7449           else
7450             continue;
7451
7452           if (is_32bit_elf)
7453             {
7454               sym = symtab + ELF32_R_SYM (rp->r_info);
7455
7456               if (ELF32_R_SYM (rp->r_info) != 0
7457                   && ELF32_ST_TYPE (sym->st_info) != STT_SECTION
7458                   /* Relocations against object symbols can happen,
7459                      eg when referencing a global array.  For an
7460                      example of this see the _clz.o binary in libgcc.a.  */
7461                   && ELF32_ST_TYPE (sym->st_info) != STT_OBJECT)
7462                 {
7463                   warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7464                         get_symbol_type (ELF32_ST_TYPE (sym->st_info)),
7465                         SECTION_NAME (section));
7466                   continue;
7467                 }
7468             }
7469           else
7470             {
7471               /* In MIPS little-endian objects, r_info isn't really a
7472                  64-bit little-endian value: it has a 32-bit little-endian
7473                  symbol index followed by four individual byte fields.
7474                  Reorder INFO accordingly.  */
7475               if (elf_header.e_machine == EM_MIPS
7476                   && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
7477                 rp->r_info = (((rp->r_info & 0xffffffff) << 32)
7478                               | ((rp->r_info >> 56) & 0xff)
7479                               | ((rp->r_info >> 40) & 0xff00)
7480                               | ((rp->r_info >> 24) & 0xff0000)
7481                               | ((rp->r_info >> 8) & 0xff000000));
7482
7483               sym = symtab + ELF64_R_SYM (rp->r_info);
7484
7485               if (ELF64_R_SYM (rp->r_info) != 0
7486                   && ELF64_ST_TYPE (sym->st_info) != STT_SECTION
7487                   && ELF64_ST_TYPE (sym->st_info) != STT_OBJECT)
7488                 {
7489                   warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7490                         get_symbol_type (ELF64_ST_TYPE (sym->st_info)),
7491                         SECTION_NAME (section));
7492                   continue;
7493                 }
7494             }
7495
7496           byte_put (loc, rp->r_addend, reloc_size);
7497         }
7498
7499       free (symtab);
7500       free (rela);
7501       break;
7502     }
7503   return 1;
7504 }
7505
7506 /* FIXME:  There are better and more efficient ways to handle
7507    these structures.  For now though, I just want something that
7508    is simple to implement.  */
7509 typedef struct abbrev_attr
7510 {
7511   unsigned long attribute;
7512   unsigned long form;
7513   struct abbrev_attr *next;
7514 }
7515 abbrev_attr;
7516
7517 typedef struct abbrev_entry
7518 {
7519   unsigned long entry;
7520   unsigned long tag;
7521   int children;
7522   struct abbrev_attr *first_attr;
7523   struct abbrev_attr *last_attr;
7524   struct abbrev_entry *next;
7525 }
7526 abbrev_entry;
7527
7528 static abbrev_entry *first_abbrev = NULL;
7529 static abbrev_entry *last_abbrev = NULL;
7530
7531 static void
7532 free_abbrevs (void)
7533 {
7534   abbrev_entry *abbrev;
7535
7536   for (abbrev = first_abbrev; abbrev;)
7537     {
7538       abbrev_entry *next = abbrev->next;
7539       abbrev_attr *attr;
7540
7541       for (attr = abbrev->first_attr; attr;)
7542         {
7543           abbrev_attr *next = attr->next;
7544
7545           free (attr);
7546           attr = next;
7547         }
7548
7549       free (abbrev);
7550       abbrev = next;
7551     }
7552
7553   last_abbrev = first_abbrev = NULL;
7554 }
7555
7556 static void
7557 add_abbrev (unsigned long number, unsigned long tag, int children)
7558 {
7559   abbrev_entry *entry;
7560
7561   entry = malloc (sizeof (*entry));
7562
7563   if (entry == NULL)
7564     /* ugg */
7565     return;
7566
7567   entry->entry      = number;
7568   entry->tag        = tag;
7569   entry->children   = children;
7570   entry->first_attr = NULL;
7571   entry->last_attr  = NULL;
7572   entry->next       = NULL;
7573
7574   if (first_abbrev == NULL)
7575     first_abbrev = entry;
7576   else
7577     last_abbrev->next = entry;
7578
7579   last_abbrev = entry;
7580 }
7581
7582 static void
7583 add_abbrev_attr (unsigned long attribute, unsigned long form)
7584 {
7585   abbrev_attr *attr;
7586
7587   attr = malloc (sizeof (*attr));
7588
7589   if (attr == NULL)
7590     /* ugg */
7591     return;
7592
7593   attr->attribute = attribute;
7594   attr->form      = form;
7595   attr->next      = NULL;
7596
7597   if (last_abbrev->first_attr == NULL)
7598     last_abbrev->first_attr = attr;
7599   else
7600     last_abbrev->last_attr->next = attr;
7601
7602   last_abbrev->last_attr = attr;
7603 }
7604
7605 /* Processes the (partial) contents of a .debug_abbrev section.
7606    Returns NULL if the end of the section was encountered.
7607    Returns the address after the last byte read if the end of
7608    an abbreviation set was found.  */
7609
7610 static unsigned char *
7611 process_abbrev_section (unsigned char *start, unsigned char *end)
7612 {
7613   if (first_abbrev != NULL)
7614     return NULL;
7615
7616   while (start < end)
7617     {
7618       unsigned int bytes_read;
7619       unsigned long entry;
7620       unsigned long tag;
7621       unsigned long attribute;
7622       int children;
7623
7624       entry = read_leb128 (start, & bytes_read, 0);
7625       start += bytes_read;
7626
7627       /* A single zero is supposed to end the section according
7628          to the standard.  If there's more, then signal that to
7629          the caller.  */
7630       if (entry == 0)
7631         return start == end ? NULL : start;
7632
7633       tag = read_leb128 (start, & bytes_read, 0);
7634       start += bytes_read;
7635
7636       children = *start++;
7637
7638       add_abbrev (entry, tag, children);
7639
7640       do
7641         {
7642           unsigned long form;
7643
7644           attribute = read_leb128 (start, & bytes_read, 0);
7645           start += bytes_read;
7646
7647           form = read_leb128 (start, & bytes_read, 0);
7648           start += bytes_read;
7649
7650           if (attribute != 0)
7651             add_abbrev_attr (attribute, form);
7652         }
7653       while (attribute != 0);
7654     }
7655
7656   return NULL;
7657 }
7658
7659 static char *
7660 get_TAG_name (unsigned long tag)
7661 {
7662   switch (tag)
7663     {
7664     case DW_TAG_padding:                return "DW_TAG_padding";
7665     case DW_TAG_array_type:             return "DW_TAG_array_type";
7666     case DW_TAG_class_type:             return "DW_TAG_class_type";
7667     case DW_TAG_entry_point:            return "DW_TAG_entry_point";
7668     case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
7669     case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
7670     case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
7671     case DW_TAG_label:                  return "DW_TAG_label";
7672     case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
7673     case DW_TAG_member:                 return "DW_TAG_member";
7674     case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
7675     case DW_TAG_reference_type:         return "DW_TAG_reference_type";
7676     case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
7677     case DW_TAG_string_type:            return "DW_TAG_string_type";
7678     case DW_TAG_structure_type:         return "DW_TAG_structure_type";
7679     case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
7680     case DW_TAG_typedef:                return "DW_TAG_typedef";
7681     case DW_TAG_union_type:             return "DW_TAG_union_type";
7682     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
7683     case DW_TAG_variant:                return "DW_TAG_variant";
7684     case DW_TAG_common_block:           return "DW_TAG_common_block";
7685     case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
7686     case DW_TAG_inheritance:            return "DW_TAG_inheritance";
7687     case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
7688     case DW_TAG_module:                 return "DW_TAG_module";
7689     case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
7690     case DW_TAG_set_type:               return "DW_TAG_set_type";
7691     case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
7692     case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
7693     case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
7694     case DW_TAG_base_type:              return "DW_TAG_base_type";
7695     case DW_TAG_catch_block:            return "DW_TAG_catch_block";
7696     case DW_TAG_const_type:             return "DW_TAG_const_type";
7697     case DW_TAG_constant:               return "DW_TAG_constant";
7698     case DW_TAG_enumerator:             return "DW_TAG_enumerator";
7699     case DW_TAG_file_type:              return "DW_TAG_file_type";
7700     case DW_TAG_friend:                 return "DW_TAG_friend";
7701     case DW_TAG_namelist:               return "DW_TAG_namelist";
7702     case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
7703     case DW_TAG_packed_type:            return "DW_TAG_packed_type";
7704     case DW_TAG_subprogram:             return "DW_TAG_subprogram";
7705     case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
7706     case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
7707     case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
7708     case DW_TAG_try_block:              return "DW_TAG_try_block";
7709     case DW_TAG_variant_part:           return "DW_TAG_variant_part";
7710     case DW_TAG_variable:               return "DW_TAG_variable";
7711     case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
7712     case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
7713     case DW_TAG_format_label:           return "DW_TAG_format_label";
7714     case DW_TAG_function_template:      return "DW_TAG_function_template";
7715     case DW_TAG_class_template:         return "DW_TAG_class_template";
7716       /* DWARF 2.1 values.  */
7717     case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
7718     case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
7719     case DW_TAG_interface_type:         return "DW_TAG_interface_type";
7720     case DW_TAG_namespace:              return "DW_TAG_namespace";
7721     case DW_TAG_imported_module:        return "DW_TAG_imported_module";
7722     case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
7723     case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
7724     case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
7725       /* UPC values.  */
7726     case DW_TAG_upc_shared_type:        return "DW_TAG_upc_shared_type";
7727     case DW_TAG_upc_strict_type:        return "DW_TAG_upc_strict_type";
7728     case DW_TAG_upc_relaxed_type:       return "DW_TAG_upc_relaxed_type";
7729     default:
7730       {
7731         static char buffer[100];
7732
7733         snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
7734         return buffer;
7735       }
7736     }
7737 }
7738
7739 static char *
7740 get_FORM_name (unsigned long form)
7741 {
7742   switch (form)
7743     {
7744     case DW_FORM_addr:          return "DW_FORM_addr";
7745     case DW_FORM_block2:        return "DW_FORM_block2";
7746     case DW_FORM_block4:        return "DW_FORM_block4";
7747     case DW_FORM_data2:         return "DW_FORM_data2";
7748     case DW_FORM_data4:         return "DW_FORM_data4";
7749     case DW_FORM_data8:         return "DW_FORM_data8";
7750     case DW_FORM_string:        return "DW_FORM_string";
7751     case DW_FORM_block:         return "DW_FORM_block";
7752     case DW_FORM_block1:        return "DW_FORM_block1";
7753     case DW_FORM_data1:         return "DW_FORM_data1";
7754     case DW_FORM_flag:          return "DW_FORM_flag";
7755     case DW_FORM_sdata:         return "DW_FORM_sdata";
7756     case DW_FORM_strp:          return "DW_FORM_strp";
7757     case DW_FORM_udata:         return "DW_FORM_udata";
7758     case DW_FORM_ref_addr:      return "DW_FORM_ref_addr";
7759     case DW_FORM_ref1:          return "DW_FORM_ref1";
7760     case DW_FORM_ref2:          return "DW_FORM_ref2";
7761     case DW_FORM_ref4:          return "DW_FORM_ref4";
7762     case DW_FORM_ref8:          return "DW_FORM_ref8";
7763     case DW_FORM_ref_udata:     return "DW_FORM_ref_udata";
7764     case DW_FORM_indirect:      return "DW_FORM_indirect";
7765     default:
7766       {
7767         static char buffer[100];
7768
7769         snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
7770         return buffer;
7771       }
7772     }
7773 }
7774
7775 static unsigned char *
7776 display_block (unsigned char *data, unsigned long length)
7777 {
7778   printf (_(" %lu byte block: "), length);
7779
7780   while (length --)
7781     printf ("%lx ", (unsigned long) byte_get (data++, 1));
7782
7783   return data;
7784 }
7785
7786 static int
7787 decode_location_expression (unsigned char * data,
7788                             unsigned int pointer_size,
7789                             unsigned long length,
7790                             unsigned long cu_offset)
7791 {
7792   unsigned op;
7793   unsigned int bytes_read;
7794   unsigned long uvalue;
7795   unsigned char *end = data + length;
7796   int need_frame_base = 0;
7797
7798   while (data < end)
7799     {
7800       op = *data++;
7801
7802       switch (op)
7803         {
7804         case DW_OP_addr:
7805           printf ("DW_OP_addr: %lx",
7806                   (unsigned long) byte_get (data, pointer_size));
7807           data += pointer_size;
7808           break;
7809         case DW_OP_deref:
7810           printf ("DW_OP_deref");
7811           break;
7812         case DW_OP_const1u:
7813           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
7814           break;
7815         case DW_OP_const1s:
7816           printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
7817           break;
7818         case DW_OP_const2u:
7819           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
7820           data += 2;
7821           break;
7822         case DW_OP_const2s:
7823           printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
7824           data += 2;
7825           break;
7826         case DW_OP_const4u:
7827           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
7828           data += 4;
7829           break;
7830         case DW_OP_const4s:
7831           printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
7832           data += 4;
7833           break;
7834         case DW_OP_const8u:
7835           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
7836                   (unsigned long) byte_get (data + 4, 4));
7837           data += 8;
7838           break;
7839         case DW_OP_const8s:
7840           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
7841                   (long) byte_get (data + 4, 4));
7842           data += 8;
7843           break;
7844         case DW_OP_constu:
7845           printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
7846           data += bytes_read;
7847           break;
7848         case DW_OP_consts:
7849           printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
7850           data += bytes_read;
7851           break;
7852         case DW_OP_dup:
7853           printf ("DW_OP_dup");
7854           break;
7855         case DW_OP_drop:
7856           printf ("DW_OP_drop");
7857           break;
7858         case DW_OP_over:
7859           printf ("DW_OP_over");
7860           break;
7861         case DW_OP_pick:
7862           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
7863           break;
7864         case DW_OP_swap:
7865           printf ("DW_OP_swap");
7866           break;
7867         case DW_OP_rot:
7868           printf ("DW_OP_rot");
7869           break;
7870         case DW_OP_xderef:
7871           printf ("DW_OP_xderef");
7872           break;
7873         case DW_OP_abs:
7874           printf ("DW_OP_abs");
7875           break;
7876         case DW_OP_and:
7877           printf ("DW_OP_and");
7878           break;
7879         case DW_OP_div:
7880           printf ("DW_OP_div");
7881           break;
7882         case DW_OP_minus:
7883           printf ("DW_OP_minus");
7884           break;
7885         case DW_OP_mod:
7886           printf ("DW_OP_mod");
7887           break;
7888         case DW_OP_mul:
7889           printf ("DW_OP_mul");
7890           break;
7891         case DW_OP_neg:
7892           printf ("DW_OP_neg");
7893           break;
7894         case DW_OP_not:
7895           printf ("DW_OP_not");
7896           break;
7897         case DW_OP_or:
7898           printf ("DW_OP_or");
7899           break;
7900         case DW_OP_plus:
7901           printf ("DW_OP_plus");
7902           break;
7903         case DW_OP_plus_uconst:
7904           printf ("DW_OP_plus_uconst: %lu",
7905                   read_leb128 (data, &bytes_read, 0));
7906           data += bytes_read;
7907           break;
7908         case DW_OP_shl:
7909           printf ("DW_OP_shl");
7910           break;
7911         case DW_OP_shr:
7912           printf ("DW_OP_shr");
7913           break;
7914         case DW_OP_shra:
7915           printf ("DW_OP_shra");
7916           break;
7917         case DW_OP_xor:
7918           printf ("DW_OP_xor");
7919           break;
7920         case DW_OP_bra:
7921           printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
7922           data += 2;
7923           break;
7924         case DW_OP_eq:
7925           printf ("DW_OP_eq");
7926           break;
7927         case DW_OP_ge:
7928           printf ("DW_OP_ge");
7929           break;
7930         case DW_OP_gt:
7931           printf ("DW_OP_gt");
7932           break;
7933         case DW_OP_le:
7934           printf ("DW_OP_le");
7935           break;
7936         case DW_OP_lt:
7937           printf ("DW_OP_lt");
7938           break;
7939         case DW_OP_ne:
7940           printf ("DW_OP_ne");
7941           break;
7942         case DW_OP_skip:
7943           printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
7944           data += 2;
7945           break;
7946
7947         case DW_OP_lit0:
7948         case DW_OP_lit1:
7949         case DW_OP_lit2:
7950         case DW_OP_lit3:
7951         case DW_OP_lit4:
7952         case DW_OP_lit5:
7953         case DW_OP_lit6:
7954         case DW_OP_lit7:
7955         case DW_OP_lit8:
7956         case DW_OP_lit9:
7957         case DW_OP_lit10:
7958         case DW_OP_lit11:
7959         case DW_OP_lit12:
7960         case DW_OP_lit13:
7961         case DW_OP_lit14:
7962         case DW_OP_lit15:
7963         case DW_OP_lit16:
7964         case DW_OP_lit17:
7965         case DW_OP_lit18:
7966         case DW_OP_lit19:
7967         case DW_OP_lit20:
7968         case DW_OP_lit21:
7969         case DW_OP_lit22:
7970         case DW_OP_lit23:
7971         case DW_OP_lit24:
7972         case DW_OP_lit25:
7973         case DW_OP_lit26:
7974         case DW_OP_lit27:
7975         case DW_OP_lit28:
7976         case DW_OP_lit29:
7977         case DW_OP_lit30:
7978         case DW_OP_lit31:
7979           printf ("DW_OP_lit%d", op - DW_OP_lit0);
7980           break;
7981
7982         case DW_OP_reg0:
7983         case DW_OP_reg1:
7984         case DW_OP_reg2:
7985         case DW_OP_reg3:
7986         case DW_OP_reg4:
7987         case DW_OP_reg5:
7988         case DW_OP_reg6:
7989         case DW_OP_reg7:
7990         case DW_OP_reg8:
7991         case DW_OP_reg9:
7992         case DW_OP_reg10:
7993         case DW_OP_reg11:
7994         case DW_OP_reg12:
7995         case DW_OP_reg13:
7996         case DW_OP_reg14:
7997         case DW_OP_reg15:
7998         case DW_OP_reg16:
7999         case DW_OP_reg17:
8000         case DW_OP_reg18:
8001         case DW_OP_reg19:
8002         case DW_OP_reg20:
8003         case DW_OP_reg21:
8004         case DW_OP_reg22:
8005         case DW_OP_reg23:
8006         case DW_OP_reg24:
8007         case DW_OP_reg25:
8008         case DW_OP_reg26:
8009         case DW_OP_reg27:
8010         case DW_OP_reg28:
8011         case DW_OP_reg29:
8012         case DW_OP_reg30:
8013         case DW_OP_reg31:
8014           printf ("DW_OP_reg%d", op - DW_OP_reg0);
8015           break;
8016
8017         case DW_OP_breg0:
8018         case DW_OP_breg1:
8019         case DW_OP_breg2:
8020         case DW_OP_breg3:
8021         case DW_OP_breg4:
8022         case DW_OP_breg5:
8023         case DW_OP_breg6:
8024         case DW_OP_breg7:
8025         case DW_OP_breg8:
8026         case DW_OP_breg9:
8027         case DW_OP_breg10:
8028         case DW_OP_breg11:
8029         case DW_OP_breg12:
8030         case DW_OP_breg13:
8031         case DW_OP_breg14:
8032         case DW_OP_breg15:
8033         case DW_OP_breg16:
8034         case DW_OP_breg17:
8035         case DW_OP_breg18:
8036         case DW_OP_breg19:
8037         case DW_OP_breg20:
8038         case DW_OP_breg21:
8039         case DW_OP_breg22:
8040         case DW_OP_breg23:
8041         case DW_OP_breg24:
8042         case DW_OP_breg25:
8043         case DW_OP_breg26:
8044         case DW_OP_breg27:
8045         case DW_OP_breg28:
8046         case DW_OP_breg29:
8047         case DW_OP_breg30:
8048         case DW_OP_breg31:
8049           printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
8050                   read_leb128 (data, &bytes_read, 1));
8051           data += bytes_read;
8052           break;
8053
8054         case DW_OP_regx:
8055           printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
8056           data += bytes_read;
8057           break;
8058         case DW_OP_fbreg:
8059           need_frame_base = 1;
8060           printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
8061           data += bytes_read;
8062           break;
8063         case DW_OP_bregx:
8064           uvalue = read_leb128 (data, &bytes_read, 0);
8065           data += bytes_read;
8066           printf ("DW_OP_bregx: %lu %ld", uvalue,
8067                   read_leb128 (data, &bytes_read, 1));
8068           data += bytes_read;
8069           break;
8070         case DW_OP_piece:
8071           printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
8072           data += bytes_read;
8073           break;
8074         case DW_OP_deref_size:
8075           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
8076           break;
8077         case DW_OP_xderef_size:
8078           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
8079           break;
8080         case DW_OP_nop:
8081           printf ("DW_OP_nop");
8082           break;
8083
8084           /* DWARF 3 extensions.  */
8085         case DW_OP_push_object_address:
8086           printf ("DW_OP_push_object_address");
8087           break;
8088         case DW_OP_call2:
8089           /* XXX: Strictly speaking for 64-bit DWARF3 files
8090              this ought to be an 8-byte wide computation.  */
8091           printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
8092           data += 2;
8093           break;
8094         case DW_OP_call4:
8095           /* XXX: Strictly speaking for 64-bit DWARF3 files
8096              this ought to be an 8-byte wide computation.  */
8097           printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
8098           data += 4;
8099           break;
8100         case DW_OP_call_ref:
8101           printf ("DW_OP_call_ref");
8102           break;
8103
8104           /* GNU extensions.  */
8105         case DW_OP_GNU_push_tls_address:
8106           printf ("DW_OP_GNU_push_tls_address");
8107           break;
8108
8109         default:
8110           if (op >= DW_OP_lo_user
8111               && op <= DW_OP_hi_user)
8112             printf (_("(User defined location op)"));
8113           else
8114             printf (_("(Unknown location op)"));
8115           /* No way to tell where the next op is, so just bail.  */
8116           return need_frame_base;
8117         }
8118
8119       /* Separate the ops.  */
8120       if (data < end)
8121         printf ("; ");
8122     }
8123
8124   return need_frame_base;
8125 }
8126
8127 /* This structure records the information that
8128    we extract from the.debug_info section.  */
8129 typedef struct
8130 {
8131   unsigned int   pointer_size;
8132   unsigned long  cu_offset;
8133   unsigned long  base_address;
8134   /* This is an array of offsets to the location list table.  */
8135   unsigned long *loc_offsets;
8136   int           *have_frame_base;
8137   unsigned int   num_loc_offsets;
8138   unsigned int   max_loc_offsets;
8139   unsigned long *range_lists;
8140   unsigned int   num_range_lists;
8141   unsigned int   max_range_lists;
8142 }
8143 debug_info;
8144
8145 static debug_info *   debug_information = NULL;
8146 static unsigned int   num_debug_info_entries = 0;
8147 static unsigned int   last_pointer_size = 0;
8148 static int            warned_about_missing_comp_units = FALSE;
8149
8150 static unsigned char *
8151 read_and_display_attr_value (unsigned long attribute,
8152                              unsigned long form,
8153                              unsigned char *data,
8154                              unsigned long cu_offset,
8155                              unsigned long pointer_size,
8156                              unsigned long offset_size,
8157                              int dwarf_version,
8158                              debug_info *debug_info_p,
8159                              int do_loc)
8160 {
8161   unsigned long uvalue = 0;
8162   unsigned char *block_start = NULL;
8163   unsigned int bytes_read;
8164
8165   switch (form)
8166     {
8167     default:
8168       break;
8169
8170     case DW_FORM_ref_addr:
8171       if (dwarf_version == 2)
8172         {
8173           uvalue = byte_get (data, pointer_size);
8174           data += pointer_size;
8175         }
8176       else if (dwarf_version == 3)
8177         {
8178           uvalue = byte_get (data, offset_size);
8179           data += offset_size;
8180         }
8181       else
8182         {
8183           error (_("Internal error: DWARF version is not 2 or 3.\n"));
8184         }
8185       break;
8186
8187     case DW_FORM_addr:
8188       uvalue = byte_get (data, pointer_size);
8189       data += pointer_size;
8190       break;
8191
8192     case DW_FORM_strp:
8193       uvalue = byte_get (data, offset_size);
8194       data += offset_size;
8195       break;
8196
8197     case DW_FORM_ref1:
8198     case DW_FORM_flag:
8199     case DW_FORM_data1:
8200       uvalue = byte_get (data++, 1);
8201       break;
8202
8203     case DW_FORM_ref2:
8204     case DW_FORM_data2:
8205       uvalue = byte_get (data, 2);
8206       data += 2;
8207       break;
8208
8209     case DW_FORM_ref4:
8210     case DW_FORM_data4:
8211       uvalue = byte_get (data, 4);
8212       data += 4;
8213       break;
8214
8215     case DW_FORM_sdata:
8216       uvalue = read_leb128 (data, & bytes_read, 1);
8217       data += bytes_read;
8218       break;
8219
8220     case DW_FORM_ref_udata:
8221     case DW_FORM_udata:
8222       uvalue = read_leb128 (data, & bytes_read, 0);
8223       data += bytes_read;
8224       break;
8225
8226     case DW_FORM_indirect:
8227       form = read_leb128 (data, & bytes_read, 0);
8228       data += bytes_read;
8229       if (!do_loc)
8230         printf (" %s", get_FORM_name (form));
8231       return read_and_display_attr_value (attribute, form, data,
8232                                           cu_offset, pointer_size,
8233                                           offset_size, dwarf_version,
8234                                           debug_info_p, do_loc);
8235     }
8236
8237   switch (form)
8238     {
8239     case DW_FORM_ref_addr:
8240       if (!do_loc)
8241         printf (" <#%lx>", uvalue);
8242       break;
8243
8244     case DW_FORM_ref1:
8245     case DW_FORM_ref2:
8246     case DW_FORM_ref4:
8247     case DW_FORM_ref_udata:
8248       if (!do_loc)
8249         printf (" <%lx>", uvalue + cu_offset);
8250       break;
8251
8252     case DW_FORM_data4:
8253     case DW_FORM_addr:
8254       if (!do_loc)
8255         printf (" %#lx", uvalue);
8256       break;
8257
8258     case DW_FORM_flag:
8259     case DW_FORM_data1:
8260     case DW_FORM_data2:
8261     case DW_FORM_sdata:
8262     case DW_FORM_udata:
8263       if (!do_loc)
8264         printf (" %ld", uvalue);
8265       break;
8266
8267     case DW_FORM_ref8:
8268     case DW_FORM_data8:
8269       if (!do_loc)
8270         {
8271           uvalue = byte_get (data, 4);
8272           printf (" %lx", uvalue);
8273           printf (" %lx", (unsigned long) byte_get (data + 4, 4));
8274         }
8275       if ((do_loc || do_debug_loc || do_debug_ranges)
8276           && num_debug_info_entries == 0)
8277         {
8278           if (sizeof (uvalue) == 8)
8279             uvalue = byte_get (data, 8);
8280           else
8281             error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8282         }
8283       data += 8;
8284       break;
8285
8286     case DW_FORM_string:
8287       if (!do_loc)
8288         printf (" %s", data);
8289       data += strlen ((char *) data) + 1;
8290       break;
8291
8292     case DW_FORM_block:
8293       uvalue = read_leb128 (data, & bytes_read, 0);
8294       block_start = data + bytes_read;
8295       if (do_loc)
8296         data = block_start + uvalue;
8297       else
8298         data = display_block (block_start, uvalue);
8299       break;
8300
8301     case DW_FORM_block1:
8302       uvalue = byte_get (data, 1);
8303       block_start = data + 1;
8304       if (do_loc)
8305         data = block_start + uvalue;
8306       else
8307         data = display_block (block_start, uvalue);
8308       break;
8309
8310     case DW_FORM_block2:
8311       uvalue = byte_get (data, 2);
8312       block_start = data + 2;
8313       if (do_loc)
8314         data = block_start + uvalue;
8315       else
8316         data = display_block (block_start, uvalue);
8317       break;
8318
8319     case DW_FORM_block4:
8320       uvalue = byte_get (data, 4);
8321       block_start = data + 4;
8322       if (do_loc)
8323         data = block_start + uvalue;
8324       else
8325         data = display_block (block_start, uvalue);
8326       break;
8327
8328     case DW_FORM_strp:
8329       if (!do_loc)
8330         printf (_(" (indirect string, offset: 0x%lx): %s"),
8331                 uvalue, fetch_indirect_string (uvalue));
8332       break;
8333
8334     case DW_FORM_indirect:
8335       /* Handled above.  */
8336       break;
8337
8338     default:
8339       warn (_("Unrecognized form: %d\n"), form);
8340       break;
8341     }
8342
8343   /* For some attributes we can display further information.  */
8344   if ((do_loc || do_debug_loc || do_debug_ranges)
8345       && num_debug_info_entries == 0)
8346     {
8347       switch (attribute)
8348         {
8349         case DW_AT_frame_base:
8350           have_frame_base = 1;
8351         case DW_AT_location:
8352         case DW_AT_data_member_location:
8353         case DW_AT_vtable_elem_location:
8354         case DW_AT_allocated:
8355         case DW_AT_associated:
8356         case DW_AT_data_location:
8357         case DW_AT_stride:
8358         case DW_AT_upper_bound:
8359         case DW_AT_lower_bound:
8360           if (form == DW_FORM_data4 || form == DW_FORM_data8)
8361             {
8362               /* Process location list.  */
8363               unsigned int max = debug_info_p->max_loc_offsets;
8364               unsigned int num = debug_info_p->num_loc_offsets;
8365
8366               if (max == 0 || num >= max)
8367                 {
8368                   max += 1024;
8369                   debug_info_p->loc_offsets
8370                     = xrealloc (debug_info_p->loc_offsets,
8371                                 max * sizeof (*debug_info_p->loc_offsets));
8372                   debug_info_p->have_frame_base
8373                     = xrealloc (debug_info_p->have_frame_base,
8374                                 max * sizeof (*debug_info_p->have_frame_base));
8375                   debug_info_p->max_loc_offsets = max;
8376                 }
8377               debug_info_p->loc_offsets [num] = uvalue;
8378               debug_info_p->have_frame_base [num] = have_frame_base;
8379               debug_info_p->num_loc_offsets++;
8380             }
8381           break;
8382
8383         case DW_AT_low_pc:
8384           if (need_base_address)
8385             debug_info_p->base_address = uvalue;
8386           break;
8387
8388         case DW_AT_ranges:
8389           if (form == DW_FORM_data4 || form == DW_FORM_data8)
8390             {
8391               /* Process range list.  */
8392               unsigned int max = debug_info_p->max_range_lists;
8393               unsigned int num = debug_info_p->num_range_lists;
8394
8395               if (max == 0 || num >= max)
8396                 {
8397                   max += 1024;
8398                   debug_info_p->range_lists
8399                     = xrealloc (debug_info_p->range_lists,
8400                                 max * sizeof (*debug_info_p->range_lists));
8401                   debug_info_p->max_range_lists = max;
8402                 }
8403               debug_info_p->range_lists [num] = uvalue;
8404               debug_info_p->num_range_lists++;
8405             }
8406           break;
8407
8408         default:
8409           break;
8410         }
8411     }
8412
8413   if (do_loc)
8414     return data;
8415
8416   printf ("\t");
8417
8418   switch (attribute)
8419     {
8420     case DW_AT_inline:
8421       switch (uvalue)
8422         {
8423         case DW_INL_not_inlined:
8424           printf (_("(not inlined)"));
8425           break;
8426         case DW_INL_inlined:
8427           printf (_("(inlined)"));
8428           break;
8429         case DW_INL_declared_not_inlined:
8430           printf (_("(declared as inline but ignored)"));
8431           break;
8432         case DW_INL_declared_inlined:
8433           printf (_("(declared as inline and inlined)"));
8434           break;
8435         default:
8436           printf (_("  (Unknown inline attribute value: %lx)"), uvalue);
8437           break;
8438         }
8439       break;
8440
8441     case DW_AT_language:
8442       switch (uvalue)
8443         {
8444         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
8445         case DW_LANG_C89:               printf ("(ANSI C)"); break;
8446         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
8447         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
8448         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
8449         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
8450         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
8451         case DW_LANG_Ada83:             printf ("(Ada)"); break;
8452         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
8453         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
8454           /* DWARF 2.1 values.  */
8455         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
8456         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
8457         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
8458           /* MIPS extension.  */
8459         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
8460           /* UPC extension.  */
8461         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
8462         default:
8463           printf ("(Unknown: %lx)", uvalue);
8464           break;
8465         }
8466       break;
8467
8468     case DW_AT_encoding:
8469       switch (uvalue)
8470         {
8471         case DW_ATE_void:               printf ("(void)"); break;
8472         case DW_ATE_address:            printf ("(machine address)"); break;
8473         case DW_ATE_boolean:            printf ("(boolean)"); break;
8474         case DW_ATE_complex_float:      printf ("(complex float)"); break;
8475         case DW_ATE_float:              printf ("(float)"); break;
8476         case DW_ATE_signed:             printf ("(signed)"); break;
8477         case DW_ATE_signed_char:        printf ("(signed char)"); break;
8478         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
8479         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
8480           /* DWARF 2.1 value.  */
8481         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
8482           /* GNU extension.  */
8483         case DW_ATE_GNU_decimal_float:  printf ("(decimal float)"); break;
8484         default:
8485           if (uvalue >= DW_ATE_lo_user
8486               && uvalue <= DW_ATE_hi_user)
8487             printf ("(user defined type)");
8488           else
8489             printf ("(unknown type)");
8490           break;
8491         }
8492       break;
8493
8494     case DW_AT_accessibility:
8495       switch (uvalue)
8496         {
8497         case DW_ACCESS_public:          printf ("(public)"); break;
8498         case DW_ACCESS_protected:       printf ("(protected)"); break;
8499         case DW_ACCESS_private:         printf ("(private)"); break;
8500         default:
8501           printf ("(unknown accessibility)");
8502           break;
8503         }
8504       break;
8505
8506     case DW_AT_visibility:
8507       switch (uvalue)
8508         {
8509         case DW_VIS_local:              printf ("(local)"); break;
8510         case DW_VIS_exported:           printf ("(exported)"); break;
8511         case DW_VIS_qualified:          printf ("(qualified)"); break;
8512         default:                        printf ("(unknown visibility)"); break;
8513         }
8514       break;
8515
8516     case DW_AT_virtuality:
8517       switch (uvalue)
8518         {
8519         case DW_VIRTUALITY_none:        printf ("(none)"); break;
8520         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
8521         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
8522         default:                        printf ("(unknown virtuality)"); break;
8523         }
8524       break;
8525
8526     case DW_AT_identifier_case:
8527       switch (uvalue)
8528         {
8529         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
8530         case DW_ID_up_case:             printf ("(up_case)"); break;
8531         case DW_ID_down_case:           printf ("(down_case)"); break;
8532         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
8533         default:                        printf ("(unknown case)"); break;
8534         }
8535       break;
8536
8537     case DW_AT_calling_convention:
8538       switch (uvalue)
8539         {
8540         case DW_CC_normal:      printf ("(normal)"); break;
8541         case DW_CC_program:     printf ("(program)"); break;
8542         case DW_CC_nocall:      printf ("(nocall)"); break;
8543         default:
8544           if (uvalue >= DW_CC_lo_user
8545               && uvalue <= DW_CC_hi_user)
8546             printf ("(user defined)");
8547           else
8548             printf ("(unknown convention)");
8549         }
8550       break;
8551
8552     case DW_AT_ordering:
8553       switch (uvalue)
8554         {
8555         case -1: printf ("(undefined)"); break;
8556         case 0:  printf ("(row major)"); break;
8557         case 1:  printf ("(column major)"); break;
8558         }
8559       break;
8560
8561     case DW_AT_frame_base:
8562       have_frame_base = 1;
8563     case DW_AT_location:
8564     case DW_AT_data_member_location:
8565     case DW_AT_vtable_elem_location:
8566     case DW_AT_allocated:
8567     case DW_AT_associated:
8568     case DW_AT_data_location:
8569     case DW_AT_stride:
8570     case DW_AT_upper_bound:
8571     case DW_AT_lower_bound:
8572       if (block_start)
8573         {
8574           int need_frame_base;
8575
8576           printf ("(");
8577           need_frame_base = decode_location_expression (block_start,
8578                                                         pointer_size,
8579                                                         uvalue,
8580                                                         cu_offset);
8581           printf (")");
8582           if (need_frame_base && !have_frame_base)
8583             printf (_(" [without DW_AT_frame_base]"));
8584         }
8585       else if (form == DW_FORM_data4 || form == DW_FORM_data8)
8586         printf (_("(location list)"));
8587
8588       break;
8589
8590     default:
8591       break;
8592     }
8593
8594   return data;
8595 }
8596
8597 static char *
8598 get_AT_name (unsigned long attribute)
8599 {
8600   switch (attribute)
8601     {
8602     case DW_AT_sibling:                 return "DW_AT_sibling";
8603     case DW_AT_location:                return "DW_AT_location";
8604     case DW_AT_name:                    return "DW_AT_name";
8605     case DW_AT_ordering:                return "DW_AT_ordering";
8606     case DW_AT_subscr_data:             return "DW_AT_subscr_data";
8607     case DW_AT_byte_size:               return "DW_AT_byte_size";
8608     case DW_AT_bit_offset:              return "DW_AT_bit_offset";
8609     case DW_AT_bit_size:                return "DW_AT_bit_size";
8610     case DW_AT_element_list:            return "DW_AT_element_list";
8611     case DW_AT_stmt_list:               return "DW_AT_stmt_list";
8612     case DW_AT_low_pc:                  return "DW_AT_low_pc";
8613     case DW_AT_high_pc:                 return "DW_AT_high_pc";
8614     case DW_AT_language:                return "DW_AT_language";
8615     case DW_AT_member:                  return "DW_AT_member";
8616     case DW_AT_discr:                   return "DW_AT_discr";
8617     case DW_AT_discr_value:             return "DW_AT_discr_value";
8618     case DW_AT_visibility:              return "DW_AT_visibility";
8619     case DW_AT_import:                  return "DW_AT_import";
8620     case DW_AT_string_length:           return "DW_AT_string_length";
8621     case DW_AT_common_reference:        return "DW_AT_common_reference";
8622     case DW_AT_comp_dir:                return "DW_AT_comp_dir";
8623     case DW_AT_const_value:             return "DW_AT_const_value";
8624     case DW_AT_containing_type:         return "DW_AT_containing_type";
8625     case DW_AT_default_value:           return "DW_AT_default_value";
8626     case DW_AT_inline:                  return "DW_AT_inline";
8627     case DW_AT_is_optional:             return "DW_AT_is_optional";
8628     case DW_AT_lower_bound:             return "DW_AT_lower_bound";
8629     case DW_AT_producer:                return "DW_AT_producer";
8630     case DW_AT_prototyped:              return "DW_AT_prototyped";
8631     case DW_AT_return_addr:             return "DW_AT_return_addr";
8632     case DW_AT_start_scope:             return "DW_AT_start_scope";
8633     case DW_AT_stride_size:             return "DW_AT_stride_size";
8634     case DW_AT_upper_bound:             return "DW_AT_upper_bound";
8635     case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
8636     case DW_AT_accessibility:           return "DW_AT_accessibility";
8637     case DW_AT_address_class:           return "DW_AT_address_class";
8638     case DW_AT_artificial:              return "DW_AT_artificial";
8639     case DW_AT_base_types:              return "DW_AT_base_types";
8640     case DW_AT_calling_convention:      return "DW_AT_calling_convention";
8641     case DW_AT_count:                   return "DW_AT_count";
8642     case DW_AT_data_member_location:    return "DW_AT_data_member_location";
8643     case DW_AT_decl_column:             return "DW_AT_decl_column";
8644     case DW_AT_decl_file:               return "DW_AT_decl_file";
8645     case DW_AT_decl_line:               return "DW_AT_decl_line";
8646     case DW_AT_declaration:             return "DW_AT_declaration";
8647     case DW_AT_discr_list:              return "DW_AT_discr_list";
8648     case DW_AT_encoding:                return "DW_AT_encoding";
8649     case DW_AT_external:                return "DW_AT_external";
8650     case DW_AT_frame_base:              return "DW_AT_frame_base";
8651     case DW_AT_friend:                  return "DW_AT_friend";
8652     case DW_AT_identifier_case:         return "DW_AT_identifier_case";
8653     case DW_AT_macro_info:              return "DW_AT_macro_info";
8654     case DW_AT_namelist_items:          return "DW_AT_namelist_items";
8655     case DW_AT_priority:                return "DW_AT_priority";
8656     case DW_AT_segment:                 return "DW_AT_segment";
8657     case DW_AT_specification:           return "DW_AT_specification";
8658     case DW_AT_static_link:             return "DW_AT_static_link";
8659     case DW_AT_type:                    return "DW_AT_type";
8660     case DW_AT_use_location:            return "DW_AT_use_location";
8661     case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
8662     case DW_AT_virtuality:              return "DW_AT_virtuality";
8663     case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
8664       /* DWARF 2.1 values.  */
8665     case DW_AT_allocated:               return "DW_AT_allocated";
8666     case DW_AT_associated:              return "DW_AT_associated";
8667     case DW_AT_data_location:           return "DW_AT_data_location";
8668     case DW_AT_stride:                  return "DW_AT_stride";
8669     case DW_AT_entry_pc:                return "DW_AT_entry_pc";
8670     case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
8671     case DW_AT_extension:               return "DW_AT_extension";
8672     case DW_AT_ranges:                  return "DW_AT_ranges";
8673     case DW_AT_trampoline:              return "DW_AT_trampoline";
8674     case DW_AT_call_column:             return "DW_AT_call_column";
8675     case DW_AT_call_file:               return "DW_AT_call_file";
8676     case DW_AT_call_line:               return "DW_AT_call_line";
8677       /* SGI/MIPS extensions.  */
8678     case DW_AT_MIPS_fde:                return "DW_AT_MIPS_fde";
8679     case DW_AT_MIPS_loop_begin:         return "DW_AT_MIPS_loop_begin";
8680     case DW_AT_MIPS_tail_loop_begin:    return "DW_AT_MIPS_tail_loop_begin";
8681     case DW_AT_MIPS_epilog_begin:       return "DW_AT_MIPS_epilog_begin";
8682     case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
8683     case DW_AT_MIPS_software_pipeline_depth:
8684       return "DW_AT_MIPS_software_pipeline_depth";
8685     case DW_AT_MIPS_linkage_name:       return "DW_AT_MIPS_linkage_name";
8686     case DW_AT_MIPS_stride:             return "DW_AT_MIPS_stride";
8687     case DW_AT_MIPS_abstract_name:      return "DW_AT_MIPS_abstract_name";
8688     case DW_AT_MIPS_clone_origin:       return "DW_AT_MIPS_clone_origin";
8689     case DW_AT_MIPS_has_inlines:        return "DW_AT_MIPS_has_inlines";
8690       /* GNU extensions.  */
8691     case DW_AT_sf_names:                return "DW_AT_sf_names";
8692     case DW_AT_src_info:                return "DW_AT_src_info";
8693     case DW_AT_mac_info:                return "DW_AT_mac_info";
8694     case DW_AT_src_coords:              return "DW_AT_src_coords";
8695     case DW_AT_body_begin:              return "DW_AT_body_begin";
8696     case DW_AT_body_end:                return "DW_AT_body_end";
8697     case DW_AT_GNU_vector:              return "DW_AT_GNU_vector";
8698       /* UPC extension.  */
8699     case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
8700     default:
8701       {
8702         static char buffer[100];
8703
8704         snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
8705                   attribute);
8706         return buffer;
8707       }
8708     }
8709 }
8710
8711 static unsigned char *
8712 read_and_display_attr (unsigned long attribute,
8713                        unsigned long form,
8714                        unsigned char *data,
8715                        unsigned long cu_offset,
8716                        unsigned long pointer_size,
8717                        unsigned long offset_size,
8718                        int dwarf_version,
8719                        debug_info *debug_info_p,
8720                        int do_loc)
8721 {
8722   if (!do_loc)
8723     printf ("     %-18s:", get_AT_name (attribute));
8724   data = read_and_display_attr_value (attribute, form, data, cu_offset,
8725                                       pointer_size, offset_size,
8726                                       dwarf_version, debug_info_p,
8727                                       do_loc);
8728   if (!do_loc)
8729     printf ("\n");
8730   return data;
8731 }
8732
8733
8734 /* Process the contents of a .debug_info section.  If do_loc is non-zero
8735    then we are scanning for location lists and we do not want to display
8736    anything to the user.  */
8737
8738 static int
8739 process_debug_info (Elf_Internal_Shdr *section, unsigned char *start,
8740                     FILE *file, int do_loc)
8741 {
8742   unsigned char *end = start + section->sh_size;
8743   unsigned char *section_begin;
8744   unsigned int unit;
8745   unsigned int num_units = 0;
8746
8747   if ((do_loc || do_debug_loc || do_debug_ranges)
8748       && num_debug_info_entries == 0)
8749     {
8750       unsigned long length;
8751
8752       /* First scan the section to get the number of comp units.  */
8753       for (section_begin = start, num_units = 0; section_begin < end;
8754            num_units ++)
8755         {
8756           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
8757              will be the length.  For a 64-bit DWARF section, it'll be
8758              the escape code 0xffffffff followed by an 8 byte length.  */
8759           length = byte_get (section_begin, 4);
8760
8761           if (length == 0xffffffff)
8762             {
8763               length = byte_get (section_begin + 4, 8);
8764               section_begin += length + 12;
8765             }
8766           else
8767             section_begin += length + 4;
8768         }
8769
8770       if (num_units == 0)
8771         {
8772           error (_("No comp units in .debug_info section ?"));
8773           return 0;
8774         }
8775
8776       /* Then allocate an array to hold the information.  */
8777       debug_information = malloc (num_units *
8778                                   sizeof (* debug_information));
8779       if (debug_information == NULL)
8780         {
8781           error (_("Not enough memory for a debug info array of %u entries"),
8782                  num_units);
8783           return 0;
8784         }
8785     }
8786
8787   if (!do_loc)
8788     {
8789       printf (_("The section %s contains:\n\n"),
8790               SECTION_NAME (section));
8791
8792       load_debug_str (file);
8793       load_debug_loc (file);
8794       load_debug_range (file);
8795     }
8796
8797   for (section_begin = start, unit = 0; start < end; unit++)
8798     {
8799       DWARF2_Internal_CompUnit compunit;
8800       unsigned char *hdrptr;
8801       unsigned char *cu_abbrev_offset_ptr;
8802       unsigned char *tags;
8803       int level;
8804       unsigned long cu_offset;
8805       int offset_size;
8806       int initial_length_size;
8807
8808       hdrptr = start;
8809
8810       compunit.cu_length = byte_get (hdrptr, 4);
8811       hdrptr += 4;
8812
8813       if (compunit.cu_length == 0xffffffff)
8814         {
8815           compunit.cu_length = byte_get (hdrptr, 8);
8816           hdrptr += 8;
8817           offset_size = 8;
8818           initial_length_size = 12;
8819         }
8820       else
8821         {
8822           offset_size = 4;
8823           initial_length_size = 4;
8824         }
8825
8826       compunit.cu_version = byte_get (hdrptr, 2);
8827       hdrptr += 2;
8828
8829       cu_offset = start - section_begin;
8830       start += compunit.cu_length + initial_length_size;
8831
8832       if (elf_header.e_type == ET_REL
8833           && !debug_apply_rela_addends (file, section, offset_size,
8834                                         section_begin, hdrptr, start))
8835         return 0;
8836
8837       cu_abbrev_offset_ptr = hdrptr;
8838       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
8839       hdrptr += offset_size;
8840
8841       compunit.cu_pointer_size = byte_get (hdrptr, 1);
8842       hdrptr += 1;
8843       if ((do_loc || do_debug_loc || do_debug_ranges)
8844           && num_debug_info_entries == 0)
8845         {
8846           debug_information [unit].cu_offset = cu_offset;
8847           debug_information [unit].pointer_size
8848             = compunit.cu_pointer_size;
8849           debug_information [unit].base_address = 0;
8850           debug_information [unit].loc_offsets = NULL;
8851           debug_information [unit].have_frame_base = NULL;
8852           debug_information [unit].max_loc_offsets = 0;
8853           debug_information [unit].num_loc_offsets = 0;
8854           debug_information [unit].range_lists = NULL;
8855           debug_information [unit].max_range_lists= 0;
8856           debug_information [unit].num_range_lists = 0;
8857         }
8858
8859       tags = hdrptr;
8860
8861       if (!do_loc)
8862         {
8863           printf (_("  Compilation Unit @ offset 0x%lx:\n"), cu_offset);
8864           printf (_("   Length:        %ld\n"), compunit.cu_length);
8865           printf (_("   Version:       %d\n"), compunit.cu_version);
8866           printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
8867           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
8868         }
8869
8870       if (compunit.cu_version != 2 && compunit.cu_version != 3)
8871         {
8872           warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8873           continue;
8874         }
8875
8876       free_abbrevs ();
8877
8878       /* Read in the abbrevs used by this compilation unit.  */
8879       {
8880         Elf_Internal_Shdr *sec;
8881         unsigned char *begin;
8882
8883         /* Locate the .debug_abbrev section and process it.  */
8884         sec = find_section (".debug_abbrev");
8885         if (sec == NULL)
8886           {
8887             warn (_("Unable to locate .debug_abbrev section!\n"));
8888             return 0;
8889           }
8890
8891         begin = get_data (NULL, file, sec->sh_offset, sec->sh_size,
8892                           _("debug_abbrev section data"));
8893         if (!begin)
8894           return 0;
8895
8896         process_abbrev_section (begin + compunit.cu_abbrev_offset,
8897                                 begin + sec->sh_size);
8898
8899         free (begin);
8900       }
8901
8902       level = 0;
8903       while (tags < start)
8904         {
8905           unsigned int bytes_read;
8906           unsigned long abbrev_number;
8907           abbrev_entry *entry;
8908           abbrev_attr *attr;
8909
8910           abbrev_number = read_leb128 (tags, & bytes_read, 0);
8911           tags += bytes_read;
8912
8913           /* A null DIE marks the end of a list of children.  */
8914           if (abbrev_number == 0)
8915             {
8916               --level;
8917               continue;
8918             }
8919
8920           /* Scan through the abbreviation list until we reach the
8921              correct entry.  */
8922           for (entry = first_abbrev;
8923                entry && entry->entry != abbrev_number;
8924                entry = entry->next)
8925             continue;
8926
8927           if (entry == NULL)
8928             {
8929               warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8930                     abbrev_number);
8931               return 0;
8932             }
8933
8934           if (!do_loc)
8935             printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8936                     level,
8937                     (unsigned long) (tags - section_begin
8938                                      - bytes_read),
8939                     abbrev_number,
8940                     get_TAG_name (entry->tag));
8941
8942           switch (entry->tag)
8943             {
8944             default:
8945               need_base_address = 0;
8946               break;
8947             case DW_TAG_compile_unit:
8948               need_base_address = 1;
8949               break;
8950             case DW_TAG_entry_point:
8951             case DW_TAG_inlined_subroutine:
8952             case DW_TAG_subprogram:
8953               need_base_address = 0;
8954               /* Assuming that there is no DW_AT_frame_base.  */
8955               have_frame_base = 0;
8956               break;
8957             }
8958
8959           for (attr = entry->first_attr; attr; attr = attr->next)
8960             tags = read_and_display_attr (attr->attribute,
8961                                           attr->form,
8962                                           tags, cu_offset,
8963                                           compunit.cu_pointer_size,
8964                                           offset_size,
8965                                           compunit.cu_version,
8966                                           &debug_information [unit],
8967                                           do_loc);
8968
8969           if (entry->children)
8970             ++level;
8971         }
8972     }
8973
8974   /* Set num_debug_info_entries here so that it can be used to check if
8975      we need to process .debug_loc and .debug_ranges sections.  */
8976   if ((do_loc || do_debug_loc || do_debug_ranges)
8977       && num_debug_info_entries == 0)
8978     num_debug_info_entries = num_units;
8979
8980   if (!do_loc)
8981     {
8982       free_debug_range ();
8983       free_debug_str ();
8984       free_debug_loc ();
8985
8986       printf ("\n");
8987     }
8988
8989   return 1;
8990 }
8991
8992 /* Retrieve the pointer size associated with the given compilation unit.
8993    Optionally the offset of this unit into the .debug_info section is
8994    also retutned.  If there is no .debug_info section then an error
8995    message is issued and 0 is returned.  If the requested comp unit has
8996    not been defined in the .debug_info section then a warning message
8997    is issued and the last know pointer size is returned.  This message
8998    is only issued once per section dumped per file dumped.  */
8999
9000 static unsigned int
9001 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit,
9002                                           const char * section_name,
9003                                           unsigned long * offset_return)
9004 {
9005   unsigned long offset = 0;
9006
9007   if (num_debug_info_entries == 0)
9008     error (_("%s section needs a populated .debug_info section\n"),
9009            section_name);
9010
9011   else if (comp_unit >= num_debug_info_entries)
9012     {
9013       if (!warned_about_missing_comp_units)
9014         {
9015           warn (_("%s section has more comp units than .debug_info section\n"),
9016                 section_name);
9017           warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9018                 last_pointer_size);
9019           warned_about_missing_comp_units = TRUE;
9020         }
9021     }
9022   else
9023     {
9024       last_pointer_size = debug_information [comp_unit].pointer_size;
9025       offset = debug_information [comp_unit].cu_offset;
9026     }
9027
9028   if (offset_return != NULL)
9029     * offset_return = offset;
9030
9031   return last_pointer_size;
9032 }
9033
9034 /* Locate and scan the .debug_info section in the file and record the pointer
9035    sizes and offsets for the compilation units in it.  Usually an executable
9036    will have just one pointer size, but this is not guaranteed, and so we try
9037    not to make any assumptions.  Returns zero upon failure, or the number of
9038    compilation units upon success.  */
9039
9040 static unsigned int
9041 get_debug_info (FILE * file)
9042 {
9043   Elf_Internal_Shdr * section;
9044   unsigned char *     start;
9045   int                 ret;
9046
9047   /* Reset the last pointer size so that we can issue correct error
9048      messages if we are displaying the contents of more than one section.  */
9049   last_pointer_size = 0;
9050   warned_about_missing_comp_units = FALSE;
9051
9052   /* If we already have the information there is nothing else to do.  */
9053   if (num_debug_info_entries > 0)
9054     return num_debug_info_entries;
9055
9056   section = find_section (".debug_info");
9057   if (section == NULL)
9058     return 0;
9059
9060   start = get_data (NULL, file, section->sh_offset, section->sh_size,
9061                     _("extracting information from .debug_info section"));
9062   if (start == NULL)
9063     return 0;
9064
9065   ret = process_debug_info (section, start, file, 1);
9066   free (start);
9067
9068   return ret ? num_debug_info_entries : 0;
9069 }
9070
9071 static int
9072 display_debug_lines (Elf_Internal_Shdr *section,
9073                      unsigned char *start, FILE *file)
9074 {
9075   unsigned char *data = start;
9076   unsigned char *end = start + section->sh_size;
9077   unsigned int comp_unit = 0;
9078
9079   printf (_("\nDump of debug contents of section %s:\n\n"),
9080           SECTION_NAME (section));
9081
9082   get_debug_info (file);
9083
9084   while (data < end)
9085     {
9086       DWARF2_Internal_LineInfo info;
9087       unsigned char *standard_opcodes;
9088       unsigned char *end_of_sequence;
9089       unsigned char *hdrptr;
9090       unsigned int pointer_size;
9091       int initial_length_size;
9092       int offset_size;
9093       int i;
9094
9095       hdrptr = data;
9096
9097       /* Check the length of the block.  */
9098       info.li_length = byte_get (hdrptr, 4);
9099       hdrptr += 4;
9100
9101       if (info.li_length == 0xffffffff)
9102         {
9103           /* This section is 64-bit DWARF 3.  */
9104           info.li_length = byte_get (hdrptr, 8);
9105           hdrptr += 8;
9106           offset_size = 8;
9107           initial_length_size = 12;
9108         }
9109       else
9110         {
9111           offset_size = 4;
9112           initial_length_size = 4;
9113         }
9114
9115       if (info.li_length + initial_length_size > section->sh_size)
9116         {
9117           warn
9118             (_("The line info appears to be corrupt - the section is too small\n"));
9119           return 0;
9120         }
9121
9122       /* Check its version number.  */
9123       info.li_version = byte_get (hdrptr, 2);
9124       hdrptr += 2;
9125       if (info.li_version != 2 && info.li_version != 3)
9126         {
9127           warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9128           return 0;
9129         }
9130
9131       info.li_prologue_length = byte_get (hdrptr, offset_size);
9132       hdrptr += offset_size;
9133       info.li_min_insn_length = byte_get (hdrptr, 1);
9134       hdrptr++;
9135       info.li_default_is_stmt = byte_get (hdrptr, 1);
9136       hdrptr++;
9137       info.li_line_base = byte_get (hdrptr, 1);
9138       hdrptr++;
9139       info.li_line_range = byte_get (hdrptr, 1);
9140       hdrptr++;
9141       info.li_opcode_base = byte_get (hdrptr, 1);
9142       hdrptr++;
9143
9144       /* Sign extend the line base field.  */
9145       info.li_line_base <<= 24;
9146       info.li_line_base >>= 24;
9147
9148       /* Get the pointer size from the comp unit associated
9149          with this block of line number information.  */
9150       pointer_size = get_pointer_size_and_offset_of_comp_unit
9151         (comp_unit, ".debug_line", NULL);
9152       comp_unit ++;
9153
9154       printf (_("  Length:                      %ld\n"), info.li_length);
9155       printf (_("  DWARF Version:               %d\n"), info.li_version);
9156       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
9157       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
9158       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
9159       printf (_("  Line Base:                   %d\n"), info.li_line_base);
9160       printf (_("  Line Range:                  %d\n"), info.li_line_range);
9161       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
9162       printf (_("  (Pointer size:               %u)%s\n"),
9163               pointer_size,
9164               warned_about_missing_comp_units ? " [assumed]" : "" );
9165
9166       end_of_sequence = data + info.li_length + initial_length_size;
9167
9168       reset_state_machine (info.li_default_is_stmt);
9169
9170       /* Display the contents of the Opcodes table.  */
9171       standard_opcodes = hdrptr;
9172
9173       printf (_("\n Opcodes:\n"));
9174
9175       for (i = 1; i < info.li_opcode_base; i++)
9176         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
9177
9178       /* Display the contents of the Directory table.  */
9179       data = standard_opcodes + info.li_opcode_base - 1;
9180
9181       if (*data == 0)
9182         printf (_("\n The Directory Table is empty.\n"));
9183       else
9184         {
9185           printf (_("\n The Directory Table:\n"));
9186
9187           while (*data != 0)
9188             {
9189               printf (_("  %s\n"), data);
9190
9191               data += strlen ((char *) data) + 1;
9192             }
9193         }
9194
9195       /* Skip the NUL at the end of the table.  */
9196       data++;
9197
9198       /* Display the contents of the File Name table.  */
9199       if (*data == 0)
9200         printf (_("\n The File Name Table is empty.\n"));
9201       else
9202         {
9203           printf (_("\n The File Name Table:\n"));
9204           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
9205
9206           while (*data != 0)
9207             {
9208               unsigned char *name;
9209               unsigned int bytes_read;
9210
9211               printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
9212               name = data;
9213
9214               data += strlen ((char *) data) + 1;
9215
9216               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
9217               data += bytes_read;
9218               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
9219               data += bytes_read;
9220               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
9221               data += bytes_read;
9222               printf (_("%s\n"), name);
9223             }
9224         }
9225
9226       /* Skip the NUL at the end of the table.  */
9227       data++;
9228
9229       /* Now display the statements.  */
9230       printf (_("\n Line Number Statements:\n"));
9231
9232       while (data < end_of_sequence)
9233         {
9234           unsigned char op_code;
9235           int adv;
9236           unsigned int bytes_read;
9237
9238           op_code = *data++;
9239
9240           if (op_code >= info.li_opcode_base)
9241             {
9242               op_code -= info.li_opcode_base;
9243               adv      = (op_code / info.li_line_range) * info.li_min_insn_length;
9244               state_machine_regs.address += adv;
9245               printf (_("  Special opcode %d: advance Address by %d to 0x%lx"),
9246                       op_code, adv, state_machine_regs.address);
9247               adv = (op_code % info.li_line_range) + info.li_line_base;
9248               state_machine_regs.line += adv;
9249               printf (_(" and Line by %d to %d\n"),
9250                       adv, state_machine_regs.line);
9251             }
9252           else switch (op_code)
9253             {
9254             case DW_LNS_extended_op:
9255               if (pointer_size == 0)
9256                 {
9257                   warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9258                   pointer_size = 4;
9259                 }
9260
9261               data += process_extended_line_op (data, info.li_default_is_stmt,
9262                                                 pointer_size);
9263               break;
9264
9265             case DW_LNS_copy:
9266               printf (_("  Copy\n"));
9267               break;
9268
9269             case DW_LNS_advance_pc:
9270               adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
9271               data += bytes_read;
9272               state_machine_regs.address += adv;
9273               printf (_("  Advance PC by %d to %lx\n"), adv,
9274                       state_machine_regs.address);
9275               break;
9276
9277             case DW_LNS_advance_line:
9278               adv = read_leb128 (data, & bytes_read, 1);
9279               data += bytes_read;
9280               state_machine_regs.line += adv;
9281               printf (_("  Advance Line by %d to %d\n"), adv,
9282                       state_machine_regs.line);
9283               break;
9284
9285             case DW_LNS_set_file:
9286               adv = read_leb128 (data, & bytes_read, 0);
9287               data += bytes_read;
9288               printf (_("  Set File Name to entry %d in the File Name Table\n"),
9289                       adv);
9290               state_machine_regs.file = adv;
9291               break;
9292
9293             case DW_LNS_set_column:
9294               adv = read_leb128 (data, & bytes_read, 0);
9295               data += bytes_read;
9296               printf (_("  Set column to %d\n"), adv);
9297               state_machine_regs.column = adv;
9298               break;
9299
9300             case DW_LNS_negate_stmt:
9301               adv = state_machine_regs.is_stmt;
9302               adv = ! adv;
9303               printf (_("  Set is_stmt to %d\n"), adv);
9304               state_machine_regs.is_stmt = adv;
9305               break;
9306
9307             case DW_LNS_set_basic_block:
9308               printf (_("  Set basic block\n"));
9309               state_machine_regs.basic_block = 1;
9310               break;
9311
9312             case DW_LNS_const_add_pc:
9313               adv = (((255 - info.li_opcode_base) / info.li_line_range)
9314                      * info.li_min_insn_length);
9315               state_machine_regs.address += adv;
9316               printf (_("  Advance PC by constant %d to 0x%lx\n"), adv,
9317                       state_machine_regs.address);
9318               break;
9319
9320             case DW_LNS_fixed_advance_pc:
9321               adv = byte_get (data, 2);
9322               data += 2;
9323               state_machine_regs.address += adv;
9324               printf (_("  Advance PC by fixed size amount %d to 0x%lx\n"),
9325                       adv, state_machine_regs.address);
9326               break;
9327
9328             case DW_LNS_set_prologue_end:
9329               printf (_("  Set prologue_end to true\n"));
9330               break;
9331
9332             case DW_LNS_set_epilogue_begin:
9333               printf (_("  Set epilogue_begin to true\n"));
9334               break;
9335
9336             case DW_LNS_set_isa:
9337               adv = read_leb128 (data, & bytes_read, 0);
9338               data += bytes_read;
9339               printf (_("  Set ISA to %d\n"), adv);
9340               break;
9341
9342             default:
9343               printf (_("  Unknown opcode %d with operands: "), op_code);
9344
9345               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
9346                 {
9347                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
9348                           i == 1 ? "" : ", ");
9349                   data += bytes_read;
9350                 }
9351               putchar ('\n');
9352               break;
9353             }
9354         }
9355       putchar ('\n');
9356     }
9357
9358   return 1;
9359 }
9360
9361 static int
9362 display_debug_pubnames (Elf_Internal_Shdr *section,
9363                         unsigned char *start,
9364                         FILE *file ATTRIBUTE_UNUSED)
9365 {
9366   DWARF2_Internal_PubNames pubnames;
9367   unsigned char *end;
9368
9369   end = start + section->sh_size;
9370
9371   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
9372
9373   while (start < end)
9374     {
9375       unsigned char *data;
9376       unsigned long offset;
9377       int offset_size, initial_length_size;
9378
9379       data = start;
9380
9381       pubnames.pn_length = byte_get (data, 4);
9382       data += 4;
9383       if (pubnames.pn_length == 0xffffffff)
9384         {
9385           pubnames.pn_length = byte_get (data, 8);
9386           data += 8;
9387           offset_size = 8;
9388           initial_length_size = 12;
9389         }
9390       else
9391         {
9392           offset_size = 4;
9393           initial_length_size = 4;
9394         }
9395
9396       pubnames.pn_version = byte_get (data, 2);
9397       data += 2;
9398       pubnames.pn_offset = byte_get (data, offset_size);
9399       data += offset_size;
9400       pubnames.pn_size = byte_get (data, offset_size);
9401       data += offset_size;
9402
9403       start += pubnames.pn_length + initial_length_size;
9404
9405       if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
9406         {
9407           static int warned = 0;
9408
9409           if (! warned)
9410             {
9411               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9412               warned = 1;
9413             }
9414
9415           continue;
9416         }
9417
9418       printf (_("  Length:                              %ld\n"),
9419               pubnames.pn_length);
9420       printf (_("  Version:                             %d\n"),
9421               pubnames.pn_version);
9422       printf (_("  Offset into .debug_info section:     %ld\n"),
9423               pubnames.pn_offset);
9424       printf (_("  Size of area in .debug_info section: %ld\n"),
9425               pubnames.pn_size);
9426
9427       printf (_("\n    Offset\tName\n"));
9428
9429       do
9430         {
9431           offset = byte_get (data, offset_size);
9432
9433           if (offset != 0)
9434             {
9435               data += offset_size;
9436               printf ("    %-6ld\t\t%s\n", offset, data);
9437               data += strlen ((char *) data) + 1;
9438             }
9439         }
9440       while (offset != 0);
9441     }
9442
9443   printf ("\n");
9444   return 1;
9445 }
9446
9447 static int
9448 display_debug_macinfo (Elf_Internal_Shdr *section,
9449                        unsigned char *start,
9450                        FILE *file ATTRIBUTE_UNUSED)
9451 {
9452   unsigned char *end = start + section->sh_size;
9453   unsigned char *curr = start;
9454   unsigned int bytes_read;
9455   enum dwarf_macinfo_record_type op;
9456
9457   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
9458
9459   while (curr < end)
9460     {
9461       unsigned int lineno;
9462       const char *string;
9463
9464       op = *curr;
9465       curr++;
9466
9467       switch (op)
9468         {
9469         case DW_MACINFO_start_file:
9470           {
9471             unsigned int filenum;
9472
9473             lineno = read_leb128 (curr, & bytes_read, 0);
9474             curr += bytes_read;
9475             filenum = read_leb128 (curr, & bytes_read, 0);
9476             curr += bytes_read;
9477
9478             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9479                     lineno, filenum);
9480           }
9481           break;
9482
9483         case DW_MACINFO_end_file:
9484           printf (_(" DW_MACINFO_end_file\n"));
9485           break;
9486
9487         case DW_MACINFO_define:
9488           lineno = read_leb128 (curr, & bytes_read, 0);
9489           curr += bytes_read;
9490           string = (char *) curr;
9491           curr += strlen (string) + 1;
9492           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9493                   lineno, string);
9494           break;
9495
9496         case DW_MACINFO_undef:
9497           lineno = read_leb128 (curr, & bytes_read, 0);
9498           curr += bytes_read;
9499           string = (char *) curr;
9500           curr += strlen (string) + 1;
9501           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9502                   lineno, string);
9503           break;
9504
9505         case DW_MACINFO_vendor_ext:
9506           {
9507             unsigned int constant;
9508
9509             constant = read_leb128 (curr, & bytes_read, 0);
9510             curr += bytes_read;
9511             string = (char *) curr;
9512             curr += strlen (string) + 1;
9513             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9514                     constant, string);
9515           }
9516           break;
9517         }
9518     }
9519
9520   return 1;
9521 }
9522
9523
9524 static int
9525 display_debug_abbrev (Elf_Internal_Shdr *section,
9526                       unsigned char *start,
9527                       FILE *file ATTRIBUTE_UNUSED)
9528 {
9529   abbrev_entry *entry;
9530   unsigned char *end = start + section->sh_size;
9531
9532   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
9533
9534   do
9535     {
9536       start = process_abbrev_section (start, end);
9537
9538       if (first_abbrev == NULL)
9539         continue;
9540
9541       printf (_("  Number TAG\n"));
9542
9543       for (entry = first_abbrev; entry; entry = entry->next)
9544         {
9545           abbrev_attr *attr;
9546
9547           printf (_("   %ld      %s    [%s]\n"),
9548                   entry->entry,
9549                   get_TAG_name (entry->tag),
9550                   entry->children ? _("has children") : _("no children"));
9551
9552           for (attr = entry->first_attr; attr; attr = attr->next)
9553             printf (_("    %-18s %s\n"),
9554                     get_AT_name (attr->attribute),
9555                     get_FORM_name (attr->form));
9556         }
9557
9558       free_abbrevs ();
9559     }
9560   while (start);
9561
9562   printf ("\n");
9563
9564   return 1;
9565 }
9566
9567 static int
9568 display_debug_loc (Elf_Internal_Shdr *section,
9569                    unsigned char *start, FILE *file)
9570 {
9571   unsigned char *section_end;
9572   unsigned long bytes;
9573   unsigned char *section_begin = start;
9574   unsigned int num_loc_list = 0;
9575   unsigned long last_offset = 0;
9576   unsigned int first = 0;
9577   unsigned int i;
9578   unsigned int j;
9579   int seen_first_offset = 0;
9580   int use_debug_info = 1;
9581   unsigned char *next;
9582
9583   bytes = section->sh_size;
9584   section_end = start + bytes;
9585
9586   if (bytes == 0)
9587     {
9588       printf (_("\nThe .debug_loc section is empty.\n"));
9589       return 0;
9590     }
9591
9592   get_debug_info (file);
9593
9594   /* Check the order of location list in .debug_info section. If
9595      offsets of location lists are in the ascending order, we can
9596      use `debug_information' directly.  */
9597   for (i = 0; i < num_debug_info_entries; i++)
9598     {
9599       unsigned int num;
9600
9601       num = debug_information [i].num_loc_offsets;
9602       num_loc_list += num;
9603
9604       /* Check if we can use `debug_information' directly.  */
9605       if (use_debug_info && num != 0)
9606         {
9607           if (!seen_first_offset)
9608             {
9609               /* This is the first location list.  */
9610               last_offset = debug_information [i].loc_offsets [0];
9611               first = i;
9612               seen_first_offset = 1;
9613               j = 1;
9614             }
9615           else
9616             j = 0;
9617
9618           for (; j < num; j++)
9619             {
9620               if (last_offset >
9621                   debug_information [i].loc_offsets [j])
9622                 {
9623                   use_debug_info = 0;
9624                   break;
9625                 }
9626               last_offset = debug_information [i].loc_offsets [j];
9627             }
9628         }
9629     }
9630
9631   if (!use_debug_info)
9632     /* FIXME: Should we handle this case?  */
9633     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9634
9635   if (!seen_first_offset)
9636     error (_("No location lists in .debug_info section!\n"));
9637
9638   if (debug_information [first].loc_offsets [0] != 0)
9639     warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9640           debug_information [first].loc_offsets [0]);
9641
9642   printf (_("Contents of the .debug_loc section:\n\n"));
9643   printf (_("    Offset   Begin    End      Expression\n"));
9644
9645   seen_first_offset = 0;
9646   for (i = first; i < num_debug_info_entries; i++)
9647     {
9648       unsigned long begin;
9649       unsigned long end;
9650       unsigned short length;
9651       unsigned long offset;
9652       unsigned int pointer_size;
9653       unsigned long cu_offset;
9654       unsigned long base_address;
9655       int need_frame_base;
9656       int has_frame_base;
9657
9658       pointer_size = debug_information [i].pointer_size;
9659       cu_offset = debug_information [i].cu_offset;
9660
9661       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
9662         {
9663           has_frame_base = debug_information [i].have_frame_base [j];
9664           offset = debug_information [i].loc_offsets [j];
9665           next = section_begin + offset;
9666           base_address = debug_information [i].base_address;
9667
9668           if (!seen_first_offset)
9669             seen_first_offset = 1;
9670           else
9671             {
9672               if (start < next)
9673                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9674                       start - section_begin, next - section_begin);
9675               else if (start > next)
9676                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9677                       start - section_begin, next - section_begin);
9678             }
9679           start = next;
9680
9681           while (1)
9682             {
9683               begin = byte_get (start, pointer_size);
9684               start += pointer_size;
9685               end = byte_get (start, pointer_size);
9686               start += pointer_size;
9687
9688               if (begin == 0 && end == 0)
9689                 {
9690                   printf (_("    %8.8lx <End of list>\n"), offset);
9691                   break;
9692                 }
9693
9694               /* Check base address specifiers.  */
9695               if (begin == -1UL && end != -1UL)
9696                 {
9697                   base_address = end;
9698                   printf ("    %8.8lx %8.8lx %8.8lx (base address)\n",
9699                           offset, begin, end);
9700                   continue;
9701                 }
9702
9703               length = byte_get (start, 2);
9704               start += 2;
9705
9706               printf ("    %8.8lx %8.8lx %8.8lx (",
9707                       offset, begin + base_address, end + base_address);
9708               need_frame_base = decode_location_expression (start,
9709                                                             pointer_size,
9710                                                             length,
9711                                                             cu_offset);
9712               putchar (')');
9713
9714               if (need_frame_base && !has_frame_base)
9715                 printf (_(" [without DW_AT_frame_base]"));
9716
9717               if (begin == end)
9718                 fputs (_(" (start == end)"), stdout);
9719               else if (begin > end)
9720                 fputs (_(" (start > end)"), stdout);
9721
9722               putchar ('\n');
9723
9724               start += length;
9725             }
9726         }
9727     }
9728   return 1;
9729 }
9730
9731 static int
9732 display_debug_str (Elf_Internal_Shdr *section,
9733                    unsigned char *start,
9734                    FILE *file ATTRIBUTE_UNUSED)
9735 {
9736   unsigned long bytes;
9737   bfd_vma addr;
9738
9739   addr  = section->sh_addr;
9740   bytes = section->sh_size;
9741
9742   if (bytes == 0)
9743     {
9744       printf (_("\nThe .debug_str section is empty.\n"));
9745       return 0;
9746     }
9747
9748   printf (_("Contents of the .debug_str section:\n\n"));
9749
9750   while (bytes)
9751     {
9752       int j;
9753       int k;
9754       int lbytes;
9755
9756       lbytes = (bytes > 16 ? 16 : bytes);
9757
9758       printf ("  0x%8.8lx ", (unsigned long) addr);
9759
9760       for (j = 0; j < 16; j++)
9761         {
9762           if (j < lbytes)
9763             printf ("%2.2x", start[j]);
9764           else
9765             printf ("  ");
9766
9767           if ((j & 3) == 3)
9768             printf (" ");
9769         }
9770
9771       for (j = 0; j < lbytes; j++)
9772         {
9773           k = start[j];
9774           if (k >= ' ' && k < 0x80)
9775             printf ("%c", k);
9776           else
9777             printf (".");
9778         }
9779
9780       putchar ('\n');
9781
9782       start += lbytes;
9783       addr  += lbytes;
9784       bytes -= lbytes;
9785     }
9786
9787   putchar ('\n');
9788
9789   return 1;
9790 }
9791
9792
9793 static int
9794 display_debug_info (Elf_Internal_Shdr * section,
9795                     unsigned char * start, FILE * file)
9796 {
9797   return process_debug_info (section, start, file, 0);
9798 }
9799
9800
9801 static int
9802 display_debug_aranges (Elf_Internal_Shdr *section,
9803                        unsigned char *start,
9804                        FILE *file ATTRIBUTE_UNUSED)
9805 {
9806   unsigned char *end = start + section->sh_size;
9807
9808   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
9809
9810   while (start < end)
9811     {
9812       unsigned char *hdrptr;
9813       DWARF2_Internal_ARange arange;
9814       unsigned char *ranges;
9815       unsigned long length;
9816       unsigned long address;
9817       int excess;
9818       int offset_size;
9819       int initial_length_size;
9820
9821       hdrptr = start;
9822
9823       arange.ar_length = byte_get (hdrptr, 4);
9824       hdrptr += 4;
9825
9826       if (arange.ar_length == 0xffffffff)
9827         {
9828           arange.ar_length = byte_get (hdrptr, 8);
9829           hdrptr += 8;
9830           offset_size = 8;
9831           initial_length_size = 12;
9832         }
9833       else
9834         {
9835           offset_size = 4;
9836           initial_length_size = 4;
9837         }
9838
9839       arange.ar_version = byte_get (hdrptr, 2);
9840       hdrptr += 2;
9841
9842       arange.ar_info_offset = byte_get (hdrptr, offset_size);
9843       hdrptr += offset_size;
9844
9845       arange.ar_pointer_size = byte_get (hdrptr, 1);
9846       hdrptr += 1;
9847
9848       arange.ar_segment_size = byte_get (hdrptr, 1);
9849       hdrptr += 1;
9850
9851       if (arange.ar_version != 2 && arange.ar_version != 3)
9852         {
9853           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9854           break;
9855         }
9856
9857       printf (_("  Length:                   %ld\n"), arange.ar_length);
9858       printf (_("  Version:                  %d\n"), arange.ar_version);
9859       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
9860       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
9861       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
9862
9863       printf (_("\n    Address  Length\n"));
9864
9865       ranges = hdrptr;
9866
9867       /* Must pad to an alignment boundary that is twice the pointer size.  */
9868       excess = (hdrptr - start) % (2 * arange.ar_pointer_size);
9869       if (excess)
9870         ranges += (2 * arange.ar_pointer_size) - excess;
9871
9872       for (;;)
9873         {
9874           address = byte_get (ranges, arange.ar_pointer_size);
9875
9876           ranges += arange.ar_pointer_size;
9877
9878           length  = byte_get (ranges, arange.ar_pointer_size);
9879
9880           ranges += arange.ar_pointer_size;
9881
9882           /* A pair of zeros marks the end of the list.  */
9883           if (address == 0 && length == 0)
9884             break;
9885
9886           printf ("    %8.8lx %lu\n", address, length);
9887         }
9888
9889       start += arange.ar_length + initial_length_size;
9890     }
9891
9892   printf ("\n");
9893
9894   return 1;
9895 }
9896
9897 static int
9898 display_debug_ranges (Elf_Internal_Shdr *section,
9899                       unsigned char *start,
9900                       FILE *file ATTRIBUTE_UNUSED)
9901 {
9902   unsigned char *section_end;
9903   unsigned long bytes;
9904   unsigned char *section_begin = start;
9905   unsigned int num_range_list = 0;
9906   unsigned long last_offset = 0;
9907   unsigned int first = 0;
9908   unsigned int i;
9909   unsigned int j;
9910   int seen_first_offset = 0;
9911   int use_debug_info = 1;
9912   unsigned char *next;
9913
9914   bytes = section->sh_size;
9915   section_end = start + bytes;
9916
9917   if (bytes == 0)
9918     {
9919       printf (_("\nThe .debug_ranges section is empty.\n"));
9920       return 0;
9921     }
9922
9923   get_debug_info (file);
9924
9925   /* Check the order of range list in .debug_info section. If
9926      offsets of range lists are in the ascending order, we can
9927      use `debug_information' directly.  */
9928   for (i = 0; i < num_debug_info_entries; i++)
9929     {
9930       unsigned int num;
9931
9932       num = debug_information [i].num_range_lists;
9933       num_range_list += num;
9934
9935       /* Check if we can use `debug_information' directly.  */
9936       if (use_debug_info && num != 0)
9937         {
9938           if (!seen_first_offset)
9939             {
9940               /* This is the first range list.  */
9941               last_offset = debug_information [i].range_lists [0];
9942               first = i;
9943               seen_first_offset = 1;
9944               j = 1;
9945             }
9946           else
9947             j = 0;
9948
9949           for (; j < num; j++)
9950             {
9951               if (last_offset >
9952                   debug_information [i].range_lists [j])
9953                 {
9954                   use_debug_info = 0;
9955                   break;
9956                 }
9957               last_offset = debug_information [i].range_lists [j];
9958             }
9959         }
9960     }
9961
9962   if (!use_debug_info)
9963     /* FIXME: Should we handle this case?  */
9964     error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9965
9966   if (!seen_first_offset)
9967     error (_("No range lists in .debug_info section!\n"));
9968
9969   if (debug_information [first].range_lists [0] != 0)
9970     warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9971           debug_information [first].range_lists [0]);
9972
9973   printf (_("Contents of the .debug_ranges section:\n\n"));
9974   printf (_("    Offset   Begin    End\n"));
9975
9976   seen_first_offset = 0;
9977   for (i = first; i < num_debug_info_entries; i++)
9978     {
9979       unsigned long begin;
9980       unsigned long end;
9981       unsigned long offset;
9982       unsigned int pointer_size;
9983       unsigned long base_address;
9984
9985       pointer_size = debug_information [i].pointer_size;
9986
9987       for (j = 0; j < debug_information [i].num_range_lists; j++)
9988         {
9989           offset = debug_information [i].range_lists [j];
9990           next = section_begin + offset;
9991           base_address = debug_information [i].base_address;
9992
9993           if (!seen_first_offset)
9994             seen_first_offset = 1;
9995           else
9996             {
9997               if (start < next)
9998                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9999                       start - section_begin, next - section_begin);
10000               else if (start > next)
10001                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
10002                       start - section_begin, next - section_begin);
10003             }
10004           start = next;
10005
10006           while (1)
10007             {
10008               begin = byte_get (start, pointer_size);
10009               start += pointer_size;
10010               end = byte_get (start, pointer_size);
10011               start += pointer_size;
10012
10013               if (begin == 0 && end == 0)
10014                 {
10015                   printf (_("    %8.8lx <End of list>\n"), offset);
10016                   break;
10017                 }
10018
10019               /* Check base address specifiers.  */
10020               if (begin == -1UL && end != -1UL)
10021                 {
10022                   base_address = end;
10023                   printf ("    %8.8lx %8.8lx %8.8lx (base address)\n",
10024                           offset, begin, end);
10025                   continue;
10026                 }
10027
10028               printf ("    %8.8lx %8.8lx %8.8lx",
10029                       offset, begin + base_address, end + base_address);
10030
10031               if (begin == end)
10032                 fputs (_(" (start == end)"), stdout);
10033               else if (begin > end)
10034                 fputs (_(" (start > end)"), stdout);
10035
10036               putchar ('\n');
10037             }
10038         }
10039     }
10040   putchar ('\n');
10041   return 1;
10042 }
10043
10044 typedef struct Frame_Chunk
10045 {
10046   struct Frame_Chunk *next;
10047   unsigned char *chunk_start;
10048   int ncols;
10049   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
10050   short int *col_type;
10051   int *col_offset;
10052   char *augmentation;
10053   unsigned int code_factor;
10054   int data_factor;
10055   unsigned long pc_begin;
10056   unsigned long pc_range;
10057   int cfa_reg;
10058   int cfa_offset;
10059   int ra;
10060   unsigned char fde_encoding;
10061   unsigned char cfa_exp;
10062 }
10063 Frame_Chunk;
10064
10065 /* A marker for a col_type that means this column was never referenced
10066    in the frame info.  */
10067 #define DW_CFA_unreferenced (-1)
10068
10069 static void
10070 frame_need_space (Frame_Chunk *fc, int reg)
10071 {
10072   int prev = fc->ncols;
10073
10074   if (reg < fc->ncols)
10075     return;
10076
10077   fc->ncols = reg + 1;
10078   fc->col_type = xrealloc (fc->col_type, fc->ncols * sizeof (short int));
10079   fc->col_offset = xrealloc (fc->col_offset, fc->ncols * sizeof (int));
10080
10081   while (prev < fc->ncols)
10082     {
10083       fc->col_type[prev] = DW_CFA_unreferenced;
10084       fc->col_offset[prev] = 0;
10085       prev++;
10086     }
10087 }
10088
10089 static void
10090 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
10091 {
10092   int r;
10093   char tmp[100];
10094
10095   if (*max_regs < fc->ncols)
10096     *max_regs = fc->ncols;
10097
10098   if (*need_col_headers)
10099     {
10100       *need_col_headers = 0;
10101
10102       printf ("   LOC   CFA      ");
10103
10104       for (r = 0; r < *max_regs; r++)
10105         if (fc->col_type[r] != DW_CFA_unreferenced)
10106           {
10107             if (r == fc->ra)
10108               printf ("ra   ");
10109             else
10110               printf ("r%-4d", r);
10111           }
10112
10113       printf ("\n");
10114     }
10115
10116   printf ("%08lx ", fc->pc_begin);
10117   if (fc->cfa_exp)
10118     strcpy (tmp, "exp");
10119   else
10120     sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
10121   printf ("%-8s ", tmp);
10122
10123   for (r = 0; r < fc->ncols; r++)
10124     {
10125       if (fc->col_type[r] != DW_CFA_unreferenced)
10126         {
10127           switch (fc->col_type[r])
10128             {
10129             case DW_CFA_undefined:
10130               strcpy (tmp, "u");
10131               break;
10132             case DW_CFA_same_value:
10133               strcpy (tmp, "s");
10134               break;
10135             case DW_CFA_offset:
10136               sprintf (tmp, "c%+d", fc->col_offset[r]);
10137               break;
10138             case DW_CFA_register:
10139               sprintf (tmp, "r%d", fc->col_offset[r]);
10140               break;
10141             case DW_CFA_expression:
10142               strcpy (tmp, "exp");
10143               break;
10144             default:
10145               strcpy (tmp, "n/a");
10146               break;
10147             }
10148           printf ("%-5s", tmp);
10149         }
10150     }
10151   printf ("\n");
10152 }
10153
10154 static int
10155 size_of_encoded_value (int encoding)
10156 {
10157   switch (encoding & 0x7)
10158     {
10159     default:    /* ??? */
10160     case 0:     return eh_addr_size;
10161     case 2:     return 2;
10162     case 3:     return 4;
10163     case 4:     return 8;
10164     }
10165 }
10166
10167 static bfd_vma
10168 get_encoded_value (unsigned char *data, int encoding)
10169 {
10170   int size = size_of_encoded_value (encoding);
10171   if (encoding & DW_EH_PE_signed)
10172     return byte_get_signed (data, size);
10173   else
10174     return byte_get (data, size);
10175 }
10176
10177 #define GET(N)  byte_get (start, N); start += N
10178 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
10179 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
10180
10181 static int
10182 display_debug_frames (Elf_Internal_Shdr *section,
10183                       unsigned char *start,
10184                       FILE *file ATTRIBUTE_UNUSED)
10185 {
10186   unsigned char *end = start + section->sh_size;
10187   unsigned char *section_start = start;
10188   Frame_Chunk *chunks = 0;
10189   Frame_Chunk *remembered_state = 0;
10190   Frame_Chunk *rs;
10191   int is_eh = streq (SECTION_NAME (section), ".eh_frame");
10192   unsigned int length_return;
10193   int max_regs = 0;
10194
10195   printf (_("The section %s contains:\n"), SECTION_NAME (section));
10196
10197   while (start < end)
10198     {
10199       unsigned char *saved_start;
10200       unsigned char *block_end;
10201       unsigned long length;
10202       unsigned long cie_id;
10203       Frame_Chunk *fc;
10204       Frame_Chunk *cie;
10205       int need_col_headers = 1;
10206       unsigned char *augmentation_data = NULL;
10207       unsigned long augmentation_data_len = 0;
10208       int encoded_ptr_size = eh_addr_size;
10209       int offset_size;
10210       int initial_length_size;
10211
10212       saved_start = start;
10213       length = byte_get (start, 4); start += 4;
10214
10215       if (length == 0)
10216         {
10217           printf ("\n%08lx ZERO terminator\n\n",
10218                     (unsigned long)(saved_start - section_start));
10219           return 1;
10220         }
10221
10222       if (length == 0xffffffff)
10223         {
10224           length = byte_get (start, 8);
10225           start += 8;
10226           offset_size = 8;
10227           initial_length_size = 12;
10228         }
10229       else
10230         {
10231           offset_size = 4;
10232           initial_length_size = 4;
10233         }
10234
10235       block_end = saved_start + length + initial_length_size;
10236       cie_id = byte_get (start, offset_size); start += offset_size;
10237
10238       if (elf_header.e_type == ET_REL
10239           && !debug_apply_rela_addends (file, section, offset_size,
10240                                         section_start, start, block_end))
10241         return 0;
10242
10243       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
10244         {
10245           int version;
10246
10247           fc = xmalloc (sizeof (Frame_Chunk));
10248           memset (fc, 0, sizeof (Frame_Chunk));
10249
10250           fc->next = chunks;
10251           chunks = fc;
10252           fc->chunk_start = saved_start;
10253           fc->ncols = 0;
10254           fc->col_type = xmalloc (sizeof (short int));
10255           fc->col_offset = xmalloc (sizeof (int));
10256           frame_need_space (fc, max_regs-1);
10257
10258           version = *start++;
10259
10260           fc->augmentation = (char *) start;
10261           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
10262
10263           if (fc->augmentation[0] == 'z')
10264             {
10265               fc->code_factor = LEB ();
10266               fc->data_factor = SLEB ();
10267               if (version == 1)
10268                 {
10269                   fc->ra = GET (1);
10270                 }
10271               else
10272                 {
10273                   fc->ra = LEB ();
10274                 }
10275               augmentation_data_len = LEB ();
10276               augmentation_data = start;
10277               start += augmentation_data_len;
10278             }
10279           else if (streq (fc->augmentation, "eh"))
10280             {
10281               start += eh_addr_size;
10282               fc->code_factor = LEB ();
10283               fc->data_factor = SLEB ();
10284               if (version == 1)
10285                 {
10286                   fc->ra = GET (1);
10287                 }
10288               else
10289                 {
10290                   fc->ra = LEB ();
10291                 }
10292             }
10293           else
10294             {
10295               fc->code_factor = LEB ();
10296               fc->data_factor = SLEB ();
10297               if (version == 1)
10298                 {
10299                   fc->ra = GET (1);
10300                 }
10301               else
10302                 {
10303                   fc->ra = LEB ();
10304                 }
10305             }
10306           cie = fc;
10307
10308           if (do_debug_frames_interp)
10309             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10310                     (unsigned long)(saved_start - section_start), length, cie_id,
10311                     fc->augmentation, fc->code_factor, fc->data_factor,
10312                     fc->ra);
10313           else
10314             {
10315               printf ("\n%08lx %08lx %08lx CIE\n",
10316                       (unsigned long)(saved_start - section_start), length, cie_id);
10317               printf ("  Version:               %d\n", version);
10318               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
10319               printf ("  Code alignment factor: %u\n", fc->code_factor);
10320               printf ("  Data alignment factor: %d\n", fc->data_factor);
10321               printf ("  Return address column: %d\n", fc->ra);
10322
10323               if (augmentation_data_len)
10324                 {
10325                   unsigned long i;
10326                   printf ("  Augmentation data:    ");
10327                   for (i = 0; i < augmentation_data_len; ++i)
10328                     printf (" %02x", augmentation_data[i]);
10329                   putchar ('\n');
10330                 }
10331               putchar ('\n');
10332             }
10333
10334           if (augmentation_data_len)
10335             {
10336               unsigned char *p, *q;
10337               p = (unsigned char *) fc->augmentation + 1;
10338               q = augmentation_data;
10339
10340               while (1)
10341                 {
10342                   if (*p == 'L')
10343                     q++;
10344                   else if (*p == 'P')
10345                     q += 1 + size_of_encoded_value (*q);
10346                   else if (*p == 'R')
10347                     fc->fde_encoding = *q++;
10348                   else
10349                     break;
10350                   p++;
10351                 }
10352
10353               if (fc->fde_encoding)
10354                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
10355             }
10356
10357           frame_need_space (fc, fc->ra);
10358         }
10359       else
10360         {
10361           unsigned char *look_for;
10362           static Frame_Chunk fde_fc;
10363
10364           fc = & fde_fc;
10365           memset (fc, 0, sizeof (Frame_Chunk));
10366
10367           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
10368
10369           for (cie = chunks; cie ; cie = cie->next)
10370             if (cie->chunk_start == look_for)
10371               break;
10372
10373           if (!cie)
10374             {
10375               warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10376                     cie_id, saved_start);
10377               start = block_end;
10378               fc->ncols = 0;
10379               fc->col_type = xmalloc (sizeof (short int));
10380               fc->col_offset = xmalloc (sizeof (int));
10381               frame_need_space (fc, max_regs - 1);
10382               cie = fc;
10383               fc->augmentation = "";
10384               fc->fde_encoding = 0;
10385             }
10386           else
10387             {
10388               fc->ncols = cie->ncols;
10389               fc->col_type = xmalloc (fc->ncols * sizeof (short int));
10390               fc->col_offset = xmalloc (fc->ncols * sizeof (int));
10391               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
10392               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
10393               fc->augmentation = cie->augmentation;
10394               fc->code_factor = cie->code_factor;
10395               fc->data_factor = cie->data_factor;
10396               fc->cfa_reg = cie->cfa_reg;
10397               fc->cfa_offset = cie->cfa_offset;
10398               fc->ra = cie->ra;
10399               frame_need_space (fc, max_regs-1);
10400               fc->fde_encoding = cie->fde_encoding;
10401             }
10402
10403           if (fc->fde_encoding)
10404             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
10405
10406           fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
10407           if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
10408               /* Don't adjust for ET_REL since there's invariably a pcrel
10409                  reloc here, which we haven't applied.  */
10410               && elf_header.e_type != ET_REL)
10411             fc->pc_begin += section->sh_addr + (start - section_start);
10412           start += encoded_ptr_size;
10413           fc->pc_range = byte_get (start, encoded_ptr_size);
10414           start += encoded_ptr_size;
10415
10416           if (cie->augmentation[0] == 'z')
10417             {
10418               augmentation_data_len = LEB ();
10419               augmentation_data = start;
10420               start += augmentation_data_len;
10421             }
10422
10423           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10424                   (unsigned long)(saved_start - section_start), length, cie_id,
10425                   (unsigned long)(cie->chunk_start - section_start),
10426                   fc->pc_begin, fc->pc_begin + fc->pc_range);
10427           if (! do_debug_frames_interp && augmentation_data_len)
10428             {
10429               unsigned long i;
10430
10431               printf ("  Augmentation data:    ");
10432               for (i = 0; i < augmentation_data_len; ++i)
10433                 printf (" %02x", augmentation_data[i]);
10434               putchar ('\n');
10435               putchar ('\n');
10436             }
10437         }
10438
10439       /* At this point, fc is the current chunk, cie (if any) is set, and
10440          we're about to interpret instructions for the chunk.  */
10441       /* ??? At present we need to do this always, since this sizes the
10442          fc->col_type and fc->col_offset arrays, which we write into always.
10443          We should probably split the interpreted and non-interpreted bits
10444          into two different routines, since there's so much that doesn't
10445          really overlap between them.  */
10446       if (1 || do_debug_frames_interp)
10447         {
10448           /* Start by making a pass over the chunk, allocating storage
10449              and taking note of what registers are used.  */
10450           unsigned char *tmp = start;
10451
10452           while (start < block_end)
10453             {
10454               unsigned op, opa;
10455               unsigned long reg, tmp;
10456
10457               op = *start++;
10458               opa = op & 0x3f;
10459               if (op & 0xc0)
10460                 op &= 0xc0;
10461
10462               /* Warning: if you add any more cases to this switch, be
10463                  sure to add them to the corresponding switch below.  */
10464               switch (op)
10465                 {
10466                 case DW_CFA_advance_loc:
10467                   break;
10468                 case DW_CFA_offset:
10469                   LEB ();
10470                   frame_need_space (fc, opa);
10471                   fc->col_type[opa] = DW_CFA_undefined;
10472                   break;
10473                 case DW_CFA_restore:
10474                   frame_need_space (fc, opa);
10475                   fc->col_type[opa] = DW_CFA_undefined;
10476                   break;
10477                 case DW_CFA_set_loc:
10478                   start += encoded_ptr_size;
10479                   break;
10480                 case DW_CFA_advance_loc1:
10481                   start += 1;
10482                   break;
10483                 case DW_CFA_advance_loc2:
10484                   start += 2;
10485                   break;
10486                 case DW_CFA_advance_loc4:
10487                   start += 4;
10488                   break;
10489                 case DW_CFA_offset_extended:
10490                   reg = LEB (); LEB ();
10491                   frame_need_space (fc, reg);
10492                   fc->col_type[reg] = DW_CFA_undefined;
10493                   break;
10494                 case DW_CFA_restore_extended:
10495                   reg = LEB ();
10496                   frame_need_space (fc, reg);
10497                   fc->col_type[reg] = DW_CFA_undefined;
10498                   break;
10499                 case DW_CFA_undefined:
10500                   reg = LEB ();
10501                   frame_need_space (fc, reg);
10502                   fc->col_type[reg] = DW_CFA_undefined;
10503                   break;
10504                 case DW_CFA_same_value:
10505                   reg = LEB ();
10506                   frame_need_space (fc, reg);
10507                   fc->col_type[reg] = DW_CFA_undefined;
10508                   break;
10509                 case DW_CFA_register:
10510                   reg = LEB (); LEB ();
10511                   frame_need_space (fc, reg);
10512                   fc->col_type[reg] = DW_CFA_undefined;
10513                   break;
10514                 case DW_CFA_def_cfa:
10515                   LEB (); LEB ();
10516                   break;
10517                 case DW_CFA_def_cfa_register:
10518                   LEB ();
10519                   break;
10520                 case DW_CFA_def_cfa_offset:
10521                   LEB ();
10522                   break;
10523                 case DW_CFA_def_cfa_expression:
10524                   tmp = LEB ();
10525                   start += tmp;
10526                   break;
10527                 case DW_CFA_expression:
10528                   reg = LEB ();
10529                   tmp = LEB ();
10530                   start += tmp;
10531                   frame_need_space (fc, reg);
10532                   fc->col_type[reg] = DW_CFA_undefined;
10533                   break;
10534                 case DW_CFA_offset_extended_sf:
10535                   reg = LEB (); SLEB ();
10536                   frame_need_space (fc, reg);
10537                   fc->col_type[reg] = DW_CFA_undefined;
10538                   break;
10539                 case DW_CFA_def_cfa_sf:
10540                   LEB (); SLEB ();
10541                   break;
10542                 case DW_CFA_def_cfa_offset_sf:
10543                   SLEB ();
10544                   break;
10545                 case DW_CFA_MIPS_advance_loc8:
10546                   start += 8;
10547                   break;
10548                 case DW_CFA_GNU_args_size:
10549                   LEB ();
10550                   break;
10551                 case DW_CFA_GNU_negative_offset_extended:
10552                   reg = LEB (); LEB ();
10553                   frame_need_space (fc, reg);
10554                   fc->col_type[reg] = DW_CFA_undefined;
10555
10556                 default:
10557                   break;
10558                 }
10559             }
10560           start = tmp;
10561         }
10562
10563       /* Now we know what registers are used, make a second pass over
10564          the chunk, this time actually printing out the info.  */
10565
10566       while (start < block_end)
10567         {
10568           unsigned op, opa;
10569           unsigned long ul, reg, roffs;
10570           long l, ofs;
10571           bfd_vma vma;
10572
10573           op = *start++;
10574           opa = op & 0x3f;
10575           if (op & 0xc0)
10576             op &= 0xc0;
10577
10578           /* Warning: if you add any more cases to this switch, be
10579              sure to add them to the corresponding switch above.  */
10580           switch (op)
10581             {
10582             case DW_CFA_advance_loc:
10583               if (do_debug_frames_interp)
10584                 frame_display_row (fc, &need_col_headers, &max_regs);
10585               else
10586                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
10587                         opa * fc->code_factor,
10588                         fc->pc_begin + opa * fc->code_factor);
10589               fc->pc_begin += opa * fc->code_factor;
10590               break;
10591
10592             case DW_CFA_offset:
10593               roffs = LEB ();
10594               if (! do_debug_frames_interp)
10595                 printf ("  DW_CFA_offset: r%d at cfa%+ld\n",
10596                         opa, roffs * fc->data_factor);
10597               fc->col_type[opa] = DW_CFA_offset;
10598               fc->col_offset[opa] = roffs * fc->data_factor;
10599               break;
10600
10601             case DW_CFA_restore:
10602               if (! do_debug_frames_interp)
10603                 printf ("  DW_CFA_restore: r%d\n", opa);
10604               fc->col_type[opa] = cie->col_type[opa];
10605               fc->col_offset[opa] = cie->col_offset[opa];
10606               break;
10607
10608             case DW_CFA_set_loc:
10609               vma = get_encoded_value (start, fc->fde_encoding);
10610               if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
10611                   && elf_header.e_type != ET_REL)
10612                 vma += section->sh_addr + (start - section_start);
10613               start += encoded_ptr_size;
10614               if (do_debug_frames_interp)
10615                 frame_display_row (fc, &need_col_headers, &max_regs);
10616               else
10617                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
10618               fc->pc_begin = vma;
10619               break;
10620
10621             case DW_CFA_advance_loc1:
10622               ofs = byte_get (start, 1); start += 1;
10623               if (do_debug_frames_interp)
10624                 frame_display_row (fc, &need_col_headers, &max_regs);
10625               else
10626                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
10627                         ofs * fc->code_factor,
10628                         fc->pc_begin + ofs * fc->code_factor);
10629               fc->pc_begin += ofs * fc->code_factor;
10630               break;
10631
10632             case DW_CFA_advance_loc2:
10633               ofs = byte_get (start, 2); start += 2;
10634               if (do_debug_frames_interp)
10635                 frame_display_row (fc, &need_col_headers, &max_regs);
10636               else
10637                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
10638                         ofs * fc->code_factor,
10639                         fc->pc_begin + ofs * fc->code_factor);
10640               fc->pc_begin += ofs * fc->code_factor;
10641               break;
10642
10643             case DW_CFA_advance_loc4:
10644               ofs = byte_get (start, 4); start += 4;
10645               if (do_debug_frames_interp)
10646                 frame_display_row (fc, &need_col_headers, &max_regs);
10647               else
10648                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
10649                         ofs * fc->code_factor,
10650                         fc->pc_begin + ofs * fc->code_factor);
10651               fc->pc_begin += ofs * fc->code_factor;
10652               break;
10653
10654             case DW_CFA_offset_extended:
10655               reg = LEB ();
10656               roffs = LEB ();
10657               if (! do_debug_frames_interp)
10658                 printf ("  DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10659                         reg, roffs * fc->data_factor);
10660               fc->col_type[reg] = DW_CFA_offset;
10661               fc->col_offset[reg] = roffs * fc->data_factor;
10662               break;
10663
10664             case DW_CFA_restore_extended:
10665               reg = LEB ();
10666               if (! do_debug_frames_interp)
10667                 printf ("  DW_CFA_restore_extended: r%ld\n", reg);
10668               fc->col_type[reg] = cie->col_type[reg];
10669               fc->col_offset[reg] = cie->col_offset[reg];
10670               break;
10671
10672             case DW_CFA_undefined:
10673               reg = LEB ();
10674               if (! do_debug_frames_interp)
10675                 printf ("  DW_CFA_undefined: r%ld\n", reg);
10676               fc->col_type[reg] = DW_CFA_undefined;
10677               fc->col_offset[reg] = 0;
10678               break;
10679
10680             case DW_CFA_same_value:
10681               reg = LEB ();
10682               if (! do_debug_frames_interp)
10683                 printf ("  DW_CFA_same_value: r%ld\n", reg);
10684               fc->col_type[reg] = DW_CFA_same_value;
10685               fc->col_offset[reg] = 0;
10686               break;
10687
10688             case DW_CFA_register:
10689               reg = LEB ();
10690               roffs = LEB ();
10691               if (! do_debug_frames_interp)
10692                 printf ("  DW_CFA_register: r%ld in r%ld\n", reg, roffs);
10693               fc->col_type[reg] = DW_CFA_register;
10694               fc->col_offset[reg] = roffs;
10695               break;
10696
10697             case DW_CFA_remember_state:
10698               if (! do_debug_frames_interp)
10699                 printf ("  DW_CFA_remember_state\n");
10700               rs = xmalloc (sizeof (Frame_Chunk));
10701               rs->ncols = fc->ncols;
10702               rs->col_type = xmalloc (rs->ncols * sizeof (short int));
10703               rs->col_offset = xmalloc (rs->ncols * sizeof (int));
10704               memcpy (rs->col_type, fc->col_type, rs->ncols);
10705               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
10706               rs->next = remembered_state;
10707               remembered_state = rs;
10708               break;
10709
10710             case DW_CFA_restore_state:
10711               if (! do_debug_frames_interp)
10712                 printf ("  DW_CFA_restore_state\n");
10713               rs = remembered_state;
10714               if (rs)
10715                 {
10716                   remembered_state = rs->next;
10717                   frame_need_space (fc, rs->ncols-1);
10718                   memcpy (fc->col_type, rs->col_type, rs->ncols);
10719                   memcpy (fc->col_offset, rs->col_offset,
10720                           rs->ncols * sizeof (int));
10721                   free (rs->col_type);
10722                   free (rs->col_offset);
10723                   free (rs);
10724                 }
10725               else if (do_debug_frames_interp)
10726                 printf ("Mismatched DW_CFA_restore_state\n");
10727               break;
10728
10729             case DW_CFA_def_cfa:
10730               fc->cfa_reg = LEB ();
10731               fc->cfa_offset = LEB ();
10732               fc->cfa_exp = 0;
10733               if (! do_debug_frames_interp)
10734                 printf ("  DW_CFA_def_cfa: r%d ofs %d\n",
10735                         fc->cfa_reg, fc->cfa_offset);
10736               break;
10737
10738             case DW_CFA_def_cfa_register:
10739               fc->cfa_reg = LEB ();
10740               fc->cfa_exp = 0;
10741               if (! do_debug_frames_interp)
10742                 printf ("  DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
10743               break;
10744
10745             case DW_CFA_def_cfa_offset:
10746               fc->cfa_offset = LEB ();
10747               if (! do_debug_frames_interp)
10748                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
10749               break;
10750
10751             case DW_CFA_nop:
10752               if (! do_debug_frames_interp)
10753                 printf ("  DW_CFA_nop\n");
10754               break;
10755
10756             case DW_CFA_def_cfa_expression:
10757               ul = LEB ();
10758               if (! do_debug_frames_interp)
10759                 {
10760                   printf ("  DW_CFA_def_cfa_expression (");
10761                   decode_location_expression (start, eh_addr_size, ul, 0);
10762                   printf (")\n");
10763                 }
10764               fc->cfa_exp = 1;
10765               start += ul;
10766               break;
10767
10768             case DW_CFA_expression:
10769               reg = LEB ();
10770               ul = LEB ();
10771               if (! do_debug_frames_interp)
10772                 {
10773                   printf ("  DW_CFA_expression: r%ld (", reg);
10774                   decode_location_expression (start, eh_addr_size, ul, 0);
10775                   printf (")\n");
10776                 }
10777               fc->col_type[reg] = DW_CFA_expression;
10778               start += ul;
10779               break;
10780
10781             case DW_CFA_offset_extended_sf:
10782               reg = LEB ();
10783               l = SLEB ();
10784               frame_need_space (fc, reg);
10785               if (! do_debug_frames_interp)
10786                 printf ("  DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10787                         reg, l * fc->data_factor);
10788               fc->col_type[reg] = DW_CFA_offset;
10789               fc->col_offset[reg] = l * fc->data_factor;
10790               break;
10791
10792             case DW_CFA_def_cfa_sf:
10793               fc->cfa_reg = LEB ();
10794               fc->cfa_offset = SLEB ();
10795               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
10796               fc->cfa_exp = 0;
10797               if (! do_debug_frames_interp)
10798                 printf ("  DW_CFA_def_cfa_sf: r%d ofs %d\n",
10799                         fc->cfa_reg, fc->cfa_offset);
10800               break;
10801
10802             case DW_CFA_def_cfa_offset_sf:
10803               fc->cfa_offset = SLEB ();
10804               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
10805               if (! do_debug_frames_interp)
10806                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
10807               break;
10808
10809             case DW_CFA_MIPS_advance_loc8:
10810               ofs = byte_get (start, 8); start += 8;
10811               if (do_debug_frames_interp)
10812                 frame_display_row (fc, &need_col_headers, &max_regs);
10813               else
10814                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10815                         ofs * fc->code_factor,
10816                         fc->pc_begin + ofs * fc->code_factor);
10817               fc->pc_begin += ofs * fc->code_factor;
10818               break;
10819
10820             case DW_CFA_GNU_window_save:
10821               if (! do_debug_frames_interp)
10822                 printf ("  DW_CFA_GNU_window_save\n");
10823               break;
10824
10825             case DW_CFA_GNU_args_size:
10826               ul = LEB ();
10827               if (! do_debug_frames_interp)
10828                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
10829               break;
10830
10831             case DW_CFA_GNU_negative_offset_extended:
10832               reg = LEB ();
10833               l = - LEB ();
10834               frame_need_space (fc, reg);
10835               if (! do_debug_frames_interp)
10836                 printf ("  DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10837                         reg, l * fc->data_factor);
10838               fc->col_type[reg] = DW_CFA_offset;
10839               fc->col_offset[reg] = l * fc->data_factor;
10840               break;
10841
10842             default:
10843               warn (_("unsupported or unknown DW_CFA_%d\n"), op);
10844               start = block_end;
10845             }
10846         }
10847
10848       if (do_debug_frames_interp)
10849         frame_display_row (fc, &need_col_headers, &max_regs);
10850
10851       start = block_end;
10852     }
10853
10854   printf ("\n");
10855
10856   return 1;
10857 }
10858
10859 #undef GET
10860 #undef LEB
10861 #undef SLEB
10862
10863 static int
10864 display_debug_not_supported (Elf_Internal_Shdr *section,
10865                              unsigned char *start ATTRIBUTE_UNUSED,
10866                              FILE *file ATTRIBUTE_UNUSED)
10867 {
10868   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10869             SECTION_NAME (section));
10870
10871   return 1;
10872 }
10873
10874 /* A structure containing the name of a debug section
10875    and a pointer to a function that can decode it.  */
10876 static struct
10877 {
10878   const char *const name;
10879   int (*display) (Elf_Internal_Shdr *, unsigned char *, FILE *);
10880 }
10881 debug_displays[] =
10882 {
10883   { ".debug_abbrev",            display_debug_abbrev },
10884   { ".debug_aranges",           display_debug_aranges },
10885   { ".debug_frame",             display_debug_frames },
10886   { ".debug_info",              display_debug_info },
10887   { ".debug_line",              display_debug_lines },
10888   { ".debug_pubnames",          display_debug_pubnames },
10889   { ".eh_frame",                display_debug_frames },
10890   { ".debug_macinfo",           display_debug_macinfo },
10891   { ".debug_str",               display_debug_str },
10892   { ".debug_loc",               display_debug_loc },
10893   { ".debug_pubtypes",          display_debug_pubnames },
10894   { ".debug_ranges",            display_debug_ranges },
10895   { ".debug_static_func",       display_debug_not_supported },
10896   { ".debug_static_vars",       display_debug_not_supported },
10897   { ".debug_types",             display_debug_not_supported },
10898   { ".debug_weaknames",         display_debug_not_supported }
10899 };
10900
10901 static int
10902 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
10903 {
10904   char *name = SECTION_NAME (section);
10905   bfd_size_type length;
10906   int result = 1;
10907   int i;
10908
10909   length = section->sh_size;
10910   if (length == 0)
10911     {
10912       printf (_("\nSection '%s' has no debugging data.\n"), name);
10913       return 0;
10914     }
10915
10916   if (strneq (name, ".gnu.linkonce.wi.", 17))
10917     name = ".debug_info";
10918
10919   /* See if we know how to display the contents of this section.  */
10920   for (i = NUM_ELEM (debug_displays); i--;)
10921     if (streq (debug_displays[i].name, name))
10922       {
10923         unsigned char *start;
10924
10925         start = get_data (NULL, file, section->sh_offset, length,
10926                           _("debug section data"));
10927         if (start == NULL)
10928           {
10929             result = 0;
10930             break;
10931           }
10932
10933         result &= debug_displays[i].display (section, start, file);
10934         free (start);
10935
10936         /* If we loaded in the abbrev section
10937            at some point, we must release it here.  */
10938         free_abbrevs ();
10939
10940         break;
10941       }
10942
10943   if (i == -1)
10944     {
10945       printf (_("Unrecognized debug section: %s\n"), name);
10946       result = 0;
10947     }
10948
10949   return result;
10950 }
10951
10952 static void
10953 process_section_contents (FILE *file)
10954 {
10955   Elf_Internal_Shdr *section;
10956   unsigned int i;
10957
10958   if (! do_dump)
10959     return;
10960
10961   for (i = 0, section = section_headers;
10962        i < elf_header.e_shnum && i < num_dump_sects;
10963        i++, section++)
10964     {
10965 #ifdef SUPPORT_DISASSEMBLY
10966       if (dump_sects[i] & DISASS_DUMP)
10967         disassemble_section (section, file);
10968 #endif
10969       if (dump_sects[i] & HEX_DUMP)
10970         dump_section (section, file);
10971
10972       if (dump_sects[i] & DEBUG_DUMP)
10973         display_debug_section (section, file);
10974     }
10975
10976   /* Check to see if the user requested a
10977      dump of a section that does not exist.  */
10978   while (i++ < num_dump_sects)
10979     if (dump_sects[i])
10980       warn (_("Section %d was not dumped because it does not exist!\n"), i);
10981 }
10982
10983 static void
10984 process_mips_fpe_exception (int mask)
10985 {
10986   if (mask)
10987     {
10988       int first = 1;
10989       if (mask & OEX_FPU_INEX)
10990         fputs ("INEX", stdout), first = 0;
10991       if (mask & OEX_FPU_UFLO)
10992         printf ("%sUFLO", first ? "" : "|"), first = 0;
10993       if (mask & OEX_FPU_OFLO)
10994         printf ("%sOFLO", first ? "" : "|"), first = 0;
10995       if (mask & OEX_FPU_DIV0)
10996         printf ("%sDIV0", first ? "" : "|"), first = 0;
10997       if (mask & OEX_FPU_INVAL)
10998         printf ("%sINVAL", first ? "" : "|");
10999     }
11000   else
11001     fputs ("0", stdout);
11002 }
11003
11004 static int
11005 process_mips_specific (FILE *file)
11006 {
11007   Elf_Internal_Dyn *entry;
11008   size_t liblist_offset = 0;
11009   size_t liblistno = 0;
11010   size_t conflictsno = 0;
11011   size_t options_offset = 0;
11012   size_t conflicts_offset = 0;
11013
11014   /* We have a lot of special sections.  Thanks SGI!  */
11015   if (dynamic_section == NULL)
11016     /* No information available.  */
11017     return 0;
11018
11019   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11020     switch (entry->d_tag)
11021       {
11022       case DT_MIPS_LIBLIST:
11023         liblist_offset
11024           = offset_from_vma (file, entry->d_un.d_val,
11025                              liblistno * sizeof (Elf32_External_Lib));
11026         break;
11027       case DT_MIPS_LIBLISTNO:
11028         liblistno = entry->d_un.d_val;
11029         break;
11030       case DT_MIPS_OPTIONS:
11031         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11032         break;
11033       case DT_MIPS_CONFLICT:
11034         conflicts_offset
11035           = offset_from_vma (file, entry->d_un.d_val,
11036                              conflictsno * sizeof (Elf32_External_Conflict));
11037         break;
11038       case DT_MIPS_CONFLICTNO:
11039         conflictsno = entry->d_un.d_val;
11040         break;
11041       default:
11042         break;
11043       }
11044
11045   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11046     {
11047       Elf32_External_Lib *elib;
11048       size_t cnt;
11049
11050       elib = get_data (NULL, file, liblist_offset,
11051                        liblistno * sizeof (Elf32_External_Lib),
11052                        _("liblist"));
11053       if (elib)
11054         {
11055           printf ("\nSection '.liblist' contains %lu entries:\n",
11056                   (unsigned long) liblistno);
11057           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
11058                  stdout);
11059
11060           for (cnt = 0; cnt < liblistno; ++cnt)
11061             {
11062               Elf32_Lib liblist;
11063               time_t time;
11064               char timebuf[20];
11065               struct tm *tmp;
11066
11067               liblist.l_name = BYTE_GET (elib[cnt].l_name);
11068               time = BYTE_GET (elib[cnt].l_time_stamp);
11069               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11070               liblist.l_version = BYTE_GET (elib[cnt].l_version);
11071               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11072
11073               tmp = gmtime (&time);
11074               snprintf (timebuf, sizeof (timebuf),
11075                         "%04u-%02u-%02uT%02u:%02u:%02u",
11076                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11077                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11078
11079               printf ("%3lu: ", (unsigned long) cnt);
11080               if (VALID_DYNAMIC_NAME (liblist.l_name))
11081                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11082               else
11083                 printf ("<corrupt: %9ld>", liblist.l_name);
11084               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11085                       liblist.l_version);
11086
11087               if (liblist.l_flags == 0)
11088                 puts (" NONE");
11089               else
11090                 {
11091                   static const struct
11092                   {
11093                     const char *name;
11094                     int bit;
11095                   }
11096                   l_flags_vals[] =
11097                   {
11098                     { " EXACT_MATCH", LL_EXACT_MATCH },
11099                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11100                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11101                     { " EXPORTS", LL_EXPORTS },
11102                     { " DELAY_LOAD", LL_DELAY_LOAD },
11103                     { " DELTA", LL_DELTA }
11104                   };
11105                   int flags = liblist.l_flags;
11106                   size_t fcnt;
11107
11108                   for (fcnt = 0;
11109                        fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
11110                        ++fcnt)
11111                     if ((flags & l_flags_vals[fcnt].bit) != 0)
11112                       {
11113                         fputs (l_flags_vals[fcnt].name, stdout);
11114                         flags ^= l_flags_vals[fcnt].bit;
11115                       }
11116                   if (flags != 0)
11117                     printf (" %#x", (unsigned int) flags);
11118
11119                   puts ("");
11120                 }
11121             }
11122
11123           free (elib);
11124         }
11125     }
11126
11127   if (options_offset != 0)
11128     {
11129       Elf_External_Options *eopt;
11130       Elf_Internal_Shdr *sect = section_headers;
11131       Elf_Internal_Options *iopt;
11132       Elf_Internal_Options *option;
11133       size_t offset;
11134       int cnt;
11135
11136       /* Find the section header so that we get the size.  */
11137       while (sect->sh_type != SHT_MIPS_OPTIONS)
11138         ++sect;
11139
11140       eopt = get_data (NULL, file, options_offset, sect->sh_size,
11141                        _("options"));
11142       if (eopt)
11143         {
11144           iopt = malloc ((sect->sh_size / sizeof (eopt)) * sizeof (*iopt));
11145           if (iopt == NULL)
11146             {
11147               error (_("Out of memory"));
11148               return 0;
11149             }
11150
11151           offset = cnt = 0;
11152           option = iopt;
11153
11154           while (offset < sect->sh_size)
11155             {
11156               Elf_External_Options *eoption;
11157
11158               eoption = (Elf_External_Options *) ((char *) eopt + offset);
11159
11160               option->kind = BYTE_GET (eoption->kind);
11161               option->size = BYTE_GET (eoption->size);
11162               option->section = BYTE_GET (eoption->section);
11163               option->info = BYTE_GET (eoption->info);
11164
11165               offset += option->size;
11166
11167               ++option;
11168               ++cnt;
11169             }
11170
11171           printf (_("\nSection '%s' contains %d entries:\n"),
11172                   SECTION_NAME (sect), cnt);
11173
11174           option = iopt;
11175
11176           while (cnt-- > 0)
11177             {
11178               size_t len;
11179
11180               switch (option->kind)
11181                 {
11182                 case ODK_NULL:
11183                   /* This shouldn't happen.  */
11184                   printf (" NULL       %d %lx", option->section, option->info);
11185                   break;
11186                 case ODK_REGINFO:
11187                   printf (" REGINFO    ");
11188                   if (elf_header.e_machine == EM_MIPS)
11189                     {
11190                       /* 32bit form.  */
11191                       Elf32_External_RegInfo *ereg;
11192                       Elf32_RegInfo reginfo;
11193
11194                       ereg = (Elf32_External_RegInfo *) (option + 1);
11195                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11196                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11197                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11198                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11199                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11200                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11201
11202                       printf ("GPR %08lx  GP 0x%lx\n",
11203                               reginfo.ri_gprmask,
11204                               (unsigned long) reginfo.ri_gp_value);
11205                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
11206                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11207                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11208                     }
11209                   else
11210                     {
11211                       /* 64 bit form.  */
11212                       Elf64_External_RegInfo *ereg;
11213                       Elf64_Internal_RegInfo reginfo;
11214
11215                       ereg = (Elf64_External_RegInfo *) (option + 1);
11216                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
11217                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11218                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11219                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11220                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11221                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
11222
11223                       printf ("GPR %08lx  GP 0x",
11224                               reginfo.ri_gprmask);
11225                       printf_vma (reginfo.ri_gp_value);
11226                       printf ("\n");
11227
11228                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
11229                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11230                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11231                     }
11232                   ++option;
11233                   continue;
11234                 case ODK_EXCEPTIONS:
11235                   fputs (" EXCEPTIONS fpe_min(", stdout);
11236                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11237                   fputs (") fpe_max(", stdout);
11238                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11239                   fputs (")", stdout);
11240
11241                   if (option->info & OEX_PAGE0)
11242                     fputs (" PAGE0", stdout);
11243                   if (option->info & OEX_SMM)
11244                     fputs (" SMM", stdout);
11245                   if (option->info & OEX_FPDBUG)
11246                     fputs (" FPDBUG", stdout);
11247                   if (option->info & OEX_DISMISS)
11248                     fputs (" DISMISS", stdout);
11249                   break;
11250                 case ODK_PAD:
11251                   fputs (" PAD       ", stdout);
11252                   if (option->info & OPAD_PREFIX)
11253                     fputs (" PREFIX", stdout);
11254                   if (option->info & OPAD_POSTFIX)
11255                     fputs (" POSTFIX", stdout);
11256                   if (option->info & OPAD_SYMBOL)
11257                     fputs (" SYMBOL", stdout);
11258                   break;
11259                 case ODK_HWPATCH:
11260                   fputs (" HWPATCH   ", stdout);
11261                   if (option->info & OHW_R4KEOP)
11262                     fputs (" R4KEOP", stdout);
11263                   if (option->info & OHW_R8KPFETCH)
11264                     fputs (" R8KPFETCH", stdout);
11265                   if (option->info & OHW_R5KEOP)
11266                     fputs (" R5KEOP", stdout);
11267                   if (option->info & OHW_R5KCVTL)
11268                     fputs (" R5KCVTL", stdout);
11269                   break;
11270                 case ODK_FILL:
11271                   fputs (" FILL       ", stdout);
11272                   /* XXX Print content of info word?  */
11273                   break;
11274                 case ODK_TAGS:
11275                   fputs (" TAGS       ", stdout);
11276                   /* XXX Print content of info word?  */
11277                   break;
11278                 case ODK_HWAND:
11279                   fputs (" HWAND     ", stdout);
11280                   if (option->info & OHWA0_R4KEOP_CHECKED)
11281                     fputs (" R4KEOP_CHECKED", stdout);
11282                   if (option->info & OHWA0_R4KEOP_CLEAN)
11283                     fputs (" R4KEOP_CLEAN", stdout);
11284                   break;
11285                 case ODK_HWOR:
11286                   fputs (" HWOR      ", stdout);
11287                   if (option->info & OHWA0_R4KEOP_CHECKED)
11288                     fputs (" R4KEOP_CHECKED", stdout);
11289                   if (option->info & OHWA0_R4KEOP_CLEAN)
11290                     fputs (" R4KEOP_CLEAN", stdout);
11291                   break;
11292                 case ODK_GP_GROUP:
11293                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
11294                           option->info & OGP_GROUP,
11295                           (option->info & OGP_SELF) >> 16);
11296                   break;
11297                 case ODK_IDENT:
11298                   printf (" IDENT     %#06lx  self-contained %#06lx",
11299                           option->info & OGP_GROUP,
11300                           (option->info & OGP_SELF) >> 16);
11301                   break;
11302                 default:
11303                   /* This shouldn't happen.  */
11304                   printf (" %3d ???     %d %lx",
11305                           option->kind, option->section, option->info);
11306                   break;
11307                 }
11308
11309               len = sizeof (*eopt);
11310               while (len < option->size)
11311                 if (((char *) option)[len] >= ' '
11312                     && ((char *) option)[len] < 0x7f)
11313                   printf ("%c", ((char *) option)[len++]);
11314                 else
11315                   printf ("\\%03o", ((char *) option)[len++]);
11316
11317               fputs ("\n", stdout);
11318               ++option;
11319             }
11320
11321           free (eopt);
11322         }
11323     }
11324
11325   if (conflicts_offset != 0 && conflictsno != 0)
11326     {
11327       Elf32_Conflict *iconf;
11328       size_t cnt;
11329
11330       if (dynamic_symbols == NULL)
11331         {
11332           error (_("conflict list found without a dynamic symbol table"));
11333           return 0;
11334         }
11335
11336       iconf = malloc (conflictsno * sizeof (*iconf));
11337       if (iconf == NULL)
11338         {
11339           error (_("Out of memory"));
11340           return 0;
11341         }
11342
11343       if (is_32bit_elf)
11344         {
11345           Elf32_External_Conflict *econf32;
11346
11347           econf32 = get_data (NULL, file, conflicts_offset,
11348                               conflictsno * sizeof (*econf32), _("conflict"));
11349           if (!econf32)
11350             return 0;
11351
11352           for (cnt = 0; cnt < conflictsno; ++cnt)
11353             iconf[cnt] = BYTE_GET (econf32[cnt]);
11354
11355           free (econf32);
11356         }
11357       else
11358         {
11359           Elf64_External_Conflict *econf64;
11360
11361           econf64 = get_data (NULL, file, conflicts_offset,
11362                               conflictsno * sizeof (*econf64), _("conflict"));
11363           if (!econf64)
11364             return 0;
11365
11366           for (cnt = 0; cnt < conflictsno; ++cnt)
11367             iconf[cnt] = BYTE_GET (econf64[cnt]);
11368
11369           free (econf64);
11370         }
11371
11372       printf (_("\nSection '.conflict' contains %lu entries:\n"),
11373               (unsigned long) conflictsno);
11374       puts (_("  Num:    Index       Value  Name"));
11375
11376       for (cnt = 0; cnt < conflictsno; ++cnt)
11377         {
11378           Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
11379
11380           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
11381           print_vma (psym->st_value, FULL_HEX);
11382           putchar (' ');
11383           if (VALID_DYNAMIC_NAME (psym->st_name))
11384             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11385           else
11386             printf ("<corrupt: %14ld>", psym->st_name);
11387           putchar ('\n');
11388         }
11389
11390       free (iconf);
11391     }
11392
11393   return 1;
11394 }
11395
11396 static int
11397 process_gnu_liblist (FILE *file)
11398 {
11399   Elf_Internal_Shdr *section, *string_sec;
11400   Elf32_External_Lib *elib;
11401   char *strtab;
11402   size_t cnt;
11403   unsigned i;
11404
11405   if (! do_arch)
11406     return 0;
11407
11408   for (i = 0, section = section_headers;
11409        i < elf_header.e_shnum;
11410        i++, section++)
11411     {
11412       switch (section->sh_type)
11413         {
11414         case SHT_GNU_LIBLIST:
11415           elib = get_data (NULL, file, section->sh_offset, section->sh_size,
11416                            _("liblist"));
11417
11418           if (elib == NULL)
11419             break;
11420           string_sec = SECTION_HEADER (section->sh_link);
11421
11422           strtab = get_data (NULL, file, string_sec->sh_offset,
11423                              string_sec->sh_size, _("liblist string table"));
11424
11425           if (strtab == NULL
11426               || section->sh_entsize != sizeof (Elf32_External_Lib))
11427             {
11428               free (elib);
11429               break;
11430             }
11431
11432           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11433                   SECTION_NAME (section),
11434                   (long) (section->sh_size / sizeof (Elf32_External_Lib)));
11435
11436           puts ("     Library              Time Stamp          Checksum   Version Flags");
11437
11438           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11439                ++cnt)
11440             {
11441               Elf32_Lib liblist;
11442               time_t time;
11443               char timebuf[20];
11444               struct tm *tmp;
11445
11446               liblist.l_name = BYTE_GET (elib[cnt].l_name);
11447               time = BYTE_GET (elib[cnt].l_time_stamp);
11448               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11449               liblist.l_version = BYTE_GET (elib[cnt].l_version);
11450               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11451
11452               tmp = gmtime (&time);
11453               snprintf (timebuf, sizeof (timebuf),
11454                         "%04u-%02u-%02uT%02u:%02u:%02u",
11455                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11456                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11457
11458               printf ("%3lu: ", (unsigned long) cnt);
11459               if (do_wide)
11460                 printf ("%-20s", strtab + liblist.l_name);
11461               else
11462                 printf ("%-20.20s", strtab + liblist.l_name);
11463               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11464                       liblist.l_version, liblist.l_flags);
11465             }
11466
11467           free (elib);
11468         }
11469     }
11470
11471   return 1;
11472 }
11473
11474 static const char *
11475 get_note_type (unsigned e_type)
11476 {
11477   static char buff[64];
11478
11479   if (elf_header.e_type == ET_CORE)
11480     switch (e_type)
11481       {
11482       case NT_AUXV:
11483         return _("NT_AUXV (auxiliary vector)");
11484       case NT_PRSTATUS:
11485         return _("NT_PRSTATUS (prstatus structure)");
11486       case NT_FPREGSET:
11487         return _("NT_FPREGSET (floating point registers)");
11488       case NT_PRPSINFO:
11489         return _("NT_PRPSINFO (prpsinfo structure)");
11490       case NT_TASKSTRUCT:
11491         return _("NT_TASKSTRUCT (task structure)");
11492       case NT_PRXFPREG:
11493         return _("NT_PRXFPREG (user_xfpregs structure)");
11494       case NT_PSTATUS:
11495         return _("NT_PSTATUS (pstatus structure)");
11496       case NT_FPREGS:
11497         return _("NT_FPREGS (floating point registers)");
11498       case NT_PSINFO:
11499         return _("NT_PSINFO (psinfo structure)");
11500       case NT_LWPSTATUS:
11501         return _("NT_LWPSTATUS (lwpstatus_t structure)");
11502       case NT_LWPSINFO:
11503         return _("NT_LWPSINFO (lwpsinfo_t structure)");
11504       case NT_WIN32PSTATUS:
11505         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11506       default:
11507         break;
11508       }
11509   else
11510     switch (e_type)
11511       {
11512       case NT_VERSION:
11513         return _("NT_VERSION (version)");
11514       case NT_ARCH:
11515         return _("NT_ARCH (architecture)");
11516       default:
11517         break;
11518       }
11519
11520   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11521   return buff;
11522 }
11523
11524 static const char *
11525 get_netbsd_elfcore_note_type (unsigned e_type)
11526 {
11527   static char buff[64];
11528
11529   if (e_type == NT_NETBSDCORE_PROCINFO)
11530     {
11531       /* NetBSD core "procinfo" structure.  */
11532       return _("NetBSD procinfo structure");
11533     }
11534
11535   /* As of Jan 2002 there are no other machine-independent notes
11536      defined for NetBSD core files.  If the note type is less
11537      than the start of the machine-dependent note types, we don't
11538      understand it.  */
11539
11540   if (e_type < NT_NETBSDCORE_FIRSTMACH)
11541     {
11542       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11543       return buff;
11544     }
11545
11546   switch (elf_header.e_machine)
11547     {
11548     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11549        and PT_GETFPREGS == mach+2.  */
11550
11551     case EM_OLD_ALPHA:
11552     case EM_ALPHA:
11553     case EM_SPARC:
11554     case EM_SPARC32PLUS:
11555     case EM_SPARCV9:
11556       switch (e_type)
11557         {
11558         case NT_NETBSDCORE_FIRSTMACH+0:
11559           return _("PT_GETREGS (reg structure)");
11560         case NT_NETBSDCORE_FIRSTMACH+2:
11561           return _("PT_GETFPREGS (fpreg structure)");
11562         default:
11563           break;
11564         }
11565       break;
11566
11567     /* On all other arch's, PT_GETREGS == mach+1 and
11568        PT_GETFPREGS == mach+3.  */
11569     default:
11570       switch (e_type)
11571         {
11572         case NT_NETBSDCORE_FIRSTMACH+1:
11573           return _("PT_GETREGS (reg structure)");
11574         case NT_NETBSDCORE_FIRSTMACH+3:
11575           return _("PT_GETFPREGS (fpreg structure)");
11576         default:
11577           break;
11578         }
11579     }
11580
11581   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
11582             e_type - NT_NETBSDCORE_FIRSTMACH);
11583   return buff;
11584 }
11585
11586 /* Note that by the ELF standard, the name field is already null byte
11587    terminated, and namesz includes the terminating null byte.
11588    I.E. the value of namesz for the name "FSF" is 4.
11589
11590    If the value of namesz is zero, there is no name present.  */
11591 static int
11592 process_note (Elf_Internal_Note *pnote)
11593 {
11594   const char *nt;
11595
11596   if (pnote->namesz == 0)
11597     /* If there is no note name, then use the default set of
11598        note type strings.  */
11599     nt = get_note_type (pnote->type);
11600
11601   else if (strneq (pnote->namedata, "NetBSD-CORE", 11))
11602     /* NetBSD-specific core file notes.  */
11603     nt = get_netbsd_elfcore_note_type (pnote->type);
11604
11605   else
11606     /* Don't recognize this note name; just use the default set of
11607        note type strings.  */
11608       nt = get_note_type (pnote->type);
11609
11610   printf ("  %s\t\t0x%08lx\t%s\n",
11611           pnote->namesz ? pnote->namedata : "(NONE)",
11612           pnote->descsz, nt);
11613   return 1;
11614 }
11615
11616
11617 static int
11618 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
11619 {
11620   Elf_External_Note *pnotes;
11621   Elf_External_Note *external;
11622   int res = 1;
11623
11624   if (length <= 0)
11625     return 0;
11626
11627   pnotes = get_data (NULL, file, offset, length, _("notes"));
11628   if (!pnotes)
11629     return 0;
11630
11631   external = pnotes;
11632
11633   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11634           (unsigned long) offset, (unsigned long) length);
11635   printf (_("  Owner\t\tData size\tDescription\n"));
11636
11637   while (external < (Elf_External_Note *)((char *) pnotes + length))
11638     {
11639       Elf_External_Note *next;
11640       Elf_Internal_Note inote;
11641       char *temp = NULL;
11642
11643       inote.type     = BYTE_GET (external->type);
11644       inote.namesz   = BYTE_GET (external->namesz);
11645       inote.namedata = external->name;
11646       inote.descsz   = BYTE_GET (external->descsz);
11647       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
11648       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
11649
11650       next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
11651
11652       if (((char *) next) > (((char *) pnotes) + length))
11653         {
11654           warn (_("corrupt note found at offset %x into core notes\n"),
11655                 ((char *) external) - ((char *) pnotes));
11656           warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11657                 inote.type, inote.namesz, inote.descsz);
11658           break;
11659         }
11660
11661       external = next;
11662
11663       /* Verify that name is null terminated.  It appears that at least
11664          one version of Linux (RedHat 6.0) generates corefiles that don't
11665          comply with the ELF spec by failing to include the null byte in
11666          namesz.  */
11667       if (inote.namedata[inote.namesz] != '\0')
11668         {
11669           temp = malloc (inote.namesz + 1);
11670
11671           if (temp == NULL)
11672             {
11673               error (_("Out of memory\n"));
11674               res = 0;
11675               break;
11676             }
11677
11678           strncpy (temp, inote.namedata, inote.namesz);
11679           temp[inote.namesz] = 0;
11680
11681           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
11682           inote.namedata = temp;
11683         }
11684
11685       res &= process_note (& inote);
11686
11687       if (temp != NULL)
11688         {
11689           free (temp);
11690           temp = NULL;
11691         }
11692     }
11693
11694   free (pnotes);
11695
11696   return res;
11697 }
11698
11699 static int
11700 process_corefile_note_segments (FILE *file)
11701 {
11702   Elf_Internal_Phdr *segment;
11703   unsigned int i;
11704   int res = 1;
11705
11706   if (! get_program_headers (file))
11707       return 0;
11708
11709   for (i = 0, segment = program_headers;
11710        i < elf_header.e_phnum;
11711        i++, segment++)
11712     {
11713       if (segment->p_type == PT_NOTE)
11714         res &= process_corefile_note_segment (file,
11715                                               (bfd_vma) segment->p_offset,
11716                                               (bfd_vma) segment->p_filesz);
11717     }
11718
11719   return res;
11720 }
11721
11722 static int
11723 process_note_sections (FILE *file)
11724 {
11725   Elf_Internal_Shdr *section;
11726   unsigned long i;
11727   int res = 1;
11728
11729   for (i = 0, section = section_headers;
11730        i < elf_header.e_shnum;
11731        i++, section++)
11732     if (section->sh_type == SHT_NOTE)
11733       res &= process_corefile_note_segment (file,
11734                                             (bfd_vma) section->sh_offset,
11735                                             (bfd_vma) section->sh_size);
11736
11737   return res;
11738 }
11739
11740 static int
11741 process_notes (FILE *file)
11742 {
11743   /* If we have not been asked to display the notes then do nothing.  */
11744   if (! do_notes)
11745     return 1;
11746
11747   if (elf_header.e_type != ET_CORE)
11748     return process_note_sections (file);
11749
11750   /* No program headers means no NOTE segment.  */
11751   if (elf_header.e_phnum > 0)
11752     return process_corefile_note_segments (file);
11753
11754   printf (_("No note segments present in the core file.\n"));
11755   return 1;
11756 }
11757
11758 static int
11759 process_arch_specific (FILE *file)
11760 {
11761   if (! do_arch)
11762     return 1;
11763
11764   switch (elf_header.e_machine)
11765     {
11766     case EM_MIPS:
11767     case EM_MIPS_RS3_LE:
11768       return process_mips_specific (file);
11769       break;
11770     default:
11771       break;
11772     }
11773   return 1;
11774 }
11775
11776 static int
11777 get_file_header (FILE *file)
11778 {
11779   /* Read in the identity array.  */
11780   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
11781     return 0;
11782
11783   /* Determine how to read the rest of the header.  */
11784   switch (elf_header.e_ident[EI_DATA])
11785     {
11786     default: /* fall through */
11787     case ELFDATANONE: /* fall through */
11788     case ELFDATA2LSB:
11789       byte_get = byte_get_little_endian;
11790       byte_put = byte_put_little_endian;
11791       break;
11792     case ELFDATA2MSB:
11793       byte_get = byte_get_big_endian;
11794       byte_put = byte_put_big_endian;
11795       break;
11796     }
11797
11798   /* For now we only support 32 bit and 64 bit ELF files.  */
11799   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
11800
11801   /* Read in the rest of the header.  */
11802   if (is_32bit_elf)
11803     {
11804       Elf32_External_Ehdr ehdr32;
11805
11806       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
11807         return 0;
11808
11809       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
11810       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
11811       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
11812       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
11813       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
11814       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
11815       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
11816       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
11817       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
11818       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
11819       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
11820       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
11821       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
11822     }
11823   else
11824     {
11825       Elf64_External_Ehdr ehdr64;
11826
11827       /* If we have been compiled with sizeof (bfd_vma) == 4, then
11828          we will not be able to cope with the 64bit data found in
11829          64 ELF files.  Detect this now and abort before we start
11830          overwriting things.  */
11831       if (sizeof (bfd_vma) < 8)
11832         {
11833           error (_("This instance of readelf has been built without support for a\n\
11834 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11835           return 0;
11836         }
11837
11838       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
11839         return 0;
11840
11841       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
11842       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
11843       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
11844       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
11845       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
11846       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
11847       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
11848       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
11849       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
11850       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
11851       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
11852       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
11853       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
11854     }
11855
11856   if (elf_header.e_shoff)
11857     {
11858       /* There may be some extensions in the first section header.  Don't
11859          bomb if we can't read it.  */
11860       if (is_32bit_elf)
11861         get_32bit_section_headers (file, 1);
11862       else
11863         get_64bit_section_headers (file, 1);
11864     }
11865
11866   return 1;
11867 }
11868
11869 /* Process one ELF object file according to the command line options.
11870    This file may actually be stored in an archive.  The file is
11871    positioned at the start of the ELF object.  */
11872
11873 static int
11874 process_object (char *file_name, FILE *file)
11875 {
11876   unsigned int i;
11877
11878   if (! get_file_header (file))
11879     {
11880       error (_("%s: Failed to read file header\n"), file_name);
11881       return 1;
11882     }
11883
11884   /* Initialise per file variables.  */
11885   for (i = NUM_ELEM (version_info); i--;)
11886     version_info[i] = 0;
11887
11888   for (i = NUM_ELEM (dynamic_info); i--;)
11889     dynamic_info[i] = 0;
11890
11891   /* Process the file.  */
11892   if (show_name)
11893     printf (_("\nFile: %s\n"), file_name);
11894
11895   /* Initialise the dump_sects array from the cmdline_dump_sects array.
11896      Note we do this even if cmdline_dump_sects is empty because we
11897      must make sure that the dump_sets array is zeroed out before each
11898      object file is processed.  */
11899   if (num_dump_sects > num_cmdline_dump_sects)
11900     memset (dump_sects, 0, num_dump_sects);
11901
11902   if (num_cmdline_dump_sects > 0)
11903     {
11904       if (num_dump_sects == 0)
11905         /* A sneaky way of allocating the dump_sects array.  */
11906         request_dump (num_cmdline_dump_sects, 0);
11907
11908       assert (num_dump_sects >= num_cmdline_dump_sects);
11909       memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
11910     }
11911
11912   if (! process_file_header ())
11913     return 1;
11914
11915   if (! process_section_headers (file))
11916     {
11917       /* Without loaded section headers we cannot process lots of
11918          things.  */
11919       do_unwind = do_version = do_dump = do_arch = 0;
11920
11921       if (! do_using_dynamic)
11922         do_syms = do_reloc = 0;
11923     }
11924
11925   if (! process_section_groups (file))
11926     {
11927       /* Without loaded section groups we cannot process unwind.  */
11928       do_unwind = 0;
11929     }
11930
11931   if (process_program_headers (file))
11932     process_dynamic_section (file);
11933
11934   process_relocs (file);
11935
11936   process_unwind (file);
11937
11938   process_symbol_table (file);
11939
11940   process_syminfo (file);
11941
11942   process_version_sections (file);
11943
11944   process_section_contents (file);
11945
11946   process_notes (file);
11947
11948   process_gnu_liblist (file);
11949
11950   process_arch_specific (file);
11951
11952   if (program_headers)
11953     {
11954       free (program_headers);
11955       program_headers = NULL;
11956     }
11957
11958   if (section_headers)
11959     {
11960       free (section_headers);
11961       section_headers = NULL;
11962     }
11963
11964   if (string_table)
11965     {
11966       free (string_table);
11967       string_table = NULL;
11968       string_table_length = 0;
11969     }
11970
11971   if (dynamic_strings)
11972     {
11973       free (dynamic_strings);
11974       dynamic_strings = NULL;
11975       dynamic_strings_length = 0;
11976     }
11977
11978   if (dynamic_symbols)
11979     {
11980       free (dynamic_symbols);
11981       dynamic_symbols = NULL;
11982       num_dynamic_syms = 0;
11983     }
11984
11985   if (dynamic_syminfo)
11986     {
11987       free (dynamic_syminfo);
11988       dynamic_syminfo = NULL;
11989     }
11990
11991   if (section_headers_groups)
11992     {
11993       free (section_headers_groups);
11994       section_headers_groups = NULL;
11995     }
11996
11997   if (section_groups)
11998     {
11999       struct group_list *g, *next;
12000
12001       for (i = 0; i < group_count; i++)
12002         {
12003           for (g = section_groups [i].root; g != NULL; g = next)
12004             {
12005               next = g->next;
12006               free (g);
12007             }
12008         }
12009
12010       free (section_groups);
12011       section_groups = NULL;
12012     }
12013
12014   if (debug_information)
12015     {
12016       for (i = 0; i < num_debug_info_entries; i++)
12017         {
12018           if (!debug_information [i].max_loc_offsets)
12019             {
12020               free (debug_information [i].loc_offsets);
12021               free (debug_information [i].have_frame_base);
12022             }
12023           if (!debug_information [i].max_range_lists)
12024             free (debug_information [i].range_lists);
12025         }
12026       free (debug_information);
12027       debug_information = NULL;
12028       num_debug_info_entries = 0;
12029     }
12030
12031   return 0;
12032 }
12033
12034 /* Process an ELF archive.  The file is positioned just after the
12035    ARMAG string.  */
12036
12037 static int
12038 process_archive (char *file_name, FILE *file)
12039 {
12040   struct ar_hdr arhdr;
12041   size_t got;
12042   unsigned long size;
12043   char *longnames = NULL;
12044   unsigned long longnames_size = 0;
12045   size_t file_name_size;
12046   int ret;
12047
12048   show_name = 1;
12049
12050   got = fread (&arhdr, 1, sizeof arhdr, file);
12051   if (got != sizeof arhdr)
12052     {
12053       if (got == 0)
12054         return 0;
12055
12056       error (_("%s: failed to read archive header\n"), file_name);
12057       return 1;
12058     }
12059
12060   if (memcmp (arhdr.ar_name, "/               ", 16) == 0)
12061     {
12062       /* This is the archive symbol table.  Skip it.
12063          FIXME: We should have an option to dump it.  */
12064       size = strtoul (arhdr.ar_size, NULL, 10);
12065       if (fseek (file, size + (size & 1), SEEK_CUR) != 0)
12066         {
12067           error (_("%s: failed to skip archive symbol table\n"), file_name);
12068           return 1;
12069         }
12070
12071       got = fread (&arhdr, 1, sizeof arhdr, file);
12072       if (got != sizeof arhdr)
12073         {
12074           if (got == 0)
12075             return 0;
12076
12077           error (_("%s: failed to read archive header\n"), file_name);
12078           return 1;
12079         }
12080     }
12081
12082   if (memcmp (arhdr.ar_name, "//              ", 16) == 0)
12083     {
12084       /* This is the archive string table holding long member
12085          names.  */
12086
12087       longnames_size = strtoul (arhdr.ar_size, NULL, 10);
12088
12089       longnames = malloc (longnames_size);
12090       if (longnames == NULL)
12091         {
12092           error (_("Out of memory\n"));
12093           return 1;
12094         }
12095
12096       if (fread (longnames, longnames_size, 1, file) != 1)
12097         {
12098           free (longnames);
12099           error (_("%s: failed to read string table\n"), file_name);
12100           return 1;
12101         }
12102
12103       if ((longnames_size & 1) != 0)
12104         getc (file);
12105
12106       got = fread (&arhdr, 1, sizeof arhdr, file);
12107       if (got != sizeof arhdr)
12108         {
12109           free (longnames);
12110
12111           if (got == 0)
12112             return 0;
12113
12114           error (_("%s: failed to read archive header\n"), file_name);
12115           return 1;
12116         }
12117     }
12118
12119   file_name_size = strlen (file_name);
12120   ret = 0;
12121
12122   while (1)
12123     {
12124       char *name;
12125       char *nameend;
12126       char *namealc;
12127
12128       if (arhdr.ar_name[0] == '/')
12129         {
12130           unsigned long off;
12131
12132           off = strtoul (arhdr.ar_name + 1, NULL, 10);
12133           if (off >= longnames_size)
12134             {
12135               error (_("%s: invalid archive string table offset %lu\n"), off);
12136               ret = 1;
12137               break;
12138             }
12139
12140           name = longnames + off;
12141           nameend = memchr (name, '/', longnames_size - off);
12142         }
12143       else
12144         {
12145           name = arhdr.ar_name;
12146           nameend = memchr (name, '/', 16);
12147         }
12148
12149       if (nameend == NULL)
12150         {
12151           error (_("%s: bad archive file name\n"));
12152           ret = 1;
12153           break;
12154         }
12155
12156       namealc = malloc (file_name_size + (nameend - name) + 3);
12157       if (namealc == NULL)
12158         {
12159           error (_("Out of memory\n"));
12160           ret = 1;
12161           break;
12162         }
12163
12164       memcpy (namealc, file_name, file_name_size);
12165       namealc[file_name_size] = '(';
12166       memcpy (namealc + file_name_size + 1, name, nameend - name);
12167       namealc[file_name_size + 1 + (nameend - name)] = ')';
12168       namealc[file_name_size + 2 + (nameend - name)] = '\0';
12169
12170       archive_file_offset = ftell (file);
12171       archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
12172
12173       ret |= process_object (namealc, file);
12174
12175       free (namealc);
12176
12177       if (fseek (file,
12178                  (archive_file_offset
12179                   + archive_file_size
12180                   + (archive_file_size & 1)),
12181                  SEEK_SET) != 0)
12182         {
12183           error (_("%s: failed to seek to next archive header\n"), file_name);
12184           ret = 1;
12185           break;
12186         }
12187
12188       got = fread (&arhdr, 1, sizeof arhdr, file);
12189       if (got != sizeof arhdr)
12190         {
12191           if (got == 0)
12192             break;
12193
12194           error (_("%s: failed to read archive header\n"), file_name);
12195           ret = 1;
12196           break;
12197         }
12198     }
12199
12200   if (longnames != 0)
12201     free (longnames);
12202
12203   return ret;
12204 }
12205
12206 static int
12207 process_file (char *file_name)
12208 {
12209   FILE *file;
12210   struct stat statbuf;
12211   char armag[SARMAG];
12212   int ret;
12213
12214   if (stat (file_name, &statbuf) < 0)
12215     {
12216       if (errno == ENOENT)
12217         error (_("'%s': No such file\n"), file_name);
12218       else
12219         error (_("Could not locate '%s'.  System error message: %s\n"),
12220                file_name, strerror (errno));
12221       return 1;
12222     }
12223
12224   if (! S_ISREG (statbuf.st_mode))
12225     {
12226       error (_("'%s' is not an ordinary file\n"), file_name);
12227       return 1;
12228     }
12229
12230   file = fopen (file_name, "rb");
12231   if (file == NULL)
12232     {
12233       error (_("Input file '%s' is not readable.\n"), file_name);
12234       return 1;
12235     }
12236
12237   if (fread (armag, SARMAG, 1, file) != 1)
12238     {
12239       error (_("%s: Failed to read file header\n"), file_name);
12240       fclose (file);
12241       return 1;
12242     }
12243
12244   if (memcmp (armag, ARMAG, SARMAG) == 0)
12245     ret = process_archive (file_name, file);
12246   else
12247     {
12248       rewind (file);
12249       archive_file_size = archive_file_offset = 0;
12250       ret = process_object (file_name, file);
12251     }
12252
12253   fclose (file);
12254
12255   return ret;
12256 }
12257
12258 #ifdef SUPPORT_DISASSEMBLY
12259 /* Needed by the i386 disassembler.  For extra credit, someone could
12260    fix this so that we insert symbolic addresses here, esp for GOT/PLT
12261    symbols.  */
12262
12263 void
12264 print_address (unsigned int addr, FILE *outfile)
12265 {
12266   fprintf (outfile,"0x%8.8x", addr);
12267 }
12268
12269 /* Needed by the i386 disassembler.  */
12270 void
12271 db_task_printsym (unsigned int addr)
12272 {
12273   print_address (addr, stderr);
12274 }
12275 #endif
12276
12277 int
12278 main (int argc, char **argv)
12279 {
12280   int err;
12281
12282 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12283   setlocale (LC_MESSAGES, "");
12284 #endif
12285 #if defined (HAVE_SETLOCALE)
12286   setlocale (LC_CTYPE, "");
12287 #endif
12288   bindtextdomain (PACKAGE, LOCALEDIR);
12289   textdomain (PACKAGE);
12290
12291   parse_args (argc, argv);
12292
12293   if (num_dump_sects > 0)
12294     {
12295       /* Make a copy of the dump_sects array.  */
12296       cmdline_dump_sects = malloc (num_dump_sects);
12297       if (cmdline_dump_sects == NULL)
12298         error (_("Out of memory allocating dump request table."));
12299       else
12300         {
12301           memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
12302           num_cmdline_dump_sects = num_dump_sects;
12303         }
12304     }
12305
12306   if (optind < (argc - 1))
12307     show_name = 1;
12308
12309   err = 0;
12310   while (optind < argc)
12311     err |= process_file (argv[optind++]);
12312
12313   if (dump_sects != NULL)
12314     free (dump_sects);
12315   if (cmdline_dump_sects != NULL)
12316     free (cmdline_dump_sects);
12317
12318   return err;
12319 }