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         snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6906       else
6907         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6908       return buff;
6909     }
6910 }
6911
6912 static const char *
6913 get_symbol_type (unsigned int type)
6914 {
6915   static char buff[32];
6916
6917   switch (type)
6918     {
6919     case STT_NOTYPE:    return "NOTYPE";
6920     case STT_OBJECT:    return "OBJECT";
6921     case STT_FUNC:      return "FUNC";
6922     case STT_SECTION:   return "SECTION";
6923     case STT_FILE:      return "FILE";
6924     case STT_COMMON:    return "COMMON";
6925     case STT_TLS:       return "TLS";
6926     case STT_RELC:      return "RELC";
6927     case STT_SRELC:     return "SRELC";
6928     default:
6929       if (type >= STT_LOPROC && type <= STT_HIPROC)
6930         {
6931           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
6932             return "THUMB_FUNC";
6933
6934           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
6935             return "REGISTER";
6936
6937           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
6938             return "PARISC_MILLI";
6939
6940           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
6941         }
6942       else if (type >= STT_LOOS && type <= STT_HIOS)
6943         {
6944           if (elf_header.e_machine == EM_PARISC)
6945             {
6946               if (type == STT_HP_OPAQUE)
6947                 return "HP_OPAQUE";
6948               if (type == STT_HP_STUB)
6949                 return "HP_STUB";
6950             }
6951
6952           if (type == STT_GNU_IFUNC
6953               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
6954                   /* GNU/Linux is still using the default value 0.  */
6955                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
6956             return "IFUNC";
6957
6958           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
6959         }
6960       else
6961         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
6962       return buff;
6963     }
6964 }
6965
6966 static const char *
6967 get_symbol_visibility (unsigned int visibility)
6968 {
6969   switch (visibility)
6970     {
6971     case STV_DEFAULT:   return "DEFAULT";
6972     case STV_INTERNAL:  return "INTERNAL";
6973     case STV_HIDDEN:    return "HIDDEN";
6974     case STV_PROTECTED: return "PROTECTED";
6975     default: abort ();
6976     }
6977 }
6978
6979 static const char *
6980 get_mips_symbol_other (unsigned int other)
6981 {
6982   switch (other)
6983     {
6984     case STO_OPTIONAL:  return "OPTIONAL";
6985     case STO_MIPS16:    return "MIPS16";
6986     case STO_MIPS_PLT:  return "MIPS PLT";
6987     case STO_MIPS_PIC:  return "MIPS PIC";
6988     default:            return NULL;
6989     }
6990 }
6991
6992 static const char *
6993 get_symbol_other (unsigned int other)
6994 {
6995   const char * result = NULL;
6996   static char buff [32];
6997
6998   if (other == 0)
6999     return "";
7000
7001   switch (elf_header.e_machine)
7002     {
7003     case EM_MIPS:
7004       result = get_mips_symbol_other (other);
7005     default:
7006       break;
7007     }
7008
7009   if (result)
7010     return result;
7011
7012   snprintf (buff, sizeof buff, _("<other>: %x"), other);
7013   return buff;
7014 }
7015
7016 static const char *
7017 get_symbol_index_type (unsigned int type)
7018 {
7019   static char buff[32];
7020
7021   switch (type)
7022     {
7023     case SHN_UNDEF:     return "UND";
7024     case SHN_ABS:       return "ABS";
7025     case SHN_COMMON:    return "COM";
7026     default:
7027       if (type == SHN_IA_64_ANSI_COMMON
7028           && elf_header.e_machine == EM_IA_64
7029           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7030         return "ANSI_COM";
7031       else if (elf_header.e_machine == EM_X86_64
7032                && type == SHN_X86_64_LCOMMON)
7033         return "LARGE_COM";
7034       else if (type == SHN_MIPS_SCOMMON
7035                && elf_header.e_machine == EM_MIPS)
7036         return "SCOM";
7037       else if (type == SHN_MIPS_SUNDEFINED
7038                && elf_header.e_machine == EM_MIPS)
7039         return "SUND";
7040       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
7041         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
7042       else if (type >= SHN_LOOS && type <= SHN_HIOS)
7043         sprintf (buff, "OS [0x%04x]", type & 0xffff);
7044       else if (type >= SHN_LORESERVE)
7045         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
7046       else
7047         sprintf (buff, "%3d", type);
7048       break;
7049     }
7050
7051   return buff;
7052 }
7053
7054 static bfd_vma *
7055 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
7056 {
7057   unsigned char * e_data;
7058   bfd_vma * i_data;
7059
7060   e_data = cmalloc (number, ent_size);
7061
7062   if (e_data == NULL)
7063     {
7064       error (_("Out of memory\n"));
7065       return NULL;
7066     }
7067
7068   if (fread (e_data, ent_size, number, file) != number)
7069     {
7070       error (_("Unable to read in dynamic data\n"));
7071       return NULL;
7072     }
7073
7074   i_data = cmalloc (number, sizeof (*i_data));
7075
7076   if (i_data == NULL)
7077     {
7078       error (_("Out of memory\n"));
7079       free (e_data);
7080       return NULL;
7081     }
7082
7083   while (number--)
7084     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7085
7086   free (e_data);
7087
7088   return i_data;
7089 }
7090
7091 static void
7092 print_dynamic_symbol (bfd_vma si, unsigned long hn)
7093 {
7094   Elf_Internal_Sym * psym;
7095   int n;
7096
7097   psym = dynamic_symbols + si;
7098
7099   n = print_vma (si, DEC_5);
7100   if (n < 5)
7101     fputs ("     " + n, stdout);
7102   printf (" %3lu: ", hn);
7103   print_vma (psym->st_value, LONG_HEX);
7104   putchar (' ');
7105   print_vma (psym->st_size, DEC_5);
7106
7107   printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7108   printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7109   printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7110   /* Check to see if any other bits in the st_other field are set.
7111      Note - displaying this information disrupts the layout of the
7112      table being generated, but for the moment this case is very
7113      rare.  */
7114   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7115     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7116   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7117   if (VALID_DYNAMIC_NAME (psym->st_name))
7118     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7119   else
7120     printf (" <corrupt: %14ld>", psym->st_name);
7121   putchar ('\n');
7122 }
7123
7124 /* Dump the symbol table.  */
7125 static int
7126 process_symbol_table (FILE * file)
7127 {
7128   Elf_Internal_Shdr * section;
7129   bfd_vma nbuckets = 0;
7130   bfd_vma nchains = 0;
7131   bfd_vma * buckets = NULL;
7132   bfd_vma * chains = NULL;
7133   bfd_vma ngnubuckets = 0;
7134   bfd_vma * gnubuckets = NULL;
7135   bfd_vma * gnuchains = NULL;
7136   bfd_vma gnusymidx = 0;
7137
7138   if (! do_syms && !do_histogram)
7139     return 1;
7140
7141   if (dynamic_info[DT_HASH]
7142       && (do_histogram
7143           || (do_using_dynamic && dynamic_strings != NULL)))
7144     {
7145       unsigned char nb[8];
7146       unsigned char nc[8];
7147       int hash_ent_size = 4;
7148
7149       if ((elf_header.e_machine == EM_ALPHA
7150            || elf_header.e_machine == EM_S390
7151            || elf_header.e_machine == EM_S390_OLD)
7152           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7153         hash_ent_size = 8;
7154
7155       if (fseek (file,
7156                  (archive_file_offset
7157                   + offset_from_vma (file, dynamic_info[DT_HASH],
7158                                      sizeof nb + sizeof nc)),
7159                  SEEK_SET))
7160         {
7161           error (_("Unable to seek to start of dynamic information\n"));
7162           goto no_hash;
7163         }
7164
7165       if (fread (nb, hash_ent_size, 1, file) != 1)
7166         {
7167           error (_("Failed to read in number of buckets\n"));
7168           goto no_hash;
7169         }
7170
7171       if (fread (nc, hash_ent_size, 1, file) != 1)
7172         {
7173           error (_("Failed to read in number of chains\n"));
7174           goto no_hash;
7175         }
7176
7177       nbuckets = byte_get (nb, hash_ent_size);
7178       nchains  = byte_get (nc, hash_ent_size);
7179
7180       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7181       chains  = get_dynamic_data (file, nchains, hash_ent_size);
7182
7183     no_hash:
7184       if (buckets == NULL || chains == NULL)
7185         {
7186           if (do_using_dynamic)
7187             return 0;
7188           free (buckets);
7189           free (chains);
7190           buckets = NULL;
7191           chains = NULL;
7192           nbuckets = 0;
7193           nchains = 0;
7194         }
7195     }
7196
7197   if (dynamic_info_DT_GNU_HASH
7198       && (do_histogram
7199           || (do_using_dynamic && dynamic_strings != NULL)))
7200     {
7201       unsigned char nb[16];
7202       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7203       bfd_vma buckets_vma;
7204
7205       if (fseek (file,
7206                  (archive_file_offset
7207                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7208                                      sizeof nb)),
7209                  SEEK_SET))
7210         {
7211           error (_("Unable to seek to start of dynamic information\n"));
7212           goto no_gnu_hash;
7213         }
7214
7215       if (fread (nb, 16, 1, file) != 1)
7216         {
7217           error (_("Failed to read in number of buckets\n"));
7218           goto no_gnu_hash;
7219         }
7220
7221       ngnubuckets = byte_get (nb, 4);
7222       gnusymidx = byte_get (nb + 4, 4);
7223       bitmaskwords = byte_get (nb + 8, 4);
7224       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7225       if (is_32bit_elf)
7226         buckets_vma += bitmaskwords * 4;
7227       else
7228         buckets_vma += bitmaskwords * 8;
7229
7230       if (fseek (file,
7231                  (archive_file_offset
7232                   + offset_from_vma (file, buckets_vma, 4)),
7233                  SEEK_SET))
7234         {
7235           error (_("Unable to seek to start of dynamic information\n"));
7236           goto no_gnu_hash;
7237         }
7238
7239       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7240
7241       if (gnubuckets == NULL)
7242         goto no_gnu_hash;
7243
7244       for (i = 0; i < ngnubuckets; i++)
7245         if (gnubuckets[i] != 0)
7246           {
7247             if (gnubuckets[i] < gnusymidx)
7248               return 0;
7249
7250             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7251               maxchain = gnubuckets[i];
7252           }
7253
7254       if (maxchain == 0xffffffff)
7255         goto no_gnu_hash;
7256
7257       maxchain -= gnusymidx;
7258
7259       if (fseek (file,
7260                  (archive_file_offset
7261                   + offset_from_vma (file, buckets_vma
7262                                            + 4 * (ngnubuckets + maxchain), 4)),
7263                  SEEK_SET))
7264         {
7265           error (_("Unable to seek to start of dynamic information\n"));
7266           goto no_gnu_hash;
7267         }
7268
7269       do
7270         {
7271           if (fread (nb, 4, 1, file) != 1)
7272             {
7273               error (_("Failed to determine last chain length\n"));
7274               goto no_gnu_hash;
7275             }
7276
7277           if (maxchain + 1 == 0)
7278             goto no_gnu_hash;
7279
7280           ++maxchain;
7281         }
7282       while ((byte_get (nb, 4) & 1) == 0);
7283
7284       if (fseek (file,
7285                  (archive_file_offset
7286                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7287                  SEEK_SET))
7288         {
7289           error (_("Unable to seek to start of dynamic information\n"));
7290           goto no_gnu_hash;
7291         }
7292
7293       gnuchains = get_dynamic_data (file, maxchain, 4);
7294
7295     no_gnu_hash:
7296       if (gnuchains == NULL)
7297         {
7298           free (gnubuckets);
7299           gnubuckets = NULL;
7300           ngnubuckets = 0;
7301           if (do_using_dynamic)
7302             return 0;
7303         }
7304     }
7305
7306   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7307       && do_syms
7308       && do_using_dynamic
7309       && dynamic_strings != NULL)
7310     {
7311       unsigned long hn;
7312
7313       if (dynamic_info[DT_HASH])
7314         {
7315           bfd_vma si;
7316
7317           printf (_("\nSymbol table for image:\n"));
7318           if (is_32bit_elf)
7319             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
7320           else
7321             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
7322
7323           for (hn = 0; hn < nbuckets; hn++)
7324             {
7325               if (! buckets[hn])
7326                 continue;
7327
7328               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7329                 print_dynamic_symbol (si, hn);
7330             }
7331         }
7332
7333       if (dynamic_info_DT_GNU_HASH)
7334         {
7335           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7336           if (is_32bit_elf)
7337             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
7338           else
7339             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
7340
7341           for (hn = 0; hn < ngnubuckets; ++hn)
7342             if (gnubuckets[hn] != 0)
7343               {
7344                 bfd_vma si = gnubuckets[hn];
7345                 bfd_vma off = si - gnusymidx;
7346
7347                 do
7348                   {
7349                     print_dynamic_symbol (si, hn);
7350                     si++;
7351                   }
7352                 while ((gnuchains[off++] & 1) == 0);
7353               }
7354         }
7355     }
7356   else if (do_syms && !do_using_dynamic)
7357     {
7358       unsigned int i;
7359
7360       for (i = 0, section = section_headers;
7361            i < elf_header.e_shnum;
7362            i++, section++)
7363         {
7364           unsigned int si;
7365           char * strtab = NULL;
7366           unsigned long int strtab_size = 0;
7367           Elf_Internal_Sym * symtab;
7368           Elf_Internal_Sym * psym;
7369
7370           if (   section->sh_type != SHT_SYMTAB
7371               && section->sh_type != SHT_DYNSYM)
7372             continue;
7373
7374           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7375                   SECTION_NAME (section),
7376                   (unsigned long) (section->sh_size / section->sh_entsize));
7377           if (is_32bit_elf)
7378             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
7379           else
7380             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
7381
7382           symtab = GET_ELF_SYMBOLS (file, section);
7383           if (symtab == NULL)
7384             continue;
7385
7386           if (section->sh_link == elf_header.e_shstrndx)
7387             {
7388               strtab = string_table;
7389               strtab_size = string_table_length;
7390             }
7391           else if (section->sh_link < elf_header.e_shnum)
7392             {
7393               Elf_Internal_Shdr * string_sec;
7394
7395               string_sec = section_headers + section->sh_link;
7396
7397               strtab = get_data (NULL, file, string_sec->sh_offset,
7398                                  1, string_sec->sh_size, _("string table"));
7399               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7400             }
7401
7402           for (si = 0, psym = symtab;
7403                si < section->sh_size / section->sh_entsize;
7404                si++, psym++)
7405             {
7406               printf ("%6d: ", si);
7407               print_vma (psym->st_value, LONG_HEX);
7408               putchar (' ');
7409               print_vma (psym->st_size, DEC_5);
7410               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7411               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7412               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7413               /* Check to see if any other bits in the st_other field are set.
7414                  Note - displaying this information disrupts the layout of the
7415                  table being generated, but for the moment this case is very rare.  */
7416               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7417                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7418               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7419               print_symbol (25, psym->st_name < strtab_size
7420                             ? strtab + psym->st_name : "<corrupt>");
7421
7422               if (section->sh_type == SHT_DYNSYM &&
7423                   version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7424                 {
7425                   unsigned char data[2];
7426                   unsigned short vers_data;
7427                   unsigned long offset;
7428                   int is_nobits;
7429                   int check_def;
7430
7431                   offset = offset_from_vma
7432                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7433                      sizeof data + si * sizeof (vers_data));
7434
7435                   get_data (&data, file, offset + si * sizeof (vers_data),
7436                             sizeof (data), 1, _("version data"));
7437
7438                   vers_data = byte_get (data, 2);
7439
7440                   is_nobits = (psym->st_shndx < elf_header.e_shnum
7441                                && section_headers[psym->st_shndx].sh_type
7442                                   == SHT_NOBITS);
7443
7444                   check_def = (psym->st_shndx != SHN_UNDEF);
7445
7446                   if ((vers_data & 0x8000) || vers_data > 1)
7447                     {
7448                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7449                           && (is_nobits || ! check_def))
7450                         {
7451                           Elf_External_Verneed evn;
7452                           Elf_Internal_Verneed ivn;
7453                           Elf_Internal_Vernaux ivna;
7454
7455                           /* We must test both.  */
7456                           offset = offset_from_vma
7457                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7458                              sizeof evn);
7459
7460                           do
7461                             {
7462                               unsigned long vna_off;
7463
7464                               get_data (&evn, file, offset, sizeof (evn), 1,
7465                                         _("version need"));
7466
7467                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
7468                               ivn.vn_next = BYTE_GET (evn.vn_next);
7469
7470                               vna_off = offset + ivn.vn_aux;
7471
7472                               do
7473                                 {
7474                                   Elf_External_Vernaux evna;
7475
7476                                   get_data (&evna, file, vna_off,
7477                                             sizeof (evna), 1,
7478                                             _("version need aux (3)"));
7479
7480                                   ivna.vna_other = BYTE_GET (evna.vna_other);
7481                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
7482                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
7483
7484                                   vna_off += ivna.vna_next;
7485                                 }
7486                               while (ivna.vna_other != vers_data
7487                                      && ivna.vna_next != 0);
7488
7489                               if (ivna.vna_other == vers_data)
7490                                 break;
7491
7492                               offset += ivn.vn_next;
7493                             }
7494                           while (ivn.vn_next != 0);
7495
7496                           if (ivna.vna_other == vers_data)
7497                             {
7498                               printf ("@%s (%d)",
7499                                       ivna.vna_name < strtab_size
7500                                       ? strtab + ivna.vna_name : "<corrupt>",
7501                                       ivna.vna_other);
7502                               check_def = 0;
7503                             }
7504                           else if (! is_nobits)
7505                             error (_("bad dynamic symbol\n"));
7506                           else
7507                             check_def = 1;
7508                         }
7509
7510                       if (check_def)
7511                         {
7512                           if (vers_data != 0x8001
7513                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7514                             {
7515                               Elf_Internal_Verdef ivd;
7516                               Elf_Internal_Verdaux ivda;
7517                               Elf_External_Verdaux evda;
7518                               unsigned long offset;
7519
7520                               offset = offset_from_vma
7521                                 (file,
7522                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7523                                  sizeof (Elf_External_Verdef));
7524
7525                               do
7526                                 {
7527                                   Elf_External_Verdef evd;
7528
7529                                   get_data (&evd, file, offset, sizeof (evd),
7530                                             1, _("version def"));
7531
7532                                   ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7533                                   ivd.vd_aux = BYTE_GET (evd.vd_aux);
7534                                   ivd.vd_next = BYTE_GET (evd.vd_next);
7535
7536                                   offset += ivd.vd_next;
7537                                 }
7538                               while (ivd.vd_ndx != (vers_data & 0x7fff)
7539                                      && ivd.vd_next != 0);
7540
7541                               offset -= ivd.vd_next;
7542                               offset += ivd.vd_aux;
7543
7544                               get_data (&evda, file, offset, sizeof (evda),
7545                                         1, _("version def aux"));
7546
7547                               ivda.vda_name = BYTE_GET (evda.vda_name);
7548
7549                               if (psym->st_name != ivda.vda_name)
7550                                 printf ((vers_data & 0x8000)
7551                                         ? "@%s" : "@@%s",
7552                                         ivda.vda_name < strtab_size
7553                                         ? strtab + ivda.vda_name : "<corrupt>");
7554                             }
7555                         }
7556                     }
7557                 }
7558
7559               putchar ('\n');
7560             }
7561
7562           free (symtab);
7563           if (strtab != string_table)
7564             free (strtab);
7565         }
7566     }
7567   else if (do_syms)
7568     printf
7569       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7570
7571   if (do_histogram && buckets != NULL)
7572     {
7573       unsigned long * lengths;
7574       unsigned long * counts;
7575       unsigned long hn;
7576       bfd_vma si;
7577       unsigned long maxlength = 0;
7578       unsigned long nzero_counts = 0;
7579       unsigned long nsyms = 0;
7580
7581       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7582               (unsigned long) nbuckets);
7583       printf (_(" Length  Number     %% of total  Coverage\n"));
7584
7585       lengths = calloc (nbuckets, sizeof (*lengths));
7586       if (lengths == NULL)
7587         {
7588           error (_("Out of memory\n"));
7589           return 0;
7590         }
7591       for (hn = 0; hn < nbuckets; ++hn)
7592         {
7593           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7594             {
7595               ++nsyms;
7596               if (maxlength < ++lengths[hn])
7597                 ++maxlength;
7598             }
7599         }
7600
7601       counts = calloc (maxlength + 1, sizeof (*counts));
7602       if (counts == NULL)
7603         {
7604           error (_("Out of memory\n"));
7605           return 0;
7606         }
7607
7608       for (hn = 0; hn < nbuckets; ++hn)
7609         ++counts[lengths[hn]];
7610
7611       if (nbuckets > 0)
7612         {
7613           unsigned long i;
7614           printf ("      0  %-10lu (%5.1f%%)\n",
7615                   counts[0], (counts[0] * 100.0) / nbuckets);
7616           for (i = 1; i <= maxlength; ++i)
7617             {
7618               nzero_counts += counts[i] * i;
7619               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7620                       i, counts[i], (counts[i] * 100.0) / nbuckets,
7621                       (nzero_counts * 100.0) / nsyms);
7622             }
7623         }
7624
7625       free (counts);
7626       free (lengths);
7627     }
7628
7629   if (buckets != NULL)
7630     {
7631       free (buckets);
7632       free (chains);
7633     }
7634
7635   if (do_histogram && gnubuckets != NULL)
7636     {
7637       unsigned long * lengths;
7638       unsigned long * counts;
7639       unsigned long hn;
7640       unsigned long maxlength = 0;
7641       unsigned long nzero_counts = 0;
7642       unsigned long nsyms = 0;
7643
7644       lengths = calloc (ngnubuckets, sizeof (*lengths));
7645       if (lengths == NULL)
7646         {
7647           error (_("Out of memory\n"));
7648           return 0;
7649         }
7650
7651       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7652               (unsigned long) ngnubuckets);
7653       printf (_(" Length  Number     %% of total  Coverage\n"));
7654
7655       for (hn = 0; hn < ngnubuckets; ++hn)
7656         if (gnubuckets[hn] != 0)
7657           {
7658             bfd_vma off, length = 1;
7659
7660             for (off = gnubuckets[hn] - gnusymidx;
7661                  (gnuchains[off] & 1) == 0; ++off)
7662               ++length;
7663             lengths[hn] = length;
7664             if (length > maxlength)
7665               maxlength = length;
7666             nsyms += length;
7667           }
7668
7669       counts = calloc (maxlength + 1, sizeof (*counts));
7670       if (counts == NULL)
7671         {
7672           error (_("Out of memory\n"));
7673           return 0;
7674         }
7675
7676       for (hn = 0; hn < ngnubuckets; ++hn)
7677         ++counts[lengths[hn]];
7678
7679       if (ngnubuckets > 0)
7680         {
7681           unsigned long j;
7682           printf ("      0  %-10lu (%5.1f%%)\n",
7683                   counts[0], (counts[0] * 100.0) / ngnubuckets);
7684           for (j = 1; j <= maxlength; ++j)
7685             {
7686               nzero_counts += counts[j] * j;
7687               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7688                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7689                       (nzero_counts * 100.0) / nsyms);
7690             }
7691         }
7692
7693       free (counts);
7694       free (lengths);
7695       free (gnubuckets);
7696       free (gnuchains);
7697     }
7698
7699   return 1;
7700 }
7701
7702 static int
7703 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
7704 {
7705   unsigned int i;
7706
7707   if (dynamic_syminfo == NULL
7708       || !do_dynamic)
7709     /* No syminfo, this is ok.  */
7710     return 1;
7711
7712   /* There better should be a dynamic symbol section.  */
7713   if (dynamic_symbols == NULL || dynamic_strings == NULL)
7714     return 0;
7715
7716   if (dynamic_addr)
7717     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7718             dynamic_syminfo_offset, dynamic_syminfo_nent);
7719
7720   printf (_(" Num: Name                           BoundTo     Flags\n"));
7721   for (i = 0; i < dynamic_syminfo_nent; ++i)
7722     {
7723       unsigned short int flags = dynamic_syminfo[i].si_flags;
7724
7725       printf ("%4d: ", i);
7726       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7727         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7728       else
7729         printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7730       putchar (' ');
7731
7732       switch (dynamic_syminfo[i].si_boundto)
7733         {
7734         case SYMINFO_BT_SELF:
7735           fputs ("SELF       ", stdout);
7736           break;
7737         case SYMINFO_BT_PARENT:
7738           fputs ("PARENT     ", stdout);
7739           break;
7740         default:
7741           if (dynamic_syminfo[i].si_boundto > 0
7742               && dynamic_syminfo[i].si_boundto < dynamic_nent
7743               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7744             {
7745               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7746               putchar (' ' );
7747             }
7748           else
7749             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7750           break;
7751         }
7752
7753       if (flags & SYMINFO_FLG_DIRECT)
7754         printf (" DIRECT");
7755       if (flags & SYMINFO_FLG_PASSTHRU)
7756         printf (" PASSTHRU");
7757       if (flags & SYMINFO_FLG_COPY)
7758         printf (" COPY");
7759       if (flags & SYMINFO_FLG_LAZYLOAD)
7760         printf (" LAZYLOAD");
7761
7762       puts ("");
7763     }
7764
7765   return 1;
7766 }
7767
7768 /* Check to see if the given reloc needs to be handled in a target specific
7769    manner.  If so then process the reloc and return TRUE otherwise return
7770    FALSE.  */
7771
7772 static bfd_boolean
7773 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
7774                                 unsigned char *     start,
7775                                 Elf_Internal_Sym *  symtab)
7776 {
7777   unsigned int reloc_type = get_reloc_type (reloc->r_info);
7778
7779   switch (elf_header.e_machine)
7780     {
7781     case EM_MN10300:
7782     case EM_CYGNUS_MN10300:
7783       {
7784         static Elf_Internal_Sym * saved_sym = NULL;
7785
7786         switch (reloc_type)
7787           {
7788           case 34: /* R_MN10300_ALIGN */
7789             return TRUE;
7790           case 33: /* R_MN10300_SYM_DIFF */
7791             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
7792             return TRUE;
7793           case 1: /* R_MN10300_32 */
7794           case 2: /* R_MN10300_16 */
7795             if (saved_sym != NULL)
7796               {
7797                 bfd_vma value;
7798
7799                 value = reloc->r_addend
7800                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
7801                      - saved_sym->st_value);
7802
7803                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
7804
7805                 saved_sym = NULL;
7806                 return TRUE;
7807               }
7808             break;
7809           default:
7810             if (saved_sym != NULL)
7811               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
7812             break;
7813           }
7814         break;
7815       }
7816     }
7817
7818   return FALSE;
7819 }
7820
7821 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7822    DWARF debug sections.  This is a target specific test.  Note - we do not
7823    go through the whole including-target-headers-multiple-times route, (as
7824    we have already done with <elf/h8.h>) because this would become very
7825    messy and even then this function would have to contain target specific
7826    information (the names of the relocs instead of their numeric values).
7827    FIXME: This is not the correct way to solve this problem.  The proper way
7828    is to have target specific reloc sizing and typing functions created by
7829    the reloc-macros.h header, in the same way that it already creates the
7830    reloc naming functions.  */
7831
7832 static bfd_boolean
7833 is_32bit_abs_reloc (unsigned int reloc_type)
7834 {
7835   switch (elf_header.e_machine)
7836     {
7837     case EM_386:
7838     case EM_486:
7839       return reloc_type == 1; /* R_386_32.  */
7840     case EM_68K:
7841       return reloc_type == 1; /* R_68K_32.  */
7842     case EM_860:
7843       return reloc_type == 1; /* R_860_32.  */
7844     case EM_ALPHA:
7845       return reloc_type == 1; /* XXX Is this right ?  */
7846     case EM_ARC:
7847       return reloc_type == 1; /* R_ARC_32.  */
7848     case EM_ARM:
7849       return reloc_type == 2; /* R_ARM_ABS32 */
7850     case EM_AVR_OLD:
7851     case EM_AVR:
7852       return reloc_type == 1;
7853     case EM_BLACKFIN:
7854       return reloc_type == 0x12; /* R_byte4_data.  */
7855     case EM_CRIS:
7856       return reloc_type == 3; /* R_CRIS_32.  */
7857     case EM_CR16:
7858     case EM_CR16_OLD:
7859       return reloc_type == 3; /* R_CR16_NUM32.  */
7860     case EM_CRX:
7861       return reloc_type == 15; /* R_CRX_NUM32.  */
7862     case EM_CYGNUS_FRV:
7863       return reloc_type == 1;
7864     case EM_CYGNUS_D10V:
7865     case EM_D10V:
7866       return reloc_type == 6; /* R_D10V_32.  */
7867     case EM_CYGNUS_D30V:
7868     case EM_D30V:
7869       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
7870     case EM_DLX:
7871       return reloc_type == 3; /* R_DLX_RELOC_32.  */
7872     case EM_CYGNUS_FR30:
7873     case EM_FR30:
7874       return reloc_type == 3; /* R_FR30_32.  */
7875     case EM_H8S:
7876     case EM_H8_300:
7877     case EM_H8_300H:
7878       return reloc_type == 1; /* R_H8_DIR32.  */
7879     case EM_IA_64:
7880       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
7881     case EM_IP2K_OLD:
7882     case EM_IP2K:
7883       return reloc_type == 2; /* R_IP2K_32.  */
7884     case EM_IQ2000:
7885       return reloc_type == 2; /* R_IQ2000_32.  */
7886     case EM_LATTICEMICO32:
7887       return reloc_type == 3; /* R_LM32_32.  */
7888     case EM_M32C_OLD:
7889     case EM_M32C:
7890       return reloc_type == 3; /* R_M32C_32.  */
7891     case EM_M32R:
7892       return reloc_type == 34; /* R_M32R_32_RELA.  */
7893     case EM_MCORE:
7894       return reloc_type == 1; /* R_MCORE_ADDR32.  */
7895     case EM_CYGNUS_MEP:
7896       return reloc_type == 4; /* R_MEP_32.  */
7897     case EM_MIPS:
7898       return reloc_type == 2; /* R_MIPS_32.  */
7899     case EM_MMIX:
7900       return reloc_type == 4; /* R_MMIX_32.  */
7901     case EM_CYGNUS_MN10200:
7902     case EM_MN10200:
7903       return reloc_type == 1; /* R_MN10200_32.  */
7904     case EM_CYGNUS_MN10300:
7905     case EM_MN10300:
7906       return reloc_type == 1; /* R_MN10300_32.  */
7907     case EM_MSP430_OLD:
7908     case EM_MSP430:
7909       return reloc_type == 1; /* R_MSP43_32.  */
7910     case EM_MT:
7911       return reloc_type == 2; /* R_MT_32.  */
7912     case EM_ALTERA_NIOS2:
7913     case EM_NIOS32:
7914       return reloc_type == 1; /* R_NIOS_32.  */
7915     case EM_OPENRISC:
7916     case EM_OR32:
7917       return reloc_type == 1; /* R_OR32_32.  */
7918     case EM_PARISC:
7919       return reloc_type == 1; /* R_PARISC_DIR32.  */
7920     case EM_PJ:
7921     case EM_PJ_OLD:
7922       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
7923     case EM_PPC64:
7924       return reloc_type == 1; /* R_PPC64_ADDR32.  */
7925     case EM_PPC:
7926       return reloc_type == 1; /* R_PPC_ADDR32.  */
7927     case EM_S370:
7928       return reloc_type == 1; /* R_I370_ADDR31.  */
7929     case EM_S390_OLD:
7930     case EM_S390:
7931       return reloc_type == 4; /* R_S390_32.  */
7932     case EM_SCORE:
7933       return reloc_type == 8; /* R_SCORE_ABS32.  */
7934     case EM_SH:
7935       return reloc_type == 1; /* R_SH_DIR32.  */
7936     case EM_SPARC32PLUS:
7937     case EM_SPARCV9:
7938     case EM_SPARC:
7939       return reloc_type == 3 /* R_SPARC_32.  */
7940         || reloc_type == 23; /* R_SPARC_UA32.  */
7941     case EM_SPU:
7942       return reloc_type == 6; /* R_SPU_ADDR32 */
7943     case EM_CYGNUS_V850:
7944     case EM_V850:
7945       return reloc_type == 6; /* R_V850_ABS32.  */
7946     case EM_VAX:
7947       return reloc_type == 1; /* R_VAX_32.  */
7948     case EM_X86_64:
7949       return reloc_type == 10; /* R_X86_64_32.  */
7950     case EM_XSTORMY16:
7951       return reloc_type == 1; /* R_XSTROMY16_32.  */
7952     case EM_XTENSA_OLD:
7953     case EM_XTENSA:
7954       return reloc_type == 1; /* R_XTENSA_32.  */
7955
7956     default:
7957       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
7958              elf_header.e_machine);
7959       abort ();
7960     }
7961 }
7962
7963 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
7964    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
7965
7966 static bfd_boolean
7967 is_32bit_pcrel_reloc (unsigned int reloc_type)
7968 {
7969   switch (elf_header.e_machine)
7970     {
7971     case EM_386:
7972     case EM_486:
7973       return reloc_type == 2;  /* R_386_PC32.  */
7974     case EM_68K:
7975       return reloc_type == 4;  /* R_68K_PC32.  */
7976     case EM_ALPHA:
7977       return reloc_type == 10; /* R_ALPHA_SREL32.  */
7978     case EM_ARM:
7979       return reloc_type == 3;  /* R_ARM_REL32 */
7980     case EM_PARISC:
7981       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
7982     case EM_PPC:
7983       return reloc_type == 26; /* R_PPC_REL32.  */
7984     case EM_PPC64:
7985       return reloc_type == 26; /* R_PPC64_REL32.  */
7986     case EM_S390_OLD:
7987     case EM_S390:
7988       return reloc_type == 5;  /* R_390_PC32.  */
7989     case EM_SH:
7990       return reloc_type == 2;  /* R_SH_REL32.  */
7991     case EM_SPARC32PLUS:
7992     case EM_SPARCV9:
7993     case EM_SPARC:
7994       return reloc_type == 6;  /* R_SPARC_DISP32.  */
7995     case EM_SPU:
7996       return reloc_type == 13; /* R_SPU_REL32.  */
7997     case EM_X86_64:
7998       return reloc_type == 2;  /* R_X86_64_PC32.  */
7999     case EM_XTENSA_OLD:
8000     case EM_XTENSA:
8001       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
8002     default:
8003       /* Do not abort or issue an error message here.  Not all targets use
8004          pc-relative 32-bit relocs in their DWARF debug information and we
8005          have already tested for target coverage in is_32bit_abs_reloc.  A
8006          more helpful warning message will be generated by apply_relocations
8007          anyway, so just return.  */
8008       return FALSE;
8009     }
8010 }
8011
8012 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8013    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
8014
8015 static bfd_boolean
8016 is_64bit_abs_reloc (unsigned int reloc_type)
8017 {
8018   switch (elf_header.e_machine)
8019     {
8020     case EM_ALPHA:
8021       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
8022     case EM_IA_64:
8023       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
8024     case EM_PARISC:
8025       return reloc_type == 80; /* R_PARISC_DIR64.  */
8026     case EM_PPC64:
8027       return reloc_type == 38; /* R_PPC64_ADDR64.  */
8028     case EM_SPARC32PLUS:
8029     case EM_SPARCV9:
8030     case EM_SPARC:
8031       return reloc_type == 54; /* R_SPARC_UA64.  */
8032     case EM_X86_64:
8033       return reloc_type == 1; /* R_X86_64_64.  */
8034     case EM_S390_OLD:
8035     case EM_S390:
8036       return reloc_type == 22;  /* R_S390_64 */
8037     case EM_MIPS:
8038       return reloc_type == 18;  /* R_MIPS_64 */
8039     default:
8040       return FALSE;
8041     }
8042 }
8043
8044 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8045    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
8046
8047 static bfd_boolean
8048 is_64bit_pcrel_reloc (unsigned int reloc_type)
8049 {
8050   switch (elf_header.e_machine)
8051     {
8052     case EM_ALPHA:
8053       return reloc_type == 11; /* R_ALPHA_SREL64 */
8054     case EM_IA_64:
8055       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
8056     case EM_PARISC:
8057       return reloc_type == 72; /* R_PARISC_PCREL64 */
8058     case EM_PPC64:
8059       return reloc_type == 44; /* R_PPC64_REL64 */
8060     case EM_SPARC32PLUS:
8061     case EM_SPARCV9:
8062     case EM_SPARC:
8063       return reloc_type == 46; /* R_SPARC_DISP64 */
8064     case EM_X86_64:
8065       return reloc_type == 24; /* R_X86_64_PC64 */
8066     case EM_S390_OLD:
8067     case EM_S390:
8068       return reloc_type == 23;  /* R_S390_PC64 */
8069     default:
8070       return FALSE;
8071     }
8072 }
8073
8074 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8075    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
8076
8077 static bfd_boolean
8078 is_16bit_abs_reloc (unsigned int reloc_type)
8079 {
8080   switch (elf_header.e_machine)
8081     {
8082     case EM_AVR_OLD:
8083     case EM_AVR:
8084       return reloc_type == 4; /* R_AVR_16.  */
8085     case EM_CYGNUS_D10V:
8086     case EM_D10V:
8087       return reloc_type == 3; /* R_D10V_16.  */
8088     case EM_H8S:
8089     case EM_H8_300:
8090     case EM_H8_300H:
8091       return reloc_type == R_H8_DIR16;
8092     case EM_IP2K_OLD:
8093     case EM_IP2K:
8094       return reloc_type == 1; /* R_IP2K_16.  */
8095     case EM_M32C_OLD:
8096     case EM_M32C:
8097       return reloc_type == 1; /* R_M32C_16 */
8098     case EM_MSP430_OLD:
8099     case EM_MSP430:
8100       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
8101     case EM_ALTERA_NIOS2:
8102     case EM_NIOS32:
8103       return reloc_type == 9; /* R_NIOS_16.  */
8104     default:
8105       return FALSE;
8106     }
8107 }
8108
8109 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8110    relocation entries (possibly formerly used for SHT_GROUP sections).  */
8111
8112 static bfd_boolean
8113 is_none_reloc (unsigned int reloc_type)
8114 {
8115   switch (elf_header.e_machine)
8116     {
8117     case EM_68K:     /* R_68K_NONE.  */
8118     case EM_386:     /* R_386_NONE.  */
8119     case EM_SPARC32PLUS:
8120     case EM_SPARCV9:
8121     case EM_SPARC:   /* R_SPARC_NONE.  */
8122     case EM_MIPS:    /* R_MIPS_NONE.  */
8123     case EM_PARISC:  /* R_PARISC_NONE.  */
8124     case EM_ALPHA:   /* R_ALPHA_NONE.  */
8125     case EM_PPC:     /* R_PPC_NONE.  */
8126     case EM_PPC64:   /* R_PPC64_NONE.  */
8127     case EM_ARM:     /* R_ARM_NONE.  */
8128     case EM_IA_64:   /* R_IA64_NONE.  */
8129     case EM_SH:      /* R_SH_NONE.  */
8130     case EM_S390_OLD:
8131     case EM_S390:    /* R_390_NONE.  */
8132     case EM_CRIS:    /* R_CRIS_NONE.  */
8133     case EM_X86_64:  /* R_X86_64_NONE.  */
8134     case EM_MN10300: /* R_MN10300_NONE.  */
8135     case EM_M32R:    /* R_M32R_NONE.  */
8136       return reloc_type == 0;
8137     }
8138   return FALSE;
8139 }
8140
8141 /* Apply relocations to a section.
8142    Note: So far support has been added only for those relocations
8143    which can be found in debug sections.
8144    FIXME: Add support for more relocations ?  */
8145
8146 static void
8147 apply_relocations (void * file,
8148                    Elf_Internal_Shdr * section,
8149                    unsigned char * start)
8150 {
8151   Elf_Internal_Shdr * relsec;
8152   unsigned char * end = start + section->sh_size;
8153
8154   if (elf_header.e_type != ET_REL)
8155     return;
8156
8157   /* Find the reloc section associated with the section.  */
8158   for (relsec = section_headers;
8159        relsec < section_headers + elf_header.e_shnum;
8160        ++relsec)
8161     {
8162       bfd_boolean is_rela;
8163       unsigned long num_relocs;
8164       Elf_Internal_Rela * relocs;
8165       Elf_Internal_Rela * rp;
8166       Elf_Internal_Shdr * symsec;
8167       Elf_Internal_Sym * symtab;
8168       Elf_Internal_Sym * sym;
8169
8170       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8171           || relsec->sh_info >= elf_header.e_shnum
8172           || section_headers + relsec->sh_info != section
8173           || relsec->sh_size == 0
8174           || relsec->sh_link >= elf_header.e_shnum)
8175         continue;
8176
8177       is_rela = relsec->sh_type == SHT_RELA;
8178
8179       if (is_rela)
8180         {
8181           if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8182                                   & relocs, & num_relocs))
8183             return;
8184         }
8185       else
8186         {
8187           if (!slurp_rel_relocs (file, relsec->sh_offset, relsec->sh_size,
8188                                  & relocs, & num_relocs))
8189             return;
8190         }
8191
8192       /* SH uses RELA but uses in place value instead of the addend field.  */
8193       if (elf_header.e_machine == EM_SH)
8194         is_rela = FALSE;
8195
8196       symsec = section_headers + relsec->sh_link;
8197       symtab = GET_ELF_SYMBOLS (file, symsec);
8198
8199       for (rp = relocs; rp < relocs + num_relocs; ++rp)
8200         {
8201           bfd_vma         addend;
8202           unsigned int    reloc_type;
8203           unsigned int    reloc_size;
8204           unsigned char * loc;
8205
8206           reloc_type = get_reloc_type (rp->r_info);
8207
8208           if (target_specific_reloc_handling (rp, start, symtab))
8209             continue;
8210           else if (is_none_reloc (reloc_type))
8211             continue;
8212           else if (is_32bit_abs_reloc (reloc_type)
8213                    || is_32bit_pcrel_reloc (reloc_type))
8214             reloc_size = 4;
8215           else if (is_64bit_abs_reloc (reloc_type)
8216                    || is_64bit_pcrel_reloc (reloc_type))
8217             reloc_size = 8;
8218           else if (is_16bit_abs_reloc (reloc_type))
8219             reloc_size = 2;
8220           else
8221             {
8222               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8223                     reloc_type, SECTION_NAME (section));
8224               continue;
8225             }
8226
8227           loc = start + rp->r_offset;
8228           if ((loc + reloc_size) > end)
8229             {
8230               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8231                     (unsigned long) rp->r_offset,
8232                     SECTION_NAME (section));
8233               continue;
8234             }
8235
8236           sym = symtab + get_reloc_symindex (rp->r_info);
8237
8238           /* If the reloc has a symbol associated with it,
8239              make sure that it is of an appropriate type.
8240
8241              Relocations against symbols without type can happen.
8242              Gcc -feliminate-dwarf2-dups may generate symbols
8243              without type for debug info.
8244
8245              Icc generates relocations against function symbols
8246              instead of local labels.
8247
8248              Relocations against object symbols can happen, eg when
8249              referencing a global array.  For an example of this see
8250              the _clz.o binary in libgcc.a.  */
8251           if (sym != symtab
8252               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
8253             {
8254               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8255                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
8256                     (long int)(rp - relocs),
8257                     SECTION_NAME (relsec));
8258               continue;
8259             }
8260
8261           addend = is_rela ? rp->r_addend : byte_get (loc, reloc_size);
8262
8263           if (is_32bit_pcrel_reloc (reloc_type)
8264               || is_64bit_pcrel_reloc (reloc_type))
8265             {
8266               /* On HPPA, all pc-relative relocations are biased by 8.  */
8267               if (elf_header.e_machine == EM_PARISC)
8268                 addend -= 8;
8269               byte_put (loc, (addend + sym->st_value) - rp->r_offset,
8270                         reloc_size);
8271             }
8272           else
8273             byte_put (loc, addend + sym->st_value, reloc_size);
8274         }
8275
8276       free (symtab);
8277       free (relocs);
8278       break;
8279     }
8280 }
8281
8282 #ifdef SUPPORT_DISASSEMBLY
8283 static int
8284 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
8285 {
8286   printf (_("\nAssembly dump of section %s\n"),
8287           SECTION_NAME (section));
8288
8289   /* XXX -- to be done --- XXX */
8290
8291   return 1;
8292 }
8293 #endif
8294
8295 /* Reads in the contents of SECTION from FILE, returning a pointer
8296    to a malloc'ed buffer or NULL if something went wrong.  */
8297
8298 static char *
8299 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
8300 {
8301   bfd_size_type num_bytes;
8302
8303   num_bytes = section->sh_size;
8304
8305   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
8306     {
8307       printf (_("\nSection '%s' has no data to dump.\n"),
8308               SECTION_NAME (section));
8309       return NULL;
8310     }
8311
8312   return get_data (NULL, file, section->sh_offset, 1, num_bytes,
8313                    _("section contents"));
8314 }
8315
8316
8317 static void
8318 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
8319 {
8320   Elf_Internal_Shdr * relsec;
8321   bfd_size_type num_bytes;
8322   bfd_vma addr;
8323   char * data;
8324   char * end;
8325   char * start;
8326   char * name = SECTION_NAME (section);
8327   bfd_boolean some_strings_shown;
8328
8329   start = get_section_contents (section, file);
8330   if (start == NULL)
8331     return;
8332
8333   printf (_("\nString dump of section '%s':\n"), name);
8334
8335   /* If the section being dumped has relocations against it the user might
8336      be expecting these relocations to have been applied.  Check for this
8337      case and issue a warning message in order to avoid confusion.
8338      FIXME: Maybe we ought to have an option that dumps a section with
8339      relocs applied ?  */
8340   for (relsec = section_headers;
8341        relsec < section_headers + elf_header.e_shnum;
8342        ++relsec)
8343     {
8344       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8345           || relsec->sh_info >= elf_header.e_shnum
8346           || section_headers + relsec->sh_info != section
8347           || relsec->sh_size == 0
8348           || relsec->sh_link >= elf_header.e_shnum)
8349         continue;
8350
8351       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8352       break;
8353     }
8354
8355   num_bytes = section->sh_size;
8356   addr = section->sh_addr;
8357   data = start;
8358   end  = start + num_bytes;
8359   some_strings_shown = FALSE;
8360
8361   while (data < end)
8362     {
8363       while (!ISPRINT (* data))
8364         if (++ data >= end)
8365           break;
8366
8367       if (data < end)
8368         {
8369 #ifndef __MSVCRT__
8370           printf ("  [%6tx]  %s\n", data - start, data);
8371 #else
8372           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
8373 #endif
8374           data += strlen (data);
8375           some_strings_shown = TRUE;
8376         }
8377     }
8378
8379   if (! some_strings_shown)
8380     printf (_("  No strings found in this section."));
8381
8382   free (start);
8383
8384   putchar ('\n');
8385 }
8386
8387 static void
8388 dump_section_as_bytes (Elf_Internal_Shdr * section,
8389                        FILE * file,
8390                        bfd_boolean relocate)
8391 {
8392   Elf_Internal_Shdr * relsec;
8393   bfd_size_type bytes;
8394   bfd_vma addr;
8395   unsigned char * data;
8396   unsigned char * start;
8397
8398   start = (unsigned char *) get_section_contents (section, file);
8399   if (start == NULL)
8400     return;
8401
8402   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
8403
8404   if (relocate)
8405     {
8406       apply_relocations (file, section, start);
8407     }
8408   else
8409     {
8410       /* If the section being dumped has relocations against it the user might
8411          be expecting these relocations to have been applied.  Check for this
8412          case and issue a warning message in order to avoid confusion.
8413          FIXME: Maybe we ought to have an option that dumps a section with
8414          relocs applied ?  */
8415       for (relsec = section_headers;
8416            relsec < section_headers + elf_header.e_shnum;
8417            ++relsec)
8418         {
8419           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8420               || relsec->sh_info >= elf_header.e_shnum
8421               || section_headers + relsec->sh_info != section
8422               || relsec->sh_size == 0
8423               || relsec->sh_link >= elf_header.e_shnum)
8424             continue;
8425
8426           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8427           break;
8428         }
8429     }
8430
8431   addr = section->sh_addr;
8432   bytes = section->sh_size;
8433   data = start;
8434
8435   while (bytes)
8436     {
8437       int j;
8438       int k;
8439       int lbytes;
8440
8441       lbytes = (bytes > 16 ? 16 : bytes);
8442
8443       printf ("  0x%8.8lx ", (unsigned long) addr);
8444
8445       for (j = 0; j < 16; j++)
8446         {
8447           if (j < lbytes)
8448             printf ("%2.2x", data[j]);
8449           else
8450             printf ("  ");
8451
8452           if ((j & 3) == 3)
8453             printf (" ");
8454         }
8455
8456       for (j = 0; j < lbytes; j++)
8457         {
8458           k = data[j];
8459           if (k >= ' ' && k < 0x7f)
8460             printf ("%c", k);
8461           else
8462             printf (".");
8463         }
8464
8465       putchar ('\n');
8466
8467       data  += lbytes;
8468       addr  += lbytes;
8469       bytes -= lbytes;
8470     }
8471
8472   free (start);
8473
8474   putchar ('\n');
8475 }
8476
8477 /* Uncompresses a section that was compressed using zlib, in place.
8478    This is a copy of bfd_uncompress_section_contents, in bfd/compress.c  */
8479
8480 static int
8481 uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
8482 {
8483 #ifndef HAVE_ZLIB_H
8484   /* These are just to quiet gcc.  */
8485   buffer = 0;
8486   size = 0;
8487   return FALSE;
8488 #else
8489   dwarf_size_type compressed_size = *size;
8490   unsigned char * compressed_buffer = *buffer;
8491   dwarf_size_type uncompressed_size;
8492   unsigned char * uncompressed_buffer;
8493   z_stream strm;
8494   int rc;
8495   dwarf_size_type header_size = 12;
8496
8497   /* Read the zlib header.  In this case, it should be "ZLIB" followed
8498      by the uncompressed section size, 8 bytes in big-endian order.  */
8499   if (compressed_size < header_size
8500       || ! streq ((char *) compressed_buffer, "ZLIB"))
8501     return 0;
8502
8503   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
8504   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
8505   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
8506   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
8507   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
8508   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
8509   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
8510   uncompressed_size += compressed_buffer[11];
8511
8512   /* It is possible the section consists of several compressed
8513      buffers concatenated together, so we uncompress in a loop.  */
8514   strm.zalloc = NULL;
8515   strm.zfree = NULL;
8516   strm.opaque = NULL;
8517   strm.avail_in = compressed_size - header_size;
8518   strm.next_in = (Bytef *) compressed_buffer + header_size;
8519   strm.avail_out = uncompressed_size;
8520   uncompressed_buffer = xmalloc (uncompressed_size);
8521
8522   rc = inflateInit (& strm);
8523   while (strm.avail_in > 0)
8524     {
8525       if (rc != Z_OK)
8526         goto fail;
8527       strm.next_out = ((Bytef *) uncompressed_buffer
8528                        + (uncompressed_size - strm.avail_out));
8529       rc = inflate (&strm, Z_FINISH);
8530       if (rc != Z_STREAM_END)
8531         goto fail;
8532       rc = inflateReset (& strm);
8533     }
8534   rc = inflateEnd (& strm);
8535   if (rc != Z_OK
8536       || strm.avail_out != 0)
8537     goto fail;
8538
8539   free (compressed_buffer);
8540   *buffer = uncompressed_buffer;
8541   *size = uncompressed_size;
8542   return 1;
8543
8544  fail:
8545   free (uncompressed_buffer);
8546   return 0;
8547 #endif  /* HAVE_ZLIB_H */
8548 }
8549
8550 static int
8551 load_specific_debug_section (enum dwarf_section_display_enum debug,
8552                              Elf_Internal_Shdr * sec, void * file)
8553 {
8554   struct dwarf_section * section = &debug_displays [debug].section;
8555   char buf [64];
8556   int section_is_compressed;
8557
8558   /* If it is already loaded, do nothing.  */
8559   if (section->start != NULL)
8560     return 1;
8561
8562   section_is_compressed = section->name == section->compressed_name;
8563
8564   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8565   section->address = sec->sh_addr;
8566   section->size = sec->sh_size;
8567   section->start = get_data (NULL, file, sec->sh_offset, 1,
8568                              sec->sh_size, buf);
8569   if (section->start == NULL)
8570     return 0;
8571
8572   if (section_is_compressed)
8573     if (! uncompress_section_contents (&section->start, &section->size))
8574       return 0;
8575
8576   if (debug_displays [debug].relocate)
8577     apply_relocations (file, sec, section->start);
8578
8579   return 1;
8580 }
8581
8582 int
8583 load_debug_section (enum dwarf_section_display_enum debug, void * file)
8584 {
8585   struct dwarf_section * section = &debug_displays [debug].section;
8586   Elf_Internal_Shdr * sec;
8587
8588   /* Locate the debug section.  */
8589   sec = find_section (section->uncompressed_name);
8590   if (sec != NULL)
8591     section->name = section->uncompressed_name;
8592   else
8593     {
8594       sec = find_section (section->compressed_name);
8595       if (sec != NULL)
8596         section->name = section->compressed_name;
8597     }
8598   if (sec == NULL)
8599     return 0;
8600
8601   return load_specific_debug_section (debug, sec, file);
8602 }
8603
8604 void
8605 free_debug_section (enum dwarf_section_display_enum debug)
8606 {
8607   struct dwarf_section * section = &debug_displays [debug].section;
8608
8609   if (section->start == NULL)
8610     return;
8611
8612   free ((char *) section->start);
8613   section->start = NULL;
8614   section->address = 0;
8615   section->size = 0;
8616 }
8617
8618 static int
8619 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
8620 {
8621   char * name = SECTION_NAME (section);
8622   bfd_size_type length;
8623   int result = 1;
8624   enum dwarf_section_display_enum i;
8625
8626   length = section->sh_size;
8627   if (length == 0)
8628     {
8629       printf (_("\nSection '%s' has no debugging data.\n"), name);
8630       return 0;
8631     }
8632   if (section->sh_type == SHT_NOBITS)
8633     {
8634       /* There is no point in dumping the contents of a debugging section
8635          which has the NOBITS type - the bits in the file will be random.
8636          This can happen when a file containing a .eh_frame section is
8637          stripped with the --only-keep-debug command line option.  */
8638       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
8639       return 0;
8640     }
8641
8642   if (const_strneq (name, ".gnu.linkonce.wi."))
8643     name = ".debug_info";
8644
8645   /* See if we know how to display the contents of this section.  */
8646   for (i = 0; i < max; i++)
8647     if (streq (debug_displays[i].section.uncompressed_name, name)
8648         || streq (debug_displays[i].section.compressed_name, name))
8649       {
8650         struct dwarf_section * sec = &debug_displays [i].section;
8651         int secondary = (section != find_section (name));
8652
8653         if (secondary)
8654           free_debug_section (i);
8655
8656         if (streq (debug_displays[i].section.uncompressed_name, name))
8657           sec->name = sec->uncompressed_name;
8658         else
8659           sec->name = sec->compressed_name;
8660         if (load_specific_debug_section (i, section, file))
8661           {
8662             result &= debug_displays[i].display (sec, file);
8663
8664             if (secondary || (i != info && i != abbrev))
8665               free_debug_section (i);
8666           }
8667
8668         break;
8669       }
8670
8671   if (i == max)
8672     {
8673       printf (_("Unrecognized debug section: %s\n"), name);
8674       result = 0;
8675     }
8676
8677   return result;
8678 }
8679
8680 /* Set DUMP_SECTS for all sections where dumps were requested
8681    based on section name.  */
8682
8683 static void
8684 initialise_dumps_byname (void)
8685 {
8686   struct dump_list_entry * cur;
8687
8688   for (cur = dump_sects_byname; cur; cur = cur->next)
8689     {
8690       unsigned int i;
8691       int any;
8692
8693       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8694         if (streq (SECTION_NAME (section_headers + i), cur->name))
8695           {
8696             request_dump_bynumber (i, cur->type);
8697             any = 1;
8698           }
8699
8700       if (!any)
8701         warn (_("Section '%s' was not dumped because it does not exist!\n"),
8702               cur->name);
8703     }
8704 }
8705
8706 static void
8707 process_section_contents (FILE * file)
8708 {
8709   Elf_Internal_Shdr * section;
8710   unsigned int i;
8711
8712   if (! do_dump)
8713     return;
8714
8715   initialise_dumps_byname ();
8716
8717   for (i = 0, section = section_headers;
8718        i < elf_header.e_shnum && i < num_dump_sects;
8719        i++, section++)
8720     {
8721 #ifdef SUPPORT_DISASSEMBLY
8722       if (dump_sects[i] & DISASS_DUMP)
8723         disassemble_section (section, file);
8724 #endif
8725       if (dump_sects[i] & HEX_DUMP)
8726         dump_section_as_bytes (section, file, FALSE);
8727
8728       if (dump_sects[i] & RELOC_DUMP)
8729         dump_section_as_bytes (section, file, TRUE);
8730
8731       if (dump_sects[i] & STRING_DUMP)
8732         dump_section_as_strings (section, file);
8733
8734       if (dump_sects[i] & DEBUG_DUMP)
8735         display_debug_section (section, file);
8736     }
8737
8738   /* Check to see if the user requested a
8739      dump of a section that does not exist.  */
8740   while (i++ < num_dump_sects)
8741     if (dump_sects[i])
8742       warn (_("Section %d was not dumped because it does not exist!\n"), i);
8743 }
8744
8745 static void
8746 process_mips_fpe_exception (int mask)
8747 {
8748   if (mask)
8749     {
8750       int first = 1;
8751       if (mask & OEX_FPU_INEX)
8752         fputs ("INEX", stdout), first = 0;
8753       if (mask & OEX_FPU_UFLO)
8754         printf ("%sUFLO", first ? "" : "|"), first = 0;
8755       if (mask & OEX_FPU_OFLO)
8756         printf ("%sOFLO", first ? "" : "|"), first = 0;
8757       if (mask & OEX_FPU_DIV0)
8758         printf ("%sDIV0", first ? "" : "|"), first = 0;
8759       if (mask & OEX_FPU_INVAL)
8760         printf ("%sINVAL", first ? "" : "|");
8761     }
8762   else
8763     fputs ("0", stdout);
8764 }
8765
8766 /* ARM EABI attributes section.  */
8767 typedef struct
8768 {
8769   int tag;
8770   const char * name;
8771   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
8772   int type;
8773   const char ** table;
8774 } arm_attr_public_tag;
8775
8776 static const char * arm_attr_tag_CPU_arch[] =
8777   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8778    "v6K", "v7", "v6-M", "v6S-M"};
8779 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
8780 static const char * arm_attr_tag_THUMB_ISA_use[] =
8781   {"No", "Thumb-1", "Thumb-2"};
8782 static const char * arm_attr_tag_VFP_arch[] =
8783   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8784 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
8785 static const char * arm_attr_tag_Advanced_SIMD_arch[] = {"No", "NEONv1"};
8786 static const char * arm_attr_tag_PCS_config[] =
8787   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8788    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8789 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
8790   {"V6", "SB", "TLS", "Unused"};
8791 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
8792   {"Absolute", "PC-relative", "SB-relative", "None"};
8793 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
8794   {"Absolute", "PC-relative", "None"};
8795 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
8796   {"None", "direct", "GOT-indirect"};
8797 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
8798   {"None", "??? 1", "2", "??? 3", "4"};
8799 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
8800 static const char * arm_attr_tag_ABI_FP_denormal[] =
8801   {"Unused", "Needed", "Sign only"};
8802 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
8803 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
8804 static const char * arm_attr_tag_ABI_FP_number_model[] =
8805   {"Unused", "Finite", "RTABI", "IEEE 754"};
8806 static const char * arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
8807 static const char * arm_attr_tag_ABI_align8_preserved[] =
8808   {"No", "Yes, except leaf SP", "Yes"};
8809 static const char * arm_attr_tag_ABI_enum_size[] =
8810   {"Unused", "small", "int", "forced to int"};
8811 static const char * arm_attr_tag_ABI_HardFP_use[] =
8812   {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8813 static const char * arm_attr_tag_ABI_VFP_args[] =
8814   {"AAPCS", "VFP registers", "custom"};
8815 static const char * arm_attr_tag_ABI_WMMX_args[] =
8816   {"AAPCS", "WMMX registers", "custom"};
8817 static const char * arm_attr_tag_ABI_optimization_goals[] =
8818   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8819     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8820 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
8821   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8822     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8823 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
8824 static const char * arm_attr_tag_VFP_HP_extension[] =
8825   {"Not Allowed", "Allowed"};
8826 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8827   {"None", "IEEE 754", "Alternative Format"};
8828 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
8829 static const char * arm_attr_tag_Virtualization_use[] =
8830   {"Not Allowed", "Allowed"};
8831 static const char * arm_attr_tag_MPextension_use[] = {"Not Allowed", "Allowed"};
8832
8833 #define LOOKUP(id, name) \
8834   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8835 static arm_attr_public_tag arm_attr_public_tags[] =
8836 {
8837   {4, "CPU_raw_name", 1, NULL},
8838   {5, "CPU_name", 1, NULL},
8839   LOOKUP(6, CPU_arch),
8840   {7, "CPU_arch_profile", 0, NULL},
8841   LOOKUP(8, ARM_ISA_use),
8842   LOOKUP(9, THUMB_ISA_use),
8843   LOOKUP(10, VFP_arch),
8844   LOOKUP(11, WMMX_arch),
8845   LOOKUP(12, Advanced_SIMD_arch),
8846   LOOKUP(13, PCS_config),
8847   LOOKUP(14, ABI_PCS_R9_use),
8848   LOOKUP(15, ABI_PCS_RW_data),
8849   LOOKUP(16, ABI_PCS_RO_data),
8850   LOOKUP(17, ABI_PCS_GOT_use),
8851   LOOKUP(18, ABI_PCS_wchar_t),
8852   LOOKUP(19, ABI_FP_rounding),
8853   LOOKUP(20, ABI_FP_denormal),
8854   LOOKUP(21, ABI_FP_exceptions),
8855   LOOKUP(22, ABI_FP_user_exceptions),
8856   LOOKUP(23, ABI_FP_number_model),
8857   LOOKUP(24, ABI_align8_needed),
8858   LOOKUP(25, ABI_align8_preserved),
8859   LOOKUP(26, ABI_enum_size),
8860   LOOKUP(27, ABI_HardFP_use),
8861   LOOKUP(28, ABI_VFP_args),
8862   LOOKUP(29, ABI_WMMX_args),
8863   LOOKUP(30, ABI_optimization_goals),
8864   LOOKUP(31, ABI_FP_optimization_goals),
8865   {32, "compatibility", 0, NULL},
8866   LOOKUP(34, CPU_unaligned_access),
8867   LOOKUP(36, VFP_HP_extension),
8868   LOOKUP(38, ABI_FP_16bit_format),
8869   {64, "nodefaults", 0, NULL},
8870   {65, "also_compatible_with", 0, NULL},
8871   LOOKUP(66, T2EE_use),
8872   {67, "conformance", 1, NULL},
8873   LOOKUP(68, Virtualization_use),
8874   LOOKUP(70, MPextension_use)
8875 };
8876 #undef LOOKUP
8877
8878 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
8879    bytes read.  */
8880
8881 static unsigned int
8882 read_uleb128 (unsigned char * p, unsigned int * plen)
8883 {
8884   unsigned char c;
8885   unsigned int val;
8886   int shift;
8887   int len;
8888
8889   val = 0;
8890   shift = 0;
8891   len = 0;
8892   do
8893     {
8894       c = *(p++);
8895       len++;
8896       val |= ((unsigned int)c & 0x7f) << shift;
8897       shift += 7;
8898     }
8899   while (c & 0x80);
8900
8901   *plen = len;
8902   return val;
8903 }
8904
8905 static unsigned char *
8906 display_arm_attribute (unsigned char * p)
8907 {
8908   int tag;
8909   unsigned int len;
8910   int val;
8911   arm_attr_public_tag * attr;
8912   unsigned i;
8913   int type;
8914
8915   tag = read_uleb128 (p, &len);
8916   p += len;
8917   attr = NULL;
8918   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
8919     {
8920       if (arm_attr_public_tags[i].tag == tag)
8921         {
8922           attr = &arm_attr_public_tags[i];
8923           break;
8924         }
8925     }
8926
8927   if (attr)
8928     {
8929       printf ("  Tag_%s: ", attr->name);
8930       switch (attr->type)
8931         {
8932         case 0:
8933           switch (tag)
8934             {
8935             case 7: /* Tag_CPU_arch_profile.  */
8936               val = read_uleb128 (p, &len);
8937               p += len;
8938               switch (val)
8939                 {
8940                 case 0: printf ("None\n"); break;
8941                 case 'A': printf ("Application\n"); break;
8942                 case 'R': printf ("Realtime\n"); break;
8943                 case 'M': printf ("Microcontroller\n"); break;
8944                 default: printf ("??? (%d)\n", val); break;
8945                 }
8946               break;
8947
8948             case 32: /* Tag_compatibility.  */
8949               val = read_uleb128 (p, &len);
8950               p += len;
8951               printf ("flag = %d, vendor = %s\n", val, p);
8952               p += strlen ((char *) p) + 1;
8953               break;
8954
8955             case 64: /* Tag_nodefaults.  */
8956               p++;
8957               printf ("True\n");
8958               break;
8959
8960             case 65: /* Tag_also_compatible_with.  */
8961               val = read_uleb128 (p, &len);
8962               p += len;
8963               if (val == 6 /* Tag_CPU_arch.  */)
8964                 {
8965                   val = read_uleb128 (p, &len);
8966                   p += len;
8967                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
8968                     printf ("??? (%d)\n", val);
8969                   else
8970                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
8971                 }
8972               else
8973                 printf ("???\n");
8974               while (*(p++) != '\0' /* NUL terminator.  */);
8975               break;
8976
8977             default:
8978               abort ();
8979             }
8980           return p;
8981
8982         case 1:
8983         case 2:
8984           type = attr->type;
8985           break;
8986
8987         default:
8988           assert (attr->type & 0x80);
8989           val = read_uleb128 (p, &len);
8990           p += len;
8991           type = attr->type & 0x7f;
8992           if (val >= type)
8993             printf ("??? (%d)\n", val);
8994           else
8995             printf ("%s\n", attr->table[val]);
8996           return p;
8997         }
8998     }
8999   else
9000     {
9001       if (tag & 1)
9002         type = 1; /* String.  */
9003       else
9004         type = 2; /* uleb128.  */
9005       printf ("  Tag_unknown_%d: ", tag);
9006     }
9007
9008   if (type == 1)
9009     {
9010       printf ("\"%s\"\n", p);
9011       p += strlen ((char *) p) + 1;
9012     }
9013   else
9014     {
9015       val = read_uleb128 (p, &len);
9016       p += len;
9017       printf ("%d (0x%x)\n", val, val);
9018     }
9019
9020   return p;
9021 }
9022
9023 static unsigned char *
9024 display_gnu_attribute (unsigned char * p,
9025                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9026 {
9027   int tag;
9028   unsigned int len;
9029   int val;
9030   int type;
9031
9032   tag = read_uleb128 (p, &len);
9033   p += len;
9034
9035   /* Tag_compatibility is the only generic GNU attribute defined at
9036      present.  */
9037   if (tag == 32)
9038     {
9039       val = read_uleb128 (p, &len);
9040       p += len;
9041       printf ("flag = %d, vendor = %s\n", val, p);
9042       p += strlen ((char *) p) + 1;
9043       return p;
9044     }
9045
9046   if ((tag & 2) == 0 && display_proc_gnu_attribute)
9047     return display_proc_gnu_attribute (p, tag);
9048
9049   if (tag & 1)
9050     type = 1; /* String.  */
9051   else
9052     type = 2; /* uleb128.  */
9053   printf ("  Tag_unknown_%d: ", tag);
9054
9055   if (type == 1)
9056     {
9057       printf ("\"%s\"\n", p);
9058       p += strlen ((char *) p) + 1;
9059     }
9060   else
9061     {
9062       val = read_uleb128 (p, &len);
9063       p += len;
9064       printf ("%d (0x%x)\n", val, val);
9065     }
9066
9067   return p;
9068 }
9069
9070 static unsigned char *
9071 display_power_gnu_attribute (unsigned char * p, int tag)
9072 {
9073   int type;
9074   unsigned int len;
9075   int val;
9076
9077   if (tag == Tag_GNU_Power_ABI_FP)
9078     {
9079       val = read_uleb128 (p, &len);
9080       p += len;
9081       printf ("  Tag_GNU_Power_ABI_FP: ");
9082
9083       switch (val)
9084         {
9085         case 0:
9086           printf ("Hard or soft float\n");
9087           break;
9088         case 1:
9089           printf ("Hard float\n");
9090           break;
9091         case 2:
9092           printf ("Soft float\n");
9093           break;
9094         case 3:
9095           printf ("Single-precision hard float\n");
9096           break;
9097         default:
9098           printf ("??? (%d)\n", val);
9099           break;
9100         }
9101       return p;
9102    }
9103
9104   if (tag == Tag_GNU_Power_ABI_Vector)
9105     {
9106       val = read_uleb128 (p, &len);
9107       p += len;
9108       printf ("  Tag_GNU_Power_ABI_Vector: ");
9109       switch (val)
9110         {
9111         case 0:
9112           printf ("Any\n");
9113           break;
9114         case 1:
9115           printf ("Generic\n");
9116           break;
9117         case 2:
9118           printf ("AltiVec\n");
9119           break;
9120         case 3:
9121           printf ("SPE\n");
9122           break;
9123         default:
9124           printf ("??? (%d)\n", val);
9125           break;
9126         }
9127       return p;
9128    }
9129
9130   if (tag == Tag_GNU_Power_ABI_Struct_Return)
9131     {
9132       val = read_uleb128 (p, &len);
9133       p += len;
9134       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
9135       switch (val)
9136        {
9137        case 0:
9138          printf ("Any\n");
9139          break;
9140        case 1:
9141          printf ("r3/r4\n");
9142          break;
9143        case 2:
9144          printf ("Memory\n");
9145          break;
9146        default:
9147          printf ("??? (%d)\n", val);
9148          break;
9149        }
9150       return p;
9151     }
9152
9153   if (tag & 1)
9154     type = 1; /* String.  */
9155   else
9156     type = 2; /* uleb128.  */
9157   printf ("  Tag_unknown_%d: ", tag);
9158
9159   if (type == 1)
9160     {
9161       printf ("\"%s\"\n", p);
9162       p += strlen ((char *) p) + 1;
9163     }
9164   else
9165     {
9166       val = read_uleb128 (p, &len);
9167       p += len;
9168       printf ("%d (0x%x)\n", val, val);
9169     }
9170
9171   return p;
9172 }
9173
9174 static unsigned char *
9175 display_mips_gnu_attribute (unsigned char * p, int tag)
9176 {
9177   int type;
9178   unsigned int len;
9179   int val;
9180
9181   if (tag == Tag_GNU_MIPS_ABI_FP)
9182     {
9183       val = read_uleb128 (p, &len);
9184       p += len;
9185       printf ("  Tag_GNU_MIPS_ABI_FP: ");
9186
9187       switch (val)
9188         {
9189         case 0:
9190           printf ("Hard or soft float\n");
9191           break;
9192         case 1:
9193           printf ("Hard float (-mdouble-float)\n");
9194           break;
9195         case 2:
9196           printf ("Hard float (-msingle-float)\n");
9197           break;
9198         case 3:
9199           printf ("Soft float\n");
9200           break;
9201         case 4:
9202           printf ("64-bit float (-mips32r2 -mfp64)\n");
9203           break;
9204         default:
9205           printf ("??? (%d)\n", val);
9206           break;
9207         }
9208       return p;
9209    }
9210
9211   if (tag & 1)
9212     type = 1; /* String.  */
9213   else
9214     type = 2; /* uleb128.  */
9215   printf ("  Tag_unknown_%d: ", tag);
9216
9217   if (type == 1)
9218     {
9219       printf ("\"%s\"\n", p);
9220       p += strlen ((char *) p) + 1;
9221     }
9222   else
9223     {
9224       val = read_uleb128 (p, &len);
9225       p += len;
9226       printf ("%d (0x%x)\n", val, val);
9227     }
9228
9229   return p;
9230 }
9231
9232 static int
9233 process_attributes (FILE * file,
9234                     const char * public_name,
9235                     unsigned int proc_type,
9236                     unsigned char * (* display_pub_attribute) (unsigned char *),
9237                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9238 {
9239   Elf_Internal_Shdr * sect;
9240   unsigned char * contents;
9241   unsigned char * p;
9242   unsigned char * end;
9243   bfd_vma section_len;
9244   bfd_vma len;
9245   unsigned i;
9246
9247   /* Find the section header so that we get the size.  */
9248   for (i = 0, sect = section_headers;
9249        i < elf_header.e_shnum;
9250        i++, sect++)
9251     {
9252       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
9253         continue;
9254
9255       contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
9256                            _("attributes"));
9257       if (contents == NULL)
9258         continue;
9259
9260       p = contents;
9261       if (*p == 'A')
9262         {
9263           len = sect->sh_size - 1;
9264           p++;
9265
9266           while (len > 0)
9267             {
9268               int namelen;
9269               bfd_boolean public_section;
9270               bfd_boolean gnu_section;
9271
9272               section_len = byte_get (p, 4);
9273               p += 4;
9274
9275               if (section_len > len)
9276                 {
9277                   printf (_("ERROR: Bad section length (%d > %d)\n"),
9278                           (int) section_len, (int) len);
9279                   section_len = len;
9280                 }
9281
9282               len -= section_len;
9283               printf ("Attribute Section: %s\n", p);
9284
9285               if (public_name && streq ((char *) p, public_name))
9286                 public_section = TRUE;
9287               else
9288                 public_section = FALSE;
9289
9290               if (streq ((char *) p, "gnu"))
9291                 gnu_section = TRUE;
9292               else
9293                 gnu_section = FALSE;
9294
9295               namelen = strlen ((char *) p) + 1;
9296               p += namelen;
9297               section_len -= namelen + 4;
9298
9299               while (section_len > 0)
9300                 {
9301                   int tag = *(p++);
9302                   int val;
9303                   bfd_vma size;
9304
9305                   size = byte_get (p, 4);
9306                   if (size > section_len)
9307                     {
9308                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9309                               (int) size, (int) section_len);
9310                       size = section_len;
9311                     }
9312
9313                   section_len -= size;
9314                   end = p + size - 1;
9315                   p += 4;
9316
9317                   switch (tag)
9318                     {
9319                     case 1:
9320                       printf ("File Attributes\n");
9321                       break;
9322                     case 2:
9323                       printf ("Section Attributes:");
9324                       goto do_numlist;
9325                     case 3:
9326                       printf ("Symbol Attributes:");
9327                     do_numlist:
9328                       for (;;)
9329                         {
9330                           unsigned int i;
9331
9332                           val = read_uleb128 (p, &i);
9333                           p += i;
9334                           if (val == 0)
9335                             break;
9336                           printf (" %d", val);
9337                         }
9338                       printf ("\n");
9339                       break;
9340                     default:
9341                       printf ("Unknown tag: %d\n", tag);
9342                       public_section = FALSE;
9343                       break;
9344                     }
9345
9346                   if (public_section)
9347                     {
9348                       while (p < end)
9349                         p = display_pub_attribute (p);
9350                     }
9351                   else if (gnu_section)
9352                     {
9353                       while (p < end)
9354                         p = display_gnu_attribute (p,
9355                                                    display_proc_gnu_attribute);
9356                     }
9357                   else
9358                     {
9359                       /* ??? Do something sensible, like dump hex.  */
9360                       printf ("  Unknown section contexts\n");
9361                       p = end;
9362                     }
9363                 }
9364             }
9365         }
9366       else
9367         printf (_("Unknown format '%c'\n"), *p);
9368
9369       free (contents);
9370     }
9371   return 1;
9372 }
9373
9374 static int
9375 process_arm_specific (FILE * file)
9376 {
9377   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
9378                              display_arm_attribute, NULL);
9379 }
9380
9381 static int
9382 process_power_specific (FILE * file)
9383 {
9384   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9385                              display_power_gnu_attribute);
9386 }
9387
9388 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9389    Print the Address, Access and Initial fields of an entry at VMA ADDR
9390    and return the VMA of the next entry.  */
9391
9392 static bfd_vma
9393 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
9394 {
9395   printf ("  ");
9396   print_vma (addr, LONG_HEX);
9397   printf (" ");
9398   if (addr < pltgot + 0xfff0)
9399     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
9400   else
9401     printf ("%10s", "");
9402   printf (" ");
9403   if (data == NULL)
9404     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9405   else
9406     {
9407       bfd_vma entry;
9408
9409       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9410       print_vma (entry, LONG_HEX);
9411     }
9412   return addr + (is_32bit_elf ? 4 : 8);
9413 }
9414
9415 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9416    PLTGOT.  Print the Address and Initial fields of an entry at VMA
9417    ADDR and return the VMA of the next entry.  */
9418
9419 static bfd_vma
9420 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
9421 {
9422   printf ("  ");
9423   print_vma (addr, LONG_HEX);
9424   printf (" ");
9425   if (data == NULL)
9426     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9427   else
9428     {
9429       bfd_vma entry;
9430
9431       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9432       print_vma (entry, LONG_HEX);
9433     }
9434   return addr + (is_32bit_elf ? 4 : 8);
9435 }
9436
9437 static int
9438 process_mips_specific (FILE * file)
9439 {
9440   Elf_Internal_Dyn * entry;
9441   size_t liblist_offset = 0;
9442   size_t liblistno = 0;
9443   size_t conflictsno = 0;
9444   size_t options_offset = 0;
9445   size_t conflicts_offset = 0;
9446   size_t pltrelsz = 0;
9447   size_t pltrel = 0;
9448   bfd_vma pltgot = 0;
9449   bfd_vma mips_pltgot = 0;
9450   bfd_vma jmprel = 0;
9451   bfd_vma local_gotno = 0;
9452   bfd_vma gotsym = 0;
9453   bfd_vma symtabno = 0;
9454
9455   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9456                       display_mips_gnu_attribute);
9457
9458   /* We have a lot of special sections.  Thanks SGI!  */
9459   if (dynamic_section == NULL)
9460     /* No information available.  */
9461     return 0;
9462
9463   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9464     switch (entry->d_tag)
9465       {
9466       case DT_MIPS_LIBLIST:
9467         liblist_offset
9468           = offset_from_vma (file, entry->d_un.d_val,
9469                              liblistno * sizeof (Elf32_External_Lib));
9470         break;
9471       case DT_MIPS_LIBLISTNO:
9472         liblistno = entry->d_un.d_val;
9473         break;
9474       case DT_MIPS_OPTIONS:
9475         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9476         break;
9477       case DT_MIPS_CONFLICT:
9478         conflicts_offset
9479           = offset_from_vma (file, entry->d_un.d_val,
9480                              conflictsno * sizeof (Elf32_External_Conflict));
9481         break;
9482       case DT_MIPS_CONFLICTNO:
9483         conflictsno = entry->d_un.d_val;
9484         break;
9485       case DT_PLTGOT:
9486         pltgot = entry->d_un.d_ptr;
9487         break;
9488       case DT_MIPS_LOCAL_GOTNO:
9489         local_gotno = entry->d_un.d_val;
9490         break;
9491       case DT_MIPS_GOTSYM:
9492         gotsym = entry->d_un.d_val;
9493         break;
9494       case DT_MIPS_SYMTABNO:
9495         symtabno = entry->d_un.d_val;
9496         break;
9497       case DT_MIPS_PLTGOT:
9498         mips_pltgot = entry->d_un.d_ptr;
9499         break;
9500       case DT_PLTREL:
9501         pltrel = entry->d_un.d_val;
9502         break;
9503       case DT_PLTRELSZ:
9504         pltrelsz = entry->d_un.d_val;
9505         break;
9506       case DT_JMPREL:
9507         jmprel = entry->d_un.d_ptr;
9508         break;
9509       default:
9510         break;
9511       }
9512
9513   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9514     {
9515       Elf32_External_Lib * elib;
9516       size_t cnt;
9517
9518       elib = get_data (NULL, file, liblist_offset,
9519                        liblistno, sizeof (Elf32_External_Lib),
9520                        _("liblist"));
9521       if (elib)
9522         {
9523           printf ("\nSection '.liblist' contains %lu entries:\n",
9524                   (unsigned long) liblistno);
9525           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
9526                  stdout);
9527
9528           for (cnt = 0; cnt < liblistno; ++cnt)
9529             {
9530               Elf32_Lib liblist;
9531               time_t time;
9532               char timebuf[20];
9533               struct tm * tmp;
9534
9535               liblist.l_name = BYTE_GET (elib[cnt].l_name);
9536               time = BYTE_GET (elib[cnt].l_time_stamp);
9537               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9538               liblist.l_version = BYTE_GET (elib[cnt].l_version);
9539               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9540
9541               tmp = gmtime (&time);
9542               snprintf (timebuf, sizeof (timebuf),
9543                         "%04u-%02u-%02uT%02u:%02u:%02u",
9544                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9545                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9546
9547               printf ("%3lu: ", (unsigned long) cnt);
9548               if (VALID_DYNAMIC_NAME (liblist.l_name))
9549                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9550               else
9551                 printf ("<corrupt: %9ld>", liblist.l_name);
9552               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9553                       liblist.l_version);
9554
9555               if (liblist.l_flags == 0)
9556                 puts (" NONE");
9557               else
9558                 {
9559                   static const struct
9560                   {
9561                     const char * name;
9562                     int bit;
9563                   }
9564                   l_flags_vals[] =
9565                   {
9566                     { " EXACT_MATCH", LL_EXACT_MATCH },
9567                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9568                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9569                     { " EXPORTS", LL_EXPORTS },
9570                     { " DELAY_LOAD", LL_DELAY_LOAD },
9571                     { " DELTA", LL_DELTA }
9572                   };
9573                   int flags = liblist.l_flags;
9574                   size_t fcnt;
9575
9576                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
9577                     if ((flags & l_flags_vals[fcnt].bit) != 0)
9578                       {
9579                         fputs (l_flags_vals[fcnt].name, stdout);
9580                         flags ^= l_flags_vals[fcnt].bit;
9581                       }
9582                   if (flags != 0)
9583                     printf (" %#x", (unsigned int) flags);
9584
9585                   puts ("");
9586                 }
9587             }
9588
9589           free (elib);
9590         }
9591     }
9592
9593   if (options_offset != 0)
9594     {
9595       Elf_External_Options * eopt;
9596       Elf_Internal_Shdr * sect = section_headers;
9597       Elf_Internal_Options * iopt;
9598       Elf_Internal_Options * option;
9599       size_t offset;
9600       int cnt;
9601
9602       /* Find the section header so that we get the size.  */
9603       while (sect->sh_type != SHT_MIPS_OPTIONS)
9604         ++sect;
9605
9606       eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
9607                        _("options"));
9608       if (eopt)
9609         {
9610           iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
9611           if (iopt == NULL)
9612             {
9613               error (_("Out of memory\n"));
9614               return 0;
9615             }
9616
9617           offset = cnt = 0;
9618           option = iopt;
9619
9620           while (offset < sect->sh_size)
9621             {
9622               Elf_External_Options * eoption;
9623
9624               eoption = (Elf_External_Options *) ((char *) eopt + offset);
9625
9626               option->kind = BYTE_GET (eoption->kind);
9627               option->size = BYTE_GET (eoption->size);
9628               option->section = BYTE_GET (eoption->section);
9629               option->info = BYTE_GET (eoption->info);
9630
9631               offset += option->size;
9632
9633               ++option;
9634               ++cnt;
9635             }
9636
9637           printf (_("\nSection '%s' contains %d entries:\n"),
9638                   SECTION_NAME (sect), cnt);
9639
9640           option = iopt;
9641
9642           while (cnt-- > 0)
9643             {
9644               size_t len;
9645
9646               switch (option->kind)
9647                 {
9648                 case ODK_NULL:
9649                   /* This shouldn't happen.  */
9650                   printf (" NULL       %d %lx", option->section, option->info);
9651                   break;
9652                 case ODK_REGINFO:
9653                   printf (" REGINFO    ");
9654                   if (elf_header.e_machine == EM_MIPS)
9655                     {
9656                       /* 32bit form.  */
9657                       Elf32_External_RegInfo * ereg;
9658                       Elf32_RegInfo reginfo;
9659
9660                       ereg = (Elf32_External_RegInfo *) (option + 1);
9661                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9662                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9663                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9664                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9665                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9666                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9667
9668                       printf ("GPR %08lx  GP 0x%lx\n",
9669                               reginfo.ri_gprmask,
9670                               (unsigned long) reginfo.ri_gp_value);
9671                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9672                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9673                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9674                     }
9675                   else
9676                     {
9677                       /* 64 bit form.  */
9678                       Elf64_External_RegInfo * ereg;
9679                       Elf64_Internal_RegInfo reginfo;
9680
9681                       ereg = (Elf64_External_RegInfo *) (option + 1);
9682                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
9683                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9684                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9685                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9686                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9687                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
9688
9689                       printf ("GPR %08lx  GP 0x",
9690                               reginfo.ri_gprmask);
9691                       printf_vma (reginfo.ri_gp_value);
9692                       printf ("\n");
9693
9694                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9695                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9696                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9697                     }
9698                   ++option;
9699                   continue;
9700                 case ODK_EXCEPTIONS:
9701                   fputs (" EXCEPTIONS fpe_min(", stdout);
9702                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9703                   fputs (") fpe_max(", stdout);
9704                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9705                   fputs (")", stdout);
9706
9707                   if (option->info & OEX_PAGE0)
9708                     fputs (" PAGE0", stdout);
9709                   if (option->info & OEX_SMM)
9710                     fputs (" SMM", stdout);
9711                   if (option->info & OEX_FPDBUG)
9712                     fputs (" FPDBUG", stdout);
9713                   if (option->info & OEX_DISMISS)
9714                     fputs (" DISMISS", stdout);
9715                   break;
9716                 case ODK_PAD:
9717                   fputs (" PAD       ", stdout);
9718                   if (option->info & OPAD_PREFIX)
9719                     fputs (" PREFIX", stdout);
9720                   if (option->info & OPAD_POSTFIX)
9721                     fputs (" POSTFIX", stdout);
9722                   if (option->info & OPAD_SYMBOL)
9723                     fputs (" SYMBOL", stdout);
9724                   break;
9725                 case ODK_HWPATCH:
9726                   fputs (" HWPATCH   ", stdout);
9727                   if (option->info & OHW_R4KEOP)
9728                     fputs (" R4KEOP", stdout);
9729                   if (option->info & OHW_R8KPFETCH)
9730                     fputs (" R8KPFETCH", stdout);
9731                   if (option->info & OHW_R5KEOP)
9732                     fputs (" R5KEOP", stdout);
9733                   if (option->info & OHW_R5KCVTL)
9734                     fputs (" R5KCVTL", stdout);
9735                   break;
9736                 case ODK_FILL:
9737                   fputs (" FILL       ", stdout);
9738                   /* XXX Print content of info word?  */
9739                   break;
9740                 case ODK_TAGS:
9741                   fputs (" TAGS       ", stdout);
9742                   /* XXX Print content of info word?  */
9743                   break;
9744                 case ODK_HWAND:
9745                   fputs (" HWAND     ", stdout);
9746                   if (option->info & OHWA0_R4KEOP_CHECKED)
9747                     fputs (" R4KEOP_CHECKED", stdout);
9748                   if (option->info & OHWA0_R4KEOP_CLEAN)
9749                     fputs (" R4KEOP_CLEAN", stdout);
9750                   break;
9751                 case ODK_HWOR:
9752                   fputs (" HWOR      ", 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_GP_GROUP:
9759                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
9760                           option->info & OGP_GROUP,
9761                           (option->info & OGP_SELF) >> 16);
9762                   break;
9763                 case ODK_IDENT:
9764                   printf (" IDENT     %#06lx  self-contained %#06lx",
9765                           option->info & OGP_GROUP,
9766                           (option->info & OGP_SELF) >> 16);
9767                   break;
9768                 default:
9769                   /* This shouldn't happen.  */
9770                   printf (" %3d ???     %d %lx",
9771                           option->kind, option->section, option->info);
9772                   break;
9773                 }
9774
9775               len = sizeof (* eopt);
9776               while (len < option->size)
9777                 if (((char *) option)[len] >= ' '
9778                     && ((char *) option)[len] < 0x7f)
9779                   printf ("%c", ((char *) option)[len++]);
9780                 else
9781                   printf ("\\%03o", ((char *) option)[len++]);
9782
9783               fputs ("\n", stdout);
9784               ++option;
9785             }
9786
9787           free (eopt);
9788         }
9789     }
9790
9791   if (conflicts_offset != 0 && conflictsno != 0)
9792     {
9793       Elf32_Conflict * iconf;
9794       size_t cnt;
9795
9796       if (dynamic_symbols == NULL)
9797         {
9798           error (_("conflict list found without a dynamic symbol table\n"));
9799           return 0;
9800         }
9801
9802       iconf = cmalloc (conflictsno, sizeof (* iconf));
9803       if (iconf == NULL)
9804         {
9805           error (_("Out of memory\n"));
9806           return 0;
9807         }
9808
9809       if (is_32bit_elf)
9810         {
9811           Elf32_External_Conflict * econf32;
9812
9813           econf32 = get_data (NULL, file, conflicts_offset,
9814                               conflictsno, sizeof (* econf32), _("conflict"));
9815           if (!econf32)
9816             return 0;
9817
9818           for (cnt = 0; cnt < conflictsno; ++cnt)
9819             iconf[cnt] = BYTE_GET (econf32[cnt]);
9820
9821           free (econf32);
9822         }
9823       else
9824         {
9825           Elf64_External_Conflict * econf64;
9826
9827           econf64 = get_data (NULL, file, conflicts_offset,
9828                               conflictsno, sizeof (* econf64), _("conflict"));
9829           if (!econf64)
9830             return 0;
9831
9832           for (cnt = 0; cnt < conflictsno; ++cnt)
9833             iconf[cnt] = BYTE_GET (econf64[cnt]);
9834
9835           free (econf64);
9836         }
9837
9838       printf (_("\nSection '.conflict' contains %lu entries:\n"),
9839               (unsigned long) conflictsno);
9840       puts (_("  Num:    Index       Value  Name"));
9841
9842       for (cnt = 0; cnt < conflictsno; ++cnt)
9843         {
9844           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
9845
9846           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
9847           print_vma (psym->st_value, FULL_HEX);
9848           putchar (' ');
9849           if (VALID_DYNAMIC_NAME (psym->st_name))
9850             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9851           else
9852             printf ("<corrupt: %14ld>", psym->st_name);
9853           putchar ('\n');
9854         }
9855
9856       free (iconf);
9857     }
9858
9859   if (pltgot != 0 && local_gotno != 0)
9860     {
9861       bfd_vma entry, local_end, global_end;
9862       size_t i, offset;
9863       unsigned char * data;
9864       int addr_size;
9865
9866       entry = pltgot;
9867       addr_size = (is_32bit_elf ? 4 : 8);
9868       local_end = pltgot + local_gotno * addr_size;
9869       global_end = local_end + (symtabno - gotsym) * addr_size;
9870
9871       offset = offset_from_vma (file, pltgot, global_end - pltgot);
9872       data = get_data (NULL, file, offset, global_end - pltgot, 1, _("GOT"));
9873       printf (_("\nPrimary GOT:\n"));
9874       printf (_(" Canonical gp value: "));
9875       print_vma (pltgot + 0x7ff0, LONG_HEX);
9876       printf ("\n\n");
9877
9878       printf (_(" Reserved entries:\n"));
9879       printf (_("  %*s %10s %*s Purpose\n"),
9880               addr_size * 2, "Address", "Access",
9881               addr_size * 2, "Initial");
9882       entry = print_mips_got_entry (data, pltgot, entry);
9883       printf (" Lazy resolver\n");
9884       if (data
9885           && (byte_get (data + entry - pltgot, addr_size)
9886               >> (addr_size * 8 - 1)) != 0)
9887         {
9888           entry = print_mips_got_entry (data, pltgot, entry);
9889           printf (" Module pointer (GNU extension)\n");
9890         }
9891       printf ("\n");
9892
9893       if (entry < local_end)
9894         {
9895           printf (_(" Local entries:\n"));
9896           printf (_("  %*s %10s %*s\n"),
9897                   addr_size * 2, "Address", "Access",
9898                   addr_size * 2, "Initial");
9899           while (entry < local_end)
9900             {
9901               entry = print_mips_got_entry (data, pltgot, entry);
9902               printf ("\n");
9903             }
9904           printf ("\n");
9905         }
9906
9907       if (gotsym < symtabno)
9908         {
9909           int sym_width;
9910
9911           printf (_(" Global entries:\n"));
9912           printf (_("  %*s %10s %*s %*s %-7s %3s %s\n"),
9913                   addr_size * 2, "Address", "Access",
9914                   addr_size * 2, "Initial",
9915                   addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
9916           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
9917           for (i = gotsym; i < symtabno; i++)
9918             {
9919               Elf_Internal_Sym * psym;
9920
9921               psym = dynamic_symbols + i;
9922               entry = print_mips_got_entry (data, pltgot, entry);
9923               printf (" ");
9924               print_vma (psym->st_value, LONG_HEX);
9925               printf (" %-7s %3s ",
9926                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
9927                       get_symbol_index_type (psym->st_shndx));
9928               if (VALID_DYNAMIC_NAME (psym->st_name))
9929                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
9930               else
9931                 printf ("<corrupt: %14ld>", psym->st_name);
9932               printf ("\n");
9933             }
9934           printf ("\n");
9935         }
9936
9937       if (data)
9938         free (data);
9939     }
9940
9941   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
9942     {
9943       bfd_vma entry, end;
9944       size_t offset, rel_offset;
9945       unsigned long count, i;
9946       unsigned char * data;
9947       int addr_size, sym_width;
9948       Elf_Internal_Rela * rels;
9949
9950       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
9951       if (pltrel == DT_RELA)
9952         {
9953           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
9954             return 0;
9955         }
9956       else
9957         {
9958           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
9959             return 0;
9960         }
9961
9962       entry = mips_pltgot;
9963       addr_size = (is_32bit_elf ? 4 : 8);
9964       end = mips_pltgot + (2 + count) * addr_size;
9965
9966       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
9967       data = get_data (NULL, file, offset, end - mips_pltgot, 1, _("PLT GOT"));
9968       printf (_("\nPLT GOT:\n\n"));
9969       printf (_(" Reserved entries:\n"));
9970       printf (_("  %*s %*s Purpose\n"),
9971               addr_size * 2, "Address", addr_size * 2, "Initial");
9972       entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9973       printf (" PLT lazy resolver\n");
9974       entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9975       printf (" Module pointer\n");
9976       printf ("\n");
9977
9978       printf (_(" Entries:\n"));
9979       printf (_("  %*s %*s %*s %-7s %3s %s\n"),
9980               addr_size * 2, "Address",
9981               addr_size * 2, "Initial",
9982               addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
9983       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
9984       for (i = 0; i < count; i++)
9985         {
9986           Elf_Internal_Sym * psym;
9987
9988           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
9989           entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9990           printf (" ");
9991           print_vma (psym->st_value, LONG_HEX);
9992           printf (" %-7s %3s ",
9993                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
9994                   get_symbol_index_type (psym->st_shndx));
9995           if (VALID_DYNAMIC_NAME (psym->st_name))
9996             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
9997           else
9998             printf ("<corrupt: %14ld>", psym->st_name);
9999           printf ("\n");
10000         }
10001       printf ("\n");
10002
10003       if (data)
10004         free (data);
10005       free (rels);
10006     }
10007
10008   return 1;
10009 }
10010
10011 static int
10012 process_gnu_liblist (FILE * file)
10013 {
10014   Elf_Internal_Shdr * section;
10015   Elf_Internal_Shdr * string_sec;
10016   Elf32_External_Lib * elib;
10017   char * strtab;
10018   size_t strtab_size;
10019   size_t cnt;
10020   unsigned i;
10021
10022   if (! do_arch)
10023     return 0;
10024
10025   for (i = 0, section = section_headers;
10026        i < elf_header.e_shnum;
10027        i++, section++)
10028     {
10029       switch (section->sh_type)
10030         {
10031         case SHT_GNU_LIBLIST:
10032           if (section->sh_link >= elf_header.e_shnum)
10033             break;
10034
10035           elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
10036                            _("liblist"));
10037
10038           if (elib == NULL)
10039             break;
10040           string_sec = section_headers + section->sh_link;
10041
10042           strtab = get_data (NULL, file, string_sec->sh_offset, 1,
10043                              string_sec->sh_size, _("liblist string table"));
10044           strtab_size = string_sec->sh_size;
10045
10046           if (strtab == NULL
10047               || section->sh_entsize != sizeof (Elf32_External_Lib))
10048             {
10049               free (elib);
10050               break;
10051             }
10052
10053           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10054                   SECTION_NAME (section),
10055                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
10056
10057           puts ("     Library              Time Stamp          Checksum   Version Flags");
10058
10059           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
10060                ++cnt)
10061             {
10062               Elf32_Lib liblist;
10063               time_t time;
10064               char timebuf[20];
10065               struct tm * tmp;
10066
10067               liblist.l_name = BYTE_GET (elib[cnt].l_name);
10068               time = BYTE_GET (elib[cnt].l_time_stamp);
10069               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10070               liblist.l_version = BYTE_GET (elib[cnt].l_version);
10071               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10072
10073               tmp = gmtime (&time);
10074               snprintf (timebuf, sizeof (timebuf),
10075                         "%04u-%02u-%02uT%02u:%02u:%02u",
10076                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10077                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10078
10079               printf ("%3lu: ", (unsigned long) cnt);
10080               if (do_wide)
10081                 printf ("%-20s", liblist.l_name < strtab_size
10082                                  ? strtab + liblist.l_name : "<corrupt>");
10083               else
10084                 printf ("%-20.20s", liblist.l_name < strtab_size
10085                                     ? strtab + liblist.l_name : "<corrupt>");
10086               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
10087                       liblist.l_version, liblist.l_flags);
10088             }
10089
10090           free (elib);
10091         }
10092     }
10093
10094   return 1;
10095 }
10096
10097 static const char *
10098 get_note_type (unsigned e_type)
10099 {
10100   static char buff[64];
10101
10102   if (elf_header.e_type == ET_CORE)
10103     switch (e_type)
10104       {
10105       case NT_AUXV:
10106         return _("NT_AUXV (auxiliary vector)");
10107       case NT_PRSTATUS:
10108         return _("NT_PRSTATUS (prstatus structure)");
10109       case NT_FPREGSET:
10110         return _("NT_FPREGSET (floating point registers)");
10111       case NT_PRPSINFO:
10112         return _("NT_PRPSINFO (prpsinfo structure)");
10113       case NT_TASKSTRUCT:
10114         return _("NT_TASKSTRUCT (task structure)");
10115       case NT_PRXFPREG:
10116         return _("NT_PRXFPREG (user_xfpregs structure)");
10117       case NT_PPC_VMX:
10118         return _("NT_PPC_VMX (ppc Altivec registers)");
10119       case NT_PPC_VSX:
10120         return _("NT_PPC_VSX (ppc VSX registers)");
10121       case NT_PSTATUS:
10122         return _("NT_PSTATUS (pstatus structure)");
10123       case NT_FPREGS:
10124         return _("NT_FPREGS (floating point registers)");
10125       case NT_PSINFO:
10126         return _("NT_PSINFO (psinfo structure)");
10127       case NT_LWPSTATUS:
10128         return _("NT_LWPSTATUS (lwpstatus_t structure)");
10129       case NT_LWPSINFO:
10130         return _("NT_LWPSINFO (lwpsinfo_t structure)");
10131       case NT_WIN32PSTATUS:
10132         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10133       default:
10134         break;
10135       }
10136   else
10137     switch (e_type)
10138       {
10139       case NT_VERSION:
10140         return _("NT_VERSION (version)");
10141       case NT_ARCH:
10142         return _("NT_ARCH (architecture)");
10143       default:
10144         break;
10145       }
10146
10147   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10148   return buff;
10149 }
10150
10151 static const char *
10152 get_gnu_elf_note_type (unsigned e_type)
10153 {
10154   static char buff[64];
10155
10156   switch (e_type)
10157     {
10158     case NT_GNU_ABI_TAG:
10159       return _("NT_GNU_ABI_TAG (ABI version tag)");
10160     case NT_GNU_HWCAP:
10161       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10162     case NT_GNU_BUILD_ID:
10163       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10164     case NT_GNU_GOLD_VERSION:
10165       return _("NT_GNU_GOLD_VERSION (gold version)");
10166     default:
10167       break;
10168     }
10169
10170   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10171   return buff;
10172 }
10173
10174 static const char *
10175 get_netbsd_elfcore_note_type (unsigned e_type)
10176 {
10177   static char buff[64];
10178
10179   if (e_type == NT_NETBSDCORE_PROCINFO)
10180     {
10181       /* NetBSD core "procinfo" structure.  */
10182       return _("NetBSD procinfo structure");
10183     }
10184
10185   /* As of Jan 2002 there are no other machine-independent notes
10186      defined for NetBSD core files.  If the note type is less
10187      than the start of the machine-dependent note types, we don't
10188      understand it.  */
10189
10190   if (e_type < NT_NETBSDCORE_FIRSTMACH)
10191     {
10192       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10193       return buff;
10194     }
10195
10196   switch (elf_header.e_machine)
10197     {
10198     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10199        and PT_GETFPREGS == mach+2.  */
10200
10201     case EM_OLD_ALPHA:
10202     case EM_ALPHA:
10203     case EM_SPARC:
10204     case EM_SPARC32PLUS:
10205     case EM_SPARCV9:
10206       switch (e_type)
10207         {
10208         case NT_NETBSDCORE_FIRSTMACH+0:
10209           return _("PT_GETREGS (reg structure)");
10210         case NT_NETBSDCORE_FIRSTMACH+2:
10211           return _("PT_GETFPREGS (fpreg structure)");
10212         default:
10213           break;
10214         }
10215       break;
10216
10217     /* On all other arch's, PT_GETREGS == mach+1 and
10218        PT_GETFPREGS == mach+3.  */
10219     default:
10220       switch (e_type)
10221         {
10222         case NT_NETBSDCORE_FIRSTMACH+1:
10223           return _("PT_GETREGS (reg structure)");
10224         case NT_NETBSDCORE_FIRSTMACH+3:
10225           return _("PT_GETFPREGS (fpreg structure)");
10226         default:
10227           break;
10228         }
10229     }
10230
10231   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
10232             e_type - NT_NETBSDCORE_FIRSTMACH);
10233   return buff;
10234 }
10235
10236 /* Note that by the ELF standard, the name field is already null byte
10237    terminated, and namesz includes the terminating null byte.
10238    I.E. the value of namesz for the name "FSF" is 4.
10239
10240    If the value of namesz is zero, there is no name present.  */
10241 static int
10242 process_note (Elf_Internal_Note * pnote)
10243 {
10244   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
10245   const char * nt;
10246
10247   if (pnote->namesz == 0)
10248     /* If there is no note name, then use the default set of
10249        note type strings.  */
10250     nt = get_note_type (pnote->type);
10251
10252   else if (const_strneq (pnote->namedata, "GNU"))
10253     /* GNU-specific object file notes.  */
10254     nt = get_gnu_elf_note_type (pnote->type);
10255
10256   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
10257     /* NetBSD-specific core file notes.  */
10258     nt = get_netbsd_elfcore_note_type (pnote->type);
10259
10260   else if (strneq (pnote->namedata, "SPU/", 4))
10261     {
10262       /* SPU-specific core file notes.  */
10263       nt = pnote->namedata + 4;
10264       name = "SPU";
10265     }
10266
10267   else
10268     /* Don't recognize this note name; just use the default set of
10269        note type strings.  */
10270       nt = get_note_type (pnote->type);
10271
10272   printf ("  %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
10273   return 1;
10274 }
10275
10276
10277 static int
10278 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
10279 {
10280   Elf_External_Note * pnotes;
10281   Elf_External_Note * external;
10282   int res = 1;
10283
10284   if (length <= 0)
10285     return 0;
10286
10287   pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
10288   if (!pnotes)
10289     return 0;
10290
10291   external = pnotes;
10292
10293   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10294           (unsigned long) offset, (unsigned long) length);
10295   printf (_("  Owner\t\tData size\tDescription\n"));
10296
10297   while (external < (Elf_External_Note *) ((char *) pnotes + length))
10298     {
10299       Elf_External_Note * next;
10300       Elf_Internal_Note inote;
10301       char * temp = NULL;
10302
10303       inote.type     = BYTE_GET (external->type);
10304       inote.namesz   = BYTE_GET (external->namesz);
10305       inote.namedata = external->name;
10306       inote.descsz   = BYTE_GET (external->descsz);
10307       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10308       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
10309
10310       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
10311
10312       if (((char *) next) > (((char *) pnotes) + length))
10313         {
10314           warn (_("corrupt note found at offset %lx into core notes\n"),
10315                 (unsigned long) ((char *) external - (char *) pnotes));
10316           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10317                 inote.type, inote.namesz, inote.descsz);
10318           break;
10319         }
10320
10321       external = next;
10322
10323       /* Verify that name is null terminated.  It appears that at least
10324          one version of Linux (RedHat 6.0) generates corefiles that don't
10325          comply with the ELF spec by failing to include the null byte in
10326          namesz.  */
10327       if (inote.namedata[inote.namesz] != '\0')
10328         {
10329           temp = malloc (inote.namesz + 1);
10330
10331           if (temp == NULL)
10332             {
10333               error (_("Out of memory\n"));
10334               res = 0;
10335               break;
10336             }
10337
10338           strncpy (temp, inote.namedata, inote.namesz);
10339           temp[inote.namesz] = 0;
10340
10341           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
10342           inote.namedata = temp;
10343         }
10344
10345       res &= process_note (& inote);
10346
10347       if (temp != NULL)
10348         {
10349           free (temp);
10350           temp = NULL;
10351         }
10352     }
10353
10354   free (pnotes);
10355
10356   return res;
10357 }
10358
10359 static int
10360 process_corefile_note_segments (FILE * file)
10361 {
10362   Elf_Internal_Phdr * segment;
10363   unsigned int i;
10364   int res = 1;
10365
10366   if (! get_program_headers (file))
10367       return 0;
10368
10369   for (i = 0, segment = program_headers;
10370        i < elf_header.e_phnum;
10371        i++, segment++)
10372     {
10373       if (segment->p_type == PT_NOTE)
10374         res &= process_corefile_note_segment (file,
10375                                               (bfd_vma) segment->p_offset,
10376                                               (bfd_vma) segment->p_filesz);
10377     }
10378
10379   return res;
10380 }
10381
10382 static int
10383 process_note_sections (FILE * file)
10384 {
10385   Elf_Internal_Shdr * section;
10386   unsigned long i;
10387   int res = 1;
10388
10389   for (i = 0, section = section_headers;
10390        i < elf_header.e_shnum;
10391        i++, section++)
10392     if (section->sh_type == SHT_NOTE)
10393       res &= process_corefile_note_segment (file,
10394                                             (bfd_vma) section->sh_offset,
10395                                             (bfd_vma) section->sh_size);
10396
10397   return res;
10398 }
10399
10400 static int
10401 process_notes (FILE * file)
10402 {
10403   /* If we have not been asked to display the notes then do nothing.  */
10404   if (! do_notes)
10405     return 1;
10406
10407   if (elf_header.e_type != ET_CORE)
10408     return process_note_sections (file);
10409
10410   /* No program headers means no NOTE segment.  */
10411   if (elf_header.e_phnum > 0)
10412     return process_corefile_note_segments (file);
10413
10414   printf (_("No note segments present in the core file.\n"));
10415   return 1;
10416 }
10417
10418 static int
10419 process_arch_specific (FILE * file)
10420 {
10421   if (! do_arch)
10422     return 1;
10423
10424   switch (elf_header.e_machine)
10425     {
10426     case EM_ARM:
10427       return process_arm_specific (file);
10428     case EM_MIPS:
10429     case EM_MIPS_RS3_LE:
10430       return process_mips_specific (file);
10431       break;
10432     case EM_PPC:
10433       return process_power_specific (file);
10434       break;
10435     default:
10436       break;
10437     }
10438   return 1;
10439 }
10440
10441 static int
10442 get_file_header (FILE * file)
10443 {
10444   /* Read in the identity array.  */
10445   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10446     return 0;
10447
10448   /* Determine how to read the rest of the header.  */
10449   switch (elf_header.e_ident[EI_DATA])
10450     {
10451     default: /* fall through */
10452     case ELFDATANONE: /* fall through */
10453     case ELFDATA2LSB:
10454       byte_get = byte_get_little_endian;
10455       byte_put = byte_put_little_endian;
10456       break;
10457     case ELFDATA2MSB:
10458       byte_get = byte_get_big_endian;
10459       byte_put = byte_put_big_endian;
10460       break;
10461     }
10462
10463   /* For now we only support 32 bit and 64 bit ELF files.  */
10464   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10465
10466   /* Read in the rest of the header.  */
10467   if (is_32bit_elf)
10468     {
10469       Elf32_External_Ehdr ehdr32;
10470
10471       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10472         return 0;
10473
10474       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
10475       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
10476       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
10477       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
10478       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
10479       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
10480       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
10481       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
10482       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10483       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
10484       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10485       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
10486       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
10487     }
10488   else
10489     {
10490       Elf64_External_Ehdr ehdr64;
10491
10492       /* If we have been compiled with sizeof (bfd_vma) == 4, then
10493          we will not be able to cope with the 64bit data found in
10494          64 ELF files.  Detect this now and abort before we start
10495          overwriting things.  */
10496       if (sizeof (bfd_vma) < 8)
10497         {
10498           error (_("This instance of readelf has been built without support for a\n\
10499 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10500           return 0;
10501         }
10502
10503       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10504         return 0;
10505
10506       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
10507       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
10508       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
10509       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
10510       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
10511       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
10512       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
10513       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
10514       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10515       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
10516       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10517       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
10518       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
10519     }
10520
10521   if (elf_header.e_shoff)
10522     {
10523       /* There may be some extensions in the first section header.  Don't
10524          bomb if we can't read it.  */
10525       if (is_32bit_elf)
10526         get_32bit_section_headers (file, 1);
10527       else
10528         get_64bit_section_headers (file, 1);
10529     }
10530
10531   return 1;
10532 }
10533
10534 /* Process one ELF object file according to the command line options.
10535    This file may actually be stored in an archive.  The file is
10536    positioned at the start of the ELF object.  */
10537
10538 static int
10539 process_object (char * file_name, FILE * file)
10540 {
10541   unsigned int i;
10542
10543   if (! get_file_header (file))
10544     {
10545       error (_("%s: Failed to read file header\n"), file_name);
10546       return 1;
10547     }
10548
10549   /* Initialise per file variables.  */
10550   for (i = ARRAY_SIZE (version_info); i--;)
10551     version_info[i] = 0;
10552
10553   for (i = ARRAY_SIZE (dynamic_info); i--;)
10554     dynamic_info[i] = 0;
10555
10556   /* Process the file.  */
10557   if (show_name)
10558     printf (_("\nFile: %s\n"), file_name);
10559
10560   /* Initialise the dump_sects array from the cmdline_dump_sects array.
10561      Note we do this even if cmdline_dump_sects is empty because we
10562      must make sure that the dump_sets array is zeroed out before each
10563      object file is processed.  */
10564   if (num_dump_sects > num_cmdline_dump_sects)
10565     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
10566
10567   if (num_cmdline_dump_sects > 0)
10568     {
10569       if (num_dump_sects == 0)
10570         /* A sneaky way of allocating the dump_sects array.  */
10571         request_dump_bynumber (num_cmdline_dump_sects, 0);
10572
10573       assert (num_dump_sects >= num_cmdline_dump_sects);
10574       memcpy (dump_sects, cmdline_dump_sects,
10575               num_cmdline_dump_sects * sizeof (* dump_sects));
10576     }
10577
10578   if (! process_file_header ())
10579     return 1;
10580
10581   if (! process_section_headers (file))
10582     {
10583       /* Without loaded section headers we cannot process lots of
10584          things.  */
10585       do_unwind = do_version = do_dump = do_arch = 0;
10586
10587       if (! do_using_dynamic)
10588         do_syms = do_reloc = 0;
10589     }
10590
10591   if (! process_section_groups (file))
10592     {
10593       /* Without loaded section groups we cannot process unwind.  */
10594       do_unwind = 0;
10595     }
10596
10597   if (process_program_headers (file))
10598     process_dynamic_section (file);
10599
10600   process_relocs (file);
10601
10602   process_unwind (file);
10603
10604   process_symbol_table (file);
10605
10606   process_syminfo (file);
10607
10608   process_version_sections (file);
10609
10610   process_section_contents (file);
10611
10612   process_notes (file);
10613
10614   process_gnu_liblist (file);
10615
10616   process_arch_specific (file);
10617
10618   if (program_headers)
10619     {
10620       free (program_headers);
10621       program_headers = NULL;
10622     }
10623
10624   if (section_headers)
10625     {
10626       free (section_headers);
10627       section_headers = NULL;
10628     }
10629
10630   if (string_table)
10631     {
10632       free (string_table);
10633       string_table = NULL;
10634       string_table_length = 0;
10635     }
10636
10637   if (dynamic_strings)
10638     {
10639       free (dynamic_strings);
10640       dynamic_strings = NULL;
10641       dynamic_strings_length = 0;
10642     }
10643
10644   if (dynamic_symbols)
10645     {
10646       free (dynamic_symbols);
10647       dynamic_symbols = NULL;
10648       num_dynamic_syms = 0;
10649     }
10650
10651   if (dynamic_syminfo)
10652     {
10653       free (dynamic_syminfo);
10654       dynamic_syminfo = NULL;
10655     }
10656
10657   if (section_headers_groups)
10658     {
10659       free (section_headers_groups);
10660       section_headers_groups = NULL;
10661     }
10662
10663   if (section_groups)
10664     {
10665       struct group_list * g;
10666       struct group_list * next;
10667
10668       for (i = 0; i < group_count; i++)
10669         {
10670           for (g = section_groups [i].root; g != NULL; g = next)
10671             {
10672               next = g->next;
10673               free (g);
10674             }
10675         }
10676
10677       free (section_groups);
10678       section_groups = NULL;
10679     }
10680
10681   free_debug_memory ();
10682
10683   return 0;
10684 }
10685
10686 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10687    to the path name of the thin archive itself if necessary.  Always returns
10688    a pointer to malloc'ed memory.  */
10689
10690 static char *
10691 adjust_relative_path (char * file_name, char * name, int name_len)
10692 {
10693   char * member_file_name;
10694   const char * base_name = lbasename (file_name);
10695
10696   /* This is a proxy entry for a thin archive member.
10697      If the extended name table contains an absolute path
10698      name, or if the archive is in the current directory,
10699      use the path name as given.  Otherwise, we need to
10700      find the member relative to the directory where the
10701      archive is located.  */
10702   if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
10703     {
10704       member_file_name = malloc (name_len + 1);
10705       if (member_file_name == NULL)
10706         {
10707           error (_("Out of memory\n"));
10708           return NULL;
10709         }
10710       memcpy (member_file_name, name, name_len);
10711       member_file_name[name_len] = '\0';
10712     }
10713   else
10714     {
10715       /* Concatenate the path components of the archive file name
10716          to the relative path name from the extended name table.  */
10717       size_t prefix_len = base_name - file_name;
10718       member_file_name = malloc (prefix_len + name_len + 1);
10719       if (member_file_name == NULL)
10720         {
10721           error (_("Out of memory\n"));
10722           return NULL;
10723         }
10724       memcpy (member_file_name, file_name, prefix_len);
10725       memcpy (member_file_name + prefix_len, name, name_len);
10726       member_file_name[prefix_len + name_len] = '\0';
10727     }
10728   return member_file_name;
10729 }
10730
10731 /* Structure to hold information about an archive file.  */
10732
10733 struct archive_info
10734 {
10735   char * file_name;                     /* Archive file name.  */
10736   FILE * file;                          /* Open file descriptor.  */
10737   unsigned long index_num;              /* Number of symbols in table.  */
10738   unsigned long * index_array;          /* The array of member offsets.  */
10739   char * sym_table;                     /* The symbol table.  */
10740   unsigned long sym_size;               /* Size of the symbol table.  */
10741   char * longnames;                     /* The long file names table.  */
10742   unsigned long longnames_size;         /* Size of the long file names table.  */
10743   unsigned long nested_member_origin;   /* Origin in the nested archive of the current member.  */
10744   unsigned long next_arhdr_offset;      /* Offset of the next archive header.  */
10745   bfd_boolean is_thin_archive;          /* TRUE if this is a thin archive.  */
10746   struct ar_hdr arhdr;                  /* Current archive header.  */
10747 };
10748
10749 /* Read the symbol table and long-name table from an archive.  */
10750
10751 static int
10752 setup_archive (struct archive_info * arch, char * file_name, FILE * file,
10753                bfd_boolean is_thin_archive, bfd_boolean read_symbols)
10754 {
10755   size_t got;
10756   unsigned long size;
10757
10758   arch->file_name = strdup (file_name);
10759   arch->file = file;
10760   arch->index_num = 0;
10761   arch->index_array = NULL;
10762   arch->sym_table = NULL;
10763   arch->sym_size = 0;
10764   arch->longnames = NULL;
10765   arch->longnames_size = 0;
10766   arch->nested_member_origin = 0;
10767   arch->is_thin_archive = is_thin_archive;
10768   arch->next_arhdr_offset = SARMAG;
10769
10770   /* Read the first archive member header.  */
10771   if (fseek (file, SARMAG, SEEK_SET) != 0)
10772     {
10773       error (_("%s: failed to seek to first archive header\n"), file_name);
10774       return 1;
10775     }
10776   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
10777   if (got != sizeof arch->arhdr)
10778     {
10779       if (got == 0)
10780         return 0;
10781
10782       error (_("%s: failed to read archive header\n"), file_name);
10783       return 1;
10784     }
10785
10786   /* See if this is the archive symbol table.  */
10787   if (const_strneq (arch->arhdr.ar_name, "/               ")
10788       || const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
10789     {
10790       size = strtoul (arch->arhdr.ar_size, NULL, 10);
10791       size = size + (size & 1);
10792
10793       arch->next_arhdr_offset += sizeof arch->arhdr + size;
10794
10795       if (read_symbols)
10796         {
10797           unsigned long i;
10798           /* A buffer used to hold numbers read in from an archive index.
10799              These are always 4 bytes long and stored in big-endian format.  */
10800 #define SIZEOF_AR_INDEX_NUMBERS 4
10801           unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
10802           unsigned char * index_buffer;
10803
10804           /* Check the size of the archive index.  */
10805           if (size < SIZEOF_AR_INDEX_NUMBERS)
10806             {
10807               error (_("%s: the archive index is empty\n"), file_name);
10808               return 1;
10809             }
10810
10811           /* Read the numer of entries in the archive index.  */
10812           got = fread (integer_buffer, 1, sizeof integer_buffer, file);
10813           if (got != sizeof (integer_buffer))
10814             {
10815               error (_("%s: failed to read archive index\n"), file_name);
10816               return 1;
10817             }
10818           arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
10819           size -= SIZEOF_AR_INDEX_NUMBERS;
10820
10821           /* Read in the archive index.  */
10822           if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
10823             {
10824               error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10825                      file_name, arch->index_num);
10826               return 1;
10827             }
10828           index_buffer = malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
10829           if (index_buffer == NULL)
10830             {
10831               error (_("Out of memory whilst trying to read archive symbol index\n"));
10832               return 1;
10833             }
10834           got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
10835           if (got != arch->index_num)
10836             {
10837               free (index_buffer);
10838               error (_("%s: failed to read archive index\n"), file_name);
10839               return 1;
10840             }
10841           size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
10842
10843           /* Convert the index numbers into the host's numeric format.  */
10844           arch->index_array = malloc (arch->index_num * sizeof (* arch->index_array));
10845           if (arch->index_array == NULL)
10846             {
10847               free (index_buffer);
10848               error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10849               return 1;
10850             }
10851
10852           for (i = 0; i < arch->index_num; i++)
10853             arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
10854                                                         SIZEOF_AR_INDEX_NUMBERS);
10855           free (index_buffer);
10856
10857           /* The remaining space in the header is taken up by the symbol table.  */
10858           if (size < 1)
10859             {
10860               error (_("%s: the archive has an index but no symbols\n"), file_name);
10861               return 1;
10862             }
10863           arch->sym_table = malloc (size);
10864           arch->sym_size = size;
10865           if (arch->sym_table == NULL)
10866             {
10867               error (_("Out of memory whilst trying to read archive index symbol table\n"));
10868               return 1;
10869             }
10870           got = fread (arch->sym_table, 1, size, file);
10871           if (got != size)
10872             {
10873               error (_("%s: failed to read archive index symbol table\n"), file_name);
10874               return 1;
10875             }
10876         }
10877       else
10878         {
10879           if (fseek (file, size, SEEK_CUR) != 0)
10880             {
10881               error (_("%s: failed to skip archive symbol table\n"), file_name);
10882               return 1;
10883             }
10884         }
10885
10886       /* Read the next archive header.  */
10887       got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
10888       if (got != sizeof arch->arhdr)
10889         {
10890           if (got == 0)
10891             return 0;
10892           error (_("%s: failed to read archive header following archive index\n"), file_name);
10893           return 1;
10894         }
10895     }
10896   else if (read_symbols)
10897     printf (_("%s has no archive index\n"), file_name);
10898
10899   if (const_strneq (arch->arhdr.ar_name, "//              "))
10900     {
10901       /* This is the archive string table holding long member names.  */
10902       arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
10903       arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
10904
10905       arch->longnames = malloc (arch->longnames_size);
10906       if (arch->longnames == NULL)
10907         {
10908           error (_("Out of memory reading long symbol names in archive\n"));
10909           return 1;
10910         }
10911
10912       if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
10913         {
10914           free (arch->longnames);
10915           arch->longnames = NULL;
10916           error (_("%s: failed to read long symbol name string table\n"), file_name);
10917           return 1;
10918         }
10919
10920       if ((arch->longnames_size & 1) != 0)
10921         getc (file);
10922     }
10923
10924   return 0;
10925 }
10926
10927 /* Release the memory used for the archive information.  */
10928
10929 static void
10930 release_archive (struct archive_info * arch)
10931 {
10932   if (arch->file_name != NULL)
10933     free (arch->file_name);
10934   if (arch->index_array != NULL)
10935     free (arch->index_array);
10936   if (arch->sym_table != NULL)
10937     free (arch->sym_table);
10938   if (arch->longnames != NULL)
10939     free (arch->longnames);
10940 }
10941
10942 /* Open and setup a nested archive, if not already open.  */
10943
10944 static int
10945 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
10946 {
10947   FILE * member_file;
10948
10949   /* Have we already setup this archive?  */
10950   if (nested_arch->file_name != NULL
10951       && streq (nested_arch->file_name, member_file_name))
10952     return 0;
10953
10954   /* Close previous file and discard cached information.  */
10955   if (nested_arch->file != NULL)
10956     fclose (nested_arch->file);
10957   release_archive (nested_arch);
10958
10959   member_file = fopen (member_file_name, "rb");
10960   if (member_file == NULL)
10961     return 1;
10962   return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
10963 }
10964
10965 static char *
10966 get_archive_member_name_at (struct archive_info *  arch,
10967                             unsigned long          offset,
10968                             struct archive_info *  nested_arch);
10969
10970 /* Get the name of an archive member from the current archive header.
10971    For simple names, this will modify the ar_name field of the current
10972    archive header.  For long names, it will return a pointer to the
10973    longnames table.  For nested archives, it will open the nested archive
10974    and get the name recursively.  NESTED_ARCH is a single-entry cache so
10975    we don't keep rereading the same information from a nested archive.  */
10976
10977 static char *
10978 get_archive_member_name (struct archive_info *  arch,
10979                          struct archive_info *  nested_arch)
10980 {
10981   unsigned long j, k;
10982
10983   if (arch->arhdr.ar_name[0] == '/')
10984     {
10985       /* We have a long name.  */
10986       char * endp;
10987       char * member_file_name;
10988       char * member_name;
10989
10990       arch->nested_member_origin = 0;
10991       k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
10992       if (arch->is_thin_archive && endp != NULL && * endp == ':')
10993         arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
10994
10995       while ((j < arch->longnames_size)
10996              && (arch->longnames[j] != '\n')
10997              && (arch->longnames[j] != '\0'))
10998         j++;
10999       if (arch->longnames[j-1] == '/')
11000         j--;
11001       arch->longnames[j] = '\0';
11002
11003       if (!arch->is_thin_archive || arch->nested_member_origin == 0)
11004         return arch->longnames + k;
11005
11006       /* This is a proxy for a member of a nested archive.
11007          Find the name of the member in that archive.  */
11008       member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
11009       if (member_file_name != NULL
11010           && setup_nested_archive (nested_arch, member_file_name) == 0
11011           && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
11012         {
11013           free (member_file_name);
11014           return member_name;
11015         }
11016       free (member_file_name);
11017
11018       /* Last resort: just return the name of the nested archive.  */
11019       return arch->longnames + k;
11020     }
11021
11022   /* We have a normal (short) name.  */
11023   j = 0;
11024   while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
11025     j++;
11026   arch->arhdr.ar_name[j] = '\0';
11027   return arch->arhdr.ar_name;
11028 }
11029
11030 /* Get the name of an archive member at a given OFFSET within an archive ARCH.  */
11031
11032 static char *
11033 get_archive_member_name_at (struct archive_info * arch,
11034                             unsigned long         offset,
11035                             struct archive_info * nested_arch)
11036 {
11037   size_t got;
11038
11039   if (fseek (arch->file, offset, SEEK_SET) != 0)
11040     {
11041       error (_("%s: failed to seek to next file name\n"), arch->file_name);
11042       return NULL;
11043     }
11044   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
11045   if (got != sizeof arch->arhdr)
11046     {
11047       error (_("%s: failed to read archive header\n"), arch->file_name);
11048       return NULL;
11049     }
11050   if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
11051     {
11052       error (_("%s: did not find a valid archive header\n"), arch->file_name);
11053       return NULL;
11054     }
11055
11056   return get_archive_member_name (arch, nested_arch);
11057 }
11058
11059 /* Construct a string showing the name of the archive member, qualified
11060    with the name of the containing archive file.  For thin archives, we
11061    use square brackets to denote the indirection.  For nested archives,
11062    we show the qualified name of the external member inside the square
11063    brackets (e.g., "thin.a[normal.a(foo.o)]").  */
11064
11065 static char *
11066 make_qualified_name (struct archive_info * arch,
11067                      struct archive_info * nested_arch,
11068                      char * member_name)
11069 {
11070   size_t len;
11071   char * name;
11072
11073   len = strlen (arch->file_name) + strlen (member_name) + 3;
11074   if (arch->is_thin_archive && arch->nested_member_origin != 0)
11075     len += strlen (nested_arch->file_name) + 2;
11076
11077   name = malloc (len);
11078   if (name == NULL)
11079     {
11080       error (_("Out of memory\n"));
11081       return NULL;
11082     }
11083
11084   if (arch->is_thin_archive && arch->nested_member_origin != 0)
11085     snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
11086   else if (arch->is_thin_archive)
11087     snprintf (name, len, "%s[%s]", arch->file_name, member_name);
11088   else
11089     snprintf (name, len, "%s(%s)", arch->file_name, member_name);
11090
11091   return name;
11092 }
11093
11094 /* Process an ELF archive.
11095    On entry the file is positioned just after the ARMAG string.  */
11096
11097 static int
11098 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
11099 {
11100   struct archive_info arch;
11101   struct archive_info nested_arch;
11102   size_t got;
11103   size_t file_name_size;
11104   int ret;
11105
11106   show_name = 1;
11107
11108   /* The ARCH structure is used to hold information about this archive.  */
11109   arch.file_name = NULL;
11110   arch.file = NULL;
11111   arch.index_array = NULL;
11112   arch.sym_table = NULL;
11113   arch.longnames = NULL;
11114
11115   /* The NESTED_ARCH structure is used as a single-item cache of information
11116      about a nested archive (when members of a thin archive reside within
11117      another regular archive file).  */
11118   nested_arch.file_name = NULL;
11119   nested_arch.file = NULL;
11120   nested_arch.index_array = NULL;
11121   nested_arch.sym_table = NULL;
11122   nested_arch.longnames = NULL;
11123
11124   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
11125     {
11126       ret = 1;
11127       goto out;
11128     }
11129
11130   if (do_archive_index)
11131     {
11132       if (arch.sym_table == NULL)
11133         error (_("%s: unable to dump the index as none was found\n"), file_name);
11134       else
11135         {
11136           unsigned int i, l;
11137           unsigned long current_pos;
11138
11139           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11140                   file_name, arch.index_num, arch.sym_size);
11141           current_pos = ftell (file);
11142
11143           for (i = l = 0; i < arch.index_num; i++)
11144             {
11145               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
11146                 {
11147                   char * member_name;
11148
11149                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
11150
11151                   if (member_name != NULL)
11152                     {
11153                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
11154
11155                       if (qualified_name != NULL)
11156                         {
11157                           printf (_("Binary %s contains:\n"), qualified_name);
11158                           free (qualified_name);
11159                         }
11160                     }
11161                 }
11162
11163               if (l >= arch.sym_size)
11164                 {
11165                   error (_("%s: end of the symbol table reached before the end of the index\n"),
11166                          file_name);
11167                   break;
11168                 }
11169               printf ("\t%s\n", arch.sym_table + l);
11170               l += strlen (arch.sym_table + l) + 1;
11171             }
11172
11173           if (l & 01)
11174             ++l;
11175           if (l < arch.sym_size)
11176             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11177                    file_name);
11178
11179           if (fseek (file, current_pos, SEEK_SET) != 0)
11180             {
11181               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
11182               ret = 1;
11183               goto out;
11184             }
11185         }
11186
11187       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
11188           && !do_segments && !do_header && !do_dump && !do_version
11189           && !do_histogram && !do_debugging && !do_arch && !do_notes
11190           && !do_section_groups)
11191         {
11192           ret = 0; /* Archive index only.  */
11193           goto out;
11194         }
11195     }
11196
11197   file_name_size = strlen (file_name);
11198   ret = 0;
11199
11200   while (1)
11201     {
11202       char * name;
11203       size_t namelen;
11204       char * qualified_name;
11205
11206       /* Read the next archive header.  */
11207       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
11208         {
11209           error (_("%s: failed to seek to next archive header\n"), file_name);
11210           return 1;
11211         }
11212       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
11213       if (got != sizeof arch.arhdr)
11214         {
11215           if (got == 0)
11216             break;
11217           error (_("%s: failed to read archive header\n"), file_name);
11218           ret = 1;
11219           break;
11220         }
11221       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
11222         {
11223           error (_("%s: did not find a valid archive header\n"), arch.file_name);
11224           ret = 1;
11225           break;
11226         }
11227
11228       arch.next_arhdr_offset += sizeof arch.arhdr;
11229
11230       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
11231       if (archive_file_size & 01)
11232         ++archive_file_size;
11233
11234       name = get_archive_member_name (&arch, &nested_arch);
11235       if (name == NULL)
11236         {
11237           error (_("%s: bad archive file name\n"), file_name);
11238           ret = 1;
11239           break;
11240         }
11241       namelen = strlen (name);
11242
11243       qualified_name = make_qualified_name (&arch, &nested_arch, name);
11244       if (qualified_name == NULL)
11245         {
11246           error (_("%s: bad archive file name\n"), file_name);
11247           ret = 1;
11248           break;
11249         }
11250
11251       if (is_thin_archive && arch.nested_member_origin == 0)
11252         {
11253           /* This is a proxy for an external member of a thin archive.  */
11254           FILE * member_file;
11255           char * member_file_name = adjust_relative_path (file_name, name, namelen);
11256           if (member_file_name == NULL)
11257             {
11258               ret = 1;
11259               break;
11260             }
11261
11262           member_file = fopen (member_file_name, "rb");
11263           if (member_file == NULL)
11264             {
11265               error (_("Input file '%s' is not readable.\n"), member_file_name);
11266               free (member_file_name);
11267               ret = 1;
11268               break;
11269             }
11270
11271           archive_file_offset = arch.nested_member_origin;
11272
11273           ret |= process_object (qualified_name, member_file);
11274
11275           fclose (member_file);
11276           free (member_file_name);
11277         }
11278       else if (is_thin_archive)
11279         {
11280           /* This is a proxy for a member of a nested archive.  */
11281           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
11282
11283           /* The nested archive file will have been opened and setup by
11284              get_archive_member_name.  */
11285           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
11286             {
11287               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
11288               ret = 1;
11289               break;
11290             }
11291
11292           ret |= process_object (qualified_name, nested_arch.file);
11293         }
11294       else
11295         {
11296           archive_file_offset = arch.next_arhdr_offset;
11297           arch.next_arhdr_offset += archive_file_size;
11298
11299           ret |= process_object (qualified_name, file);
11300         }
11301
11302       free (qualified_name);
11303     }
11304
11305  out:
11306   if (nested_arch.file != NULL)
11307     fclose (nested_arch.file);
11308   release_archive (&nested_arch);
11309   release_archive (&arch);
11310
11311   return ret;
11312 }
11313
11314 static int
11315 process_file (char * file_name)
11316 {
11317   FILE * file;
11318   struct stat statbuf;
11319   char armag[SARMAG];
11320   int ret;
11321
11322   if (stat (file_name, &statbuf) < 0)
11323     {
11324       if (errno == ENOENT)
11325         error (_("'%s': No such file\n"), file_name);
11326       else
11327         error (_("Could not locate '%s'.  System error message: %s\n"),
11328                file_name, strerror (errno));
11329       return 1;
11330     }
11331
11332   if (! S_ISREG (statbuf.st_mode))
11333     {
11334       error (_("'%s' is not an ordinary file\n"), file_name);
11335       return 1;
11336     }
11337
11338   file = fopen (file_name, "rb");
11339   if (file == NULL)
11340     {
11341       error (_("Input file '%s' is not readable.\n"), file_name);
11342       return 1;
11343     }
11344
11345   if (fread (armag, SARMAG, 1, file) != 1)
11346     {
11347       error (_("%s: Failed to read file's magic number\n"), file_name);
11348       fclose (file);
11349       return 1;
11350     }
11351
11352   if (memcmp (armag, ARMAG, SARMAG) == 0)
11353     ret = process_archive (file_name, file, FALSE);
11354   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
11355     ret = process_archive (file_name, file, TRUE);
11356   else
11357     {
11358       if (do_archive_index)
11359         error (_("File %s is not an archive so its index cannot be displayed.\n"),
11360                file_name);
11361
11362       rewind (file);
11363       archive_file_size = archive_file_offset = 0;
11364       ret = process_object (file_name, file);
11365     }
11366
11367   fclose (file);
11368
11369   return ret;
11370 }
11371
11372 #ifdef SUPPORT_DISASSEMBLY
11373 /* Needed by the i386 disassembler.  For extra credit, someone could
11374    fix this so that we insert symbolic addresses here, esp for GOT/PLT
11375    symbols.  */
11376
11377 void
11378 print_address (unsigned int addr, FILE * outfile)
11379 {
11380   fprintf (outfile,"0x%8.8x", addr);
11381 }
11382
11383 /* Needed by the i386 disassembler.  */
11384 void
11385 db_task_printsym (unsigned int addr)
11386 {
11387   print_address (addr, stderr);
11388 }
11389 #endif
11390
11391 int
11392 main (int argc, char ** argv)
11393 {
11394   int err;
11395
11396 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11397   setlocale (LC_MESSAGES, "");
11398 #endif
11399 #if defined (HAVE_SETLOCALE)
11400   setlocale (LC_CTYPE, "");
11401 #endif
11402   bindtextdomain (PACKAGE, LOCALEDIR);
11403   textdomain (PACKAGE);
11404
11405   expandargv (&argc, &argv);
11406
11407   parse_args (argc, argv);
11408
11409   if (num_dump_sects > 0)
11410     {
11411       /* Make a copy of the dump_sects array.  */
11412       cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
11413       if (cmdline_dump_sects == NULL)
11414         error (_("Out of memory allocating dump request table.\n"));
11415       else
11416         {
11417           memcpy (cmdline_dump_sects, dump_sects,
11418                   num_dump_sects * sizeof (* dump_sects));
11419           num_cmdline_dump_sects = num_dump_sects;
11420         }
11421     }
11422
11423   if (optind < (argc - 1))
11424     show_name = 1;
11425
11426   err = 0;
11427   while (optind < argc)
11428     err |= process_file (argv[optind++]);
11429
11430   if (dump_sects != NULL)
11431     free (dump_sects);
11432   if (cmdline_dump_sects != NULL)
11433     free (cmdline_dump_sects);
11434
11435   return err;
11436 }