binutils/readelf.c

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