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