binutils/readelf.c

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