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