binutils/readelf.c

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