binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  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/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.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/metag.h"
 123 #include "elf/microblaze.h"
 124 #include "elf/mips.h"
 125 #include "elf/mmix.h"
 126 #include "elf/mn10200.h"
 127 #include "elf/mn10300.h"
 128 #include "elf/moxie.h"
 129 #include "elf/mt.h"
 130 #include "elf/msp430.h"
 131 #include "elf/nds32.h"
 132 #include "elf/nios2.h"
 133 #include "elf/or1k.h"
 134 #include "elf/pj.h"
 135 #include "elf/ppc.h"
 136 #include "elf/ppc64.h"
 137 #include "elf/pru.h"
 138 #include "elf/riscv.h"
 139 #include "elf/rl78.h"
 140 #include "elf/rx.h"
 141 #include "elf/s390.h"
 142 #include "elf/score.h"
 143 #include "elf/sh.h"
 144 #include "elf/sparc.h"
 145 #include "elf/spu.h"
 146 #include "elf/tic6x.h"
 147 #include "elf/tilegx.h"
 148 #include "elf/tilepro.h"
 149 #include "elf/v850.h"
 150 #include "elf/vax.h"
 151 #include "elf/visium.h"
 152 #include "elf/wasm32.h"
 153 #include "elf/x86-64.h"
 154 #include "elf/xc16x.h"
 155 #include "elf/xgate.h"
 156 #include "elf/xstormy16.h"
 157 #include "elf/xtensa.h"
 158
 159 #include "getopt.h"
 160 #include "libiberty.h"
 161 #include "safe-ctype.h"
 162 #include "filenames.h"
 163
 164 #ifndef offsetof
 165 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 166 #endif
 167
 168 typedef struct elf_section_list
 169 {
 170   Elf_Internal_Shdr *        hdr;
 171   struct elf_section_list *  next;
 172 } elf_section_list;
 173
 174 /* Flag bits indicating particular types of dump.  */
 175 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 176 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 177 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 178 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 179 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 180
 181 typedef unsigned char dump_type;
 182
 183 /* A linked list of the section names for which dumps were requested.  */
 184 struct dump_list_entry
 185 {
 186   char *                    name;
 187   dump_type                 type;
 188   struct dump_list_entry *  next;
 189 };
 190
 191 typedef struct filedata
 192 {
 193   const char *         file_name;
 194   FILE *               handle;
 195   bfd_size_type        file_size;
 196   Elf_Internal_Ehdr    file_header;
 197   Elf_Internal_Shdr *  section_headers;
 198   Elf_Internal_Phdr *  program_headers;
 199   char *               string_table;
 200   unsigned long        string_table_length;
 201   /* A dynamic array of flags indicating for which sections a dump of
 202      some kind has been requested.  It is reset on a per-object file
 203      basis and then initialised from the cmdline_dump_sects array,
 204      the results of interpreting the -w switch, and the
 205      dump_sects_byname list.  */
 206   dump_type *          dump_sects;
 207   unsigned int         num_dump_sects;
 208 } Filedata;
 209
 210 char * program_name = "readelf";
 211
 212 static unsigned long archive_file_offset;
 213 static unsigned long archive_file_size;
 214 static unsigned long dynamic_addr;
 215 static bfd_size_type dynamic_size;
 216 static size_t dynamic_nent;
 217 static char * dynamic_strings;
 218 static unsigned long dynamic_strings_length;
 219 static unsigned long num_dynamic_syms;
 220 static Elf_Internal_Sym * dynamic_symbols;
 221 static Elf_Internal_Syminfo * dynamic_syminfo;
 222 static unsigned long dynamic_syminfo_offset;
 223 static unsigned int dynamic_syminfo_nent;
 224 static char program_interpreter[PATH_MAX];
 225 static bfd_vma dynamic_info[DT_ENCODING];
 226 static bfd_vma dynamic_info_DT_GNU_HASH;
 227 static bfd_vma version_info[16];
 228 static Elf_Internal_Dyn *  dynamic_section;
 229 static elf_section_list * symtab_shndx_list;
 230 static bfd_boolean show_name = FALSE;
 231 static bfd_boolean do_dynamic = FALSE;
 232 static bfd_boolean do_syms = FALSE;
 233 static bfd_boolean do_dyn_syms = FALSE;
 234 static bfd_boolean do_reloc = FALSE;
 235 static bfd_boolean do_sections = FALSE;
 236 static bfd_boolean do_section_groups = FALSE;
 237 static bfd_boolean do_section_details = FALSE;
 238 static bfd_boolean do_segments = FALSE;
 239 static bfd_boolean do_unwind = FALSE;
 240 static bfd_boolean do_using_dynamic = FALSE;
 241 static bfd_boolean do_header = FALSE;
 242 static bfd_boolean do_dump = FALSE;
 243 static bfd_boolean do_version = FALSE;
 244 static bfd_boolean do_histogram = FALSE;
 245 static bfd_boolean do_debugging = FALSE;
 246 static bfd_boolean do_arch = FALSE;
 247 static bfd_boolean do_notes = FALSE;
 248 static bfd_boolean do_archive_index = FALSE;
 249 static bfd_boolean is_32bit_elf = FALSE;
 250 static bfd_boolean decompress_dumps = FALSE;
 251
 252 struct group_list
 253 {
 254   struct group_list *  next;
 255   unsigned int         section_index;
 256 };
 257
 258 struct group
 259 {
 260   struct group_list *  root;
 261   unsigned int         group_index;
 262 };
 263
 264 static size_t           group_count;
 265 static struct group *   section_groups;
 266 static struct group **  section_headers_groups;
 267
 268 /* A dynamic array of flags indicating for which sections a dump
 269    has been requested via command line switches.  */
 270 static Filedata         cmdline;
 271
 272 static struct dump_list_entry * dump_sects_byname;
 273
 274 /* How to print a vma value.  */
 275 typedef enum print_mode
 276 {
 277   HEX,
 278   DEC,
 279   DEC_5,
 280   UNSIGNED,
 281   PREFIX_HEX,
 282   FULL_HEX,
 283   LONG_HEX
 284 }
 285 print_mode;
 286
 287 /* Versioned symbol info.  */
 288 enum versioned_symbol_info
 289 {
 290   symbol_undefined,
 291   symbol_hidden,
 292   symbol_public
 293 };
 294
 295 static const char * get_symbol_version_string
 296   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 297    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 298
 299 #define UNKNOWN -1
 300
 301 #define SECTION_NAME(X)                                         \
 302   ((X) == NULL ? _("<none>")                                    \
 303    : filedata->string_table == NULL ? _("<no-strings>")         \
 304    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 305   : filedata->string_table + (X)->sh_name))
 306
 307 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 308
 309 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 310   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 311    : get_64bit_elf_symbols (file, section, sym_count))
 312
 313 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 314 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 315    already been called and verified that the string exists.  */
 316 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 317
 318 #define REMOVE_ARCH_BITS(ADDR)                  \
 319   do                                            \
 320     {                                           \
 321       if (filedata->file_header.e_machine == EM_ARM)    \
 322         (ADDR) &= ~1;                           \
 323     }                                           \
 324   while (0)
 325 \f
 326 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 327    BFD_FMA_FMT can't be used in translated strings.  */
 328
 329 static const char *
 330 bfd_vmatoa (char *fmtch, bfd_vma value)
 331 {
 332   /* bfd_vmatoa is used more then once in a printf call for output.
 333      Cycle through an array of buffers.  */
 334   static int buf_pos = 0;
 335   static struct bfd_vmatoa_buf
 336   {
 337     char place[64];
 338   } buf[4];
 339   char *ret;
 340   char fmt[32];
 341
 342   ret = buf[buf_pos++].place;
 343   buf_pos %= ARRAY_SIZE (buf);
 344
 345   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 346   snprintf (ret, sizeof (buf[0].place), fmt, value);
 347   return ret;
 348 }
 349
 350 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 351    OFFSET + the offset of the current archive member, if we are examining an
 352    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 353    allocate a buffer using malloc and fill that.  In either case return the
 354    pointer to the start of the retrieved data or NULL if something went wrong.
 355    If something does go wrong and REASON is not NULL then emit an error
 356    message using REASON as part of the context.  */
 357
 358 static void *
 359 get_data (void *         var,
 360           Filedata *     filedata,
 361           unsigned long  offset,
 362           bfd_size_type  size,
 363           bfd_size_type  nmemb,
 364           const char *   reason)
 365 {
 366   void * mvar;
 367   bfd_size_type amt = size * nmemb;
 368
 369   if (size == 0 || nmemb == 0)
 370     return NULL;
 371
 372   /* If the size_t type is smaller than the bfd_size_type, eg because
 373      you are building a 32-bit tool on a 64-bit host, then make sure
 374      that when the sizes are cast to (size_t) no information is lost.  */
 375   if (sizeof (size_t) < sizeof (bfd_size_type)
 376       && (   (bfd_size_type) ((size_t) size) != size
 377           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 378     {
 379       if (reason)
 380         error (_("Size truncation prevents reading %s"
 381                  " elements of size %s for %s\n"),
 382                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 383       return NULL;
 384     }
 385
 386   /* Check for size overflow.  */
 387   if (amt < nmemb)
 388     {
 389       if (reason)
 390         error (_("Size overflow prevents reading %s"
 391                  " elements of size %s for %s\n"),
 392                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 393       return NULL;
 394     }
 395
 396   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 397      attempting to allocate memory when the read is bound to fail.  */
 398   if (amt > filedata->file_size
 399       || offset + archive_file_offset + amt > filedata->file_size)
 400     {
 401       if (reason)
 402         error (_("Reading %s bytes extends past end of file for %s\n"),
 403                bfd_vmatoa ("u", amt), reason);
 404       return NULL;
 405     }
 406
 407   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 408     {
 409       if (reason)
 410         error (_("Unable to seek to 0x%lx for %s\n"),
 411                archive_file_offset + offset, reason);
 412       return NULL;
 413     }
 414
 415   mvar = var;
 416   if (mvar == NULL)
 417     {
 418       /* Check for overflow.  */
 419       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 420         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 421         mvar = malloc ((size_t) amt + 1);
 422
 423       if (mvar == NULL)
 424         {
 425           if (reason)
 426             error (_("Out of memory allocating %s bytes for %s\n"),
 427                    bfd_vmatoa ("u", amt), reason);
 428           return NULL;
 429         }
 430
 431       ((char *) mvar)[amt] = '\0';
 432     }
 433
 434   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 435     {
 436       if (reason)
 437         error (_("Unable to read in %s bytes of %s\n"),
 438                bfd_vmatoa ("u", amt), reason);
 439       if (mvar != var)
 440         free (mvar);
 441       return NULL;
 442     }
 443
 444   return mvar;
 445 }
 446
 447 /* Print a VMA value in the MODE specified.
 448    Returns the number of characters displayed.  */
 449
 450 static unsigned int
 451 print_vma (bfd_vma vma, print_mode mode)
 452 {
 453   unsigned int nc = 0;
 454
 455   switch (mode)
 456     {
 457     case FULL_HEX:
 458       nc = printf ("0x");
 459       /* Fall through.  */
 460     case LONG_HEX:
 461 #ifdef BFD64
 462       if (is_32bit_elf)
 463         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 464 #endif
 465       printf_vma (vma);
 466       return nc + 16;
 467
 468     case DEC_5:
 469       if (vma <= 99999)
 470         return printf ("%5" BFD_VMA_FMT "d", vma);
 471       /* Fall through.  */
 472     case PREFIX_HEX:
 473       nc = printf ("0x");
 474       /* Fall through.  */
 475     case HEX:
 476       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 477
 478     case DEC:
 479       return printf ("%" BFD_VMA_FMT "d", vma);
 480
 481     case UNSIGNED:
 482       return printf ("%" BFD_VMA_FMT "u", vma);
 483
 484     default:
 485       /* FIXME: Report unrecognised mode ?  */
 486       return 0;
 487     }
 488 }
 489
 490 /* Display a symbol on stdout.  Handles the display of control characters and
 491    multibye characters (assuming the host environment supports them).
 492
 493    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 494
 495    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 496    padding as necessary.
 497
 498    Returns the number of emitted characters.  */
 499
 500 static unsigned int
 501 print_symbol (signed int width, const char *symbol)
 502 {
 503   bfd_boolean extra_padding = FALSE;
 504   signed int num_printed = 0;
 505 #ifdef HAVE_MBSTATE_T
 506   mbstate_t state;
 507 #endif
 508   unsigned int width_remaining;
 509
 510   if (width < 0)
 511     {
 512       /* Keep the width positive.  This helps the code below.  */
 513       width = - width;
 514       extra_padding = TRUE;
 515     }
 516   assert (width != 0);
 517
 518   if (do_wide)
 519     /* Set the remaining width to a very large value.
 520        This simplifies the code below.  */
 521     width_remaining = INT_MAX;
 522   else
 523     width_remaining = width;
 524
 525 #ifdef HAVE_MBSTATE_T
 526   /* Initialise the multibyte conversion state.  */
 527   memset (& state, 0, sizeof (state));
 528 #endif
 529
 530   while (width_remaining)
 531     {
 532       size_t  n;
 533       const char c = *symbol++;
 534
 535       if (c == 0)
 536         break;
 537
 538       /* Do not print control characters directly as they can affect terminal
 539          settings.  Such characters usually appear in the names generated
 540          by the assembler for local labels.  */
 541       if (ISCNTRL (c))
 542         {
 543           if (width_remaining < 2)
 544             break;
 545
 546           printf ("^%c", c + 0x40);
 547           width_remaining -= 2;
 548           num_printed += 2;
 549         }
 550       else if (ISPRINT (c))
 551         {
 552           putchar (c);
 553           width_remaining --;
 554           num_printed ++;
 555         }
 556       else
 557         {
 558 #ifdef HAVE_MBSTATE_T
 559           wchar_t w;
 560 #endif
 561           /* Let printf do the hard work of displaying multibyte characters.  */
 562           printf ("%.1s", symbol - 1);
 563           width_remaining --;
 564           num_printed ++;
 565
 566 #ifdef HAVE_MBSTATE_T
 567           /* Try to find out how many bytes made up the character that was
 568              just printed.  Advance the symbol pointer past the bytes that
 569              were displayed.  */
 570           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 571 #else
 572           n = 1;
 573 #endif
 574           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 575             symbol += (n - 1);
 576         }
 577     }
 578
 579   if (extra_padding && num_printed < width)
 580     {
 581       /* Fill in the remaining spaces.  */
 582       printf ("%-*s", width - num_printed, " ");
 583       num_printed = width;
 584     }
 585
 586   return num_printed;
 587 }
 588
 589 /* Returns a pointer to a static buffer containing a printable version of
 590    the given section's name.  Like print_symbol, except that it does not try
 591    to print multibyte characters, it just interprets them as hex values.  */
 592
 593 static const char *
 594 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 595 {
 596 #define MAX_PRINT_SEC_NAME_LEN 128
 597   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 598   const char * name = SECTION_NAME (sec);
 599   char *       buf = sec_name_buf;
 600   char         c;
 601   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 602
 603   while ((c = * name ++) != 0)
 604     {
 605       if (ISCNTRL (c))
 606         {
 607           if (remaining < 2)
 608             break;
 609
 610           * buf ++ = '^';
 611           * buf ++ = c + 0x40;
 612           remaining -= 2;
 613         }
 614       else if (ISPRINT (c))
 615         {
 616           * buf ++ = c;
 617           remaining -= 1;
 618         }
 619       else
 620         {
 621           static char hex[17] = "0123456789ABCDEF";
 622
 623           if (remaining < 4)
 624             break;
 625           * buf ++ = '<';
 626           * buf ++ = hex[(c & 0xf0) >> 4];
 627           * buf ++ = hex[c & 0x0f];
 628           * buf ++ = '>';
 629           remaining -= 4;
 630         }
 631
 632       if (remaining == 0)
 633         break;
 634     }
 635
 636   * buf = 0;
 637   return sec_name_buf;
 638 }
 639
 640 static const char *
 641 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 642 {
 643   if (ndx >= filedata->file_header.e_shnum)
 644     return _("<corrupt>");
 645
 646   return printable_section_name (filedata, filedata->section_headers + ndx);
 647 }
 648
 649 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 650
 651 static Elf_Internal_Shdr *
 652 find_section (Filedata * filedata, const char * name)
 653 {
 654   unsigned int i;
 655
 656   if (filedata->section_headers == NULL)
 657     return NULL;
 658
 659   for (i = 0; i < filedata->file_header.e_shnum; i++)
 660     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 661       return filedata->section_headers + i;
 662
 663   return NULL;
 664 }
 665
 666 /* Return a pointer to a section containing ADDR, or NULL if no such
 667    section exists.  */
 668
 669 static Elf_Internal_Shdr *
 670 find_section_by_address (Filedata * filedata, bfd_vma addr)
 671 {
 672   unsigned int i;
 673
 674   if (filedata->section_headers == NULL)
 675     return NULL;
 676
 677   for (i = 0; i < filedata->file_header.e_shnum; i++)
 678     {
 679       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 680
 681       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 682         return sec;
 683     }
 684
 685   return NULL;
 686 }
 687
 688 static Elf_Internal_Shdr *
 689 find_section_by_type (Filedata * filedata, unsigned int type)
 690 {
 691   unsigned int i;
 692
 693   if (filedata->section_headers == NULL)
 694     return NULL;
 695
 696   for (i = 0; i < filedata->file_header.e_shnum; i++)
 697     {
 698       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 699
 700       if (sec->sh_type == type)
 701         return sec;
 702     }
 703
 704   return NULL;
 705 }
 706
 707 /* Return a pointer to section NAME, or NULL if no such section exists,
 708    restricted to the list of sections given in SET.  */
 709
 710 static Elf_Internal_Shdr *
 711 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 712 {
 713   unsigned int i;
 714
 715   if (filedata->section_headers == NULL)
 716     return NULL;
 717
 718   if (set != NULL)
 719     {
 720       while ((i = *set++) > 0)
 721         {
 722           /* See PR 21156 for a reproducer.  */
 723           if (i >= filedata->file_header.e_shnum)
 724             continue; /* FIXME: Should we issue an error message ?  */
 725
 726           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 727             return filedata->section_headers + i;
 728         }
 729     }
 730
 731   return find_section (filedata, name);
 732 }
 733
 734 /* Read an unsigned LEB128 encoded value from DATA.
 735    Set *LENGTH_RETURN to the number of bytes read.  */
 736
 737 static inline unsigned long
 738 read_uleb128 (unsigned char * data,
 739               unsigned int * length_return,
 740               const unsigned char * const end)
 741 {
 742   return read_leb128 (data, length_return, FALSE, end);
 743 }
 744
 745 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 746    This OS has so many departures from the ELF standard that we test it at
 747    many places.  */
 748
 749 static inline bfd_boolean
 750 is_ia64_vms (Filedata * filedata)
 751 {
 752   return filedata->file_header.e_machine == EM_IA_64
 753     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 754 }
 755
 756 /* Guess the relocation size commonly used by the specific machines.  */
 757
 758 static bfd_boolean
 759 guess_is_rela (unsigned int e_machine)
 760 {
 761   switch (e_machine)
 762     {
 763       /* Targets that use REL relocations.  */
 764     case EM_386:
 765     case EM_IAMCU:
 766     case EM_ARM:
 767     case EM_D10V:
 768     case EM_CYGNUS_D10V:
 769     case EM_DLX:
 770     case EM_MIPS:
 771     case EM_MIPS_RS3_LE:
 772     case EM_CYGNUS_M32R:
 773     case EM_SCORE:
 774     case EM_XGATE:
 775       return FALSE;
 776
 777       /* Targets that use RELA relocations.  */
 778     case EM_68K:
 779     case EM_AARCH64:
 780     case EM_ADAPTEVA_EPIPHANY:
 781     case EM_ALPHA:
 782     case EM_ALTERA_NIOS2:
 783     case EM_ARC:
 784     case EM_ARC_COMPACT:
 785     case EM_ARC_COMPACT2:
 786     case EM_AVR:
 787     case EM_AVR_OLD:
 788     case EM_BLACKFIN:
 789     case EM_CR16:
 790     case EM_CRIS:
 791     case EM_CRX:
 792     case EM_D30V:
 793     case EM_CYGNUS_D30V:
 794     case EM_FR30:
 795     case EM_FT32:
 796     case EM_CYGNUS_FR30:
 797     case EM_CYGNUS_FRV:
 798     case EM_H8S:
 799     case EM_H8_300:
 800     case EM_H8_300H:
 801     case EM_IA_64:
 802     case EM_IP2K:
 803     case EM_IP2K_OLD:
 804     case EM_IQ2000:
 805     case EM_LATTICEMICO32:
 806     case EM_M32C_OLD:
 807     case EM_M32C:
 808     case EM_M32R:
 809     case EM_MCORE:
 810     case EM_CYGNUS_MEP:
 811     case EM_METAG:
 812     case EM_MMIX:
 813     case EM_MN10200:
 814     case EM_CYGNUS_MN10200:
 815     case EM_MN10300:
 816     case EM_CYGNUS_MN10300:
 817     case EM_MOXIE:
 818     case EM_MSP430:
 819     case EM_MSP430_OLD:
 820     case EM_MT:
 821     case EM_NDS32:
 822     case EM_NIOS32:
 823     case EM_OR1K:
 824     case EM_PPC64:
 825     case EM_PPC:
 826     case EM_TI_PRU:
 827     case EM_RISCV:
 828     case EM_RL78:
 829     case EM_RX:
 830     case EM_S390:
 831     case EM_S390_OLD:
 832     case EM_SH:
 833     case EM_SPARC:
 834     case EM_SPARC32PLUS:
 835     case EM_SPARCV9:
 836     case EM_SPU:
 837     case EM_TI_C6000:
 838     case EM_TILEGX:
 839     case EM_TILEPRO:
 840     case EM_V800:
 841     case EM_V850:
 842     case EM_CYGNUS_V850:
 843     case EM_VAX:
 844     case EM_VISIUM:
 845     case EM_X86_64:
 846     case EM_L1OM:
 847     case EM_K1OM:
 848     case EM_XSTORMY16:
 849     case EM_XTENSA:
 850     case EM_XTENSA_OLD:
 851     case EM_MICROBLAZE:
 852     case EM_MICROBLAZE_OLD:
 853     case EM_WEBASSEMBLY:
 854       return TRUE;
 855
 856     case EM_68HC05:
 857     case EM_68HC08:
 858     case EM_68HC11:
 859     case EM_68HC16:
 860     case EM_FX66:
 861     case EM_ME16:
 862     case EM_MMA:
 863     case EM_NCPU:
 864     case EM_NDR1:
 865     case EM_PCP:
 866     case EM_ST100:
 867     case EM_ST19:
 868     case EM_ST7:
 869     case EM_ST9PLUS:
 870     case EM_STARCORE:
 871     case EM_SVX:
 872     case EM_TINYJ:
 873     default:
 874       warn (_("Don't know about relocations on this machine architecture\n"));
 875       return FALSE;
 876     }
 877 }
 878
 879 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 880    Returns TRUE upon success, FALSE otherwise.  If successful then a
 881    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 882    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 883    responsibility to free the allocated buffer.  */
 884
 885 static bfd_boolean
 886 slurp_rela_relocs (Filedata *            filedata,
 887                    unsigned long         rel_offset,
 888                    unsigned long         rel_size,
 889                    Elf_Internal_Rela **  relasp,
 890                    unsigned long *       nrelasp)
 891 {
 892   Elf_Internal_Rela * relas;
 893   size_t nrelas;
 894   unsigned int i;
 895
 896   if (is_32bit_elf)
 897     {
 898       Elf32_External_Rela * erelas;
 899
 900       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 901                                                  rel_size, _("32-bit relocation data"));
 902       if (!erelas)
 903         return FALSE;
 904
 905       nrelas = rel_size / sizeof (Elf32_External_Rela);
 906
 907       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 908                                              sizeof (Elf_Internal_Rela));
 909
 910       if (relas == NULL)
 911         {
 912           free (erelas);
 913           error (_("out of memory parsing relocs\n"));
 914           return FALSE;
 915         }
 916
 917       for (i = 0; i < nrelas; i++)
 918         {
 919           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 920           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 921           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 922         }
 923
 924       free (erelas);
 925     }
 926   else
 927     {
 928       Elf64_External_Rela * erelas;
 929
 930       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 931                                                  rel_size, _("64-bit relocation data"));
 932       if (!erelas)
 933         return FALSE;
 934
 935       nrelas = rel_size / sizeof (Elf64_External_Rela);
 936
 937       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 938                                              sizeof (Elf_Internal_Rela));
 939
 940       if (relas == NULL)
 941         {
 942           free (erelas);
 943           error (_("out of memory parsing relocs\n"));
 944           return FALSE;
 945         }
 946
 947       for (i = 0; i < nrelas; i++)
 948         {
 949           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 950           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 951           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 952
 953           /* The #ifdef BFD64 below is to prevent a compile time
 954              warning.  We know that if we do not have a 64 bit data
 955              type that we will never execute this code anyway.  */
 956 #ifdef BFD64
 957           if (filedata->file_header.e_machine == EM_MIPS
 958               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 959             {
 960               /* In little-endian objects, r_info isn't really a
 961                  64-bit little-endian value: it has a 32-bit
 962                  little-endian symbol index followed by four
 963                  individual byte fields.  Reorder INFO
 964                  accordingly.  */
 965               bfd_vma inf = relas[i].r_info;
 966               inf = (((inf & 0xffffffff) << 32)
 967                       | ((inf >> 56) & 0xff)
 968                       | ((inf >> 40) & 0xff00)
 969                       | ((inf >> 24) & 0xff0000)
 970                       | ((inf >> 8) & 0xff000000));
 971               relas[i].r_info = inf;
 972             }
 973 #endif /* BFD64 */
 974         }
 975
 976       free (erelas);
 977     }
 978
 979   *relasp = relas;
 980   *nrelasp = nrelas;
 981   return TRUE;
 982 }
 983
 984 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 985    Returns TRUE upon success, FALSE otherwise.  If successful then a
 986    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 987    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 988    responsibility to free the allocated buffer.  */
 989
 990 static bfd_boolean
 991 slurp_rel_relocs (Filedata *            filedata,
 992                   unsigned long         rel_offset,
 993                   unsigned long         rel_size,
 994                   Elf_Internal_Rela **  relsp,
 995                   unsigned long *       nrelsp)
 996 {
 997   Elf_Internal_Rela * rels;
 998   size_t nrels;
 999   unsigned int i;
1000
1001   if (is_32bit_elf)
1002     {
1003       Elf32_External_Rel * erels;
1004
1005       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1006                                                rel_size, _("32-bit relocation data"));
1007       if (!erels)
1008         return FALSE;
1009
1010       nrels = rel_size / sizeof (Elf32_External_Rel);
1011
1012       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1013
1014       if (rels == NULL)
1015         {
1016           free (erels);
1017           error (_("out of memory parsing relocs\n"));
1018           return FALSE;
1019         }
1020
1021       for (i = 0; i < nrels; i++)
1022         {
1023           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1024           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1025           rels[i].r_addend = 0;
1026         }
1027
1028       free (erels);
1029     }
1030   else
1031     {
1032       Elf64_External_Rel * erels;
1033
1034       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1035                                                rel_size, _("64-bit relocation data"));
1036       if (!erels)
1037         return FALSE;
1038
1039       nrels = rel_size / sizeof (Elf64_External_Rel);
1040
1041       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1042
1043       if (rels == NULL)
1044         {
1045           free (erels);
1046           error (_("out of memory parsing relocs\n"));
1047           return FALSE;
1048         }
1049
1050       for (i = 0; i < nrels; i++)
1051         {
1052           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1053           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1054           rels[i].r_addend = 0;
1055
1056           /* The #ifdef BFD64 below is to prevent a compile time
1057              warning.  We know that if we do not have a 64 bit data
1058              type that we will never execute this code anyway.  */
1059 #ifdef BFD64
1060           if (filedata->file_header.e_machine == EM_MIPS
1061               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1062             {
1063               /* In little-endian objects, r_info isn't really a
1064                  64-bit little-endian value: it has a 32-bit
1065                  little-endian symbol index followed by four
1066                  individual byte fields.  Reorder INFO
1067                  accordingly.  */
1068               bfd_vma inf = rels[i].r_info;
1069               inf = (((inf & 0xffffffff) << 32)
1070                      | ((inf >> 56) & 0xff)
1071                      | ((inf >> 40) & 0xff00)
1072                      | ((inf >> 24) & 0xff0000)
1073                      | ((inf >> 8) & 0xff000000));
1074               rels[i].r_info = inf;
1075             }
1076 #endif /* BFD64 */
1077         }
1078
1079       free (erels);
1080     }
1081
1082   *relsp = rels;
1083   *nrelsp = nrels;
1084   return TRUE;
1085 }
1086
1087 /* Returns the reloc type extracted from the reloc info field.  */
1088
1089 static unsigned int
1090 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1091 {
1092   if (is_32bit_elf)
1093     return ELF32_R_TYPE (reloc_info);
1094
1095   switch (filedata->file_header.e_machine)
1096     {
1097     case EM_MIPS:
1098       /* Note: We assume that reloc_info has already been adjusted for us.  */
1099       return ELF64_MIPS_R_TYPE (reloc_info);
1100
1101     case EM_SPARCV9:
1102       return ELF64_R_TYPE_ID (reloc_info);
1103
1104     default:
1105       return ELF64_R_TYPE (reloc_info);
1106     }
1107 }
1108
1109 /* Return the symbol index extracted from the reloc info field.  */
1110
1111 static bfd_vma
1112 get_reloc_symindex (bfd_vma reloc_info)
1113 {
1114   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1115 }
1116
1117 static inline bfd_boolean
1118 uses_msp430x_relocs (Filedata * filedata)
1119 {
1120   return
1121     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1122     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1123     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1124         /* TI compiler uses ELFOSABI_NONE.  */
1125         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1126 }
1127
1128 /* Display the contents of the relocation data found at the specified
1129    offset.  */
1130
1131 static bfd_boolean
1132 dump_relocations (Filedata *          filedata,
1133                   unsigned long       rel_offset,
1134                   unsigned long       rel_size,
1135                   Elf_Internal_Sym *  symtab,
1136                   unsigned long       nsyms,
1137                   char *              strtab,
1138                   unsigned long       strtablen,
1139                   int                 is_rela,
1140                   bfd_boolean         is_dynsym)
1141 {
1142   unsigned long i;
1143   Elf_Internal_Rela * rels;
1144   bfd_boolean res = TRUE;
1145
1146   if (is_rela == UNKNOWN)
1147     is_rela = guess_is_rela (filedata->file_header.e_machine);
1148
1149   if (is_rela)
1150     {
1151       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1152         return FALSE;
1153     }
1154   else
1155     {
1156       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1157         return FALSE;
1158     }
1159
1160   if (is_32bit_elf)
1161     {
1162       if (is_rela)
1163         {
1164           if (do_wide)
1165             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1166           else
1167             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1168         }
1169       else
1170         {
1171           if (do_wide)
1172             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1173           else
1174             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1175         }
1176     }
1177   else
1178     {
1179       if (is_rela)
1180         {
1181           if (do_wide)
1182             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1183           else
1184             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1185         }
1186       else
1187         {
1188           if (do_wide)
1189             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1190           else
1191             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1192         }
1193     }
1194
1195   for (i = 0; i < rel_size; i++)
1196     {
1197       const char * rtype;
1198       bfd_vma offset;
1199       bfd_vma inf;
1200       bfd_vma symtab_index;
1201       bfd_vma type;
1202
1203       offset = rels[i].r_offset;
1204       inf    = rels[i].r_info;
1205
1206       type = get_reloc_type (filedata, inf);
1207       symtab_index = get_reloc_symindex  (inf);
1208
1209       if (is_32bit_elf)
1210         {
1211           printf ("%8.8lx  %8.8lx ",
1212                   (unsigned long) offset & 0xffffffff,
1213                   (unsigned long) inf & 0xffffffff);
1214         }
1215       else
1216         {
1217 #if BFD_HOST_64BIT_LONG
1218           printf (do_wide
1219                   ? "%16.16lx  %16.16lx "
1220                   : "%12.12lx  %12.12lx ",
1221                   offset, inf);
1222 #elif BFD_HOST_64BIT_LONG_LONG
1223 #ifndef __MSVCRT__
1224           printf (do_wide
1225                   ? "%16.16llx  %16.16llx "
1226                   : "%12.12llx  %12.12llx ",
1227                   offset, inf);
1228 #else
1229           printf (do_wide
1230                   ? "%16.16I64x  %16.16I64x "
1231                   : "%12.12I64x  %12.12I64x ",
1232                   offset, inf);
1233 #endif
1234 #else
1235           printf (do_wide
1236                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1237                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1238                   _bfd_int64_high (offset),
1239                   _bfd_int64_low (offset),
1240                   _bfd_int64_high (inf),
1241                   _bfd_int64_low (inf));
1242 #endif
1243         }
1244
1245       switch (filedata->file_header.e_machine)
1246         {
1247         default:
1248           rtype = NULL;
1249           break;
1250
1251         case EM_AARCH64:
1252           rtype = elf_aarch64_reloc_type (type);
1253           break;
1254
1255         case EM_M32R:
1256         case EM_CYGNUS_M32R:
1257           rtype = elf_m32r_reloc_type (type);
1258           break;
1259
1260         case EM_386:
1261         case EM_IAMCU:
1262           rtype = elf_i386_reloc_type (type);
1263           break;
1264
1265         case EM_68HC11:
1266         case EM_68HC12:
1267           rtype = elf_m68hc11_reloc_type (type);
1268           break;
1269
1270         case EM_68K:
1271           rtype = elf_m68k_reloc_type (type);
1272           break;
1273
1274         case EM_AVR:
1275         case EM_AVR_OLD:
1276           rtype = elf_avr_reloc_type (type);
1277           break;
1278
1279         case EM_OLD_SPARCV9:
1280         case EM_SPARC32PLUS:
1281         case EM_SPARCV9:
1282         case EM_SPARC:
1283           rtype = elf_sparc_reloc_type (type);
1284           break;
1285
1286         case EM_SPU:
1287           rtype = elf_spu_reloc_type (type);
1288           break;
1289
1290         case EM_V800:
1291           rtype = v800_reloc_type (type);
1292           break;
1293         case EM_V850:
1294         case EM_CYGNUS_V850:
1295           rtype = v850_reloc_type (type);
1296           break;
1297
1298         case EM_D10V:
1299         case EM_CYGNUS_D10V:
1300           rtype = elf_d10v_reloc_type (type);
1301           break;
1302
1303         case EM_D30V:
1304         case EM_CYGNUS_D30V:
1305           rtype = elf_d30v_reloc_type (type);
1306           break;
1307
1308         case EM_DLX:
1309           rtype = elf_dlx_reloc_type (type);
1310           break;
1311
1312         case EM_SH:
1313           rtype = elf_sh_reloc_type (type);
1314           break;
1315
1316         case EM_MN10300:
1317         case EM_CYGNUS_MN10300:
1318           rtype = elf_mn10300_reloc_type (type);
1319           break;
1320
1321         case EM_MN10200:
1322         case EM_CYGNUS_MN10200:
1323           rtype = elf_mn10200_reloc_type (type);
1324           break;
1325
1326         case EM_FR30:
1327         case EM_CYGNUS_FR30:
1328           rtype = elf_fr30_reloc_type (type);
1329           break;
1330
1331         case EM_CYGNUS_FRV:
1332           rtype = elf_frv_reloc_type (type);
1333           break;
1334
1335         case EM_FT32:
1336           rtype = elf_ft32_reloc_type (type);
1337           break;
1338
1339         case EM_MCORE:
1340           rtype = elf_mcore_reloc_type (type);
1341           break;
1342
1343         case EM_MMIX:
1344           rtype = elf_mmix_reloc_type (type);
1345           break;
1346
1347         case EM_MOXIE:
1348           rtype = elf_moxie_reloc_type (type);
1349           break;
1350
1351         case EM_MSP430:
1352           if (uses_msp430x_relocs (filedata))
1353             {
1354               rtype = elf_msp430x_reloc_type (type);
1355               break;
1356             }
1357           /* Fall through.  */
1358         case EM_MSP430_OLD:
1359           rtype = elf_msp430_reloc_type (type);
1360           break;
1361
1362         case EM_NDS32:
1363           rtype = elf_nds32_reloc_type (type);
1364           break;
1365
1366         case EM_PPC:
1367           rtype = elf_ppc_reloc_type (type);
1368           break;
1369
1370         case EM_PPC64:
1371           rtype = elf_ppc64_reloc_type (type);
1372           break;
1373
1374         case EM_MIPS:
1375         case EM_MIPS_RS3_LE:
1376           rtype = elf_mips_reloc_type (type);
1377           break;
1378
1379         case EM_RISCV:
1380           rtype = elf_riscv_reloc_type (type);
1381           break;
1382
1383         case EM_ALPHA:
1384           rtype = elf_alpha_reloc_type (type);
1385           break;
1386
1387         case EM_ARM:
1388           rtype = elf_arm_reloc_type (type);
1389           break;
1390
1391         case EM_ARC:
1392         case EM_ARC_COMPACT:
1393         case EM_ARC_COMPACT2:
1394           rtype = elf_arc_reloc_type (type);
1395           break;
1396
1397         case EM_PARISC:
1398           rtype = elf_hppa_reloc_type (type);
1399           break;
1400
1401         case EM_H8_300:
1402         case EM_H8_300H:
1403         case EM_H8S:
1404           rtype = elf_h8_reloc_type (type);
1405           break;
1406
1407         case EM_OR1K:
1408           rtype = elf_or1k_reloc_type (type);
1409           break;
1410
1411         case EM_PJ:
1412         case EM_PJ_OLD:
1413           rtype = elf_pj_reloc_type (type);
1414           break;
1415         case EM_IA_64:
1416           rtype = elf_ia64_reloc_type (type);
1417           break;
1418
1419         case EM_CRIS:
1420           rtype = elf_cris_reloc_type (type);
1421           break;
1422
1423         case EM_X86_64:
1424         case EM_L1OM:
1425         case EM_K1OM:
1426           rtype = elf_x86_64_reloc_type (type);
1427           break;
1428
1429         case EM_S370:
1430           rtype = i370_reloc_type (type);
1431           break;
1432
1433         case EM_S390_OLD:
1434         case EM_S390:
1435           rtype = elf_s390_reloc_type (type);
1436           break;
1437
1438         case EM_SCORE:
1439           rtype = elf_score_reloc_type (type);
1440           break;
1441
1442         case EM_XSTORMY16:
1443           rtype = elf_xstormy16_reloc_type (type);
1444           break;
1445
1446         case EM_CRX:
1447           rtype = elf_crx_reloc_type (type);
1448           break;
1449
1450         case EM_VAX:
1451           rtype = elf_vax_reloc_type (type);
1452           break;
1453
1454         case EM_VISIUM:
1455           rtype = elf_visium_reloc_type (type);
1456           break;
1457
1458         case EM_ADAPTEVA_EPIPHANY:
1459           rtype = elf_epiphany_reloc_type (type);
1460           break;
1461
1462         case EM_IP2K:
1463         case EM_IP2K_OLD:
1464           rtype = elf_ip2k_reloc_type (type);
1465           break;
1466
1467         case EM_IQ2000:
1468           rtype = elf_iq2000_reloc_type (type);
1469           break;
1470
1471         case EM_XTENSA_OLD:
1472         case EM_XTENSA:
1473           rtype = elf_xtensa_reloc_type (type);
1474           break;
1475
1476         case EM_LATTICEMICO32:
1477           rtype = elf_lm32_reloc_type (type);
1478           break;
1479
1480         case EM_M32C_OLD:
1481         case EM_M32C:
1482           rtype = elf_m32c_reloc_type (type);
1483           break;
1484
1485         case EM_MT:
1486           rtype = elf_mt_reloc_type (type);
1487           break;
1488
1489         case EM_BLACKFIN:
1490           rtype = elf_bfin_reloc_type (type);
1491           break;
1492
1493         case EM_CYGNUS_MEP:
1494           rtype = elf_mep_reloc_type (type);
1495           break;
1496
1497         case EM_CR16:
1498           rtype = elf_cr16_reloc_type (type);
1499           break;
1500
1501         case EM_MICROBLAZE:
1502         case EM_MICROBLAZE_OLD:
1503           rtype = elf_microblaze_reloc_type (type);
1504           break;
1505
1506         case EM_RL78:
1507           rtype = elf_rl78_reloc_type (type);
1508           break;
1509
1510         case EM_RX:
1511           rtype = elf_rx_reloc_type (type);
1512           break;
1513
1514         case EM_METAG:
1515           rtype = elf_metag_reloc_type (type);
1516           break;
1517
1518         case EM_XC16X:
1519         case EM_C166:
1520           rtype = elf_xc16x_reloc_type (type);
1521           break;
1522
1523         case EM_TI_C6000:
1524           rtype = elf_tic6x_reloc_type (type);
1525           break;
1526
1527         case EM_TILEGX:
1528           rtype = elf_tilegx_reloc_type (type);
1529           break;
1530
1531         case EM_TILEPRO:
1532           rtype = elf_tilepro_reloc_type (type);
1533           break;
1534
1535         case EM_WEBASSEMBLY:
1536           rtype = elf_wasm32_reloc_type (type);
1537           break;
1538
1539         case EM_XGATE:
1540           rtype = elf_xgate_reloc_type (type);
1541           break;
1542
1543         case EM_ALTERA_NIOS2:
1544           rtype = elf_nios2_reloc_type (type);
1545           break;
1546
1547         case EM_TI_PRU:
1548           rtype = elf_pru_reloc_type (type);
1549           break;
1550         }
1551
1552       if (rtype == NULL)
1553         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1554       else
1555         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1556
1557       if (filedata->file_header.e_machine == EM_ALPHA
1558           && rtype != NULL
1559           && streq (rtype, "R_ALPHA_LITUSE")
1560           && is_rela)
1561         {
1562           switch (rels[i].r_addend)
1563             {
1564             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1565             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1566             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1567             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1568             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1569             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1570             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1571             default: rtype = NULL;
1572             }
1573
1574           if (rtype)
1575             printf (" (%s)", rtype);
1576           else
1577             {
1578               putchar (' ');
1579               printf (_("<unknown addend: %lx>"),
1580                       (unsigned long) rels[i].r_addend);
1581               res = FALSE;
1582             }
1583         }
1584       else if (symtab_index)
1585         {
1586           if (symtab == NULL || symtab_index >= nsyms)
1587             {
1588               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1589               res = FALSE;
1590             }
1591           else
1592             {
1593               Elf_Internal_Sym * psym;
1594               const char * version_string;
1595               enum versioned_symbol_info sym_info;
1596               unsigned short vna_other;
1597
1598               psym = symtab + symtab_index;
1599
1600               version_string
1601                 = get_symbol_version_string (filedata, is_dynsym,
1602                                              strtab, strtablen,
1603                                              symtab_index,
1604                                              psym,
1605                                              &sym_info,
1606                                              &vna_other);
1607
1608               printf (" ");
1609
1610               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1611                 {
1612                   const char * name;
1613                   unsigned int len;
1614                   unsigned int width = is_32bit_elf ? 8 : 14;
1615
1616                   /* Relocations against GNU_IFUNC symbols do not use the value
1617                      of the symbol as the address to relocate against.  Instead
1618                      they invoke the function named by the symbol and use its
1619                      result as the address for relocation.
1620
1621                      To indicate this to the user, do not display the value of
1622                      the symbol in the "Symbols's Value" field.  Instead show
1623                      its name followed by () as a hint that the symbol is
1624                      invoked.  */
1625
1626                   if (strtab == NULL
1627                       || psym->st_name == 0
1628                       || psym->st_name >= strtablen)
1629                     name = "??";
1630                   else
1631                     name = strtab + psym->st_name;
1632
1633                   len = print_symbol (width, name);
1634                   if (version_string)
1635                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1636                             version_string);
1637                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1638                 }
1639               else
1640                 {
1641                   print_vma (psym->st_value, LONG_HEX);
1642
1643                   printf (is_32bit_elf ? "   " : " ");
1644                 }
1645
1646               if (psym->st_name == 0)
1647                 {
1648                   const char * sec_name = "<null>";
1649                   char name_buf[40];
1650
1651                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1652                     {
1653                       if (psym->st_shndx < filedata->file_header.e_shnum)
1654                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1655                       else if (psym->st_shndx == SHN_ABS)
1656                         sec_name = "ABS";
1657                       else if (psym->st_shndx == SHN_COMMON)
1658                         sec_name = "COMMON";
1659                       else if ((filedata->file_header.e_machine == EM_MIPS
1660                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1661                                || (filedata->file_header.e_machine == EM_TI_C6000
1662                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1663                         sec_name = "SCOMMON";
1664                       else if (filedata->file_header.e_machine == EM_MIPS
1665                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1666                         sec_name = "SUNDEF";
1667                       else if ((filedata->file_header.e_machine == EM_X86_64
1668                                 || filedata->file_header.e_machine == EM_L1OM
1669                                 || filedata->file_header.e_machine == EM_K1OM)
1670                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1671                         sec_name = "LARGE_COMMON";
1672                       else if (filedata->file_header.e_machine == EM_IA_64
1673                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1674                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1675                         sec_name = "ANSI_COM";
1676                       else if (is_ia64_vms (filedata)
1677                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1678                         sec_name = "VMS_SYMVEC";
1679                       else
1680                         {
1681                           sprintf (name_buf, "<section 0x%x>",
1682                                    (unsigned int) psym->st_shndx);
1683                           sec_name = name_buf;
1684                         }
1685                     }
1686                   print_symbol (22, sec_name);
1687                 }
1688               else if (strtab == NULL)
1689                 printf (_("<string table index: %3ld>"), psym->st_name);
1690               else if (psym->st_name >= strtablen)
1691                 {
1692                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1693                   res = FALSE;
1694                 }
1695               else
1696                 {
1697                   print_symbol (22, strtab + psym->st_name);
1698                   if (version_string)
1699                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1700                             version_string);
1701                 }
1702
1703               if (is_rela)
1704                 {
1705                   bfd_vma off = rels[i].r_addend;
1706
1707                   if ((bfd_signed_vma) off < 0)
1708                     printf (" - %" BFD_VMA_FMT "x", - off);
1709                   else
1710                     printf (" + %" BFD_VMA_FMT "x", off);
1711                 }
1712             }
1713         }
1714       else if (is_rela)
1715         {
1716           bfd_vma off = rels[i].r_addend;
1717
1718           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1719           if ((bfd_signed_vma) off < 0)
1720             printf ("-%" BFD_VMA_FMT "x", - off);
1721           else
1722             printf ("%" BFD_VMA_FMT "x", off);
1723         }
1724
1725       if (filedata->file_header.e_machine == EM_SPARCV9
1726           && rtype != NULL
1727           && streq (rtype, "R_SPARC_OLO10"))
1728         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1729
1730       putchar ('\n');
1731
1732 #ifdef BFD64
1733       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1734         {
1735           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1736           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1737           const char * rtype2 = elf_mips_reloc_type (type2);
1738           const char * rtype3 = elf_mips_reloc_type (type3);
1739
1740           printf ("                    Type2: ");
1741
1742           if (rtype2 == NULL)
1743             printf (_("unrecognized: %-7lx"),
1744                     (unsigned long) type2 & 0xffffffff);
1745           else
1746             printf ("%-17.17s", rtype2);
1747
1748           printf ("\n                    Type3: ");
1749
1750           if (rtype3 == NULL)
1751             printf (_("unrecognized: %-7lx"),
1752                     (unsigned long) type3 & 0xffffffff);
1753           else
1754             printf ("%-17.17s", rtype3);
1755
1756           putchar ('\n');
1757         }
1758 #endif /* BFD64 */
1759     }
1760
1761   free (rels);
1762
1763   return res;
1764 }
1765
1766 static const char *
1767 get_mips_dynamic_type (unsigned long type)
1768 {
1769   switch (type)
1770     {
1771     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1772     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1773     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1774     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1775     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1776     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1777     case DT_MIPS_MSYM: return "MIPS_MSYM";
1778     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1779     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1780     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1781     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1782     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1783     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1784     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1785     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1786     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1787     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1788     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1789     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1790     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1791     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1792     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1793     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1794     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1795     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1796     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1797     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1798     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1799     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1800     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1801     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1802     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1803     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1804     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1805     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1806     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1807     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1808     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1809     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1810     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1811     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1812     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1813     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1814     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1815     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1816     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1817     default:
1818       return NULL;
1819     }
1820 }
1821
1822 static const char *
1823 get_sparc64_dynamic_type (unsigned long type)
1824 {
1825   switch (type)
1826     {
1827     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1828     default:
1829       return NULL;
1830     }
1831 }
1832
1833 static const char *
1834 get_ppc_dynamic_type (unsigned long type)
1835 {
1836   switch (type)
1837     {
1838     case DT_PPC_GOT:    return "PPC_GOT";
1839     case DT_PPC_OPT:    return "PPC_OPT";
1840     default:
1841       return NULL;
1842     }
1843 }
1844
1845 static const char *
1846 get_ppc64_dynamic_type (unsigned long type)
1847 {
1848   switch (type)
1849     {
1850     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1851     case DT_PPC64_OPD:    return "PPC64_OPD";
1852     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1853     case DT_PPC64_OPT:    return "PPC64_OPT";
1854     default:
1855       return NULL;
1856     }
1857 }
1858
1859 static const char *
1860 get_parisc_dynamic_type (unsigned long type)
1861 {
1862   switch (type)
1863     {
1864     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1865     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1866     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1867     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1868     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1869     case DT_HP_PREINIT:         return "HP_PREINIT";
1870     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1871     case DT_HP_NEEDED:          return "HP_NEEDED";
1872     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1873     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1874     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1875     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1876     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1877     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1878     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1879     case DT_HP_FILTERED:        return "HP_FILTERED";
1880     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1881     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1882     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1883     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1884     case DT_PLT:                return "PLT";
1885     case DT_PLT_SIZE:           return "PLT_SIZE";
1886     case DT_DLT:                return "DLT";
1887     case DT_DLT_SIZE:           return "DLT_SIZE";
1888     default:
1889       return NULL;
1890     }
1891 }
1892
1893 static const char *
1894 get_ia64_dynamic_type (unsigned long type)
1895 {
1896   switch (type)
1897     {
1898     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1899     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1900     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1901     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1902     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1903     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1904     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1905     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1906     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1907     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1908     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1909     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1910     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1911     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1912     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1913     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1914     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1915     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1916     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1917     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1918     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1919     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1920     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1921     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1922     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1923     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1924     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1925     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1926     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1927     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1928     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1929     default:
1930       return NULL;
1931     }
1932 }
1933
1934 static const char *
1935 get_solaris_section_type (unsigned long type)
1936 {
1937   switch (type)
1938     {
1939     case 0x6fffffee: return "SUNW_ancillary";
1940     case 0x6fffffef: return "SUNW_capchain";
1941     case 0x6ffffff0: return "SUNW_capinfo";
1942     case 0x6ffffff1: return "SUNW_symsort";
1943     case 0x6ffffff2: return "SUNW_tlssort";
1944     case 0x6ffffff3: return "SUNW_LDYNSYM";
1945     case 0x6ffffff4: return "SUNW_dof";
1946     case 0x6ffffff5: return "SUNW_cap";
1947     case 0x6ffffff6: return "SUNW_SIGNATURE";
1948     case 0x6ffffff7: return "SUNW_ANNOTATE";
1949     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1950     case 0x6ffffff9: return "SUNW_DEBUG";
1951     case 0x6ffffffa: return "SUNW_move";
1952     case 0x6ffffffb: return "SUNW_COMDAT";
1953     case 0x6ffffffc: return "SUNW_syminfo";
1954     case 0x6ffffffd: return "SUNW_verdef";
1955     case 0x6ffffffe: return "SUNW_verneed";
1956     case 0x6fffffff: return "SUNW_versym";
1957     case 0x70000000: return "SPARC_GOTDATA";
1958     default: return NULL;
1959     }
1960 }
1961
1962 static const char *
1963 get_alpha_dynamic_type (unsigned long type)
1964 {
1965   switch (type)
1966     {
1967     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1968     default: return NULL;
1969     }
1970 }
1971
1972 static const char *
1973 get_score_dynamic_type (unsigned long type)
1974 {
1975   switch (type)
1976     {
1977     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1978     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1979     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1980     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1981     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1982     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1983     default:                    return NULL;
1984     }
1985 }
1986
1987 static const char *
1988 get_tic6x_dynamic_type (unsigned long type)
1989 {
1990   switch (type)
1991     {
1992     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1993     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1994     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1995     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1996     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1997     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1998     default:                   return NULL;
1999     }
2000 }
2001
2002 static const char *
2003 get_nios2_dynamic_type (unsigned long type)
2004 {
2005   switch (type)
2006     {
2007     case DT_NIOS2_GP: return "NIOS2_GP";
2008     default:          return NULL;
2009     }
2010 }
2011
2012 static const char *
2013 get_solaris_dynamic_type (unsigned long type)
2014 {
2015   switch (type)
2016     {
2017     case 0x6000000d: return "SUNW_AUXILIARY";
2018     case 0x6000000e: return "SUNW_RTLDINF";
2019     case 0x6000000f: return "SUNW_FILTER";
2020     case 0x60000010: return "SUNW_CAP";
2021     case 0x60000011: return "SUNW_SYMTAB";
2022     case 0x60000012: return "SUNW_SYMSZ";
2023     case 0x60000013: return "SUNW_SORTENT";
2024     case 0x60000014: return "SUNW_SYMSORT";
2025     case 0x60000015: return "SUNW_SYMSORTSZ";
2026     case 0x60000016: return "SUNW_TLSSORT";
2027     case 0x60000017: return "SUNW_TLSSORTSZ";
2028     case 0x60000018: return "SUNW_CAPINFO";
2029     case 0x60000019: return "SUNW_STRPAD";
2030     case 0x6000001a: return "SUNW_CAPCHAIN";
2031     case 0x6000001b: return "SUNW_LDMACH";
2032     case 0x6000001d: return "SUNW_CAPCHAINENT";
2033     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2034     case 0x60000021: return "SUNW_PARENT";
2035     case 0x60000023: return "SUNW_ASLR";
2036     case 0x60000025: return "SUNW_RELAX";
2037     case 0x60000029: return "SUNW_NXHEAP";
2038     case 0x6000002b: return "SUNW_NXSTACK";
2039
2040     case 0x70000001: return "SPARC_REGISTER";
2041     case 0x7ffffffd: return "AUXILIARY";
2042     case 0x7ffffffe: return "USED";
2043     case 0x7fffffff: return "FILTER";
2044
2045     default: return NULL;
2046     }
2047 }
2048
2049 static const char *
2050 get_dynamic_type (Filedata * filedata, unsigned long type)
2051 {
2052   static char buff[64];
2053
2054   switch (type)
2055     {
2056     case DT_NULL:       return "NULL";
2057     case DT_NEEDED:     return "NEEDED";
2058     case DT_PLTRELSZ:   return "PLTRELSZ";
2059     case DT_PLTGOT:     return "PLTGOT";
2060     case DT_HASH:       return "HASH";
2061     case DT_STRTAB:     return "STRTAB";
2062     case DT_SYMTAB:     return "SYMTAB";
2063     case DT_RELA:       return "RELA";
2064     case DT_RELASZ:     return "RELASZ";
2065     case DT_RELAENT:    return "RELAENT";
2066     case DT_STRSZ:      return "STRSZ";
2067     case DT_SYMENT:     return "SYMENT";
2068     case DT_INIT:       return "INIT";
2069     case DT_FINI:       return "FINI";
2070     case DT_SONAME:     return "SONAME";
2071     case DT_RPATH:      return "RPATH";
2072     case DT_SYMBOLIC:   return "SYMBOLIC";
2073     case DT_REL:        return "REL";
2074     case DT_RELSZ:      return "RELSZ";
2075     case DT_RELENT:     return "RELENT";
2076     case DT_PLTREL:     return "PLTREL";
2077     case DT_DEBUG:      return "DEBUG";
2078     case DT_TEXTREL:    return "TEXTREL";
2079     case DT_JMPREL:     return "JMPREL";
2080     case DT_BIND_NOW:   return "BIND_NOW";
2081     case DT_INIT_ARRAY: return "INIT_ARRAY";
2082     case DT_FINI_ARRAY: return "FINI_ARRAY";
2083     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2084     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2085     case DT_RUNPATH:    return "RUNPATH";
2086     case DT_FLAGS:      return "FLAGS";
2087
2088     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2089     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2090     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2091
2092     case DT_CHECKSUM:   return "CHECKSUM";
2093     case DT_PLTPADSZ:   return "PLTPADSZ";
2094     case DT_MOVEENT:    return "MOVEENT";
2095     case DT_MOVESZ:     return "MOVESZ";
2096     case DT_FEATURE:    return "FEATURE";
2097     case DT_POSFLAG_1:  return "POSFLAG_1";
2098     case DT_SYMINSZ:    return "SYMINSZ";
2099     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2100
2101     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2102     case DT_CONFIG:     return "CONFIG";
2103     case DT_DEPAUDIT:   return "DEPAUDIT";
2104     case DT_AUDIT:      return "AUDIT";
2105     case DT_PLTPAD:     return "PLTPAD";
2106     case DT_MOVETAB:    return "MOVETAB";
2107     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2108
2109     case DT_VERSYM:     return "VERSYM";
2110
2111     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2112     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2113     case DT_RELACOUNT:  return "RELACOUNT";
2114     case DT_RELCOUNT:   return "RELCOUNT";
2115     case DT_FLAGS_1:    return "FLAGS_1";
2116     case DT_VERDEF:     return "VERDEF";
2117     case DT_VERDEFNUM:  return "VERDEFNUM";
2118     case DT_VERNEED:    return "VERNEED";
2119     case DT_VERNEEDNUM: return "VERNEEDNUM";
2120
2121     case DT_AUXILIARY:  return "AUXILIARY";
2122     case DT_USED:       return "USED";
2123     case DT_FILTER:     return "FILTER";
2124
2125     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2126     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2127     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2128     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2129     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2130     case DT_GNU_HASH:   return "GNU_HASH";
2131
2132     default:
2133       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2134         {
2135           const char * result;
2136
2137           switch (filedata->file_header.e_machine)
2138             {
2139             case EM_MIPS:
2140             case EM_MIPS_RS3_LE:
2141               result = get_mips_dynamic_type (type);
2142               break;
2143             case EM_SPARCV9:
2144               result = get_sparc64_dynamic_type (type);
2145               break;
2146             case EM_PPC:
2147               result = get_ppc_dynamic_type (type);
2148               break;
2149             case EM_PPC64:
2150               result = get_ppc64_dynamic_type (type);
2151               break;
2152             case EM_IA_64:
2153               result = get_ia64_dynamic_type (type);
2154               break;
2155             case EM_ALPHA:
2156               result = get_alpha_dynamic_type (type);
2157               break;
2158             case EM_SCORE:
2159               result = get_score_dynamic_type (type);
2160               break;
2161             case EM_TI_C6000:
2162               result = get_tic6x_dynamic_type (type);
2163               break;
2164             case EM_ALTERA_NIOS2:
2165               result = get_nios2_dynamic_type (type);
2166               break;
2167             default:
2168               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2169                 result = get_solaris_dynamic_type (type);
2170               else
2171                 result = NULL;
2172               break;
2173             }
2174
2175           if (result != NULL)
2176             return result;
2177
2178           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2179         }
2180       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2181                || (filedata->file_header.e_machine == EM_PARISC
2182                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2183         {
2184           const char * result;
2185
2186           switch (filedata->file_header.e_machine)
2187             {
2188             case EM_PARISC:
2189               result = get_parisc_dynamic_type (type);
2190               break;
2191             case EM_IA_64:
2192               result = get_ia64_dynamic_type (type);
2193               break;
2194             default:
2195               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2196                 result = get_solaris_dynamic_type (type);
2197               else
2198                 result = NULL;
2199               break;
2200             }
2201
2202           if (result != NULL)
2203             return result;
2204
2205           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2206                     type);
2207         }
2208       else
2209         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2210
2211       return buff;
2212     }
2213 }
2214
2215 static char *
2216 get_file_type (unsigned e_type)
2217 {
2218   static char buff[32];
2219
2220   switch (e_type)
2221     {
2222     case ET_NONE: return _("NONE (None)");
2223     case ET_REL:  return _("REL (Relocatable file)");
2224     case ET_EXEC: return _("EXEC (Executable file)");
2225     case ET_DYN:  return _("DYN (Shared object file)");
2226     case ET_CORE: return _("CORE (Core file)");
2227
2228     default:
2229       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2230         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2231       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2232         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2233       else
2234         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2235       return buff;
2236     }
2237 }
2238
2239 static char *
2240 get_machine_name (unsigned e_machine)
2241 {
2242   static char buff[64]; /* XXX */
2243
2244   switch (e_machine)
2245     {
2246       /* Please keep this switch table sorted by increasing EM_ value.  */
2247       /* 0 */
2248     case EM_NONE:               return _("None");
2249     case EM_M32:                return "WE32100";
2250     case EM_SPARC:              return "Sparc";
2251     case EM_386:                return "Intel 80386";
2252     case EM_68K:                return "MC68000";
2253     case EM_88K:                return "MC88000";
2254     case EM_IAMCU:              return "Intel MCU";
2255     case EM_860:                return "Intel 80860";
2256     case EM_MIPS:               return "MIPS R3000";
2257     case EM_S370:               return "IBM System/370";
2258       /* 10 */
2259     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2260     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2261     case EM_PARISC:             return "HPPA";
2262     case EM_VPP550:             return "Fujitsu VPP500";
2263     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2264     case EM_960:                return "Intel 90860";
2265     case EM_PPC:                return "PowerPC";
2266       /* 20 */
2267     case EM_PPC64:              return "PowerPC64";
2268     case EM_S390_OLD:
2269     case EM_S390:               return "IBM S/390";
2270     case EM_SPU:                return "SPU";
2271       /* 30 */
2272     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2273     case EM_FR20:               return "Fujitsu FR20";
2274     case EM_RH32:               return "TRW RH32";
2275     case EM_MCORE:              return "MCORE";
2276       /* 40 */
2277     case EM_ARM:                return "ARM";
2278     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2279     case EM_SH:                 return "Renesas / SuperH SH";
2280     case EM_SPARCV9:            return "Sparc v9";
2281     case EM_TRICORE:            return "Siemens Tricore";
2282     case EM_ARC:                return "ARC";
2283     case EM_H8_300:             return "Renesas H8/300";
2284     case EM_H8_300H:            return "Renesas H8/300H";
2285     case EM_H8S:                return "Renesas H8S";
2286     case EM_H8_500:             return "Renesas H8/500";
2287       /* 50 */
2288     case EM_IA_64:              return "Intel IA-64";
2289     case EM_MIPS_X:             return "Stanford MIPS-X";
2290     case EM_COLDFIRE:           return "Motorola Coldfire";
2291     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2292     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2293     case EM_PCP:                return "Siemens PCP";
2294     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2295     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2296     case EM_STARCORE:           return "Motorola Star*Core processor";
2297     case EM_ME16:               return "Toyota ME16 processor";
2298       /* 60 */
2299     case EM_ST100:              return "STMicroelectronics ST100 processor";
2300     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2301     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2302     case EM_PDSP:               return "Sony DSP processor";
2303     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2304     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2305     case EM_FX66:               return "Siemens FX66 microcontroller";
2306     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2307     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2308     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2309       /* 70 */
2310     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2311     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2312     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2313     case EM_SVX:                return "Silicon Graphics SVx";
2314     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2315     case EM_VAX:                return "Digital VAX";
2316     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2317     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2318     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2319     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2320       /* 80 */
2321     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2322     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2323     case EM_PRISM:              return "Vitesse Prism";
2324     case EM_AVR_OLD:
2325     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2326     case EM_CYGNUS_FR30:
2327     case EM_FR30:               return "Fujitsu FR30";
2328     case EM_CYGNUS_D10V:
2329     case EM_D10V:               return "d10v";
2330     case EM_CYGNUS_D30V:
2331     case EM_D30V:               return "d30v";
2332     case EM_CYGNUS_V850:
2333     case EM_V850:               return "Renesas V850";
2334     case EM_CYGNUS_M32R:
2335     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2336     case EM_CYGNUS_MN10300:
2337     case EM_MN10300:            return "mn10300";
2338       /* 90 */
2339     case EM_CYGNUS_MN10200:
2340     case EM_MN10200:            return "mn10200";
2341     case EM_PJ:                 return "picoJava";
2342     case EM_OR1K:               return "OpenRISC 1000";
2343     case EM_ARC_COMPACT:        return "ARCompact";
2344     case EM_XTENSA_OLD:
2345     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2346     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2347     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2348     case EM_NS32K:              return "National Semiconductor 32000 series";
2349     case EM_TPC:                return "Tenor Network TPC processor";
2350     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2351       /* 100 */
2352     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2353     case EM_IP2K_OLD:
2354     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2355     case EM_MAX:                return "MAX Processor";
2356     case EM_CR:                 return "National Semiconductor CompactRISC";
2357     case EM_F2MC16:             return "Fujitsu F2MC16";
2358     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2359     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2360     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2361     case EM_SEP:                return "Sharp embedded microprocessor";
2362     case EM_ARCA:               return "Arca RISC microprocessor";
2363       /* 110 */
2364     case EM_UNICORE:            return "Unicore";
2365     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2366     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2367     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2368     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2369     case EM_XGATE:              return "Motorola XGATE embedded processor";
2370     case EM_C166:
2371     case EM_XC16X:              return "Infineon Technologies xc16x";
2372     case EM_M16C:               return "Renesas M16C series microprocessors";
2373     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2374     case EM_CE:                 return "Freescale Communication Engine RISC core";
2375       /* 120 */
2376     case EM_M32C:               return "Renesas M32c";
2377       /* 130 */
2378     case EM_TSK3000:            return "Altium TSK3000 core";
2379     case EM_RS08:               return "Freescale RS08 embedded processor";
2380     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2381     case EM_SCORE:              return "SUNPLUS S+Core";
2382     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2383     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2384     case EM_LATTICEMICO32:      return "Lattice Mico32";
2385     case EM_SE_C17:             return "Seiko Epson C17 family";
2386       /* 140 */
2387     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2388     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2389     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2390     case EM_TI_PRU:             return "TI PRU I/O processor";
2391       /* 160 */
2392     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2393     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2394     case EM_R32C:               return "Renesas R32C series microprocessors";
2395     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2396     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2397     case EM_8051:               return "Intel 8051 and variants";
2398     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2399     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2400     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2401     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2402       /* 170 */
2403     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2404     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2405     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2406     case EM_RX:                 return "Renesas RX";
2407     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2408     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2409     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2410     case EM_CR16:
2411     case EM_MICROBLAZE:
2412     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2413     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2414     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2415       /* 180 */
2416     case EM_L1OM:               return "Intel L1OM";
2417     case EM_K1OM:               return "Intel K1OM";
2418     case EM_INTEL182:           return "Intel (reserved)";
2419     case EM_AARCH64:            return "AArch64";
2420     case EM_ARM184:             return "ARM (reserved)";
2421     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2422     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2423     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2424     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2425       /* 190 */
2426     case EM_CUDA:               return "NVIDIA CUDA architecture";
2427     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2428     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2429     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2430     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2431     case EM_ARC_COMPACT2:       return "ARCv2";
2432     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2433     case EM_RL78:               return "Renesas RL78";
2434     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2435     case EM_78K0R:              return "Renesas 78K0R";
2436       /* 200 */
2437     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2438     case EM_BA1:                return "Beyond BA1 CPU architecture";
2439     case EM_BA2:                return "Beyond BA2 CPU architecture";
2440     case EM_XCORE:              return "XMOS xCORE processor family";
2441     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2442       /* 210 */
2443     case EM_KM32:               return "KM211 KM32 32-bit processor";
2444     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2445     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2446     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2447     case EM_KVARC:              return "KM211 KVARC processor";
2448     case EM_CDP:                return "Paneve CDP architecture family";
2449     case EM_COGE:               return "Cognitive Smart Memory Processor";
2450     case EM_COOL:               return "Bluechip Systems CoolEngine";
2451     case EM_NORC:               return "Nanoradio Optimized RISC";
2452     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2453       /* 220 */
2454     case EM_Z80:                return "Zilog Z80";
2455     case EM_VISIUM:             return "CDS VISIUMcore processor";
2456     case EM_FT32:               return "FTDI Chip FT32";
2457     case EM_MOXIE:              return "Moxie";
2458     case EM_AMDGPU:             return "AMD GPU";
2459     case EM_RISCV:              return "RISC-V";
2460     case EM_LANAI:              return "Lanai 32-bit processor";
2461     case EM_BPF:                return "Linux BPF";
2462
2463       /* Large numbers...  */
2464     case EM_MT:                 return "Morpho Techologies MT processor";
2465     case EM_ALPHA:              return "Alpha";
2466     case EM_WEBASSEMBLY:        return "Web Assembly";
2467     case EM_DLX:                return "OpenDLX";
2468     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2469     case EM_IQ2000:             return "Vitesse IQ2000";
2470     case EM_M32C_OLD:
2471     case EM_NIOS32:             return "Altera Nios";
2472     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2473     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2474     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2475
2476     default:
2477       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2478       return buff;
2479     }
2480 }
2481
2482 static void
2483 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2484 {
2485   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2486      other compilers don't a specific architecture type in the e_flags, and
2487      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2488      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2489      architectures.
2490
2491      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2492      but also sets a specific architecture type in the e_flags field.
2493
2494      However, when decoding the flags we don't worry if we see an
2495      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2496      ARCEM architecture type.  */
2497
2498   switch (e_flags & EF_ARC_MACH_MSK)
2499     {
2500       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2501     case EF_ARC_CPU_ARCV2EM:
2502       strcat (buf, ", ARC EM");
2503       break;
2504     case EF_ARC_CPU_ARCV2HS:
2505       strcat (buf, ", ARC HS");
2506       break;
2507
2508       /* We only expect these to occur for EM_ARC_COMPACT.  */
2509     case E_ARC_MACH_ARC600:
2510       strcat (buf, ", ARC600");
2511       break;
2512     case E_ARC_MACH_ARC601:
2513       strcat (buf, ", ARC601");
2514       break;
2515     case E_ARC_MACH_ARC700:
2516       strcat (buf, ", ARC700");
2517       break;
2518
2519       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2520          new ELF with new architecture being read by an old version of
2521          readelf, or (c) An ELF built with non-GNU compiler that does not
2522          set the architecture in the e_flags.  */
2523     default:
2524       if (e_machine == EM_ARC_COMPACT)
2525         strcat (buf, ", Unknown ARCompact");
2526       else
2527         strcat (buf, ", Unknown ARC");
2528       break;
2529     }
2530
2531   switch (e_flags & EF_ARC_OSABI_MSK)
2532     {
2533     case E_ARC_OSABI_ORIG:
2534       strcat (buf, ", (ABI:legacy)");
2535       break;
2536     case E_ARC_OSABI_V2:
2537       strcat (buf, ", (ABI:v2)");
2538       break;
2539       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2540     case E_ARC_OSABI_V3:
2541       strcat (buf, ", v3 no-legacy-syscalls ABI");
2542       break;
2543     case E_ARC_OSABI_V4:
2544       strcat (buf, ", v4 ABI");
2545       break;
2546     default:
2547       strcat (buf, ", unrecognised ARC OSABI flag");
2548       break;
2549     }
2550 }
2551
2552 static void
2553 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2554 {
2555   unsigned eabi;
2556   bfd_boolean unknown = FALSE;
2557
2558   eabi = EF_ARM_EABI_VERSION (e_flags);
2559   e_flags &= ~ EF_ARM_EABIMASK;
2560
2561   /* Handle "generic" ARM flags.  */
2562   if (e_flags & EF_ARM_RELEXEC)
2563     {
2564       strcat (buf, ", relocatable executable");
2565       e_flags &= ~ EF_ARM_RELEXEC;
2566     }
2567
2568   /* Now handle EABI specific flags.  */
2569   switch (eabi)
2570     {
2571     default:
2572       strcat (buf, ", <unrecognized EABI>");
2573       if (e_flags)
2574         unknown = TRUE;
2575       break;
2576
2577     case EF_ARM_EABI_VER1:
2578       strcat (buf, ", Version1 EABI");
2579       while (e_flags)
2580         {
2581           unsigned flag;
2582
2583           /* Process flags one bit at a time.  */
2584           flag = e_flags & - e_flags;
2585           e_flags &= ~ flag;
2586
2587           switch (flag)
2588             {
2589             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2590               strcat (buf, ", sorted symbol tables");
2591               break;
2592
2593             default:
2594               unknown = TRUE;
2595               break;
2596             }
2597         }
2598       break;
2599
2600     case EF_ARM_EABI_VER2:
2601       strcat (buf, ", Version2 EABI");
2602       while (e_flags)
2603         {
2604           unsigned flag;
2605
2606           /* Process flags one bit at a time.  */
2607           flag = e_flags & - e_flags;
2608           e_flags &= ~ flag;
2609
2610           switch (flag)
2611             {
2612             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2613               strcat (buf, ", sorted symbol tables");
2614               break;
2615
2616             case EF_ARM_DYNSYMSUSESEGIDX:
2617               strcat (buf, ", dynamic symbols use segment index");
2618               break;
2619
2620             case EF_ARM_MAPSYMSFIRST:
2621               strcat (buf, ", mapping symbols precede others");
2622               break;
2623
2624             default:
2625               unknown = TRUE;
2626               break;
2627             }
2628         }
2629       break;
2630
2631     case EF_ARM_EABI_VER3:
2632       strcat (buf, ", Version3 EABI");
2633       break;
2634
2635     case EF_ARM_EABI_VER4:
2636       strcat (buf, ", Version4 EABI");
2637       while (e_flags)
2638         {
2639           unsigned flag;
2640
2641           /* Process flags one bit at a time.  */
2642           flag = e_flags & - e_flags;
2643           e_flags &= ~ flag;
2644
2645           switch (flag)
2646             {
2647             case EF_ARM_BE8:
2648               strcat (buf, ", BE8");
2649               break;
2650
2651             case EF_ARM_LE8:
2652               strcat (buf, ", LE8");
2653               break;
2654
2655             default:
2656               unknown = TRUE;
2657               break;
2658             }
2659         }
2660       break;
2661
2662     case EF_ARM_EABI_VER5:
2663       strcat (buf, ", Version5 EABI");
2664       while (e_flags)
2665         {
2666           unsigned flag;
2667
2668           /* Process flags one bit at a time.  */
2669           flag = e_flags & - e_flags;
2670           e_flags &= ~ flag;
2671
2672           switch (flag)
2673             {
2674             case EF_ARM_BE8:
2675               strcat (buf, ", BE8");
2676               break;
2677
2678             case EF_ARM_LE8:
2679               strcat (buf, ", LE8");
2680               break;
2681
2682             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2683               strcat (buf, ", soft-float ABI");
2684               break;
2685
2686             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2687               strcat (buf, ", hard-float ABI");
2688               break;
2689
2690             default:
2691               unknown = TRUE;
2692               break;
2693             }
2694         }
2695       break;
2696
2697     case EF_ARM_EABI_UNKNOWN:
2698       strcat (buf, ", GNU EABI");
2699       while (e_flags)
2700         {
2701           unsigned flag;
2702
2703           /* Process flags one bit at a time.  */
2704           flag = e_flags & - e_flags;
2705           e_flags &= ~ flag;
2706
2707           switch (flag)
2708             {
2709             case EF_ARM_INTERWORK:
2710               strcat (buf, ", interworking enabled");
2711               break;
2712
2713             case EF_ARM_APCS_26:
2714               strcat (buf, ", uses APCS/26");
2715               break;
2716
2717             case EF_ARM_APCS_FLOAT:
2718               strcat (buf, ", uses APCS/float");
2719               break;
2720
2721             case EF_ARM_PIC:
2722               strcat (buf, ", position independent");
2723               break;
2724
2725             case EF_ARM_ALIGN8:
2726               strcat (buf, ", 8 bit structure alignment");
2727               break;
2728
2729             case EF_ARM_NEW_ABI:
2730               strcat (buf, ", uses new ABI");
2731               break;
2732
2733             case EF_ARM_OLD_ABI:
2734               strcat (buf, ", uses old ABI");
2735               break;
2736
2737             case EF_ARM_SOFT_FLOAT:
2738               strcat (buf, ", software FP");
2739               break;
2740
2741             case EF_ARM_VFP_FLOAT:
2742               strcat (buf, ", VFP");
2743               break;
2744
2745             case EF_ARM_MAVERICK_FLOAT:
2746               strcat (buf, ", Maverick FP");
2747               break;
2748
2749             default:
2750               unknown = TRUE;
2751               break;
2752             }
2753         }
2754     }
2755
2756   if (unknown)
2757     strcat (buf,_(", <unknown>"));
2758 }
2759
2760 static void
2761 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2762 {
2763   --size; /* Leave space for null terminator.  */
2764
2765   switch (e_flags & EF_AVR_MACH)
2766     {
2767     case E_AVR_MACH_AVR1:
2768       strncat (buf, ", avr:1", size);
2769       break;
2770     case E_AVR_MACH_AVR2:
2771       strncat (buf, ", avr:2", size);
2772       break;
2773     case E_AVR_MACH_AVR25:
2774       strncat (buf, ", avr:25", size);
2775       break;
2776     case E_AVR_MACH_AVR3:
2777       strncat (buf, ", avr:3", size);
2778       break;
2779     case E_AVR_MACH_AVR31:
2780       strncat (buf, ", avr:31", size);
2781       break;
2782     case E_AVR_MACH_AVR35:
2783       strncat (buf, ", avr:35", size);
2784       break;
2785     case E_AVR_MACH_AVR4:
2786       strncat (buf, ", avr:4", size);
2787       break;
2788     case E_AVR_MACH_AVR5:
2789       strncat (buf, ", avr:5", size);
2790       break;
2791     case E_AVR_MACH_AVR51:
2792       strncat (buf, ", avr:51", size);
2793       break;
2794     case E_AVR_MACH_AVR6:
2795       strncat (buf, ", avr:6", size);
2796       break;
2797     case E_AVR_MACH_AVRTINY:
2798       strncat (buf, ", avr:100", size);
2799       break;
2800     case E_AVR_MACH_XMEGA1:
2801       strncat (buf, ", avr:101", size);
2802       break;
2803     case E_AVR_MACH_XMEGA2:
2804       strncat (buf, ", avr:102", size);
2805       break;
2806     case E_AVR_MACH_XMEGA3:
2807       strncat (buf, ", avr:103", size);
2808       break;
2809     case E_AVR_MACH_XMEGA4:
2810       strncat (buf, ", avr:104", size);
2811       break;
2812     case E_AVR_MACH_XMEGA5:
2813       strncat (buf, ", avr:105", size);
2814       break;
2815     case E_AVR_MACH_XMEGA6:
2816       strncat (buf, ", avr:106", size);
2817       break;
2818     case E_AVR_MACH_XMEGA7:
2819       strncat (buf, ", avr:107", size);
2820       break;
2821     default:
2822       strncat (buf, ", avr:<unknown>", size);
2823       break;
2824     }
2825
2826   size -= strlen (buf);
2827   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2828     strncat (buf, ", link-relax", size);
2829 }
2830
2831 static void
2832 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2833 {
2834   unsigned abi;
2835   unsigned arch;
2836   unsigned config;
2837   unsigned version;
2838   bfd_boolean has_fpu = FALSE;
2839   unsigned int r = 0;
2840
2841   static const char *ABI_STRINGS[] =
2842   {
2843     "ABI v0", /* use r5 as return register; only used in N1213HC */
2844     "ABI v1", /* use r0 as return register */
2845     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2846     "ABI v2fp", /* for FPU */
2847     "AABI",
2848     "ABI2 FP+"
2849   };
2850   static const char *VER_STRINGS[] =
2851   {
2852     "Andes ELF V1.3 or older",
2853     "Andes ELF V1.3.1",
2854     "Andes ELF V1.4"
2855   };
2856   static const char *ARCH_STRINGS[] =
2857   {
2858     "",
2859     "Andes Star v1.0",
2860     "Andes Star v2.0",
2861     "Andes Star v3.0",
2862     "Andes Star v3.0m"
2863   };
2864
2865   abi = EF_NDS_ABI & e_flags;
2866   arch = EF_NDS_ARCH & e_flags;
2867   config = EF_NDS_INST & e_flags;
2868   version = EF_NDS32_ELF_VERSION & e_flags;
2869
2870   memset (buf, 0, size);
2871
2872   switch (abi)
2873     {
2874     case E_NDS_ABI_V0:
2875     case E_NDS_ABI_V1:
2876     case E_NDS_ABI_V2:
2877     case E_NDS_ABI_V2FP:
2878     case E_NDS_ABI_AABI:
2879     case E_NDS_ABI_V2FP_PLUS:
2880       /* In case there are holes in the array.  */
2881       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2882       break;
2883
2884     default:
2885       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2886       break;
2887     }
2888
2889   switch (version)
2890     {
2891     case E_NDS32_ELF_VER_1_2:
2892     case E_NDS32_ELF_VER_1_3:
2893     case E_NDS32_ELF_VER_1_4:
2894       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2895       break;
2896
2897     default:
2898       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2899       break;
2900     }
2901
2902   if (E_NDS_ABI_V0 == abi)
2903     {
2904       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2905       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2906       if (arch == E_NDS_ARCH_STAR_V1_0)
2907         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2908       return;
2909     }
2910
2911   switch (arch)
2912     {
2913     case E_NDS_ARCH_STAR_V1_0:
2914     case E_NDS_ARCH_STAR_V2_0:
2915     case E_NDS_ARCH_STAR_V3_0:
2916     case E_NDS_ARCH_STAR_V3_M:
2917       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2918       break;
2919
2920     default:
2921       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2922       /* ARCH version determines how the e_flags are interpreted.
2923          If it is unknown, we cannot proceed.  */
2924       return;
2925     }
2926
2927   /* Newer ABI; Now handle architecture specific flags.  */
2928   if (arch == E_NDS_ARCH_STAR_V1_0)
2929     {
2930       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2931         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2932
2933       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2934         r += snprintf (buf + r, size -r, ", MAC");
2935
2936       if (config & E_NDS32_HAS_DIV_INST)
2937         r += snprintf (buf + r, size -r, ", DIV");
2938
2939       if (config & E_NDS32_HAS_16BIT_INST)
2940         r += snprintf (buf + r, size -r, ", 16b");
2941     }
2942   else
2943     {
2944       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2945         {
2946           if (version <= E_NDS32_ELF_VER_1_3)
2947             r += snprintf (buf + r, size -r, ", [B8]");
2948           else
2949             r += snprintf (buf + r, size -r, ", EX9");
2950         }
2951
2952       if (config & E_NDS32_HAS_MAC_DX_INST)
2953         r += snprintf (buf + r, size -r, ", MAC_DX");
2954
2955       if (config & E_NDS32_HAS_DIV_DX_INST)
2956         r += snprintf (buf + r, size -r, ", DIV_DX");
2957
2958       if (config & E_NDS32_HAS_16BIT_INST)
2959         {
2960           if (version <= E_NDS32_ELF_VER_1_3)
2961             r += snprintf (buf + r, size -r, ", 16b");
2962           else
2963             r += snprintf (buf + r, size -r, ", IFC");
2964         }
2965     }
2966
2967   if (config & E_NDS32_HAS_EXT_INST)
2968     r += snprintf (buf + r, size -r, ", PERF1");
2969
2970   if (config & E_NDS32_HAS_EXT2_INST)
2971     r += snprintf (buf + r, size -r, ", PERF2");
2972
2973   if (config & E_NDS32_HAS_FPU_INST)
2974     {
2975       has_fpu = TRUE;
2976       r += snprintf (buf + r, size -r, ", FPU_SP");
2977     }
2978
2979   if (config & E_NDS32_HAS_FPU_DP_INST)
2980     {
2981       has_fpu = TRUE;
2982       r += snprintf (buf + r, size -r, ", FPU_DP");
2983     }
2984
2985   if (config & E_NDS32_HAS_FPU_MAC_INST)
2986     {
2987       has_fpu = TRUE;
2988       r += snprintf (buf + r, size -r, ", FPU_MAC");
2989     }
2990
2991   if (has_fpu)
2992     {
2993       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2994         {
2995         case E_NDS32_FPU_REG_8SP_4DP:
2996           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2997           break;
2998         case E_NDS32_FPU_REG_16SP_8DP:
2999           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3000           break;
3001         case E_NDS32_FPU_REG_32SP_16DP:
3002           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3003           break;
3004         case E_NDS32_FPU_REG_32SP_32DP:
3005           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3006           break;
3007         }
3008     }
3009
3010   if (config & E_NDS32_HAS_AUDIO_INST)
3011     r += snprintf (buf + r, size -r, ", AUDIO");
3012
3013   if (config & E_NDS32_HAS_STRING_INST)
3014     r += snprintf (buf + r, size -r, ", STR");
3015
3016   if (config & E_NDS32_HAS_REDUCED_REGS)
3017     r += snprintf (buf + r, size -r, ", 16REG");
3018
3019   if (config & E_NDS32_HAS_VIDEO_INST)
3020     {
3021       if (version <= E_NDS32_ELF_VER_1_3)
3022         r += snprintf (buf + r, size -r, ", VIDEO");
3023       else
3024         r += snprintf (buf + r, size -r, ", SATURATION");
3025     }
3026
3027   if (config & E_NDS32_HAS_ENCRIPT_INST)
3028     r += snprintf (buf + r, size -r, ", ENCRP");
3029
3030   if (config & E_NDS32_HAS_L2C_INST)
3031     r += snprintf (buf + r, size -r, ", L2C");
3032 }
3033
3034 static char *
3035 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3036 {
3037   static char buf[1024];
3038
3039   buf[0] = '\0';
3040
3041   if (e_flags)
3042     {
3043       switch (e_machine)
3044         {
3045         default:
3046           break;
3047
3048         case EM_ARC_COMPACT2:
3049         case EM_ARC_COMPACT:
3050           decode_ARC_machine_flags (e_flags, e_machine, buf);
3051           break;
3052
3053         case EM_ARM:
3054           decode_ARM_machine_flags (e_flags, buf);
3055           break;
3056
3057         case EM_AVR:
3058           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3059           break;
3060
3061         case EM_BLACKFIN:
3062           if (e_flags & EF_BFIN_PIC)
3063             strcat (buf, ", PIC");
3064
3065           if (e_flags & EF_BFIN_FDPIC)
3066             strcat (buf, ", FDPIC");
3067
3068           if (e_flags & EF_BFIN_CODE_IN_L1)
3069             strcat (buf, ", code in L1");
3070
3071           if (e_flags & EF_BFIN_DATA_IN_L1)
3072             strcat (buf, ", data in L1");
3073
3074           break;
3075
3076         case EM_CYGNUS_FRV:
3077           switch (e_flags & EF_FRV_CPU_MASK)
3078             {
3079             case EF_FRV_CPU_GENERIC:
3080               break;
3081
3082             default:
3083               strcat (buf, ", fr???");
3084               break;
3085
3086             case EF_FRV_CPU_FR300:
3087               strcat (buf, ", fr300");
3088               break;
3089
3090             case EF_FRV_CPU_FR400:
3091               strcat (buf, ", fr400");
3092               break;
3093             case EF_FRV_CPU_FR405:
3094               strcat (buf, ", fr405");
3095               break;
3096
3097             case EF_FRV_CPU_FR450:
3098               strcat (buf, ", fr450");
3099               break;
3100
3101             case EF_FRV_CPU_FR500:
3102               strcat (buf, ", fr500");
3103               break;
3104             case EF_FRV_CPU_FR550:
3105               strcat (buf, ", fr550");
3106               break;
3107
3108             case EF_FRV_CPU_SIMPLE:
3109               strcat (buf, ", simple");
3110               break;
3111             case EF_FRV_CPU_TOMCAT:
3112               strcat (buf, ", tomcat");
3113               break;
3114             }
3115           break;
3116
3117         case EM_68K:
3118           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3119             strcat (buf, ", m68000");
3120           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3121             strcat (buf, ", cpu32");
3122           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3123             strcat (buf, ", fido_a");
3124           else
3125             {
3126               char const * isa = _("unknown");
3127               char const * mac = _("unknown mac");
3128               char const * additional = NULL;
3129
3130               switch (e_flags & EF_M68K_CF_ISA_MASK)
3131                 {
3132                 case EF_M68K_CF_ISA_A_NODIV:
3133                   isa = "A";
3134                   additional = ", nodiv";
3135                   break;
3136                 case EF_M68K_CF_ISA_A:
3137                   isa = "A";
3138                   break;
3139                 case EF_M68K_CF_ISA_A_PLUS:
3140                   isa = "A+";
3141                   break;
3142                 case EF_M68K_CF_ISA_B_NOUSP:
3143                   isa = "B";
3144                   additional = ", nousp";
3145                   break;
3146                 case EF_M68K_CF_ISA_B:
3147                   isa = "B";
3148                   break;
3149                 case EF_M68K_CF_ISA_C:
3150                   isa = "C";
3151                   break;
3152                 case EF_M68K_CF_ISA_C_NODIV:
3153                   isa = "C";
3154                   additional = ", nodiv";
3155                   break;
3156                 }
3157               strcat (buf, ", cf, isa ");
3158               strcat (buf, isa);
3159               if (additional)
3160                 strcat (buf, additional);
3161               if (e_flags & EF_M68K_CF_FLOAT)
3162                 strcat (buf, ", float");
3163               switch (e_flags & EF_M68K_CF_MAC_MASK)
3164                 {
3165                 case 0:
3166                   mac = NULL;
3167                   break;
3168                 case EF_M68K_CF_MAC:
3169                   mac = "mac";
3170                   break;
3171                 case EF_M68K_CF_EMAC:
3172                   mac = "emac";
3173                   break;
3174                 case EF_M68K_CF_EMAC_B:
3175                   mac = "emac_b";
3176                   break;
3177                 }
3178               if (mac)
3179                 {
3180                   strcat (buf, ", ");
3181                   strcat (buf, mac);
3182                 }
3183             }
3184           break;
3185
3186         case EM_CYGNUS_MEP:
3187           switch (e_flags & EF_MEP_CPU_MASK)
3188             {
3189             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3190             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3191             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3192             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3193             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3194             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3195             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3196             }
3197
3198           switch (e_flags & EF_MEP_COP_MASK)
3199             {
3200             case EF_MEP_COP_NONE: break;
3201             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3202             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3203             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3204             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3205             default: strcat (buf, _("<unknown MeP copro type>")); break;
3206             }
3207
3208           if (e_flags & EF_MEP_LIBRARY)
3209             strcat (buf, ", Built for Library");
3210
3211           if (e_flags & EF_MEP_INDEX_MASK)
3212             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3213                      e_flags & EF_MEP_INDEX_MASK);
3214
3215           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3216             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3217                      e_flags & ~ EF_MEP_ALL_FLAGS);
3218           break;
3219
3220         case EM_PPC:
3221           if (e_flags & EF_PPC_EMB)
3222             strcat (buf, ", emb");
3223
3224           if (e_flags & EF_PPC_RELOCATABLE)
3225             strcat (buf, _(", relocatable"));
3226
3227           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3228             strcat (buf, _(", relocatable-lib"));
3229           break;
3230
3231         case EM_PPC64:
3232           if (e_flags & EF_PPC64_ABI)
3233             {
3234               char abi[] = ", abiv0";
3235
3236               abi[6] += e_flags & EF_PPC64_ABI;
3237               strcat (buf, abi);
3238             }
3239           break;
3240
3241         case EM_V800:
3242           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3243             strcat (buf, ", RH850 ABI");
3244
3245           if (e_flags & EF_V800_850E3)
3246             strcat (buf, ", V3 architecture");
3247
3248           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3249             strcat (buf, ", FPU not used");
3250
3251           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3252             strcat (buf, ", regmode: COMMON");
3253
3254           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3255             strcat (buf, ", r4 not used");
3256
3257           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3258             strcat (buf, ", r30 not used");
3259
3260           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3261             strcat (buf, ", r5 not used");
3262
3263           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3264             strcat (buf, ", r2 not used");
3265
3266           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3267             {
3268               switch (e_flags & - e_flags)
3269                 {
3270                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3271                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3272                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3273                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3274                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3275                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3276                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3277                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3278                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3279                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3280                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3281                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3282                 default: break;
3283                 }
3284             }
3285           break;
3286
3287         case EM_V850:
3288         case EM_CYGNUS_V850:
3289           switch (e_flags & EF_V850_ARCH)
3290             {
3291             case E_V850E3V5_ARCH:
3292               strcat (buf, ", v850e3v5");
3293               break;
3294             case E_V850E2V3_ARCH:
3295               strcat (buf, ", v850e2v3");
3296               break;
3297             case E_V850E2_ARCH:
3298               strcat (buf, ", v850e2");
3299               break;
3300             case E_V850E1_ARCH:
3301               strcat (buf, ", v850e1");
3302               break;
3303             case E_V850E_ARCH:
3304               strcat (buf, ", v850e");
3305               break;
3306             case E_V850_ARCH:
3307               strcat (buf, ", v850");
3308               break;
3309             default:
3310               strcat (buf, _(", unknown v850 architecture variant"));
3311               break;
3312             }
3313           break;
3314
3315         case EM_M32R:
3316         case EM_CYGNUS_M32R:
3317           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3318             strcat (buf, ", m32r");
3319           break;
3320
3321         case EM_MIPS:
3322         case EM_MIPS_RS3_LE:
3323           if (e_flags & EF_MIPS_NOREORDER)
3324             strcat (buf, ", noreorder");
3325
3326           if (e_flags & EF_MIPS_PIC)
3327             strcat (buf, ", pic");
3328
3329           if (e_flags & EF_MIPS_CPIC)
3330             strcat (buf, ", cpic");
3331
3332           if (e_flags & EF_MIPS_UCODE)
3333             strcat (buf, ", ugen_reserved");
3334
3335           if (e_flags & EF_MIPS_ABI2)
3336             strcat (buf, ", abi2");
3337
3338           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3339             strcat (buf, ", odk first");
3340
3341           if (e_flags & EF_MIPS_32BITMODE)
3342             strcat (buf, ", 32bitmode");
3343
3344           if (e_flags & EF_MIPS_NAN2008)
3345             strcat (buf, ", nan2008");
3346
3347           if (e_flags & EF_MIPS_FP64)
3348             strcat (buf, ", fp64");
3349
3350           switch ((e_flags & EF_MIPS_MACH))
3351             {
3352             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3353             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3354             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3355             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3356             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3357             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3358             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3359             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3360             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3361             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3362             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3363             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3364             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3365             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3366             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3367             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3368             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3369             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3370             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3371             case 0:
3372             /* We simply ignore the field in this case to avoid confusion:
3373                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3374                extension.  */
3375               break;
3376             default: strcat (buf, _(", unknown CPU")); break;
3377             }
3378
3379           switch ((e_flags & EF_MIPS_ABI))
3380             {
3381             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3382             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3383             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3384             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3385             case 0:
3386             /* We simply ignore the field in this case to avoid confusion:
3387                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3388                This means it is likely to be an o32 file, but not for
3389                sure.  */
3390               break;
3391             default: strcat (buf, _(", unknown ABI")); break;
3392             }
3393
3394           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3395             strcat (buf, ", mdmx");
3396
3397           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3398             strcat (buf, ", mips16");
3399
3400           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3401             strcat (buf, ", micromips");
3402
3403           switch ((e_flags & EF_MIPS_ARCH))
3404             {
3405             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3406             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3407             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3408             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3409             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3410             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3411             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3412             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3413             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3414             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3415             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3416             default: strcat (buf, _(", unknown ISA")); break;
3417             }
3418           break;
3419
3420         case EM_NDS32:
3421           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3422           break;
3423
3424         case EM_RISCV:
3425           if (e_flags & EF_RISCV_RVC)
3426             strcat (buf, ", RVC");
3427
3428           switch (e_flags & EF_RISCV_FLOAT_ABI)
3429             {
3430             case EF_RISCV_FLOAT_ABI_SOFT:
3431               strcat (buf, ", soft-float ABI");
3432               break;
3433
3434             case EF_RISCV_FLOAT_ABI_SINGLE:
3435               strcat (buf, ", single-float ABI");
3436               break;
3437
3438             case EF_RISCV_FLOAT_ABI_DOUBLE:
3439               strcat (buf, ", double-float ABI");
3440               break;
3441
3442             case EF_RISCV_FLOAT_ABI_QUAD:
3443               strcat (buf, ", quad-float ABI");
3444               break;
3445             }
3446           break;
3447
3448         case EM_SH:
3449           switch ((e_flags & EF_SH_MACH_MASK))
3450             {
3451             case EF_SH1: strcat (buf, ", sh1"); break;
3452             case EF_SH2: strcat (buf, ", sh2"); break;
3453             case EF_SH3: strcat (buf, ", sh3"); break;
3454             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3455             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3456             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3457             case EF_SH3E: strcat (buf, ", sh3e"); break;
3458             case EF_SH4: strcat (buf, ", sh4"); break;
3459             case EF_SH5: strcat (buf, ", sh5"); break;
3460             case EF_SH2E: strcat (buf, ", sh2e"); break;
3461             case EF_SH4A: strcat (buf, ", sh4a"); break;
3462             case EF_SH2A: strcat (buf, ", sh2a"); break;
3463             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3464             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3465             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3466             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3467             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3468             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3469             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3470             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3471             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3472             default: strcat (buf, _(", unknown ISA")); break;
3473             }
3474
3475           if (e_flags & EF_SH_PIC)
3476             strcat (buf, ", pic");
3477
3478           if (e_flags & EF_SH_FDPIC)
3479             strcat (buf, ", fdpic");
3480           break;
3481
3482         case EM_OR1K:
3483           if (e_flags & EF_OR1K_NODELAY)
3484             strcat (buf, ", no delay");
3485           break;
3486
3487         case EM_SPARCV9:
3488           if (e_flags & EF_SPARC_32PLUS)
3489             strcat (buf, ", v8+");
3490
3491           if (e_flags & EF_SPARC_SUN_US1)
3492             strcat (buf, ", ultrasparcI");
3493
3494           if (e_flags & EF_SPARC_SUN_US3)
3495             strcat (buf, ", ultrasparcIII");
3496
3497           if (e_flags & EF_SPARC_HAL_R1)
3498             strcat (buf, ", halr1");
3499
3500           if (e_flags & EF_SPARC_LEDATA)
3501             strcat (buf, ", ledata");
3502
3503           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3504             strcat (buf, ", tso");
3505
3506           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3507             strcat (buf, ", pso");
3508
3509           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3510             strcat (buf, ", rmo");
3511           break;
3512
3513         case EM_PARISC:
3514           switch (e_flags & EF_PARISC_ARCH)
3515             {
3516             case EFA_PARISC_1_0:
3517               strcpy (buf, ", PA-RISC 1.0");
3518               break;
3519             case EFA_PARISC_1_1:
3520               strcpy (buf, ", PA-RISC 1.1");
3521               break;
3522             case EFA_PARISC_2_0:
3523               strcpy (buf, ", PA-RISC 2.0");
3524               break;
3525             default:
3526               break;
3527             }
3528           if (e_flags & EF_PARISC_TRAPNIL)
3529             strcat (buf, ", trapnil");
3530           if (e_flags & EF_PARISC_EXT)
3531             strcat (buf, ", ext");
3532           if (e_flags & EF_PARISC_LSB)
3533             strcat (buf, ", lsb");
3534           if (e_flags & EF_PARISC_WIDE)
3535             strcat (buf, ", wide");
3536           if (e_flags & EF_PARISC_NO_KABP)
3537             strcat (buf, ", no kabp");
3538           if (e_flags & EF_PARISC_LAZYSWAP)
3539             strcat (buf, ", lazyswap");
3540           break;
3541
3542         case EM_PJ:
3543         case EM_PJ_OLD:
3544           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3545             strcat (buf, ", new calling convention");
3546
3547           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3548             strcat (buf, ", gnu calling convention");
3549           break;
3550
3551         case EM_IA_64:
3552           if ((e_flags & EF_IA_64_ABI64))
3553             strcat (buf, ", 64-bit");
3554           else
3555             strcat (buf, ", 32-bit");
3556           if ((e_flags & EF_IA_64_REDUCEDFP))
3557             strcat (buf, ", reduced fp model");
3558           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3559             strcat (buf, ", no function descriptors, constant gp");
3560           else if ((e_flags & EF_IA_64_CONS_GP))
3561             strcat (buf, ", constant gp");
3562           if ((e_flags & EF_IA_64_ABSOLUTE))
3563             strcat (buf, ", absolute");
3564           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3565             {
3566               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3567                 strcat (buf, ", vms_linkages");
3568               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3569                 {
3570                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3571                   break;
3572                 case EF_IA_64_VMS_COMCOD_WARNING:
3573                   strcat (buf, ", warning");
3574                   break;
3575                 case EF_IA_64_VMS_COMCOD_ERROR:
3576                   strcat (buf, ", error");
3577                   break;
3578                 case EF_IA_64_VMS_COMCOD_ABORT:
3579                   strcat (buf, ", abort");
3580                   break;
3581                 default:
3582                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3583                         e_flags & EF_IA_64_VMS_COMCOD);
3584                   strcat (buf, ", <unknown>");
3585                 }
3586             }
3587           break;
3588
3589         case EM_VAX:
3590           if ((e_flags & EF_VAX_NONPIC))
3591             strcat (buf, ", non-PIC");
3592           if ((e_flags & EF_VAX_DFLOAT))
3593             strcat (buf, ", D-Float");
3594           if ((e_flags & EF_VAX_GFLOAT))
3595             strcat (buf, ", G-Float");
3596           break;
3597
3598         case EM_VISIUM:
3599           if (e_flags & EF_VISIUM_ARCH_MCM)
3600             strcat (buf, ", mcm");
3601           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3602             strcat (buf, ", mcm24");
3603           if (e_flags & EF_VISIUM_ARCH_GR6)
3604             strcat (buf, ", gr6");
3605           break;
3606
3607         case EM_RL78:
3608           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3609             {
3610             case E_FLAG_RL78_ANY_CPU: break;
3611             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3612             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3613             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3614             }
3615           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3616             strcat (buf, ", 64-bit doubles");
3617           break;
3618
3619         case EM_RX:
3620           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3621             strcat (buf, ", 64-bit doubles");
3622           if (e_flags & E_FLAG_RX_DSP)
3623             strcat (buf, ", dsp");
3624           if (e_flags & E_FLAG_RX_PID)
3625             strcat (buf, ", pid");
3626           if (e_flags & E_FLAG_RX_ABI)
3627             strcat (buf, ", RX ABI");
3628           if (e_flags & E_FLAG_RX_SINSNS_SET)
3629             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3630                     ? ", uses String instructions" : ", bans String instructions");
3631           if (e_flags & E_FLAG_RX_V2)
3632             strcat (buf, ", V2");
3633           break;
3634
3635         case EM_S390:
3636           if (e_flags & EF_S390_HIGH_GPRS)
3637             strcat (buf, ", highgprs");
3638           break;
3639
3640         case EM_TI_C6000:
3641           if ((e_flags & EF_C6000_REL))
3642             strcat (buf, ", relocatable module");
3643           break;
3644
3645         case EM_MSP430:
3646           strcat (buf, _(": architecture variant: "));
3647           switch (e_flags & EF_MSP430_MACH)
3648             {
3649             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3650             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3651             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3652             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3653             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3654             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3655             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3656             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3657             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3658             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3659             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3660             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3661             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3662             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3663             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3664             default:
3665               strcat (buf, _(": unknown")); break;
3666             }
3667
3668           if (e_flags & ~ EF_MSP430_MACH)
3669             strcat (buf, _(": unknown extra flag bits also present"));
3670         }
3671     }
3672
3673   return buf;
3674 }
3675
3676 static const char *
3677 get_osabi_name (Filedata * filedata, unsigned int osabi)
3678 {
3679   static char buff[32];
3680
3681   switch (osabi)
3682     {
3683     case ELFOSABI_NONE:         return "UNIX - System V";
3684     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3685     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3686     case ELFOSABI_GNU:          return "UNIX - GNU";
3687     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3688     case ELFOSABI_AIX:          return "UNIX - AIX";
3689     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3690     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3691     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3692     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3693     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3694     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3695     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3696     case ELFOSABI_AROS:         return "AROS";
3697     case ELFOSABI_FENIXOS:      return "FenixOS";
3698     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3699     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3700     default:
3701       if (osabi >= 64)
3702         switch (filedata->file_header.e_machine)
3703           {
3704           case EM_ARM:
3705             switch (osabi)
3706               {
3707               case ELFOSABI_ARM:        return "ARM";
3708               default:
3709                 break;
3710               }
3711             break;
3712
3713           case EM_MSP430:
3714           case EM_MSP430_OLD:
3715           case EM_VISIUM:
3716             switch (osabi)
3717               {
3718               case ELFOSABI_STANDALONE: return _("Standalone App");
3719               default:
3720                 break;
3721               }
3722             break;
3723
3724           case EM_TI_C6000:
3725             switch (osabi)
3726               {
3727               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3728               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3729               default:
3730                 break;
3731               }
3732             break;
3733
3734           default:
3735             break;
3736           }
3737       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3738       return buff;
3739     }
3740 }
3741
3742 static const char *
3743 get_aarch64_segment_type (unsigned long type)
3744 {
3745   switch (type)
3746     {
3747     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3748     default:                  return NULL;
3749     }
3750 }
3751
3752 static const char *
3753 get_arm_segment_type (unsigned long type)
3754 {
3755   switch (type)
3756     {
3757     case PT_ARM_EXIDX: return "EXIDX";
3758     default:           return NULL;
3759     }
3760 }
3761
3762 static const char *
3763 get_s390_segment_type (unsigned long type)
3764 {
3765   switch (type)
3766     {
3767     case PT_S390_PGSTE: return "S390_PGSTE";
3768     default:            return NULL;
3769     }
3770 }
3771
3772 static const char *
3773 get_mips_segment_type (unsigned long type)
3774 {
3775   switch (type)
3776     {
3777     case PT_MIPS_REGINFO:   return "REGINFO";
3778     case PT_MIPS_RTPROC:    return "RTPROC";
3779     case PT_MIPS_OPTIONS:   return "OPTIONS";
3780     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3781     default:                return NULL;
3782     }
3783 }
3784
3785 static const char *
3786 get_parisc_segment_type (unsigned long type)
3787 {
3788   switch (type)
3789     {
3790     case PT_HP_TLS:             return "HP_TLS";
3791     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3792     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3793     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3794     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3795     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3796     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3797     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3798     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3799     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3800     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3801     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3802     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3803     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3804     case PT_HP_STACK:           return "HP_STACK";
3805     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3806     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3807     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3808     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3809     default:                    return NULL;
3810     }
3811 }
3812
3813 static const char *
3814 get_ia64_segment_type (unsigned long type)
3815 {
3816   switch (type)
3817     {
3818     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3819     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3820     case PT_HP_TLS:             return "HP_TLS";
3821     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3822     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3823     case PT_IA_64_HP_STACK:     return "HP_STACK";
3824     default:                    return NULL;
3825     }
3826 }
3827
3828 static const char *
3829 get_tic6x_segment_type (unsigned long type)
3830 {
3831   switch (type)
3832     {
3833     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3834     default:               return NULL;
3835     }
3836 }
3837
3838 static const char *
3839 get_solaris_segment_type (unsigned long type)
3840 {
3841   switch (type)
3842     {
3843     case 0x6464e550: return "PT_SUNW_UNWIND";
3844     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3845     case 0x6ffffff7: return "PT_LOSUNW";
3846     case 0x6ffffffa: return "PT_SUNWBSS";
3847     case 0x6ffffffb: return "PT_SUNWSTACK";
3848     case 0x6ffffffc: return "PT_SUNWDTRACE";
3849     case 0x6ffffffd: return "PT_SUNWCAP";
3850     case 0x6fffffff: return "PT_HISUNW";
3851     default:         return NULL;
3852     }
3853 }
3854
3855 static const char *
3856 get_segment_type (Filedata * filedata, unsigned long p_type)
3857 {
3858   static char buff[32];
3859
3860   switch (p_type)
3861     {
3862     case PT_NULL:       return "NULL";
3863     case PT_LOAD:       return "LOAD";
3864     case PT_DYNAMIC:    return "DYNAMIC";
3865     case PT_INTERP:     return "INTERP";
3866     case PT_NOTE:       return "NOTE";
3867     case PT_SHLIB:      return "SHLIB";
3868     case PT_PHDR:       return "PHDR";
3869     case PT_TLS:        return "TLS";
3870     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3871     case PT_GNU_STACK:  return "GNU_STACK";
3872     case PT_GNU_RELRO:  return "GNU_RELRO";
3873
3874     default:
3875       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3876         {
3877           sprintf (buff, "GNU_MBIND+%#lx",
3878                    p_type - PT_GNU_MBIND_LO);
3879         }
3880       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3881         {
3882           const char * result;
3883
3884           switch (filedata->file_header.e_machine)
3885             {
3886             case EM_AARCH64:
3887               result = get_aarch64_segment_type (p_type);
3888               break;
3889             case EM_ARM:
3890               result = get_arm_segment_type (p_type);
3891               break;
3892             case EM_MIPS:
3893             case EM_MIPS_RS3_LE:
3894               result = get_mips_segment_type (p_type);
3895               break;
3896             case EM_PARISC:
3897               result = get_parisc_segment_type (p_type);
3898               break;
3899             case EM_IA_64:
3900               result = get_ia64_segment_type (p_type);
3901               break;
3902             case EM_TI_C6000:
3903               result = get_tic6x_segment_type (p_type);
3904               break;
3905             case EM_S390:
3906             case EM_S390_OLD:
3907               result = get_s390_segment_type (p_type);
3908               break;
3909             default:
3910               result = NULL;
3911               break;
3912             }
3913
3914           if (result != NULL)
3915             return result;
3916
3917           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3918         }
3919       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3920         {
3921           const char * result;
3922
3923           switch (filedata->file_header.e_machine)
3924             {
3925             case EM_PARISC:
3926               result = get_parisc_segment_type (p_type);
3927               break;
3928             case EM_IA_64:
3929               result = get_ia64_segment_type (p_type);
3930               break;
3931             default:
3932               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3933                 result = get_solaris_segment_type (p_type);
3934               else
3935                 result = NULL;
3936               break;
3937             }
3938
3939           if (result != NULL)
3940             return result;
3941
3942           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3943         }
3944       else
3945         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3946
3947       return buff;
3948     }
3949 }
3950
3951 static const char *
3952 get_arc_section_type_name (unsigned int sh_type)
3953 {
3954   switch (sh_type)
3955     {
3956     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3957     default:
3958       break;
3959     }
3960   return NULL;
3961 }
3962
3963 static const char *
3964 get_mips_section_type_name (unsigned int sh_type)
3965 {
3966   switch (sh_type)
3967     {
3968     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3969     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3970     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3971     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3972     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3973     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3974     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3975     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3976     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3977     case SHT_MIPS_RELD:          return "MIPS_RELD";
3978     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3979     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3980     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3981     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3982     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3983     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3984     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3985     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3986     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3987     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3988     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3989     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3990     case SHT_MIPS_LINE:          return "MIPS_LINE";
3991     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3992     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3993     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3994     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3995     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3996     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3997     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3998     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3999     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4000     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4001     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4002     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4003     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4004     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4005     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4006     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4007     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4008     default:
4009       break;
4010     }
4011   return NULL;
4012 }
4013
4014 static const char *
4015 get_parisc_section_type_name (unsigned int sh_type)
4016 {
4017   switch (sh_type)
4018     {
4019     case SHT_PARISC_EXT:        return "PARISC_EXT";
4020     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4021     case SHT_PARISC_DOC:        return "PARISC_DOC";
4022     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4023     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4024     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4025     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4026     default:                    return NULL;
4027     }
4028 }
4029
4030 static const char *
4031 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4032 {
4033   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4034   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4035     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4036
4037   switch (sh_type)
4038     {
4039     case SHT_IA_64_EXT:                return "IA_64_EXT";
4040     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4041     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4042     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4043     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4044     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4045     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4046     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4047     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4048     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4049     default:
4050       break;
4051     }
4052   return NULL;
4053 }
4054
4055 static const char *
4056 get_x86_64_section_type_name (unsigned int sh_type)
4057 {
4058   switch (sh_type)
4059     {
4060     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4061     default:                    return NULL;
4062     }
4063 }
4064
4065 static const char *
4066 get_aarch64_section_type_name (unsigned int sh_type)
4067 {
4068   switch (sh_type)
4069     {
4070     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4071     default:                     return NULL;
4072     }
4073 }
4074
4075 static const char *
4076 get_arm_section_type_name (unsigned int sh_type)
4077 {
4078   switch (sh_type)
4079     {
4080     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4081     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4082     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4083     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4084     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4085     default:                      return NULL;
4086     }
4087 }
4088
4089 static const char *
4090 get_tic6x_section_type_name (unsigned int sh_type)
4091 {
4092   switch (sh_type)
4093     {
4094     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4095     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4096     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4097     case SHT_TI_ICODE:          return "TI_ICODE";
4098     case SHT_TI_XREF:           return "TI_XREF";
4099     case SHT_TI_HANDLER:        return "TI_HANDLER";
4100     case SHT_TI_INITINFO:       return "TI_INITINFO";
4101     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4102     default:                    return NULL;
4103     }
4104 }
4105
4106 static const char *
4107 get_msp430x_section_type_name (unsigned int sh_type)
4108 {
4109   switch (sh_type)
4110     {
4111     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4112     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4113     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4114     default:                      return NULL;
4115     }
4116 }
4117
4118 static const char *
4119 get_v850_section_type_name (unsigned int sh_type)
4120 {
4121   switch (sh_type)
4122     {
4123     case SHT_V850_SCOMMON:  return "V850 Small Common";
4124     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4125     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4126     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4127     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4128     default:                return NULL;
4129     }
4130 }
4131
4132 static const char *
4133 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4134 {
4135   static char buff[32];
4136   const char * result;
4137
4138   switch (sh_type)
4139     {
4140     case SHT_NULL:              return "NULL";
4141     case SHT_PROGBITS:          return "PROGBITS";
4142     case SHT_SYMTAB:            return "SYMTAB";
4143     case SHT_STRTAB:            return "STRTAB";
4144     case SHT_RELA:              return "RELA";
4145     case SHT_HASH:              return "HASH";
4146     case SHT_DYNAMIC:           return "DYNAMIC";
4147     case SHT_NOTE:              return "NOTE";
4148     case SHT_NOBITS:            return "NOBITS";
4149     case SHT_REL:               return "REL";
4150     case SHT_SHLIB:             return "SHLIB";
4151     case SHT_DYNSYM:            return "DYNSYM";
4152     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4153     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4154     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4155     case SHT_GNU_HASH:          return "GNU_HASH";
4156     case SHT_GROUP:             return "GROUP";
4157     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4158     case SHT_GNU_verdef:        return "VERDEF";
4159     case SHT_GNU_verneed:       return "VERNEED";
4160     case SHT_GNU_versym:        return "VERSYM";
4161     case 0x6ffffff0:            return "VERSYM";
4162     case 0x6ffffffc:            return "VERDEF";
4163     case 0x7ffffffd:            return "AUXILIARY";
4164     case 0x7fffffff:            return "FILTER";
4165     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4166
4167     default:
4168       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4169         {
4170           switch (filedata->file_header.e_machine)
4171             {
4172             case EM_ARC:
4173             case EM_ARC_COMPACT:
4174             case EM_ARC_COMPACT2:
4175               result = get_arc_section_type_name (sh_type);
4176               break;
4177             case EM_MIPS:
4178             case EM_MIPS_RS3_LE:
4179               result = get_mips_section_type_name (sh_type);
4180               break;
4181             case EM_PARISC:
4182               result = get_parisc_section_type_name (sh_type);
4183               break;
4184             case EM_IA_64:
4185               result = get_ia64_section_type_name (filedata, sh_type);
4186               break;
4187             case EM_X86_64:
4188             case EM_L1OM:
4189             case EM_K1OM:
4190               result = get_x86_64_section_type_name (sh_type);
4191               break;
4192             case EM_AARCH64:
4193               result = get_aarch64_section_type_name (sh_type);
4194               break;
4195             case EM_ARM:
4196               result = get_arm_section_type_name (sh_type);
4197               break;
4198             case EM_TI_C6000:
4199               result = get_tic6x_section_type_name (sh_type);
4200               break;
4201             case EM_MSP430:
4202               result = get_msp430x_section_type_name (sh_type);
4203               break;
4204             case EM_V800:
4205             case EM_V850:
4206             case EM_CYGNUS_V850:
4207               result = get_v850_section_type_name (sh_type);
4208               break;
4209             default:
4210               result = NULL;
4211               break;
4212             }
4213
4214           if (result != NULL)
4215             return result;
4216
4217           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4218         }
4219       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4220         {
4221           switch (filedata->file_header.e_machine)
4222             {
4223             case EM_IA_64:
4224               result = get_ia64_section_type_name (filedata, sh_type);
4225               break;
4226             default:
4227               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4228                 result = get_solaris_section_type (sh_type);
4229               else
4230                 {
4231                   switch (sh_type)
4232                     {
4233                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4234                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4235                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4236                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4237                     default:
4238                       result = NULL;
4239                       break;
4240                     }
4241                 }
4242               break;
4243             }
4244
4245           if (result != NULL)
4246             return result;
4247
4248           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4249         }
4250       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4251         {
4252           switch (filedata->file_header.e_machine)
4253             {
4254             case EM_V800:
4255             case EM_V850:
4256             case EM_CYGNUS_V850:
4257               result = get_v850_section_type_name (sh_type);
4258               break;
4259             default:
4260               result = NULL;
4261               break;
4262             }
4263
4264           if (result != NULL)
4265             return result;
4266
4267           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4268         }
4269       else
4270         /* This message is probably going to be displayed in a 15
4271            character wide field, so put the hex value first.  */
4272         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4273
4274       return buff;
4275     }
4276 }
4277
4278 #define OPTION_DEBUG_DUMP       512
4279 #define OPTION_DYN_SYMS         513
4280 #define OPTION_DWARF_DEPTH      514
4281 #define OPTION_DWARF_START      515
4282 #define OPTION_DWARF_CHECK      516
4283
4284 static struct option options[] =
4285 {
4286   {"all",              no_argument, 0, 'a'},
4287   {"file-header",      no_argument, 0, 'h'},
4288   {"program-headers",  no_argument, 0, 'l'},
4289   {"headers",          no_argument, 0, 'e'},
4290   {"histogram",        no_argument, 0, 'I'},
4291   {"segments",         no_argument, 0, 'l'},
4292   {"sections",         no_argument, 0, 'S'},
4293   {"section-headers",  no_argument, 0, 'S'},
4294   {"section-groups",   no_argument, 0, 'g'},
4295   {"section-details",  no_argument, 0, 't'},
4296   {"full-section-name",no_argument, 0, 'N'},
4297   {"symbols",          no_argument, 0, 's'},
4298   {"syms",             no_argument, 0, 's'},
4299   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4300   {"relocs",           no_argument, 0, 'r'},
4301   {"notes",            no_argument, 0, 'n'},
4302   {"dynamic",          no_argument, 0, 'd'},
4303   {"arch-specific",    no_argument, 0, 'A'},
4304   {"version-info",     no_argument, 0, 'V'},
4305   {"use-dynamic",      no_argument, 0, 'D'},
4306   {"unwind",           no_argument, 0, 'u'},
4307   {"archive-index",    no_argument, 0, 'c'},
4308   {"hex-dump",         required_argument, 0, 'x'},
4309   {"relocated-dump",   required_argument, 0, 'R'},
4310   {"string-dump",      required_argument, 0, 'p'},
4311   {"decompress",       no_argument, 0, 'z'},
4312 #ifdef SUPPORT_DISASSEMBLY
4313   {"instruction-dump", required_argument, 0, 'i'},
4314 #endif
4315   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4316
4317   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4318   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4319   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4320
4321   {"version",          no_argument, 0, 'v'},
4322   {"wide",             no_argument, 0, 'W'},
4323   {"help",             no_argument, 0, 'H'},
4324   {0,                  no_argument, 0, 0}
4325 };
4326
4327 static void
4328 usage (FILE * stream)
4329 {
4330   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4331   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4332   fprintf (stream, _(" Options are:\n\
4333   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4334   -h --file-header       Display the ELF file header\n\
4335   -l --program-headers   Display the program headers\n\
4336      --segments          An alias for --program-headers\n\
4337   -S --section-headers   Display the sections' header\n\
4338      --sections          An alias for --section-headers\n\
4339   -g --section-groups    Display the section groups\n\
4340   -t --section-details   Display the section details\n\
4341   -e --headers           Equivalent to: -h -l -S\n\
4342   -s --syms              Display the symbol table\n\
4343      --symbols           An alias for --syms\n\
4344   --dyn-syms             Display the dynamic symbol table\n\
4345   -n --notes             Display the core notes (if present)\n\
4346   -r --relocs            Display the relocations (if present)\n\
4347   -u --unwind            Display the unwind info (if present)\n\
4348   -d --dynamic           Display the dynamic section (if present)\n\
4349   -V --version-info      Display the version sections (if present)\n\
4350   -A --arch-specific     Display architecture specific information (if any)\n\
4351   -c --archive-index     Display the symbol/file index in an archive\n\
4352   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4353   -x --hex-dump=<number|name>\n\
4354                          Dump the contents of section <number|name> as bytes\n\
4355   -p --string-dump=<number|name>\n\
4356                          Dump the contents of section <number|name> as strings\n\
4357   -R --relocated-dump=<number|name>\n\
4358                          Dump the contents of section <number|name> as relocated bytes\n\
4359   -z --decompress        Decompress section before dumping it\n\
4360   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4361   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4362                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4363                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4364                =addr,=cu_index,=links,=follow-links]\n\
4365                          Display the contents of DWARF debug sections\n"));
4366   fprintf (stream, _("\
4367   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4368   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4369                          or deeper\n"));
4370 #ifdef SUPPORT_DISASSEMBLY
4371   fprintf (stream, _("\
4372   -i --instruction-dump=<number|name>\n\
4373                          Disassemble the contents of section <number|name>\n"));
4374 #endif
4375   fprintf (stream, _("\
4376   -I --histogram         Display histogram of bucket list lengths\n\
4377   -W --wide              Allow output width to exceed 80 characters\n\
4378   @<file>                Read options from <file>\n\
4379   -H --help              Display this information\n\
4380   -v --version           Display the version number of readelf\n"));
4381
4382   if (REPORT_BUGS_TO[0] && stream == stdout)
4383     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4384
4385   exit (stream == stdout ? 0 : 1);
4386 }
4387
4388 /* Record the fact that the user wants the contents of section number
4389    SECTION to be displayed using the method(s) encoded as flags bits
4390    in TYPE.  Note, TYPE can be zero if we are creating the array for
4391    the first time.  */
4392
4393 static void
4394 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4395 {
4396   if (section >= filedata->num_dump_sects)
4397     {
4398       dump_type * new_dump_sects;
4399
4400       new_dump_sects = (dump_type *) calloc (section + 1,
4401                                              sizeof (* new_dump_sects));
4402
4403       if (new_dump_sects == NULL)
4404         error (_("Out of memory allocating dump request table.\n"));
4405       else
4406         {
4407           if (filedata->dump_sects)
4408             {
4409               /* Copy current flag settings.  */
4410               memcpy (new_dump_sects, filedata->dump_sects,
4411                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4412
4413               free (filedata->dump_sects);
4414             }
4415
4416           filedata->dump_sects = new_dump_sects;
4417           filedata->num_dump_sects = section + 1;
4418         }
4419     }
4420
4421   if (filedata->dump_sects)
4422     filedata->dump_sects[section] |= type;
4423 }
4424
4425 /* Request a dump by section name.  */
4426
4427 static void
4428 request_dump_byname (const char * section, dump_type type)
4429 {
4430   struct dump_list_entry * new_request;
4431
4432   new_request = (struct dump_list_entry *)
4433       malloc (sizeof (struct dump_list_entry));
4434   if (!new_request)
4435     error (_("Out of memory allocating dump request table.\n"));
4436
4437   new_request->name = strdup (section);
4438   if (!new_request->name)
4439     error (_("Out of memory allocating dump request table.\n"));
4440
4441   new_request->type = type;
4442
4443   new_request->next = dump_sects_byname;
4444   dump_sects_byname = new_request;
4445 }
4446
4447 static inline void
4448 request_dump (Filedata * filedata, dump_type type)
4449 {
4450   int section;
4451   char * cp;
4452
4453   do_dump++;
4454   section = strtoul (optarg, & cp, 0);
4455
4456   if (! *cp && section >= 0)
4457     request_dump_bynumber (filedata, section, type);
4458   else
4459     request_dump_byname (optarg, type);
4460 }
4461
4462 static void
4463 parse_args (Filedata * filedata, int argc, char ** argv)
4464 {
4465   int c;
4466
4467   if (argc < 2)
4468     usage (stderr);
4469
4470   while ((c = getopt_long
4471           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4472     {
4473       switch (c)
4474         {
4475         case 0:
4476           /* Long options.  */
4477           break;
4478         case 'H':
4479           usage (stdout);
4480           break;
4481
4482         case 'a':
4483           do_syms = TRUE;
4484           do_reloc = TRUE;
4485           do_unwind = TRUE;
4486           do_dynamic = TRUE;
4487           do_header = TRUE;
4488           do_sections = TRUE;
4489           do_section_groups = TRUE;
4490           do_segments = TRUE;
4491           do_version = TRUE;
4492           do_histogram = TRUE;
4493           do_arch = TRUE;
4494           do_notes = TRUE;
4495           break;
4496         case 'g':
4497           do_section_groups = TRUE;
4498           break;
4499         case 't':
4500         case 'N':
4501           do_sections = TRUE;
4502           do_section_details = TRUE;
4503           break;
4504         case 'e':
4505           do_header = TRUE;
4506           do_sections = TRUE;
4507           do_segments = TRUE;
4508           break;
4509         case 'A':
4510           do_arch = TRUE;
4511           break;
4512         case 'D':
4513           do_using_dynamic = TRUE;
4514           break;
4515         case 'r':
4516           do_reloc = TRUE;
4517           break;
4518         case 'u':
4519           do_unwind = TRUE;
4520           break;
4521         case 'h':
4522           do_header = TRUE;
4523           break;
4524         case 'l':
4525           do_segments = TRUE;
4526           break;
4527         case 's':
4528           do_syms = TRUE;
4529           break;
4530         case 'S':
4531           do_sections = TRUE;
4532           break;
4533         case 'd':
4534           do_dynamic = TRUE;
4535           break;
4536         case 'I':
4537           do_histogram = TRUE;
4538           break;
4539         case 'n':
4540           do_notes = TRUE;
4541           break;
4542         case 'c':
4543           do_archive_index = TRUE;
4544           break;
4545         case 'x':
4546           request_dump (filedata, HEX_DUMP);
4547           break;
4548         case 'p':
4549           request_dump (filedata, STRING_DUMP);
4550           break;
4551         case 'R':
4552           request_dump (filedata, RELOC_DUMP);
4553           break;
4554         case 'z':
4555           decompress_dumps = TRUE;
4556           break;
4557         case 'w':
4558           do_dump = TRUE;
4559           if (optarg == 0)
4560             {
4561               do_debugging = TRUE;
4562               dwarf_select_sections_all ();
4563             }
4564           else
4565             {
4566               do_debugging = FALSE;
4567               dwarf_select_sections_by_letters (optarg);
4568             }
4569           break;
4570         case OPTION_DEBUG_DUMP:
4571           do_dump = TRUE;
4572           if (optarg == 0)
4573             do_debugging = TRUE;
4574           else
4575             {
4576               do_debugging = FALSE;
4577               dwarf_select_sections_by_names (optarg);
4578             }
4579           break;
4580         case OPTION_DWARF_DEPTH:
4581           {
4582             char *cp;
4583
4584             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4585           }
4586           break;
4587         case OPTION_DWARF_START:
4588           {
4589             char *cp;
4590
4591             dwarf_start_die = strtoul (optarg, & cp, 0);
4592           }
4593           break;
4594         case OPTION_DWARF_CHECK:
4595           dwarf_check = TRUE;
4596           break;
4597         case OPTION_DYN_SYMS:
4598           do_dyn_syms = TRUE;
4599           break;
4600 #ifdef SUPPORT_DISASSEMBLY
4601         case 'i':
4602           request_dump (filedata, DISASS_DUMP);
4603           break;
4604 #endif
4605         case 'v':
4606           print_version (program_name);
4607           break;
4608         case 'V':
4609           do_version = TRUE;
4610           break;
4611         case 'W':
4612           do_wide = TRUE;
4613           break;
4614         default:
4615           /* xgettext:c-format */
4616           error (_("Invalid option '-%c'\n"), c);
4617           /* Fall through.  */
4618         case '?':
4619           usage (stderr);
4620         }
4621     }
4622
4623   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4624       && !do_segments && !do_header && !do_dump && !do_version
4625       && !do_histogram && !do_debugging && !do_arch && !do_notes
4626       && !do_section_groups && !do_archive_index
4627       && !do_dyn_syms)
4628     usage (stderr);
4629 }
4630
4631 static const char *
4632 get_elf_class (unsigned int elf_class)
4633 {
4634   static char buff[32];
4635
4636   switch (elf_class)
4637     {
4638     case ELFCLASSNONE: return _("none");
4639     case ELFCLASS32:   return "ELF32";
4640     case ELFCLASS64:   return "ELF64";
4641     default:
4642       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4643       return buff;
4644     }
4645 }
4646
4647 static const char *
4648 get_data_encoding (unsigned int encoding)
4649 {
4650   static char buff[32];
4651
4652   switch (encoding)
4653     {
4654     case ELFDATANONE: return _("none");
4655     case ELFDATA2LSB: return _("2's complement, little endian");
4656     case ELFDATA2MSB: return _("2's complement, big endian");
4657     default:
4658       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4659       return buff;
4660     }
4661 }
4662
4663 /* Decode the data held in 'filedata->file_header'.  */
4664
4665 static bfd_boolean
4666 process_file_header (Filedata * filedata)
4667 {
4668   Elf_Internal_Ehdr * header = & filedata->file_header;
4669
4670   if (   header->e_ident[EI_MAG0] != ELFMAG0
4671       || header->e_ident[EI_MAG1] != ELFMAG1
4672       || header->e_ident[EI_MAG2] != ELFMAG2
4673       || header->e_ident[EI_MAG3] != ELFMAG3)
4674     {
4675       error
4676         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4677       return FALSE;
4678     }
4679
4680   init_dwarf_regnames (header->e_machine);
4681
4682   if (do_header)
4683     {
4684       unsigned i;
4685
4686       printf (_("ELF Header:\n"));
4687       printf (_("  Magic:   "));
4688       for (i = 0; i < EI_NIDENT; i++)
4689         printf ("%2.2x ", header->e_ident[i]);
4690       printf ("\n");
4691       printf (_("  Class:                             %s\n"),
4692               get_elf_class (header->e_ident[EI_CLASS]));
4693       printf (_("  Data:                              %s\n"),
4694               get_data_encoding (header->e_ident[EI_DATA]));
4695       printf (_("  Version:                           %d %s\n"),
4696               header->e_ident[EI_VERSION],
4697               (header->e_ident[EI_VERSION] == EV_CURRENT
4698                ? "(current)"
4699                : (header->e_ident[EI_VERSION] != EV_NONE
4700                   ? _("<unknown: %lx>")
4701                   : "")));
4702       printf (_("  OS/ABI:                            %s\n"),
4703               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4704       printf (_("  ABI Version:                       %d\n"),
4705               header->e_ident[EI_ABIVERSION]);
4706       printf (_("  Type:                              %s\n"),
4707               get_file_type (header->e_type));
4708       printf (_("  Machine:                           %s\n"),
4709               get_machine_name (header->e_machine));
4710       printf (_("  Version:                           0x%lx\n"),
4711               (unsigned long) header->e_version);
4712
4713       printf (_("  Entry point address:               "));
4714       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4715       printf (_("\n  Start of program headers:          "));
4716       print_vma ((bfd_vma) header->e_phoff, DEC);
4717       printf (_(" (bytes into file)\n  Start of section headers:          "));
4718       print_vma ((bfd_vma) header->e_shoff, DEC);
4719       printf (_(" (bytes into file)\n"));
4720
4721       printf (_("  Flags:                             0x%lx%s\n"),
4722               (unsigned long) header->e_flags,
4723               get_machine_flags (filedata, header->e_flags, header->e_machine));
4724       printf (_("  Size of this header:               %ld (bytes)\n"),
4725               (long) header->e_ehsize);
4726       printf (_("  Size of program headers:           %ld (bytes)\n"),
4727               (long) header->e_phentsize);
4728       printf (_("  Number of program headers:         %ld"),
4729               (long) header->e_phnum);
4730       if (filedata->section_headers != NULL
4731           && header->e_phnum == PN_XNUM
4732           && filedata->section_headers[0].sh_info != 0)
4733         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4734       putc ('\n', stdout);
4735       printf (_("  Size of section headers:           %ld (bytes)\n"),
4736               (long) header->e_shentsize);
4737       printf (_("  Number of section headers:         %ld"),
4738               (long) header->e_shnum);
4739       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4740         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4741       putc ('\n', stdout);
4742       printf (_("  Section header string table index: %ld"),
4743               (long) header->e_shstrndx);
4744       if (filedata->section_headers != NULL
4745           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4746         printf (" (%u)", filedata->section_headers[0].sh_link);
4747       else if (header->e_shstrndx != SHN_UNDEF
4748                && header->e_shstrndx >= header->e_shnum)
4749         printf (_(" <corrupt: out of range>"));
4750       putc ('\n', stdout);
4751     }
4752
4753   if (filedata->section_headers != NULL)
4754     {
4755       if (header->e_phnum == PN_XNUM
4756           && filedata->section_headers[0].sh_info != 0)
4757         header->e_phnum = filedata->section_headers[0].sh_info;
4758       if (header->e_shnum == SHN_UNDEF)
4759         header->e_shnum = filedata->section_headers[0].sh_size;
4760       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4761         header->e_shstrndx = filedata->section_headers[0].sh_link;
4762       if (header->e_shstrndx >= header->e_shnum)
4763         header->e_shstrndx = SHN_UNDEF;
4764       free (filedata->section_headers);
4765       filedata->section_headers = NULL;
4766     }
4767
4768   return TRUE;
4769 }
4770
4771 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4772    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4773
4774 static bfd_boolean
4775 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4776 {
4777   Elf32_External_Phdr * phdrs;
4778   Elf32_External_Phdr * external;
4779   Elf_Internal_Phdr *   internal;
4780   unsigned int i;
4781   unsigned int size = filedata->file_header.e_phentsize;
4782   unsigned int num  = filedata->file_header.e_phnum;
4783
4784   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4785   if (size == 0 || num == 0)
4786     return FALSE;
4787   if (size < sizeof * phdrs)
4788     {
4789       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4790       return FALSE;
4791     }
4792   if (size > sizeof * phdrs)
4793     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4794
4795   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4796                                             size, num, _("program headers"));
4797   if (phdrs == NULL)
4798     return FALSE;
4799
4800   for (i = 0, internal = pheaders, external = phdrs;
4801        i < filedata->file_header.e_phnum;
4802        i++, internal++, external++)
4803     {
4804       internal->p_type   = BYTE_GET (external->p_type);
4805       internal->p_offset = BYTE_GET (external->p_offset);
4806       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4807       internal->p_paddr  = BYTE_GET (external->p_paddr);
4808       internal->p_filesz = BYTE_GET (external->p_filesz);
4809       internal->p_memsz  = BYTE_GET (external->p_memsz);
4810       internal->p_flags  = BYTE_GET (external->p_flags);
4811       internal->p_align  = BYTE_GET (external->p_align);
4812     }
4813
4814   free (phdrs);
4815   return TRUE;
4816 }
4817
4818 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4819    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4820
4821 static bfd_boolean
4822 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4823 {
4824   Elf64_External_Phdr * phdrs;
4825   Elf64_External_Phdr * external;
4826   Elf_Internal_Phdr *   internal;
4827   unsigned int i;
4828   unsigned int size = filedata->file_header.e_phentsize;
4829   unsigned int num  = filedata->file_header.e_phnum;
4830
4831   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4832   if (size == 0 || num == 0)
4833     return FALSE;
4834   if (size < sizeof * phdrs)
4835     {
4836       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4837       return FALSE;
4838     }
4839   if (size > sizeof * phdrs)
4840     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4841
4842   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4843                                             size, num, _("program headers"));
4844   if (!phdrs)
4845     return FALSE;
4846
4847   for (i = 0, internal = pheaders, external = phdrs;
4848        i < filedata->file_header.e_phnum;
4849        i++, internal++, external++)
4850     {
4851       internal->p_type   = BYTE_GET (external->p_type);
4852       internal->p_flags  = BYTE_GET (external->p_flags);
4853       internal->p_offset = BYTE_GET (external->p_offset);
4854       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4855       internal->p_paddr  = BYTE_GET (external->p_paddr);
4856       internal->p_filesz = BYTE_GET (external->p_filesz);
4857       internal->p_memsz  = BYTE_GET (external->p_memsz);
4858       internal->p_align  = BYTE_GET (external->p_align);
4859     }
4860
4861   free (phdrs);
4862   return TRUE;
4863 }
4864
4865 /* Returns TRUE if the program headers were read into `program_headers'.  */
4866
4867 static bfd_boolean
4868 get_program_headers (Filedata * filedata)
4869 {
4870   Elf_Internal_Phdr * phdrs;
4871
4872   /* Check cache of prior read.  */
4873   if (filedata->program_headers != NULL)
4874     return TRUE;
4875
4876   /* Be kind to memory checkers by looking for
4877      e_phnum values which we know must be invalid.  */
4878   if (filedata->file_header.e_phnum
4879       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4880       >= filedata->file_size)
4881     {
4882       error (_("Too many program headers - %#x - the file is not that big\n"),
4883              filedata->file_header.e_phnum);
4884       return FALSE;
4885     }
4886
4887   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4888                                          sizeof (Elf_Internal_Phdr));
4889   if (phdrs == NULL)
4890     {
4891       error (_("Out of memory reading %u program headers\n"),
4892              filedata->file_header.e_phnum);
4893       return FALSE;
4894     }
4895
4896   if (is_32bit_elf
4897       ? get_32bit_program_headers (filedata, phdrs)
4898       : get_64bit_program_headers (filedata, phdrs))
4899     {
4900       filedata->program_headers = phdrs;
4901       return TRUE;
4902     }
4903
4904   free (phdrs);
4905   return FALSE;
4906 }
4907
4908 /* Returns TRUE if the program headers were loaded.  */
4909
4910 static bfd_boolean
4911 process_program_headers (Filedata * filedata)
4912 {
4913   Elf_Internal_Phdr * segment;
4914   unsigned int i;
4915   Elf_Internal_Phdr * previous_load = NULL;
4916
4917   if (filedata->file_header.e_phnum == 0)
4918     {
4919       /* PR binutils/12467.  */
4920       if (filedata->file_header.e_phoff != 0)
4921         {
4922           warn (_("possibly corrupt ELF header - it has a non-zero program"
4923                   " header offset, but no program headers\n"));
4924           return FALSE;
4925         }
4926       else if (do_segments)
4927         printf (_("\nThere are no program headers in this file.\n"));
4928       return TRUE;
4929     }
4930
4931   if (do_segments && !do_header)
4932     {
4933       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
4934       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
4935       printf (ngettext ("There is %d program header, starting at offset %s\n",
4936                         "There are %d program headers, starting at offset %s\n",
4937                         filedata->file_header.e_phnum),
4938               filedata->file_header.e_phnum,
4939               bfd_vmatoa ("u", filedata->file_header.e_phoff));
4940     }
4941
4942   if (! get_program_headers (filedata))
4943     return TRUE;
4944
4945   if (do_segments)
4946     {
4947       if (filedata->file_header.e_phnum > 1)
4948         printf (_("\nProgram Headers:\n"));
4949       else
4950         printf (_("\nProgram Headers:\n"));
4951
4952       if (is_32bit_elf)
4953         printf
4954           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4955       else if (do_wide)
4956         printf
4957           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4958       else
4959         {
4960           printf
4961             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4962           printf
4963             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4964         }
4965     }
4966
4967   dynamic_addr = 0;
4968   dynamic_size = 0;
4969
4970   for (i = 0, segment = filedata->program_headers;
4971        i < filedata->file_header.e_phnum;
4972        i++, segment++)
4973     {
4974       if (do_segments)
4975         {
4976           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
4977
4978           if (is_32bit_elf)
4979             {
4980               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4981               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4982               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4983               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4984               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4985               printf ("%c%c%c ",
4986                       (segment->p_flags & PF_R ? 'R' : ' '),
4987                       (segment->p_flags & PF_W ? 'W' : ' '),
4988                       (segment->p_flags & PF_X ? 'E' : ' '));
4989               printf ("%#lx", (unsigned long) segment->p_align);
4990             }
4991           else if (do_wide)
4992             {
4993               if ((unsigned long) segment->p_offset == segment->p_offset)
4994                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4995               else
4996                 {
4997                   print_vma (segment->p_offset, FULL_HEX);
4998                   putchar (' ');
4999                 }
5000
5001               print_vma (segment->p_vaddr, FULL_HEX);
5002               putchar (' ');
5003               print_vma (segment->p_paddr, FULL_HEX);
5004               putchar (' ');
5005
5006               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5007                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5008               else
5009                 {
5010                   print_vma (segment->p_filesz, FULL_HEX);
5011                   putchar (' ');
5012                 }
5013
5014               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5015                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5016               else
5017                 {
5018                   print_vma (segment->p_memsz, FULL_HEX);
5019                 }
5020
5021               printf (" %c%c%c ",
5022                       (segment->p_flags & PF_R ? 'R' : ' '),
5023                       (segment->p_flags & PF_W ? 'W' : ' '),
5024                       (segment->p_flags & PF_X ? 'E' : ' '));
5025
5026               if ((unsigned long) segment->p_align == segment->p_align)
5027                 printf ("%#lx", (unsigned long) segment->p_align);
5028               else
5029                 {
5030                   print_vma (segment->p_align, PREFIX_HEX);
5031                 }
5032             }
5033           else
5034             {
5035               print_vma (segment->p_offset, FULL_HEX);
5036               putchar (' ');
5037               print_vma (segment->p_vaddr, FULL_HEX);
5038               putchar (' ');
5039               print_vma (segment->p_paddr, FULL_HEX);
5040               printf ("\n                 ");
5041               print_vma (segment->p_filesz, FULL_HEX);
5042               putchar (' ');
5043               print_vma (segment->p_memsz, FULL_HEX);
5044               printf ("  %c%c%c    ",
5045                       (segment->p_flags & PF_R ? 'R' : ' '),
5046                       (segment->p_flags & PF_W ? 'W' : ' '),
5047                       (segment->p_flags & PF_X ? 'E' : ' '));
5048               print_vma (segment->p_align, PREFIX_HEX);
5049             }
5050
5051           putc ('\n', stdout);
5052         }
5053
5054       switch (segment->p_type)
5055         {
5056         case PT_LOAD:
5057 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5058          required by the ELF standard, several programs, including the Linux
5059          kernel, make use of non-ordered segments.  */
5060           if (previous_load
5061               && previous_load->p_vaddr > segment->p_vaddr)
5062             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5063 #endif
5064           if (segment->p_memsz < segment->p_filesz)
5065             error (_("the segment's file size is larger than its memory size\n"));
5066           previous_load = segment;
5067           break;
5068
5069         case PT_PHDR:
5070           /* PR 20815 - Verify that the program header is loaded into memory.  */
5071           if (i > 0 && previous_load != NULL)
5072             error (_("the PHDR segment must occur before any LOAD segment\n"));
5073           if (filedata->file_header.e_machine != EM_PARISC)
5074             {
5075               unsigned int j;
5076
5077               for (j = 1; j < filedata->file_header.e_phnum; j++)
5078                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5079                     && (filedata->program_headers[j].p_vaddr
5080                         + filedata->program_headers[j].p_memsz)
5081                     >= (segment->p_vaddr + segment->p_filesz))
5082                   break;
5083               if (j == filedata->file_header.e_phnum)
5084                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5085             }
5086           break;
5087
5088         case PT_DYNAMIC:
5089           if (dynamic_addr)
5090             error (_("more than one dynamic segment\n"));
5091
5092           /* By default, assume that the .dynamic section is the first
5093              section in the DYNAMIC segment.  */
5094           dynamic_addr = segment->p_offset;
5095           dynamic_size = segment->p_filesz;
5096
5097           /* Try to locate the .dynamic section. If there is
5098              a section header table, we can easily locate it.  */
5099           if (filedata->section_headers != NULL)
5100             {
5101               Elf_Internal_Shdr * sec;
5102
5103               sec = find_section (filedata, ".dynamic");
5104               if (sec == NULL || sec->sh_size == 0)
5105                 {
5106                   /* A corresponding .dynamic section is expected, but on
5107                      IA-64/OpenVMS it is OK for it to be missing.  */
5108                   if (!is_ia64_vms (filedata))
5109                     error (_("no .dynamic section in the dynamic segment\n"));
5110                   break;
5111                 }
5112
5113               if (sec->sh_type == SHT_NOBITS)
5114                 {
5115                   dynamic_size = 0;
5116                   break;
5117                 }
5118
5119               dynamic_addr = sec->sh_offset;
5120               dynamic_size = sec->sh_size;
5121
5122               if (dynamic_addr < segment->p_offset
5123                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5124                 warn (_("the .dynamic section is not contained"
5125                         " within the dynamic segment\n"));
5126               else if (dynamic_addr > segment->p_offset)
5127                 warn (_("the .dynamic section is not the first section"
5128                         " in the dynamic segment.\n"));
5129             }
5130
5131           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5132              segment.  Check this after matching against the section headers
5133              so we don't warn on debuginfo file (which have NOBITS .dynamic
5134              sections).  */
5135           if (dynamic_addr + dynamic_size >= filedata->file_size)
5136             {
5137               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5138               dynamic_addr = dynamic_size = 0;
5139             }
5140           break;
5141
5142         case PT_INTERP:
5143           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5144                      SEEK_SET))
5145             error (_("Unable to find program interpreter name\n"));
5146           else
5147             {
5148               char fmt [32];
5149               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5150
5151               if (ret >= (int) sizeof (fmt) || ret < 0)
5152                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5153
5154               program_interpreter[0] = 0;
5155               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5156                 error (_("Unable to read program interpreter name\n"));
5157
5158               if (do_segments)
5159                 printf (_("      [Requesting program interpreter: %s]\n"),
5160                     program_interpreter);
5161             }
5162           break;
5163         }
5164     }
5165
5166   if (do_segments
5167       && filedata->section_headers != NULL
5168       && filedata->string_table != NULL)
5169     {
5170       printf (_("\n Section to Segment mapping:\n"));
5171       printf (_("  Segment Sections...\n"));
5172
5173       for (i = 0; i < filedata->file_header.e_phnum; i++)
5174         {
5175           unsigned int j;
5176           Elf_Internal_Shdr * section;
5177
5178           segment = filedata->program_headers + i;
5179           section = filedata->section_headers + 1;
5180
5181           printf ("   %2.2d     ", i);
5182
5183           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5184             {
5185               if (!ELF_TBSS_SPECIAL (section, segment)
5186                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5187                 printf ("%s ", printable_section_name (filedata, section));
5188             }
5189
5190           putc ('\n',stdout);
5191         }
5192     }
5193
5194   return TRUE;
5195 }
5196
5197
5198 /* Find the file offset corresponding to VMA by using the program headers.  */
5199
5200 static long
5201 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5202 {
5203   Elf_Internal_Phdr * seg;
5204
5205   if (! get_program_headers (filedata))
5206     {
5207       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5208       return (long) vma;
5209     }
5210
5211   for (seg = filedata->program_headers;
5212        seg < filedata->program_headers + filedata->file_header.e_phnum;
5213        ++seg)
5214     {
5215       if (seg->p_type != PT_LOAD)
5216         continue;
5217
5218       if (vma >= (seg->p_vaddr & -seg->p_align)
5219           && vma + size <= seg->p_vaddr + seg->p_filesz)
5220         return vma - seg->p_vaddr + seg->p_offset;
5221     }
5222
5223   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5224         (unsigned long) vma);
5225   return (long) vma;
5226 }
5227
5228
5229 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5230    If PROBE is true, this is just a probe and we do not generate any error
5231    messages if the load fails.  */
5232
5233 static bfd_boolean
5234 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5235 {
5236   Elf32_External_Shdr * shdrs;
5237   Elf_Internal_Shdr *   internal;
5238   unsigned int          i;
5239   unsigned int          size = filedata->file_header.e_shentsize;
5240   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5241
5242   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5243   if (size == 0 || num == 0)
5244     return FALSE;
5245   if (size < sizeof * shdrs)
5246     {
5247       if (! probe)
5248         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5249       return FALSE;
5250     }
5251   if (!probe && size > sizeof * shdrs)
5252     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5253
5254   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5255                                             size, num,
5256                                             probe ? NULL : _("section headers"));
5257   if (shdrs == NULL)
5258     return FALSE;
5259
5260   free (filedata->section_headers);
5261   filedata->section_headers = (Elf_Internal_Shdr *)
5262     cmalloc (num, sizeof (Elf_Internal_Shdr));
5263   if (filedata->section_headers == NULL)
5264     {
5265       if (!probe)
5266         error (_("Out of memory reading %u section headers\n"), num);
5267       return FALSE;
5268     }
5269
5270   for (i = 0, internal = filedata->section_headers;
5271        i < num;
5272        i++, internal++)
5273     {
5274       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5275       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5276       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5277       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5278       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5279       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5280       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5281       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5282       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5283       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5284       if (!probe && internal->sh_link > num)
5285         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5286       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5287         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5288     }
5289
5290   free (shdrs);
5291   return TRUE;
5292 }
5293
5294 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5295
5296 static bfd_boolean
5297 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5298 {
5299   Elf64_External_Shdr *  shdrs;
5300   Elf_Internal_Shdr *    internal;
5301   unsigned int           i;
5302   unsigned int           size = filedata->file_header.e_shentsize;
5303   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5304
5305   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5306   if (size == 0 || num == 0)
5307     return FALSE;
5308
5309   if (size < sizeof * shdrs)
5310     {
5311       if (! probe)
5312         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5313       return FALSE;
5314     }
5315
5316   if (! probe && size > sizeof * shdrs)
5317     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5318
5319   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5320                                             filedata->file_header.e_shoff,
5321                                             size, num,
5322                                             probe ? NULL : _("section headers"));
5323   if (shdrs == NULL)
5324     return FALSE;
5325
5326   free (filedata->section_headers);
5327   filedata->section_headers = (Elf_Internal_Shdr *)
5328     cmalloc (num, sizeof (Elf_Internal_Shdr));
5329   if (filedata->section_headers == NULL)
5330     {
5331       if (! probe)
5332         error (_("Out of memory reading %u section headers\n"), num);
5333       return FALSE;
5334     }
5335
5336   for (i = 0, internal = filedata->section_headers;
5337        i < num;
5338        i++, internal++)
5339     {
5340       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5341       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5342       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5343       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5344       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5345       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5346       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5347       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5348       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5349       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5350       if (!probe && internal->sh_link > num)
5351         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5352       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5353         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5354     }
5355
5356   free (shdrs);
5357   return TRUE;
5358 }
5359
5360 static Elf_Internal_Sym *
5361 get_32bit_elf_symbols (Filedata *           filedata,
5362                        Elf_Internal_Shdr *  section,
5363                        unsigned long *      num_syms_return)
5364 {
5365   unsigned long number = 0;
5366   Elf32_External_Sym * esyms = NULL;
5367   Elf_External_Sym_Shndx * shndx = NULL;
5368   Elf_Internal_Sym * isyms = NULL;
5369   Elf_Internal_Sym * psym;
5370   unsigned int j;
5371
5372   if (section->sh_size == 0)
5373     {
5374       if (num_syms_return != NULL)
5375         * num_syms_return = 0;
5376       return NULL;
5377     }
5378
5379   /* Run some sanity checks first.  */
5380   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5381     {
5382       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5383              printable_section_name (filedata, section),
5384              (unsigned long) section->sh_entsize);
5385       goto exit_point;
5386     }
5387
5388   if (section->sh_size > filedata->file_size)
5389     {
5390       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5391              printable_section_name (filedata, section),
5392              (unsigned long) section->sh_size);
5393       goto exit_point;
5394     }
5395
5396   number = section->sh_size / section->sh_entsize;
5397
5398   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5399     {
5400       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5401              (unsigned long) section->sh_size,
5402              printable_section_name (filedata, section),
5403              (unsigned long) section->sh_entsize);
5404       goto exit_point;
5405     }
5406
5407   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5408                                            section->sh_size, _("symbols"));
5409   if (esyms == NULL)
5410     goto exit_point;
5411
5412   {
5413     elf_section_list * entry;
5414
5415     shndx = NULL;
5416     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5417       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5418         {
5419           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5420                                                        entry->hdr->sh_offset,
5421                                                        1, entry->hdr->sh_size,
5422                                                        _("symbol table section indicies"));
5423           if (shndx == NULL)
5424             goto exit_point;
5425           /* PR17531: file: heap-buffer-overflow */
5426           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5427             {
5428               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5429                      printable_section_name (filedata, entry->hdr),
5430                      (unsigned long) entry->hdr->sh_size,
5431                      (unsigned long) section->sh_size);
5432               goto exit_point;
5433             }
5434         }
5435   }
5436
5437   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5438
5439   if (isyms == NULL)
5440     {
5441       error (_("Out of memory reading %lu symbols\n"),
5442              (unsigned long) number);
5443       goto exit_point;
5444     }
5445
5446   for (j = 0, psym = isyms; j < number; j++, psym++)
5447     {
5448       psym->st_name  = BYTE_GET (esyms[j].st_name);
5449       psym->st_value = BYTE_GET (esyms[j].st_value);
5450       psym->st_size  = BYTE_GET (esyms[j].st_size);
5451       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5452       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5453         psym->st_shndx
5454           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5455       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5456         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5457       psym->st_info  = BYTE_GET (esyms[j].st_info);
5458       psym->st_other = BYTE_GET (esyms[j].st_other);
5459     }
5460
5461  exit_point:
5462   if (shndx != NULL)
5463     free (shndx);
5464   if (esyms != NULL)
5465     free (esyms);
5466
5467   if (num_syms_return != NULL)
5468     * num_syms_return = isyms == NULL ? 0 : number;
5469
5470   return isyms;
5471 }
5472
5473 static Elf_Internal_Sym *
5474 get_64bit_elf_symbols (Filedata *           filedata,
5475                        Elf_Internal_Shdr *  section,
5476                        unsigned long *      num_syms_return)
5477 {
5478   unsigned long number = 0;
5479   Elf64_External_Sym * esyms = NULL;
5480   Elf_External_Sym_Shndx * shndx = NULL;
5481   Elf_Internal_Sym * isyms = NULL;
5482   Elf_Internal_Sym * psym;
5483   unsigned int j;
5484
5485   if (section->sh_size == 0)
5486     {
5487       if (num_syms_return != NULL)
5488         * num_syms_return = 0;
5489       return NULL;
5490     }
5491
5492   /* Run some sanity checks first.  */
5493   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5494     {
5495       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5496              printable_section_name (filedata, section),
5497              (unsigned long) section->sh_entsize);
5498       goto exit_point;
5499     }
5500
5501   if (section->sh_size > filedata->file_size)
5502     {
5503       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5504              printable_section_name (filedata, section),
5505              (unsigned long) section->sh_size);
5506       goto exit_point;
5507     }
5508
5509   number = section->sh_size / section->sh_entsize;
5510
5511   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5512     {
5513       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5514              (unsigned long) section->sh_size,
5515              printable_section_name (filedata, section),
5516              (unsigned long) section->sh_entsize);
5517       goto exit_point;
5518     }
5519
5520   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5521                                            section->sh_size, _("symbols"));
5522   if (!esyms)
5523     goto exit_point;
5524
5525   {
5526     elf_section_list * entry;
5527
5528     shndx = NULL;
5529     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5530       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5531         {
5532           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5533                                                        entry->hdr->sh_offset,
5534                                                        1, entry->hdr->sh_size,
5535                                                        _("symbol table section indicies"));
5536           if (shndx == NULL)
5537             goto exit_point;
5538           /* PR17531: file: heap-buffer-overflow */
5539           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5540             {
5541               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5542                      printable_section_name (filedata, entry->hdr),
5543                      (unsigned long) entry->hdr->sh_size,
5544                      (unsigned long) section->sh_size);
5545               goto exit_point;
5546             }
5547         }
5548   }
5549
5550   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5551
5552   if (isyms == NULL)
5553     {
5554       error (_("Out of memory reading %lu symbols\n"),
5555              (unsigned long) number);
5556       goto exit_point;
5557     }
5558
5559   for (j = 0, psym = isyms; j < number; j++, psym++)
5560     {
5561       psym->st_name  = BYTE_GET (esyms[j].st_name);
5562       psym->st_info  = BYTE_GET (esyms[j].st_info);
5563       psym->st_other = BYTE_GET (esyms[j].st_other);
5564       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5565
5566       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5567         psym->st_shndx
5568           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5569       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5570         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5571
5572       psym->st_value = BYTE_GET (esyms[j].st_value);
5573       psym->st_size  = BYTE_GET (esyms[j].st_size);
5574     }
5575
5576  exit_point:
5577   if (shndx != NULL)
5578     free (shndx);
5579   if (esyms != NULL)
5580     free (esyms);
5581
5582   if (num_syms_return != NULL)
5583     * num_syms_return = isyms == NULL ? 0 : number;
5584
5585   return isyms;
5586 }
5587
5588 static const char *
5589 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5590 {
5591   static char buff[1024];
5592   char * p = buff;
5593   unsigned int field_size = is_32bit_elf ? 8 : 16;
5594   signed int sindex;
5595   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5596   bfd_vma os_flags = 0;
5597   bfd_vma proc_flags = 0;
5598   bfd_vma unknown_flags = 0;
5599   static const struct
5600     {
5601       const char * str;
5602       unsigned int len;
5603     }
5604   flags [] =
5605     {
5606       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5607       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5608       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5609       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5610       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5611       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5612       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5613       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5614       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5615       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5616       /* IA-64 specific.  */
5617       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5618       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5619       /* IA-64 OpenVMS specific.  */
5620       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5621       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5622       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5623       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5624       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5625       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5626       /* Generic.  */
5627       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5628       /* SPARC specific.  */
5629       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5630       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5631       /* ARM specific.  */
5632       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5633       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5634       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5635       /* GNU specific.  */
5636       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5637       /* VLE specific.  */
5638       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5639     };
5640
5641   if (do_section_details)
5642     {
5643       sprintf (buff, "[%*.*lx]: ",
5644                field_size, field_size, (unsigned long) sh_flags);
5645       p += field_size + 4;
5646     }
5647
5648   while (sh_flags)
5649     {
5650       bfd_vma flag;
5651
5652       flag = sh_flags & - sh_flags;
5653       sh_flags &= ~ flag;
5654
5655       if (do_section_details)
5656         {
5657           switch (flag)
5658             {
5659             case SHF_WRITE:             sindex = 0; break;
5660             case SHF_ALLOC:             sindex = 1; break;
5661             case SHF_EXECINSTR:         sindex = 2; break;
5662             case SHF_MERGE:             sindex = 3; break;
5663             case SHF_STRINGS:           sindex = 4; break;
5664             case SHF_INFO_LINK:         sindex = 5; break;
5665             case SHF_LINK_ORDER:        sindex = 6; break;
5666             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5667             case SHF_GROUP:             sindex = 8; break;
5668             case SHF_TLS:               sindex = 9; break;
5669             case SHF_EXCLUDE:           sindex = 18; break;
5670             case SHF_COMPRESSED:        sindex = 20; break;
5671             case SHF_GNU_MBIND:         sindex = 24; break;
5672
5673             default:
5674               sindex = -1;
5675               switch (filedata->file_header.e_machine)
5676                 {
5677                 case EM_IA_64:
5678                   if (flag == SHF_IA_64_SHORT)
5679                     sindex = 10;
5680                   else if (flag == SHF_IA_64_NORECOV)
5681                     sindex = 11;
5682 #ifdef BFD64
5683                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5684                     switch (flag)
5685                       {
5686                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5687                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5688                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5689                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5690                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5691                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5692                       default:                        break;
5693                       }
5694 #endif
5695                   break;
5696
5697                 case EM_386:
5698                 case EM_IAMCU:
5699                 case EM_X86_64:
5700                 case EM_L1OM:
5701                 case EM_K1OM:
5702                 case EM_OLD_SPARCV9:
5703                 case EM_SPARC32PLUS:
5704                 case EM_SPARCV9:
5705                 case EM_SPARC:
5706                   if (flag == SHF_ORDERED)
5707                     sindex = 19;
5708                   break;
5709
5710                 case EM_ARM:
5711                   switch (flag)
5712                     {
5713                     case SHF_ENTRYSECT: sindex = 21; break;
5714                     case SHF_ARM_PURECODE: sindex = 22; break;
5715                     case SHF_COMDEF: sindex = 23; break;
5716                     default: break;
5717                     }
5718                   break;
5719                 case EM_PPC:
5720                   if (flag == SHF_PPC_VLE)
5721                     sindex = 25;
5722                   break;
5723
5724                 default:
5725                   break;
5726                 }
5727             }
5728
5729           if (sindex != -1)
5730             {
5731               if (p != buff + field_size + 4)
5732                 {
5733                   if (size < (10 + 2))
5734                     {
5735                       warn (_("Internal error: not enough buffer room for section flag info"));
5736                       return _("<unknown>");
5737                     }
5738                   size -= 2;
5739                   *p++ = ',';
5740                   *p++ = ' ';
5741                 }
5742
5743               size -= flags [sindex].len;
5744               p = stpcpy (p, flags [sindex].str);
5745             }
5746           else if (flag & SHF_MASKOS)
5747             os_flags |= flag;
5748           else if (flag & SHF_MASKPROC)
5749             proc_flags |= flag;
5750           else
5751             unknown_flags |= flag;
5752         }
5753       else
5754         {
5755           switch (flag)
5756             {
5757             case SHF_WRITE:             *p = 'W'; break;
5758             case SHF_ALLOC:             *p = 'A'; break;
5759             case SHF_EXECINSTR:         *p = 'X'; break;
5760             case SHF_MERGE:             *p = 'M'; break;
5761             case SHF_STRINGS:           *p = 'S'; break;
5762             case SHF_INFO_LINK:         *p = 'I'; break;
5763             case SHF_LINK_ORDER:        *p = 'L'; break;
5764             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5765             case SHF_GROUP:             *p = 'G'; break;
5766             case SHF_TLS:               *p = 'T'; break;
5767             case SHF_EXCLUDE:           *p = 'E'; break;
5768             case SHF_COMPRESSED:        *p = 'C'; break;
5769             case SHF_GNU_MBIND:         *p = 'D'; break;
5770
5771             default:
5772               if ((filedata->file_header.e_machine == EM_X86_64
5773                    || filedata->file_header.e_machine == EM_L1OM
5774                    || filedata->file_header.e_machine == EM_K1OM)
5775                   && flag == SHF_X86_64_LARGE)
5776                 *p = 'l';
5777               else if (filedata->file_header.e_machine == EM_ARM
5778                        && flag == SHF_ARM_PURECODE)
5779                   *p = 'y';
5780               else if (filedata->file_header.e_machine == EM_PPC
5781                        && flag == SHF_PPC_VLE)
5782                   *p = 'v';
5783               else if (flag & SHF_MASKOS)
5784                 {
5785                   *p = 'o';
5786                   sh_flags &= ~ SHF_MASKOS;
5787                 }
5788               else if (flag & SHF_MASKPROC)
5789                 {
5790                   *p = 'p';
5791                   sh_flags &= ~ SHF_MASKPROC;
5792                 }
5793               else
5794                 *p = 'x';
5795               break;
5796             }
5797           p++;
5798         }
5799     }
5800
5801   if (do_section_details)
5802     {
5803       if (os_flags)
5804         {
5805           size -= 5 + field_size;
5806           if (p != buff + field_size + 4)
5807             {
5808               if (size < (2 + 1))
5809                 {
5810                   warn (_("Internal error: not enough buffer room for section flag info"));
5811                   return _("<unknown>");
5812                 }
5813               size -= 2;
5814               *p++ = ',';
5815               *p++ = ' ';
5816             }
5817           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5818                    (unsigned long) os_flags);
5819           p += 5 + field_size;
5820         }
5821       if (proc_flags)
5822         {
5823           size -= 7 + field_size;
5824           if (p != buff + field_size + 4)
5825             {
5826               if (size < (2 + 1))
5827                 {
5828                   warn (_("Internal error: not enough buffer room for section flag info"));
5829                   return _("<unknown>");
5830                 }
5831               size -= 2;
5832               *p++ = ',';
5833               *p++ = ' ';
5834             }
5835           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5836                    (unsigned long) proc_flags);
5837           p += 7 + field_size;
5838         }
5839       if (unknown_flags)
5840         {
5841           size -= 10 + field_size;
5842           if (p != buff + field_size + 4)
5843             {
5844               if (size < (2 + 1))
5845                 {
5846                   warn (_("Internal error: not enough buffer room for section flag info"));
5847                   return _("<unknown>");
5848                 }
5849               size -= 2;
5850               *p++ = ',';
5851               *p++ = ' ';
5852             }
5853           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5854                    (unsigned long) unknown_flags);
5855           p += 10 + field_size;
5856         }
5857     }
5858
5859   *p = '\0';
5860   return buff;
5861 }
5862
5863 static unsigned int
5864 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5865 {
5866   if (is_32bit_elf)
5867     {
5868       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5869
5870       if (size < sizeof (* echdr))
5871         {
5872           error (_("Compressed section is too small even for a compression header\n"));
5873           return 0;
5874         }
5875
5876       chdr->ch_type = BYTE_GET (echdr->ch_type);
5877       chdr->ch_size = BYTE_GET (echdr->ch_size);
5878       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5879       return sizeof (*echdr);
5880     }
5881   else
5882     {
5883       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5884
5885       if (size < sizeof (* echdr))
5886         {
5887           error (_("Compressed section is too small even for a compression header\n"));
5888           return 0;
5889         }
5890
5891       chdr->ch_type = BYTE_GET (echdr->ch_type);
5892       chdr->ch_size = BYTE_GET (echdr->ch_size);
5893       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5894       return sizeof (*echdr);
5895     }
5896 }
5897
5898 static bfd_boolean
5899 process_section_headers (Filedata * filedata)
5900 {
5901   Elf_Internal_Shdr * section;
5902   unsigned int i;
5903
5904   filedata->section_headers = NULL;
5905
5906   if (filedata->file_header.e_shnum == 0)
5907     {
5908       /* PR binutils/12467.  */
5909       if (filedata->file_header.e_shoff != 0)
5910         {
5911           warn (_("possibly corrupt ELF file header - it has a non-zero"
5912                   " section header offset, but no section headers\n"));
5913           return FALSE;
5914         }
5915       else if (do_sections)
5916         printf (_("\nThere are no sections in this file.\n"));
5917
5918       return TRUE;
5919     }
5920
5921   if (do_sections && !do_header)
5922     printf (ngettext ("There is %d section header, "
5923                       "starting at offset 0x%lx:\n",
5924                       "There are %d section headers, "
5925                       "starting at offset 0x%lx:\n",
5926                       filedata->file_header.e_shnum),
5927             filedata->file_header.e_shnum,
5928             (unsigned long) filedata->file_header.e_shoff);
5929
5930   if (is_32bit_elf)
5931     {
5932       if (! get_32bit_section_headers (filedata, FALSE))
5933         return FALSE;
5934     }
5935   else
5936     {
5937       if (! get_64bit_section_headers (filedata, FALSE))
5938         return FALSE;
5939     }
5940
5941   /* Read in the string table, so that we have names to display.  */
5942   if (filedata->file_header.e_shstrndx != SHN_UNDEF
5943        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
5944     {
5945       section = filedata->section_headers + filedata->file_header.e_shstrndx;
5946
5947       if (section->sh_size != 0)
5948         {
5949           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
5950                                                       1, section->sh_size,
5951                                                       _("string table"));
5952
5953           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
5954         }
5955     }
5956
5957   /* Scan the sections for the dynamic symbol table
5958      and dynamic string table and debug sections.  */
5959   dynamic_symbols = NULL;
5960   dynamic_strings = NULL;
5961   dynamic_syminfo = NULL;
5962   symtab_shndx_list = NULL;
5963
5964   eh_addr_size = is_32bit_elf ? 4 : 8;
5965   switch (filedata->file_header.e_machine)
5966     {
5967     case EM_MIPS:
5968     case EM_MIPS_RS3_LE:
5969       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5970          FDE addresses.  However, the ABI also has a semi-official ILP32
5971          variant for which the normal FDE address size rules apply.
5972
5973          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5974          section, where XX is the size of longs in bits.  Unfortunately,
5975          earlier compilers provided no way of distinguishing ILP32 objects
5976          from LP64 objects, so if there's any doubt, we should assume that
5977          the official LP64 form is being used.  */
5978       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5979           && find_section (filedata, ".gcc_compiled_long32") == NULL)
5980         eh_addr_size = 8;
5981       break;
5982
5983     case EM_H8_300:
5984     case EM_H8_300H:
5985       switch (filedata->file_header.e_flags & EF_H8_MACH)
5986         {
5987         case E_H8_MACH_H8300:
5988         case E_H8_MACH_H8300HN:
5989         case E_H8_MACH_H8300SN:
5990         case E_H8_MACH_H8300SXN:
5991           eh_addr_size = 2;
5992           break;
5993         case E_H8_MACH_H8300H:
5994         case E_H8_MACH_H8300S:
5995         case E_H8_MACH_H8300SX:
5996           eh_addr_size = 4;
5997           break;
5998         }
5999       break;
6000
6001     case EM_M32C_OLD:
6002     case EM_M32C:
6003       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6004         {
6005         case EF_M32C_CPU_M16C:
6006           eh_addr_size = 2;
6007           break;
6008         }
6009       break;
6010     }
6011
6012 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6013   do                                                                    \
6014     {                                                                   \
6015       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6016       if (section->sh_entsize != expected_entsize)                      \
6017         {                                                               \
6018           char buf[40];                                                 \
6019           sprintf_vma (buf, section->sh_entsize);                       \
6020           /* Note: coded this way so that there is a single string for  \
6021              translation.  */ \
6022           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6023           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6024                    (unsigned) expected_entsize);                        \
6025           section->sh_entsize = expected_entsize;                       \
6026         }                                                               \
6027     }                                                                   \
6028   while (0)
6029
6030 #define CHECK_ENTSIZE(section, i, type)                                 \
6031   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6032                         sizeof (Elf64_External_##type))
6033
6034   for (i = 0, section = filedata->section_headers;
6035        i < filedata->file_header.e_shnum;
6036        i++, section++)
6037     {
6038       char * name = SECTION_NAME (section);
6039
6040       if (section->sh_type == SHT_DYNSYM)
6041         {
6042           if (dynamic_symbols != NULL)
6043             {
6044               error (_("File contains multiple dynamic symbol tables\n"));
6045               continue;
6046             }
6047
6048           CHECK_ENTSIZE (section, i, Sym);
6049           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6050         }
6051       else if (section->sh_type == SHT_STRTAB
6052                && streq (name, ".dynstr"))
6053         {
6054           if (dynamic_strings != NULL)
6055             {
6056               error (_("File contains multiple dynamic string tables\n"));
6057               continue;
6058             }
6059
6060           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6061                                                1, section->sh_size,
6062                                                _("dynamic strings"));
6063           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6064         }
6065       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6066         {
6067           elf_section_list * entry = xmalloc (sizeof * entry);
6068
6069           entry->hdr = section;
6070           entry->next = symtab_shndx_list;
6071           symtab_shndx_list = entry;
6072         }
6073       else if (section->sh_type == SHT_SYMTAB)
6074         CHECK_ENTSIZE (section, i, Sym);
6075       else if (section->sh_type == SHT_GROUP)
6076         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6077       else if (section->sh_type == SHT_REL)
6078         CHECK_ENTSIZE (section, i, Rel);
6079       else if (section->sh_type == SHT_RELA)
6080         CHECK_ENTSIZE (section, i, Rela);
6081       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6082                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6083                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6084                 || do_debug_str || do_debug_loc || do_debug_ranges
6085                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6086                && (const_strneq (name, ".debug_")
6087                    || const_strneq (name, ".zdebug_")))
6088         {
6089           if (name[1] == 'z')
6090             name += sizeof (".zdebug_") - 1;
6091           else
6092             name += sizeof (".debug_") - 1;
6093
6094           if (do_debugging
6095               || (do_debug_info     && const_strneq (name, "info"))
6096               || (do_debug_info     && const_strneq (name, "types"))
6097               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6098               || (do_debug_lines    && strcmp (name, "line") == 0)
6099               || (do_debug_lines    && const_strneq (name, "line."))
6100               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6101               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6102               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6103               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6104               || (do_debug_aranges  && const_strneq (name, "aranges"))
6105               || (do_debug_ranges   && const_strneq (name, "ranges"))
6106               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6107               || (do_debug_frames   && const_strneq (name, "frame"))
6108               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6109               || (do_debug_macinfo  && const_strneq (name, "macro"))
6110               || (do_debug_str      && const_strneq (name, "str"))
6111               || (do_debug_loc      && const_strneq (name, "loc"))
6112               || (do_debug_loc      && const_strneq (name, "loclists"))
6113               || (do_debug_addr     && const_strneq (name, "addr"))
6114               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6115               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6116               )
6117             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6118         }
6119       /* Linkonce section to be combined with .debug_info at link time.  */
6120       else if ((do_debugging || do_debug_info)
6121                && const_strneq (name, ".gnu.linkonce.wi."))
6122         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6123       else if (do_debug_frames && streq (name, ".eh_frame"))
6124         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6125       else if (do_gdb_index && (streq (name, ".gdb_index")
6126                                 || streq (name, ".debug_names")))
6127         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6128       /* Trace sections for Itanium VMS.  */
6129       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6130                 || do_trace_aranges)
6131                && const_strneq (name, ".trace_"))
6132         {
6133           name += sizeof (".trace_") - 1;
6134
6135           if (do_debugging
6136               || (do_trace_info     && streq (name, "info"))
6137               || (do_trace_abbrevs  && streq (name, "abbrev"))
6138               || (do_trace_aranges  && streq (name, "aranges"))
6139               )
6140             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6141         }
6142       else if ((do_debugging || do_debug_links)
6143                && (const_strneq (name, ".gnu_debuglink")
6144                    || const_strneq (name, ".gnu_debugaltlink")))
6145         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6146     }
6147
6148   if (! do_sections)
6149     return TRUE;
6150
6151   if (filedata->file_header.e_shnum > 1)
6152     printf (_("\nSection Headers:\n"));
6153   else
6154     printf (_("\nSection Header:\n"));
6155
6156   if (is_32bit_elf)
6157     {
6158       if (do_section_details)
6159         {
6160           printf (_("  [Nr] Name\n"));
6161           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6162         }
6163       else
6164         printf
6165           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6166     }
6167   else if (do_wide)
6168     {
6169       if (do_section_details)
6170         {
6171           printf (_("  [Nr] Name\n"));
6172           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6173         }
6174       else
6175         printf
6176           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6177     }
6178   else
6179     {
6180       if (do_section_details)
6181         {
6182           printf (_("  [Nr] Name\n"));
6183           printf (_("       Type              Address          Offset            Link\n"));
6184           printf (_("       Size              EntSize          Info              Align\n"));
6185         }
6186       else
6187         {
6188           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6189           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6190         }
6191     }
6192
6193   if (do_section_details)
6194     printf (_("       Flags\n"));
6195
6196   for (i = 0, section = filedata->section_headers;
6197        i < filedata->file_header.e_shnum;
6198        i++, section++)
6199     {
6200       /* Run some sanity checks on the section header.  */
6201
6202       /* Check the sh_link field.  */
6203       switch (section->sh_type)
6204         {
6205         case SHT_SYMTAB_SHNDX:
6206         case SHT_GROUP:
6207         case SHT_HASH:
6208         case SHT_GNU_HASH:
6209         case SHT_GNU_versym:
6210         case SHT_REL:
6211         case SHT_RELA:
6212           if (section->sh_link < 1
6213               || section->sh_link >= filedata->file_header.e_shnum
6214               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6215                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6216             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6217                   i, section->sh_link);
6218           break;
6219
6220         case SHT_DYNAMIC:
6221         case SHT_SYMTAB:
6222         case SHT_DYNSYM:
6223         case SHT_GNU_verneed:
6224         case SHT_GNU_verdef:
6225         case SHT_GNU_LIBLIST:
6226           if (section->sh_link < 1
6227               || section->sh_link >= filedata->file_header.e_shnum
6228               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6229             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6230                   i, section->sh_link);
6231           break;
6232
6233         case SHT_INIT_ARRAY:
6234         case SHT_FINI_ARRAY:
6235         case SHT_PREINIT_ARRAY:
6236           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6237             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6238                   i, section->sh_link);
6239           break;
6240
6241         default:
6242           /* FIXME: Add support for target specific section types.  */
6243 #if 0     /* Currently we do not check other section types as there are too
6244              many special cases.  Stab sections for example have a type
6245              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6246              section.  */
6247           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6248             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6249                   i, section->sh_link);
6250 #endif
6251           break;
6252         }
6253
6254       /* Check the sh_info field.  */
6255       switch (section->sh_type)
6256         {
6257         case SHT_REL:
6258         case SHT_RELA:
6259           if (section->sh_info < 1
6260               || section->sh_info >= filedata->file_header.e_shnum
6261               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6262                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6263                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6264                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6265                   /* FIXME: Are other section types valid ?  */
6266                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6267             {
6268               if (section->sh_info == 0
6269                   && (filedata->file_header.e_type == ET_EXEC
6270                       || filedata->file_header.e_type == ET_DYN
6271                       /* These next two tests may be redundant, but
6272                          they have been left in for paranoia's sake.  */
6273                       || streq (SECTION_NAME (section), ".rel.dyn")
6274                       || streq (SECTION_NAME (section), ".rela.dyn")))
6275                 /* Dynamic relocations apply to segments, not sections, so
6276                    they do not need an sh_info value.  */
6277                 ;
6278               else
6279                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6280                       i, section->sh_info);
6281             }
6282           break;
6283
6284         case SHT_DYNAMIC:
6285         case SHT_HASH:
6286         case SHT_SYMTAB_SHNDX:
6287         case SHT_INIT_ARRAY:
6288         case SHT_FINI_ARRAY:
6289         case SHT_PREINIT_ARRAY:
6290           if (section->sh_info != 0)
6291             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6292                   i, section->sh_info);
6293           break;
6294
6295         case SHT_GROUP:
6296         case SHT_SYMTAB:
6297         case SHT_DYNSYM:
6298           /* A symbol index - we assume that it is valid.  */
6299           break;
6300
6301         default:
6302           /* FIXME: Add support for target specific section types.  */
6303           if (section->sh_type == SHT_NOBITS)
6304             /* NOBITS section headers with non-zero sh_info fields can be
6305                created when a binary is stripped of everything but its debug
6306                information.  The stripped sections have their headers
6307                preserved but their types set to SHT_NOBITS.  So do not check
6308                this type of section.  */
6309             ;
6310           else if (section->sh_flags & SHF_INFO_LINK)
6311             {
6312               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6313                 warn (_("[%2u]: Expected link to another section in info field"), i);
6314             }
6315           else if (section->sh_type < SHT_LOOS
6316                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6317                    && section->sh_info != 0)
6318             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6319                   i, section->sh_info);
6320           break;
6321         }
6322
6323       /* Check the sh_size field.  */
6324       if (section->sh_size > filedata->file_size
6325           && section->sh_type != SHT_NOBITS
6326           && section->sh_type != SHT_NULL
6327           && section->sh_type < SHT_LOOS)
6328         warn (_("Size of section %u is larger than the entire file!\n"), i);
6329
6330       printf ("  [%2u] ", i);
6331       if (do_section_details)
6332         printf ("%s\n      ", printable_section_name (filedata, section));
6333       else
6334         print_symbol (-17, SECTION_NAME (section));
6335
6336       printf (do_wide ? " %-15s " : " %-15.15s ",
6337               get_section_type_name (filedata, section->sh_type));
6338
6339       if (is_32bit_elf)
6340         {
6341           const char * link_too_big = NULL;
6342
6343           print_vma (section->sh_addr, LONG_HEX);
6344
6345           printf ( " %6.6lx %6.6lx %2.2lx",
6346                    (unsigned long) section->sh_offset,
6347                    (unsigned long) section->sh_size,
6348                    (unsigned long) section->sh_entsize);
6349
6350           if (do_section_details)
6351             fputs ("  ", stdout);
6352           else
6353             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6354
6355           if (section->sh_link >= filedata->file_header.e_shnum)
6356             {
6357               link_too_big = "";
6358               /* The sh_link value is out of range.  Normally this indicates
6359                  an error but it can have special values in Solaris binaries.  */
6360               switch (filedata->file_header.e_machine)
6361                 {
6362                 case EM_386:
6363                 case EM_IAMCU:
6364                 case EM_X86_64:
6365                 case EM_L1OM:
6366                 case EM_K1OM:
6367                 case EM_OLD_SPARCV9:
6368                 case EM_SPARC32PLUS:
6369                 case EM_SPARCV9:
6370                 case EM_SPARC:
6371                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6372                     link_too_big = "BEFORE";
6373                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6374                     link_too_big = "AFTER";
6375                   break;
6376                 default:
6377                   break;
6378                 }
6379             }
6380
6381           if (do_section_details)
6382             {
6383               if (link_too_big != NULL && * link_too_big)
6384                 printf ("<%s> ", link_too_big);
6385               else
6386                 printf ("%2u ", section->sh_link);
6387               printf ("%3u %2lu\n", section->sh_info,
6388                       (unsigned long) section->sh_addralign);
6389             }
6390           else
6391             printf ("%2u %3u %2lu\n",
6392                     section->sh_link,
6393                     section->sh_info,
6394                     (unsigned long) section->sh_addralign);
6395
6396           if (link_too_big && ! * link_too_big)
6397             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6398                   i, section->sh_link);
6399         }
6400       else if (do_wide)
6401         {
6402           print_vma (section->sh_addr, LONG_HEX);
6403
6404           if ((long) section->sh_offset == section->sh_offset)
6405             printf (" %6.6lx", (unsigned long) section->sh_offset);
6406           else
6407             {
6408               putchar (' ');
6409               print_vma (section->sh_offset, LONG_HEX);
6410             }
6411
6412           if ((unsigned long) section->sh_size == section->sh_size)
6413             printf (" %6.6lx", (unsigned long) section->sh_size);
6414           else
6415             {
6416               putchar (' ');
6417               print_vma (section->sh_size, LONG_HEX);
6418             }
6419
6420           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6421             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6422           else
6423             {
6424               putchar (' ');
6425               print_vma (section->sh_entsize, LONG_HEX);
6426             }
6427
6428           if (do_section_details)
6429             fputs ("  ", stdout);
6430           else
6431             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6432
6433           printf ("%2u %3u ", section->sh_link, section->sh_info);
6434
6435           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6436             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6437           else
6438             {
6439               print_vma (section->sh_addralign, DEC);
6440               putchar ('\n');
6441             }
6442         }
6443       else if (do_section_details)
6444         {
6445           printf ("       %-15.15s  ",
6446                   get_section_type_name (filedata, section->sh_type));
6447           print_vma (section->sh_addr, LONG_HEX);
6448           if ((long) section->sh_offset == section->sh_offset)
6449             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6450           else
6451             {
6452               printf ("  ");
6453               print_vma (section->sh_offset, LONG_HEX);
6454             }
6455           printf ("  %u\n       ", section->sh_link);
6456           print_vma (section->sh_size, LONG_HEX);
6457           putchar (' ');
6458           print_vma (section->sh_entsize, LONG_HEX);
6459
6460           printf ("  %-16u  %lu\n",
6461                   section->sh_info,
6462                   (unsigned long) section->sh_addralign);
6463         }
6464       else
6465         {
6466           putchar (' ');
6467           print_vma (section->sh_addr, LONG_HEX);
6468           if ((long) section->sh_offset == section->sh_offset)
6469             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6470           else
6471             {
6472               printf ("  ");
6473               print_vma (section->sh_offset, LONG_HEX);
6474             }
6475           printf ("\n       ");
6476           print_vma (section->sh_size, LONG_HEX);
6477           printf ("  ");
6478           print_vma (section->sh_entsize, LONG_HEX);
6479
6480           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6481
6482           printf ("     %2u   %3u     %lu\n",
6483                   section->sh_link,
6484                   section->sh_info,
6485                   (unsigned long) section->sh_addralign);
6486         }
6487
6488       if (do_section_details)
6489         {
6490           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6491           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6492             {
6493               /* Minimum section size is 12 bytes for 32-bit compression
6494                  header + 12 bytes for compressed data header.  */
6495               unsigned char buf[24];
6496
6497               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6498               if (get_data (&buf, filedata, section->sh_offset, 1,
6499                             sizeof (buf), _("compression header")))
6500                 {
6501                   Elf_Internal_Chdr chdr;
6502
6503                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6504
6505                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6506                     printf ("       ZLIB, ");
6507                   else
6508                     printf (_("       [<unknown>: 0x%x], "),
6509                             chdr.ch_type);
6510                   print_vma (chdr.ch_size, LONG_HEX);
6511                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6512                 }
6513             }
6514         }
6515     }
6516
6517   if (!do_section_details)
6518     {
6519       /* The ordering of the letters shown here matches the ordering of the
6520          corresponding SHF_xxx values, and hence the order in which these
6521          letters will be displayed to the user.  */
6522       printf (_("Key to Flags:\n\
6523   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6524   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6525   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6526       if (filedata->file_header.e_machine == EM_X86_64
6527           || filedata->file_header.e_machine == EM_L1OM
6528           || filedata->file_header.e_machine == EM_K1OM)
6529         printf (_("l (large), "));
6530       else if (filedata->file_header.e_machine == EM_ARM)
6531         printf (_("y (purecode), "));
6532       else if (filedata->file_header.e_machine == EM_PPC)
6533         printf (_("v (VLE), "));
6534       printf ("p (processor specific)\n");
6535     }
6536
6537   return TRUE;
6538 }
6539
6540 static const char *
6541 get_group_flags (unsigned int flags)
6542 {
6543   static char buff[128];
6544
6545   if (flags == 0)
6546     return "";
6547   else if (flags == GRP_COMDAT)
6548     return "COMDAT ";
6549
6550   snprintf (buff, 14, _("[0x%x: "), flags);
6551
6552   flags &= ~ GRP_COMDAT;
6553   if (flags & GRP_MASKOS)
6554     {
6555       strcat (buff, "<OS specific>");
6556       flags &= ~ GRP_MASKOS;
6557     }
6558
6559   if (flags & GRP_MASKPROC)
6560     {
6561       strcat (buff, "<PROC specific>");
6562       flags &= ~ GRP_MASKPROC;
6563     }
6564
6565   if (flags)
6566     strcat (buff, "<unknown>");
6567
6568   strcat (buff, "]");
6569   return buff;
6570 }
6571
6572 static bfd_boolean
6573 process_section_groups (Filedata * filedata)
6574 {
6575   Elf_Internal_Shdr * section;
6576   unsigned int i;
6577   struct group * group;
6578   Elf_Internal_Shdr * symtab_sec;
6579   Elf_Internal_Shdr * strtab_sec;
6580   Elf_Internal_Sym * symtab;
6581   unsigned long num_syms;
6582   char * strtab;
6583   size_t strtab_size;
6584
6585   /* Don't process section groups unless needed.  */
6586   if (!do_unwind && !do_section_groups)
6587     return TRUE;
6588
6589   if (filedata->file_header.e_shnum == 0)
6590     {
6591       if (do_section_groups)
6592         printf (_("\nThere are no sections to group in this file.\n"));
6593
6594       return TRUE;
6595     }
6596
6597   if (filedata->section_headers == NULL)
6598     {
6599       error (_("Section headers are not available!\n"));
6600       /* PR 13622: This can happen with a corrupt ELF header.  */
6601       return FALSE;
6602     }
6603
6604   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6605                                                      sizeof (struct group *));
6606
6607   if (section_headers_groups == NULL)
6608     {
6609       error (_("Out of memory reading %u section group headers\n"),
6610              filedata->file_header.e_shnum);
6611       return FALSE;
6612     }
6613
6614   /* Scan the sections for the group section.  */
6615   group_count = 0;
6616   for (i = 0, section = filedata->section_headers;
6617        i < filedata->file_header.e_shnum;
6618        i++, section++)
6619     if (section->sh_type == SHT_GROUP)
6620       group_count++;
6621
6622   if (group_count == 0)
6623     {
6624       if (do_section_groups)
6625         printf (_("\nThere are no section groups in this file.\n"));
6626
6627       return TRUE;
6628     }
6629
6630   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6631
6632   if (section_groups == NULL)
6633     {
6634       error (_("Out of memory reading %lu groups\n"),
6635              (unsigned long) group_count);
6636       return FALSE;
6637     }
6638
6639   symtab_sec = NULL;
6640   strtab_sec = NULL;
6641   symtab = NULL;
6642   num_syms = 0;
6643   strtab = NULL;
6644   strtab_size = 0;
6645   for (i = 0, section = filedata->section_headers, group = section_groups;
6646        i < filedata->file_header.e_shnum;
6647        i++, section++)
6648     {
6649       if (section->sh_type == SHT_GROUP)
6650         {
6651           const char * name = printable_section_name (filedata, section);
6652           const char * group_name;
6653           unsigned char * start;
6654           unsigned char * indices;
6655           unsigned int entry, j, size;
6656           Elf_Internal_Shdr * sec;
6657           Elf_Internal_Sym * sym;
6658
6659           /* Get the symbol table.  */
6660           if (section->sh_link >= filedata->file_header.e_shnum
6661               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6662                   != SHT_SYMTAB))
6663             {
6664               error (_("Bad sh_link in group section `%s'\n"), name);
6665               continue;
6666             }
6667
6668           if (symtab_sec != sec)
6669             {
6670               symtab_sec = sec;
6671               if (symtab)
6672                 free (symtab);
6673               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6674             }
6675
6676           if (symtab == NULL)
6677             {
6678               error (_("Corrupt header in group section `%s'\n"), name);
6679               continue;
6680             }
6681
6682           if (section->sh_info >= num_syms)
6683             {
6684               error (_("Bad sh_info in group section `%s'\n"), name);
6685               continue;
6686             }
6687
6688           sym = symtab + section->sh_info;
6689
6690           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6691             {
6692               if (sym->st_shndx == 0
6693                   || sym->st_shndx >= filedata->file_header.e_shnum)
6694                 {
6695                   error (_("Bad sh_info in group section `%s'\n"), name);
6696                   continue;
6697                 }
6698
6699               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6700               strtab_sec = NULL;
6701               if (strtab)
6702                 free (strtab);
6703               strtab = NULL;
6704               strtab_size = 0;
6705             }
6706           else
6707             {
6708               /* Get the string table.  */
6709               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6710                 {
6711                   strtab_sec = NULL;
6712                   if (strtab)
6713                     free (strtab);
6714                   strtab = NULL;
6715                   strtab_size = 0;
6716                 }
6717               else if (strtab_sec
6718                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6719                 {
6720                   strtab_sec = sec;
6721                   if (strtab)
6722                     free (strtab);
6723
6724                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6725                                               1, strtab_sec->sh_size,
6726                                               _("string table"));
6727                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6728                 }
6729               group_name = sym->st_name < strtab_size
6730                 ? strtab + sym->st_name : _("<corrupt>");
6731             }
6732
6733           /* PR 17531: file: loop.  */
6734           if (section->sh_entsize > section->sh_size)
6735             {
6736               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6737                      printable_section_name (filedata, section),
6738                      (unsigned long) section->sh_entsize,
6739                      (unsigned long) section->sh_size);
6740               break;
6741             }
6742
6743           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6744                                               1, section->sh_size,
6745                                               _("section data"));
6746           if (start == NULL)
6747             continue;
6748
6749           indices = start;
6750           size = (section->sh_size / section->sh_entsize) - 1;
6751           entry = byte_get (indices, 4);
6752           indices += 4;
6753
6754           if (do_section_groups)
6755             {
6756               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6757                       get_group_flags (entry), i, name, group_name, size);
6758
6759               printf (_("   [Index]    Name\n"));
6760             }
6761
6762           group->group_index = i;
6763
6764           for (j = 0; j < size; j++)
6765             {
6766               struct group_list * g;
6767
6768               entry = byte_get (indices, 4);
6769               indices += 4;
6770
6771               if (entry >= filedata->file_header.e_shnum)
6772                 {
6773                   static unsigned num_group_errors = 0;
6774
6775                   if (num_group_errors ++ < 10)
6776                     {
6777                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6778                              entry, i, filedata->file_header.e_shnum - 1);
6779                       if (num_group_errors == 10)
6780                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6781                     }
6782                   continue;
6783                 }
6784
6785               if (section_headers_groups [entry] != NULL)
6786                 {
6787                   if (entry)
6788                     {
6789                       static unsigned num_errs = 0;
6790
6791                       if (num_errs ++ < 10)
6792                         {
6793                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6794                                  entry, i,
6795                                  section_headers_groups [entry]->group_index);
6796                           if (num_errs == 10)
6797                             warn (_("Further error messages about already contained group sections suppressed\n"));
6798                         }
6799                       continue;
6800                     }
6801                   else
6802                     {
6803                       /* Intel C/C++ compiler may put section 0 in a
6804                          section group.  We just warn it the first time
6805                          and ignore it afterwards.  */
6806                       static bfd_boolean warned = FALSE;
6807                       if (!warned)
6808                         {
6809                           error (_("section 0 in group section [%5u]\n"),
6810                                  section_headers_groups [entry]->group_index);
6811                           warned = TRUE;
6812                         }
6813                     }
6814                 }
6815
6816               section_headers_groups [entry] = group;
6817
6818               if (do_section_groups)
6819                 {
6820                   sec = filedata->section_headers + entry;
6821                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6822                 }
6823
6824               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6825               g->section_index = entry;
6826               g->next = group->root;
6827               group->root = g;
6828             }
6829
6830           if (start)
6831             free (start);
6832
6833           group++;
6834         }
6835     }
6836
6837   if (symtab)
6838     free (symtab);
6839   if (strtab)
6840     free (strtab);
6841   return TRUE;
6842 }
6843
6844 /* Data used to display dynamic fixups.  */
6845
6846 struct ia64_vms_dynfixup
6847 {
6848   bfd_vma needed_ident;         /* Library ident number.  */
6849   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6850   bfd_vma fixup_needed;         /* Index of the library.  */
6851   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6852   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6853 };
6854
6855 /* Data used to display dynamic relocations.  */
6856
6857 struct ia64_vms_dynimgrela
6858 {
6859   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6860   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6861 };
6862
6863 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6864    library).  */
6865
6866 static bfd_boolean
6867 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6868                               struct ia64_vms_dynfixup *  fixup,
6869                               const char *                strtab,
6870                               unsigned int                strtab_sz)
6871 {
6872   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6873   long i;
6874   const char * lib_name;
6875
6876   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6877                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6878                    _("dynamic section image fixups"));
6879   if (!imfs)
6880     return FALSE;
6881
6882   if (fixup->needed < strtab_sz)
6883     lib_name = strtab + fixup->needed;
6884   else
6885     {
6886       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6887             (unsigned long) fixup->needed);
6888       lib_name = "???";
6889     }
6890   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6891           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6892   printf
6893     (_("Seg Offset           Type                             SymVec DataType\n"));
6894
6895   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6896     {
6897       unsigned int type;
6898       const char *rtype;
6899
6900       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6901       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6902       type = BYTE_GET (imfs [i].type);
6903       rtype = elf_ia64_reloc_type (type);
6904       if (rtype == NULL)
6905         printf (" 0x%08x                       ", type);
6906       else
6907         printf (" %-32s ", rtype);
6908       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6909       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6910     }
6911
6912   free (imfs);
6913   return TRUE;
6914 }
6915
6916 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6917
6918 static bfd_boolean
6919 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6920 {
6921   Elf64_External_VMS_IMAGE_RELA *imrs;
6922   long i;
6923
6924   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6925                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6926                    _("dynamic section image relocations"));
6927   if (!imrs)
6928     return FALSE;
6929
6930   printf (_("\nImage relocs\n"));
6931   printf
6932     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6933
6934   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6935     {
6936       unsigned int type;
6937       const char *rtype;
6938
6939       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6940       printf ("%08" BFD_VMA_FMT "x ",
6941               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6942       type = BYTE_GET (imrs [i].type);
6943       rtype = elf_ia64_reloc_type (type);
6944       if (rtype == NULL)
6945         printf ("0x%08x                      ", type);
6946       else
6947         printf ("%-31s ", rtype);
6948       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6949       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6950       printf ("%08" BFD_VMA_FMT "x\n",
6951               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6952     }
6953
6954   free (imrs);
6955   return TRUE;
6956 }
6957
6958 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6959
6960 static bfd_boolean
6961 process_ia64_vms_dynamic_relocs (Filedata * filedata)
6962 {
6963   struct ia64_vms_dynfixup fixup;
6964   struct ia64_vms_dynimgrela imgrela;
6965   Elf_Internal_Dyn *entry;
6966   bfd_vma strtab_off = 0;
6967   bfd_vma strtab_sz = 0;
6968   char *strtab = NULL;
6969   bfd_boolean res = TRUE;
6970
6971   memset (&fixup, 0, sizeof (fixup));
6972   memset (&imgrela, 0, sizeof (imgrela));
6973
6974   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6975   for (entry = dynamic_section;
6976        entry < dynamic_section + dynamic_nent;
6977        entry++)
6978     {
6979       switch (entry->d_tag)
6980         {
6981         case DT_IA_64_VMS_STRTAB_OFFSET:
6982           strtab_off = entry->d_un.d_val;
6983           break;
6984         case DT_STRSZ:
6985           strtab_sz = entry->d_un.d_val;
6986           if (strtab == NULL)
6987             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
6988                                1, strtab_sz, _("dynamic string section"));
6989           break;
6990
6991         case DT_IA_64_VMS_NEEDED_IDENT:
6992           fixup.needed_ident = entry->d_un.d_val;
6993           break;
6994         case DT_NEEDED:
6995           fixup.needed = entry->d_un.d_val;
6996           break;
6997         case DT_IA_64_VMS_FIXUP_NEEDED:
6998           fixup.fixup_needed = entry->d_un.d_val;
6999           break;
7000         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7001           fixup.fixup_rela_cnt = entry->d_un.d_val;
7002           break;
7003         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7004           fixup.fixup_rela_off = entry->d_un.d_val;
7005           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7006             res = FALSE;
7007           break;
7008         case DT_IA_64_VMS_IMG_RELA_CNT:
7009           imgrela.img_rela_cnt = entry->d_un.d_val;
7010           break;
7011         case DT_IA_64_VMS_IMG_RELA_OFF:
7012           imgrela.img_rela_off = entry->d_un.d_val;
7013           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7014             res = FALSE;
7015           break;
7016
7017         default:
7018           break;
7019         }
7020     }
7021
7022   if (strtab != NULL)
7023     free (strtab);
7024
7025   return res;
7026 }
7027
7028 static struct
7029 {
7030   const char * name;
7031   int reloc;
7032   int size;
7033   int rela;
7034 }
7035   dynamic_relocations [] =
7036 {
7037   { "REL", DT_REL, DT_RELSZ, FALSE },
7038   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7039   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7040 };
7041
7042 /* Process the reloc section.  */
7043
7044 static bfd_boolean
7045 process_relocs (Filedata * filedata)
7046 {
7047   unsigned long rel_size;
7048   unsigned long rel_offset;
7049
7050   if (!do_reloc)
7051     return TRUE;
7052
7053   if (do_using_dynamic)
7054     {
7055       int          is_rela;
7056       const char * name;
7057       bfd_boolean  has_dynamic_reloc;
7058       unsigned int i;
7059
7060       has_dynamic_reloc = FALSE;
7061
7062       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7063         {
7064           is_rela = dynamic_relocations [i].rela;
7065           name = dynamic_relocations [i].name;
7066           rel_size = dynamic_info [dynamic_relocations [i].size];
7067           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7068
7069           if (rel_size)
7070             has_dynamic_reloc = TRUE;
7071
7072           if (is_rela == UNKNOWN)
7073             {
7074               if (dynamic_relocations [i].reloc == DT_JMPREL)
7075                 switch (dynamic_info[DT_PLTREL])
7076                   {
7077                   case DT_REL:
7078                     is_rela = FALSE;
7079                     break;
7080                   case DT_RELA:
7081                     is_rela = TRUE;
7082                     break;
7083                   }
7084             }
7085
7086           if (rel_size)
7087             {
7088               printf
7089                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7090                  name, rel_offset, rel_size);
7091
7092               dump_relocations (filedata,
7093                                 offset_from_vma (filedata, rel_offset, rel_size),
7094                                 rel_size,
7095                                 dynamic_symbols, num_dynamic_syms,
7096                                 dynamic_strings, dynamic_strings_length,
7097                                 is_rela, TRUE /* is_dynamic */);
7098             }
7099         }
7100
7101       if (is_ia64_vms (filedata))
7102         if (process_ia64_vms_dynamic_relocs (filedata))
7103           has_dynamic_reloc = TRUE;
7104
7105       if (! has_dynamic_reloc)
7106         printf (_("\nThere are no dynamic relocations in this file.\n"));
7107     }
7108   else
7109     {
7110       Elf_Internal_Shdr * section;
7111       unsigned long i;
7112       bfd_boolean found = FALSE;
7113
7114       for (i = 0, section = filedata->section_headers;
7115            i < filedata->file_header.e_shnum;
7116            i++, section++)
7117         {
7118           if (   section->sh_type != SHT_RELA
7119               && section->sh_type != SHT_REL)
7120             continue;
7121
7122           rel_offset = section->sh_offset;
7123           rel_size   = section->sh_size;
7124
7125           if (rel_size)
7126             {
7127               Elf_Internal_Shdr * strsec;
7128               int is_rela;
7129               unsigned long num_rela;
7130
7131               printf (_("\nRelocation section "));
7132
7133               if (filedata->string_table == NULL)
7134                 printf ("%d", section->sh_name);
7135               else
7136                 printf ("'%s'", printable_section_name (filedata, section));
7137
7138               num_rela = rel_size / section->sh_entsize;
7139               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7140                                 " at offset 0x%lx contains %lu entries:\n",
7141                                 num_rela),
7142                       rel_offset, num_rela);
7143
7144               is_rela = section->sh_type == SHT_RELA;
7145
7146               if (section->sh_link != 0
7147                   && section->sh_link < filedata->file_header.e_shnum)
7148                 {
7149                   Elf_Internal_Shdr * symsec;
7150                   Elf_Internal_Sym *  symtab;
7151                   unsigned long nsyms;
7152                   unsigned long strtablen = 0;
7153                   char * strtab = NULL;
7154
7155                   symsec = filedata->section_headers + section->sh_link;
7156                   if (symsec->sh_type != SHT_SYMTAB
7157                       && symsec->sh_type != SHT_DYNSYM)
7158                     continue;
7159
7160                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7161
7162                   if (symtab == NULL)
7163                     continue;
7164
7165                   if (symsec->sh_link != 0
7166                       && symsec->sh_link < filedata->file_header.e_shnum)
7167                     {
7168                       strsec = filedata->section_headers + symsec->sh_link;
7169
7170                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7171                                                   1, strsec->sh_size,
7172                                                   _("string table"));
7173                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7174                     }
7175
7176                   dump_relocations (filedata, rel_offset, rel_size,
7177                                     symtab, nsyms, strtab, strtablen,
7178                                     is_rela,
7179                                     symsec->sh_type == SHT_DYNSYM);
7180                   if (strtab)
7181                     free (strtab);
7182                   free (symtab);
7183                 }
7184               else
7185                 dump_relocations (filedata, rel_offset, rel_size,
7186                                   NULL, 0, NULL, 0, is_rela,
7187                                   FALSE /* is_dynamic */);
7188
7189               found = TRUE;
7190             }
7191         }
7192
7193       if (! found)
7194         {
7195           /* Users sometimes forget the -D option, so try to be helpful.  */
7196           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7197             {
7198               if (dynamic_info [dynamic_relocations [i].size])
7199                 {
7200                   printf (_("\nThere are no static relocations in this file."));
7201                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7202
7203                   break;
7204                 }
7205             }
7206           if (i == ARRAY_SIZE (dynamic_relocations))
7207             printf (_("\nThere are no relocations in this file.\n"));
7208         }
7209     }
7210
7211   return TRUE;
7212 }
7213
7214 /* An absolute address consists of a section and an offset.  If the
7215    section is NULL, the offset itself is the address, otherwise, the
7216    address equals to LOAD_ADDRESS(section) + offset.  */
7217
7218 struct absaddr
7219 {
7220   unsigned short section;
7221   bfd_vma offset;
7222 };
7223
7224 #define ABSADDR(a) \
7225   ((a).section \
7226    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7227    : (a).offset)
7228
7229 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7230    name, if found, and the offset from the symbol to ADDR.  */
7231
7232 static void
7233 find_symbol_for_address (Filedata *          filedata,
7234                          Elf_Internal_Sym *  symtab,
7235                          unsigned long       nsyms,
7236                          const char *        strtab,
7237                          unsigned long       strtab_size,
7238                          struct absaddr      addr,
7239                          const char **       symname,
7240                          bfd_vma *           offset)
7241 {
7242   bfd_vma dist = 0x100000;
7243   Elf_Internal_Sym * sym;
7244   Elf_Internal_Sym * beg;
7245   Elf_Internal_Sym * end;
7246   Elf_Internal_Sym * best = NULL;
7247
7248   REMOVE_ARCH_BITS (addr.offset);
7249   beg = symtab;
7250   end = symtab + nsyms;
7251
7252   while (beg < end)
7253     {
7254       bfd_vma value;
7255
7256       sym = beg + (end - beg) / 2;
7257
7258       value = sym->st_value;
7259       REMOVE_ARCH_BITS (value);
7260
7261       if (sym->st_name != 0
7262           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7263           && addr.offset >= value
7264           && addr.offset - value < dist)
7265         {
7266           best = sym;
7267           dist = addr.offset - value;
7268           if (!dist)
7269             break;
7270         }
7271
7272       if (addr.offset < value)
7273         end = sym;
7274       else
7275         beg = sym + 1;
7276     }
7277
7278   if (best)
7279     {
7280       *symname = (best->st_name >= strtab_size
7281                   ? _("<corrupt>") : strtab + best->st_name);
7282       *offset = dist;
7283       return;
7284     }
7285
7286   *symname = NULL;
7287   *offset = addr.offset;
7288 }
7289
7290 static /* signed */ int
7291 symcmp (const void *p, const void *q)
7292 {
7293   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7294   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7295
7296   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7297 }
7298
7299 /* Process the unwind section.  */
7300
7301 #include "unwind-ia64.h"
7302
7303 struct ia64_unw_table_entry
7304 {
7305   struct absaddr start;
7306   struct absaddr end;
7307   struct absaddr info;
7308 };
7309
7310 struct ia64_unw_aux_info
7311 {
7312   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7313   unsigned long                 table_len;      /* Length of unwind table.  */
7314   unsigned char *               info;           /* Unwind info.  */
7315   unsigned long                 info_size;      /* Size of unwind info.  */
7316   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7317   bfd_vma                       seg_base;       /* Starting address of segment.  */
7318   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7319   unsigned long                 nsyms;          /* Number of symbols.  */
7320   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7321   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7322   char *                        strtab;         /* The string table.  */
7323   unsigned long                 strtab_size;    /* Size of string table.  */
7324 };
7325
7326 static bfd_boolean
7327 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7328 {
7329   struct ia64_unw_table_entry * tp;
7330   unsigned long j, nfuns;
7331   int in_body;
7332   bfd_boolean res = TRUE;
7333
7334   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7335   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7336     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7337       aux->funtab[nfuns++] = aux->symtab[j];
7338   aux->nfuns = nfuns;
7339   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7340
7341   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7342     {
7343       bfd_vma stamp;
7344       bfd_vma offset;
7345       const unsigned char * dp;
7346       const unsigned char * head;
7347       const unsigned char * end;
7348       const char * procname;
7349
7350       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7351                                aux->strtab_size, tp->start, &procname, &offset);
7352
7353       fputs ("\n<", stdout);
7354
7355       if (procname)
7356         {
7357           fputs (procname, stdout);
7358
7359           if (offset)
7360             printf ("+%lx", (unsigned long) offset);
7361         }
7362
7363       fputs (">: [", stdout);
7364       print_vma (tp->start.offset, PREFIX_HEX);
7365       fputc ('-', stdout);
7366       print_vma (tp->end.offset, PREFIX_HEX);
7367       printf ("], info at +0x%lx\n",
7368               (unsigned long) (tp->info.offset - aux->seg_base));
7369
7370       /* PR 17531: file: 86232b32.  */
7371       if (aux->info == NULL)
7372         continue;
7373
7374       /* PR 17531: file: 0997b4d1.  */
7375       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7376         {
7377           warn (_("Invalid offset %lx in table entry %ld\n"),
7378                 (long) tp->info.offset, (long) (tp - aux->table));
7379           res = FALSE;
7380           continue;
7381         }
7382
7383       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7384       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7385
7386       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7387               (unsigned) UNW_VER (stamp),
7388               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7389               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7390               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7391               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7392
7393       if (UNW_VER (stamp) != 1)
7394         {
7395           printf (_("\tUnknown version.\n"));
7396           continue;
7397         }
7398
7399       in_body = 0;
7400       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7401       /* PR 17531: file: 16ceda89.  */
7402       if (end > aux->info + aux->info_size)
7403         end = aux->info + aux->info_size;
7404       for (dp = head + 8; dp < end;)
7405         dp = unw_decode (dp, in_body, & in_body, end);
7406     }
7407
7408   free (aux->funtab);
7409
7410   return res;
7411 }
7412
7413 static bfd_boolean
7414 slurp_ia64_unwind_table (Filedata *                  filedata,
7415                          struct ia64_unw_aux_info *  aux,
7416                          Elf_Internal_Shdr *         sec)
7417 {
7418   unsigned long size, nrelas, i;
7419   Elf_Internal_Phdr * seg;
7420   struct ia64_unw_table_entry * tep;
7421   Elf_Internal_Shdr * relsec;
7422   Elf_Internal_Rela * rela;
7423   Elf_Internal_Rela * rp;
7424   unsigned char * table;
7425   unsigned char * tp;
7426   Elf_Internal_Sym * sym;
7427   const char * relname;
7428
7429   aux->table_len = 0;
7430
7431   /* First, find the starting address of the segment that includes
7432      this section: */
7433
7434   if (filedata->file_header.e_phnum)
7435     {
7436       if (! get_program_headers (filedata))
7437           return FALSE;
7438
7439       for (seg = filedata->program_headers;
7440            seg < filedata->program_headers + filedata->file_header.e_phnum;
7441            ++seg)
7442         {
7443           if (seg->p_type != PT_LOAD)
7444             continue;
7445
7446           if (sec->sh_addr >= seg->p_vaddr
7447               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7448             {
7449               aux->seg_base = seg->p_vaddr;
7450               break;
7451             }
7452         }
7453     }
7454
7455   /* Second, build the unwind table from the contents of the unwind section:  */
7456   size = sec->sh_size;
7457   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7458                                       _("unwind table"));
7459   if (!table)
7460     return FALSE;
7461
7462   aux->table_len = size / (3 * eh_addr_size);
7463   aux->table = (struct ia64_unw_table_entry *)
7464     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7465   tep = aux->table;
7466
7467   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7468     {
7469       tep->start.section = SHN_UNDEF;
7470       tep->end.section   = SHN_UNDEF;
7471       tep->info.section  = SHN_UNDEF;
7472       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7473       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7474       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7475       tep->start.offset += aux->seg_base;
7476       tep->end.offset   += aux->seg_base;
7477       tep->info.offset  += aux->seg_base;
7478     }
7479   free (table);
7480
7481   /* Third, apply any relocations to the unwind table:  */
7482   for (relsec = filedata->section_headers;
7483        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7484        ++relsec)
7485     {
7486       if (relsec->sh_type != SHT_RELA
7487           || relsec->sh_info >= filedata->file_header.e_shnum
7488           || filedata->section_headers + relsec->sh_info != sec)
7489         continue;
7490
7491       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7492                               & rela, & nrelas))
7493         {
7494           free (aux->table);
7495           aux->table = NULL;
7496           aux->table_len = 0;
7497           return FALSE;
7498         }
7499
7500       for (rp = rela; rp < rela + nrelas; ++rp)
7501         {
7502           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7503           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7504
7505           /* PR 17531: file: 9fa67536.  */
7506           if (relname == NULL)
7507             {
7508               warn (_("Skipping unknown relocation type: %u\n"),
7509                     get_reloc_type (filedata, rp->r_info));
7510               continue;
7511             }
7512
7513           if (! const_strneq (relname, "R_IA64_SEGREL"))
7514             {
7515               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7516               continue;
7517             }
7518
7519           i = rp->r_offset / (3 * eh_addr_size);
7520
7521           /* PR 17531: file: 5bc8d9bf.  */
7522           if (i >= aux->table_len)
7523             {
7524               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7525               continue;
7526             }
7527
7528           switch (rp->r_offset / eh_addr_size % 3)
7529             {
7530             case 0:
7531               aux->table[i].start.section = sym->st_shndx;
7532               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7533               break;
7534             case 1:
7535               aux->table[i].end.section   = sym->st_shndx;
7536               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7537               break;
7538             case 2:
7539               aux->table[i].info.section  = sym->st_shndx;
7540               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7541               break;
7542             default:
7543               break;
7544             }
7545         }
7546
7547       free (rela);
7548     }
7549
7550   return TRUE;
7551 }
7552
7553 static bfd_boolean
7554 ia64_process_unwind (Filedata * filedata)
7555 {
7556   Elf_Internal_Shdr * sec;
7557   Elf_Internal_Shdr * unwsec = NULL;
7558   Elf_Internal_Shdr * strsec;
7559   unsigned long i, unwcount = 0, unwstart = 0;
7560   struct ia64_unw_aux_info aux;
7561   bfd_boolean res = TRUE;
7562
7563   memset (& aux, 0, sizeof (aux));
7564
7565   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7566     {
7567       if (sec->sh_type == SHT_SYMTAB
7568           && sec->sh_link < filedata->file_header.e_shnum)
7569         {
7570           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7571
7572           strsec = filedata->section_headers + sec->sh_link;
7573           if (aux.strtab != NULL)
7574             {
7575               error (_("Multiple auxillary string tables encountered\n"));
7576               free (aux.strtab);
7577               res = FALSE;
7578             }
7579           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7580                                           1, strsec->sh_size,
7581                                           _("string table"));
7582           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7583         }
7584       else if (sec->sh_type == SHT_IA_64_UNWIND)
7585         unwcount++;
7586     }
7587
7588   if (!unwcount)
7589     printf (_("\nThere are no unwind sections in this file.\n"));
7590
7591   while (unwcount-- > 0)
7592     {
7593       char * suffix;
7594       size_t len, len2;
7595
7596       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7597            i < filedata->file_header.e_shnum; ++i, ++sec)
7598         if (sec->sh_type == SHT_IA_64_UNWIND)
7599           {
7600             unwsec = sec;
7601             break;
7602           }
7603       /* We have already counted the number of SHT_IA64_UNWIND
7604          sections so the loop above should never fail.  */
7605       assert (unwsec != NULL);
7606
7607       unwstart = i + 1;
7608       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7609
7610       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7611         {
7612           /* We need to find which section group it is in.  */
7613           struct group_list * g;
7614
7615           if (section_headers_groups == NULL
7616               || section_headers_groups [i] == NULL)
7617             i = filedata->file_header.e_shnum;
7618           else
7619             {
7620               g = section_headers_groups [i]->root;
7621
7622               for (; g != NULL; g = g->next)
7623                 {
7624                   sec = filedata->section_headers + g->section_index;
7625
7626                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7627                     break;
7628                 }
7629
7630               if (g == NULL)
7631                 i = filedata->file_header.e_shnum;
7632             }
7633         }
7634       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7635         {
7636           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7637           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7638           suffix = SECTION_NAME (unwsec) + len;
7639           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7640                ++i, ++sec)
7641             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7642                 && streq (SECTION_NAME (sec) + len2, suffix))
7643               break;
7644         }
7645       else
7646         {
7647           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7648              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7649           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7650           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7651           suffix = "";
7652           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7653             suffix = SECTION_NAME (unwsec) + len;
7654           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7655                ++i, ++sec)
7656             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7657                 && streq (SECTION_NAME (sec) + len2, suffix))
7658               break;
7659         }
7660
7661       if (i == filedata->file_header.e_shnum)
7662         {
7663           printf (_("\nCould not find unwind info section for "));
7664
7665           if (filedata->string_table == NULL)
7666             printf ("%d", unwsec->sh_name);
7667           else
7668             printf ("'%s'", printable_section_name (filedata, unwsec));
7669         }
7670       else
7671         {
7672           aux.info_addr = sec->sh_addr;
7673           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7674                                                  sec->sh_size,
7675                                                  _("unwind info"));
7676           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7677
7678           printf (_("\nUnwind section "));
7679
7680           if (filedata->string_table == NULL)
7681             printf ("%d", unwsec->sh_name);
7682           else
7683             printf ("'%s'", printable_section_name (filedata, unwsec));
7684
7685           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7686                   (unsigned long) unwsec->sh_offset,
7687                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7688
7689           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7690               && aux.table_len > 0)
7691             dump_ia64_unwind (filedata, & aux);
7692
7693           if (aux.table)
7694             free ((char *) aux.table);
7695           if (aux.info)
7696             free ((char *) aux.info);
7697           aux.table = NULL;
7698           aux.info = NULL;
7699         }
7700     }
7701
7702   if (aux.symtab)
7703     free (aux.symtab);
7704   if (aux.strtab)
7705     free ((char *) aux.strtab);
7706
7707   return res;
7708 }
7709
7710 struct hppa_unw_table_entry
7711 {
7712   struct absaddr start;
7713   struct absaddr end;
7714   unsigned int Cannot_unwind:1;                 /* 0 */
7715   unsigned int Millicode:1;                     /* 1 */
7716   unsigned int Millicode_save_sr0:1;            /* 2 */
7717   unsigned int Region_description:2;            /* 3..4 */
7718   unsigned int reserved1:1;                     /* 5 */
7719   unsigned int Entry_SR:1;                      /* 6 */
7720   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7721   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7722   unsigned int Args_stored:1;                   /* 16 */
7723   unsigned int Variable_Frame:1;                /* 17 */
7724   unsigned int Separate_Package_Body:1;         /* 18 */
7725   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7726   unsigned int Stack_Overflow_Check:1;          /* 20 */
7727   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7728   unsigned int Ada_Region:1;                    /* 22 */
7729   unsigned int cxx_info:1;                      /* 23 */
7730   unsigned int cxx_try_catch:1;                 /* 24 */
7731   unsigned int sched_entry_seq:1;               /* 25 */
7732   unsigned int reserved2:1;                     /* 26 */
7733   unsigned int Save_SP:1;                       /* 27 */
7734   unsigned int Save_RP:1;                       /* 28 */
7735   unsigned int Save_MRP_in_frame:1;             /* 29 */
7736   unsigned int extn_ptr_defined:1;              /* 30 */
7737   unsigned int Cleanup_defined:1;               /* 31 */
7738
7739   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7740   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7741   unsigned int Large_frame:1;                   /* 2 */
7742   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7743   unsigned int reserved4:1;                     /* 4 */
7744   unsigned int Total_frame_size:27;             /* 5..31 */
7745 };
7746
7747 struct hppa_unw_aux_info
7748 {
7749   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7750   unsigned long                  table_len;     /* Length of unwind table.  */
7751   bfd_vma                        seg_base;      /* Starting address of segment.  */
7752   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7753   unsigned long                  nsyms;         /* Number of symbols.  */
7754   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7755   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7756   char *                         strtab;        /* The string table.  */
7757   unsigned long                  strtab_size;   /* Size of string table.  */
7758 };
7759
7760 static bfd_boolean
7761 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7762 {
7763   struct hppa_unw_table_entry * tp;
7764   unsigned long j, nfuns;
7765   bfd_boolean res = TRUE;
7766
7767   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7768   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7769     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7770       aux->funtab[nfuns++] = aux->symtab[j];
7771   aux->nfuns = nfuns;
7772   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7773
7774   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7775     {
7776       bfd_vma offset;
7777       const char * procname;
7778
7779       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7780                                aux->strtab_size, tp->start, &procname,
7781                                &offset);
7782
7783       fputs ("\n<", stdout);
7784
7785       if (procname)
7786         {
7787           fputs (procname, stdout);
7788
7789           if (offset)
7790             printf ("+%lx", (unsigned long) offset);
7791         }
7792
7793       fputs (">: [", stdout);
7794       print_vma (tp->start.offset, PREFIX_HEX);
7795       fputc ('-', stdout);
7796       print_vma (tp->end.offset, PREFIX_HEX);
7797       printf ("]\n\t");
7798
7799 #define PF(_m) if (tp->_m) printf (#_m " ");
7800 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7801       PF(Cannot_unwind);
7802       PF(Millicode);
7803       PF(Millicode_save_sr0);
7804       /* PV(Region_description);  */
7805       PF(Entry_SR);
7806       PV(Entry_FR);
7807       PV(Entry_GR);
7808       PF(Args_stored);
7809       PF(Variable_Frame);
7810       PF(Separate_Package_Body);
7811       PF(Frame_Extension_Millicode);
7812       PF(Stack_Overflow_Check);
7813       PF(Two_Instruction_SP_Increment);
7814       PF(Ada_Region);
7815       PF(cxx_info);
7816       PF(cxx_try_catch);
7817       PF(sched_entry_seq);
7818       PF(Save_SP);
7819       PF(Save_RP);
7820       PF(Save_MRP_in_frame);
7821       PF(extn_ptr_defined);
7822       PF(Cleanup_defined);
7823       PF(MPE_XL_interrupt_marker);
7824       PF(HP_UX_interrupt_marker);
7825       PF(Large_frame);
7826       PF(Pseudo_SP_Set);
7827       PV(Total_frame_size);
7828 #undef PF
7829 #undef PV
7830     }
7831
7832   printf ("\n");
7833
7834   free (aux->funtab);
7835
7836   return res;
7837 }
7838
7839 static bfd_boolean
7840 slurp_hppa_unwind_table (Filedata *                  filedata,
7841                          struct hppa_unw_aux_info *  aux,
7842                          Elf_Internal_Shdr *         sec)
7843 {
7844   unsigned long size, unw_ent_size, nentries, nrelas, i;
7845   Elf_Internal_Phdr * seg;
7846   struct hppa_unw_table_entry * tep;
7847   Elf_Internal_Shdr * relsec;
7848   Elf_Internal_Rela * rela;
7849   Elf_Internal_Rela * rp;
7850   unsigned char * table;
7851   unsigned char * tp;
7852   Elf_Internal_Sym * sym;
7853   const char * relname;
7854
7855   /* First, find the starting address of the segment that includes
7856      this section.  */
7857   if (filedata->file_header.e_phnum)
7858     {
7859       if (! get_program_headers (filedata))
7860         return FALSE;
7861
7862       for (seg = filedata->program_headers;
7863            seg < filedata->program_headers + filedata->file_header.e_phnum;
7864            ++seg)
7865         {
7866           if (seg->p_type != PT_LOAD)
7867             continue;
7868
7869           if (sec->sh_addr >= seg->p_vaddr
7870               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7871             {
7872               aux->seg_base = seg->p_vaddr;
7873               break;
7874             }
7875         }
7876     }
7877
7878   /* Second, build the unwind table from the contents of the unwind
7879      section.  */
7880   size = sec->sh_size;
7881   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7882                                       _("unwind table"));
7883   if (!table)
7884     return FALSE;
7885
7886   unw_ent_size = 16;
7887   nentries = size / unw_ent_size;
7888   size = unw_ent_size * nentries;
7889
7890   tep = aux->table = (struct hppa_unw_table_entry *)
7891       xcmalloc (nentries, sizeof (aux->table[0]));
7892
7893   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7894     {
7895       unsigned int tmp1, tmp2;
7896
7897       tep->start.section = SHN_UNDEF;
7898       tep->end.section   = SHN_UNDEF;
7899
7900       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7901       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7902       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7903       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7904
7905       tep->start.offset += aux->seg_base;
7906       tep->end.offset   += aux->seg_base;
7907
7908       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7909       tep->Millicode = (tmp1 >> 30) & 0x1;
7910       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7911       tep->Region_description = (tmp1 >> 27) & 0x3;
7912       tep->reserved1 = (tmp1 >> 26) & 0x1;
7913       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7914       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7915       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7916       tep->Args_stored = (tmp1 >> 15) & 0x1;
7917       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7918       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7919       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7920       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7921       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7922       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7923       tep->cxx_info = (tmp1 >> 8) & 0x1;
7924       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7925       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7926       tep->reserved2 = (tmp1 >> 5) & 0x1;
7927       tep->Save_SP = (tmp1 >> 4) & 0x1;
7928       tep->Save_RP = (tmp1 >> 3) & 0x1;
7929       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7930       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7931       tep->Cleanup_defined = tmp1 & 0x1;
7932
7933       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7934       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7935       tep->Large_frame = (tmp2 >> 29) & 0x1;
7936       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7937       tep->reserved4 = (tmp2 >> 27) & 0x1;
7938       tep->Total_frame_size = tmp2 & 0x7ffffff;
7939     }
7940   free (table);
7941
7942   /* Third, apply any relocations to the unwind table.  */
7943   for (relsec = filedata->section_headers;
7944        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7945        ++relsec)
7946     {
7947       if (relsec->sh_type != SHT_RELA
7948           || relsec->sh_info >= filedata->file_header.e_shnum
7949           || filedata->section_headers + relsec->sh_info != sec)
7950         continue;
7951
7952       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7953                               & rela, & nrelas))
7954         return FALSE;
7955
7956       for (rp = rela; rp < rela + nrelas; ++rp)
7957         {
7958           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
7959           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7960
7961           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7962           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7963             {
7964               warn (_("Skipping unexpected relocation type %s\n"), relname);
7965               continue;
7966             }
7967
7968           i = rp->r_offset / unw_ent_size;
7969
7970           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7971             {
7972             case 0:
7973               aux->table[i].start.section = sym->st_shndx;
7974               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7975               break;
7976             case 1:
7977               aux->table[i].end.section   = sym->st_shndx;
7978               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7979               break;
7980             default:
7981               break;
7982             }
7983         }
7984
7985       free (rela);
7986     }
7987
7988   aux->table_len = nentries;
7989
7990   return TRUE;
7991 }
7992
7993 static bfd_boolean
7994 hppa_process_unwind (Filedata * filedata)
7995 {
7996   struct hppa_unw_aux_info aux;
7997   Elf_Internal_Shdr * unwsec = NULL;
7998   Elf_Internal_Shdr * strsec;
7999   Elf_Internal_Shdr * sec;
8000   unsigned long i;
8001   bfd_boolean res = TRUE;
8002
8003   if (filedata->string_table == NULL)
8004     return FALSE;
8005
8006   memset (& aux, 0, sizeof (aux));
8007
8008   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8009     {
8010       if (sec->sh_type == SHT_SYMTAB
8011           && sec->sh_link < filedata->file_header.e_shnum)
8012         {
8013           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8014
8015           strsec = filedata->section_headers + sec->sh_link;
8016           if (aux.strtab != NULL)
8017             {
8018               error (_("Multiple auxillary string tables encountered\n"));
8019               free (aux.strtab);
8020               res = FALSE;
8021             }
8022           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8023                                           1, strsec->sh_size,
8024                                           _("string table"));
8025           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8026         }
8027       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8028         unwsec = sec;
8029     }
8030
8031   if (!unwsec)
8032     printf (_("\nThere are no unwind sections in this file.\n"));
8033
8034   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8035     {
8036       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8037         {
8038           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8039
8040           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8041                             "contains %lu entry:\n",
8042                             "\nUnwind section '%s' at offset 0x%lx "
8043                             "contains %lu entries:\n",
8044                             num_unwind),
8045                   printable_section_name (filedata, sec),
8046                   (unsigned long) sec->sh_offset,
8047                   num_unwind);
8048
8049           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8050             res = FALSE;
8051
8052           if (aux.table_len > 0)
8053             {
8054               if (! dump_hppa_unwind (filedata, &aux))
8055                 res = FALSE;
8056             }
8057
8058           if (aux.table)
8059             free ((char *) aux.table);
8060           aux.table = NULL;
8061         }
8062     }
8063
8064   if (aux.symtab)
8065     free (aux.symtab);
8066   if (aux.strtab)
8067     free ((char *) aux.strtab);
8068
8069   return res;
8070 }
8071
8072 struct arm_section
8073 {
8074   unsigned char *      data;            /* The unwind data.  */
8075   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8076   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8077   unsigned long        nrelas;          /* The number of relocations.  */
8078   unsigned int         rel_type;        /* REL or RELA ?  */
8079   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8080 };
8081
8082 struct arm_unw_aux_info
8083 {
8084   Filedata *          filedata;         /* The file containing the unwind sections.  */
8085   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8086   unsigned long       nsyms;            /* Number of symbols.  */
8087   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8088   unsigned long       nfuns;            /* Number of these symbols.  */
8089   char *              strtab;           /* The file's string table.  */
8090   unsigned long       strtab_size;      /* Size of string table.  */
8091 };
8092
8093 static const char *
8094 arm_print_vma_and_name (Filedata *                 filedata,
8095                         struct arm_unw_aux_info *  aux,
8096                         bfd_vma                    fn,
8097                         struct absaddr             addr)
8098 {
8099   const char *procname;
8100   bfd_vma sym_offset;
8101
8102   if (addr.section == SHN_UNDEF)
8103     addr.offset = fn;
8104
8105   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8106                            aux->strtab_size, addr, &procname,
8107                            &sym_offset);
8108
8109   print_vma (fn, PREFIX_HEX);
8110
8111   if (procname)
8112     {
8113       fputs (" <", stdout);
8114       fputs (procname, stdout);
8115
8116       if (sym_offset)
8117         printf ("+0x%lx", (unsigned long) sym_offset);
8118       fputc ('>', stdout);
8119     }
8120
8121   return procname;
8122 }
8123
8124 static void
8125 arm_free_section (struct arm_section *arm_sec)
8126 {
8127   if (arm_sec->data != NULL)
8128     free (arm_sec->data);
8129
8130   if (arm_sec->rela != NULL)
8131     free (arm_sec->rela);
8132 }
8133
8134 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8135       cached section and install SEC instead.
8136    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8137       and return its valued in * WORDP, relocating if necessary.
8138    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8139       relocation's offset in ADDR.
8140    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8141       into the string table of the symbol associated with the reloc.  If no
8142       reloc was applied store -1 there.
8143    5) Return TRUE upon success, FALSE otherwise.  */
8144
8145 static bfd_boolean
8146 get_unwind_section_word (Filedata *                 filedata,
8147                          struct arm_unw_aux_info *  aux,
8148                          struct arm_section *       arm_sec,
8149                          Elf_Internal_Shdr *        sec,
8150                          bfd_vma                    word_offset,
8151                          unsigned int *             wordp,
8152                          struct absaddr *           addr,
8153                          bfd_vma *                  sym_name)
8154 {
8155   Elf_Internal_Rela *rp;
8156   Elf_Internal_Sym *sym;
8157   const char * relname;
8158   unsigned int word;
8159   bfd_boolean wrapped;
8160
8161   if (sec == NULL || arm_sec == NULL)
8162     return FALSE;
8163
8164   addr->section = SHN_UNDEF;
8165   addr->offset = 0;
8166
8167   if (sym_name != NULL)
8168     *sym_name = (bfd_vma) -1;
8169
8170   /* If necessary, update the section cache.  */
8171   if (sec != arm_sec->sec)
8172     {
8173       Elf_Internal_Shdr *relsec;
8174
8175       arm_free_section (arm_sec);
8176
8177       arm_sec->sec = sec;
8178       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8179                                 sec->sh_size, _("unwind data"));
8180       arm_sec->rela = NULL;
8181       arm_sec->nrelas = 0;
8182
8183       for (relsec = filedata->section_headers;
8184            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8185            ++relsec)
8186         {
8187           if (relsec->sh_info >= filedata->file_header.e_shnum
8188               || filedata->section_headers + relsec->sh_info != sec
8189               /* PR 15745: Check the section type as well.  */
8190               || (relsec->sh_type != SHT_REL
8191                   && relsec->sh_type != SHT_RELA))
8192             continue;
8193
8194           arm_sec->rel_type = relsec->sh_type;
8195           if (relsec->sh_type == SHT_REL)
8196             {
8197               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8198                                      relsec->sh_size,
8199                                      & arm_sec->rela, & arm_sec->nrelas))
8200                 return FALSE;
8201             }
8202           else /* relsec->sh_type == SHT_RELA */
8203             {
8204               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8205                                       relsec->sh_size,
8206                                       & arm_sec->rela, & arm_sec->nrelas))
8207                 return FALSE;
8208             }
8209           break;
8210         }
8211
8212       arm_sec->next_rela = arm_sec->rela;
8213     }
8214
8215   /* If there is no unwind data we can do nothing.  */
8216   if (arm_sec->data == NULL)
8217     return FALSE;
8218
8219   /* If the offset is invalid then fail.  */
8220   if (/* PR 21343 *//* PR 18879 */
8221       sec->sh_size < 4
8222       || word_offset > (sec->sh_size - 4)
8223       || ((bfd_signed_vma) word_offset) < 0)
8224     return FALSE;
8225
8226   /* Get the word at the required offset.  */
8227   word = byte_get (arm_sec->data + word_offset, 4);
8228
8229   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8230   if (arm_sec->rela == NULL)
8231     {
8232       * wordp = word;
8233       return TRUE;
8234     }
8235
8236   /* Look through the relocs to find the one that applies to the provided offset.  */
8237   wrapped = FALSE;
8238   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8239     {
8240       bfd_vma prelval, offset;
8241
8242       if (rp->r_offset > word_offset && !wrapped)
8243         {
8244           rp = arm_sec->rela;
8245           wrapped = TRUE;
8246         }
8247       if (rp->r_offset > word_offset)
8248         break;
8249
8250       if (rp->r_offset & 3)
8251         {
8252           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8253                 (unsigned long) rp->r_offset);
8254           continue;
8255         }
8256
8257       if (rp->r_offset < word_offset)
8258         continue;
8259
8260       /* PR 17531: file: 027-161405-0.004  */
8261       if (aux->symtab == NULL)
8262         continue;
8263
8264       if (arm_sec->rel_type == SHT_REL)
8265         {
8266           offset = word & 0x7fffffff;
8267           if (offset & 0x40000000)
8268             offset |= ~ (bfd_vma) 0x7fffffff;
8269         }
8270       else if (arm_sec->rel_type == SHT_RELA)
8271         offset = rp->r_addend;
8272       else
8273         {
8274           error (_("Unknown section relocation type %d encountered\n"),
8275                  arm_sec->rel_type);
8276           break;
8277         }
8278
8279       /* PR 17531 file: 027-1241568-0.004.  */
8280       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8281         {
8282           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8283                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8284           break;
8285         }
8286
8287       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8288       offset += sym->st_value;
8289       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8290
8291       /* Check that we are processing the expected reloc type.  */
8292       if (filedata->file_header.e_machine == EM_ARM)
8293         {
8294           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8295           if (relname == NULL)
8296             {
8297               warn (_("Skipping unknown ARM relocation type: %d\n"),
8298                     (int) ELF32_R_TYPE (rp->r_info));
8299               continue;
8300             }
8301
8302           if (streq (relname, "R_ARM_NONE"))
8303               continue;
8304
8305           if (! streq (relname, "R_ARM_PREL31"))
8306             {
8307               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8308               continue;
8309             }
8310         }
8311       else if (filedata->file_header.e_machine == EM_TI_C6000)
8312         {
8313           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8314           if (relname == NULL)
8315             {
8316               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8317                     (int) ELF32_R_TYPE (rp->r_info));
8318               continue;
8319             }
8320
8321           if (streq (relname, "R_C6000_NONE"))
8322             continue;
8323
8324           if (! streq (relname, "R_C6000_PREL31"))
8325             {
8326               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8327               continue;
8328             }
8329
8330           prelval >>= 1;
8331         }
8332       else
8333         {
8334           /* This function currently only supports ARM and TI unwinders.  */
8335           warn (_("Only TI and ARM unwinders are currently supported\n"));
8336           break;
8337         }
8338
8339       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8340       addr->section = sym->st_shndx;
8341       addr->offset = offset;
8342
8343       if (sym_name)
8344         * sym_name = sym->st_name;
8345       break;
8346     }
8347
8348   *wordp = word;
8349   arm_sec->next_rela = rp;
8350
8351   return TRUE;
8352 }
8353
8354 static const char *tic6x_unwind_regnames[16] =
8355 {
8356   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8357   "A14", "A13", "A12", "A11", "A10",
8358   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8359 };
8360
8361 static void
8362 decode_tic6x_unwind_regmask (unsigned int mask)
8363 {
8364   int i;
8365
8366   for (i = 12; mask; mask >>= 1, i--)
8367     {
8368       if (mask & 1)
8369         {
8370           fputs (tic6x_unwind_regnames[i], stdout);
8371           if (mask > 1)
8372             fputs (", ", stdout);
8373         }
8374     }
8375 }
8376
8377 #define ADVANCE                                                 \
8378   if (remaining == 0 && more_words)                             \
8379     {                                                           \
8380       data_offset += 4;                                         \
8381       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8382                                      data_offset, & word, & addr, NULL))        \
8383         return FALSE;                                           \
8384       remaining = 4;                                            \
8385       more_words--;                                             \
8386     }                                                           \
8387
8388 #define GET_OP(OP)                      \
8389   ADVANCE;                              \
8390   if (remaining)                        \
8391     {                                   \
8392       remaining--;                      \
8393       (OP) = word >> 24;                \
8394       word <<= 8;                       \
8395     }                                   \
8396   else                                  \
8397     {                                   \
8398       printf (_("[Truncated opcode]\n"));       \
8399       return FALSE;                     \
8400     }                                   \
8401   printf ("0x%02x ", OP)
8402
8403 static bfd_boolean
8404 decode_arm_unwind_bytecode (Filedata *                 filedata,
8405                             struct arm_unw_aux_info *  aux,
8406                             unsigned int               word,
8407                             unsigned int               remaining,
8408                             unsigned int               more_words,
8409                             bfd_vma                    data_offset,
8410                             Elf_Internal_Shdr *        data_sec,
8411                             struct arm_section *       data_arm_sec)
8412 {
8413   struct absaddr addr;
8414   bfd_boolean res = TRUE;
8415
8416   /* Decode the unwinding instructions.  */
8417   while (1)
8418     {
8419       unsigned int op, op2;
8420
8421       ADVANCE;
8422       if (remaining == 0)
8423         break;
8424       remaining--;
8425       op = word >> 24;
8426       word <<= 8;
8427
8428       printf ("  0x%02x ", op);
8429
8430       if ((op & 0xc0) == 0x00)
8431         {
8432           int offset = ((op & 0x3f) << 2) + 4;
8433
8434           printf ("     vsp = vsp + %d", offset);
8435         }
8436       else if ((op & 0xc0) == 0x40)
8437         {
8438           int offset = ((op & 0x3f) << 2) + 4;
8439
8440           printf ("     vsp = vsp - %d", offset);
8441         }
8442       else if ((op & 0xf0) == 0x80)
8443         {
8444           GET_OP (op2);
8445           if (op == 0x80 && op2 == 0)
8446             printf (_("Refuse to unwind"));
8447           else
8448             {
8449               unsigned int mask = ((op & 0x0f) << 8) | op2;
8450               bfd_boolean first = TRUE;
8451               int i;
8452
8453               printf ("pop {");
8454               for (i = 0; i < 12; i++)
8455                 if (mask & (1 << i))
8456                   {
8457                     if (first)
8458                       first = FALSE;
8459                     else
8460                       printf (", ");
8461                     printf ("r%d", 4 + i);
8462                   }
8463               printf ("}");
8464             }
8465         }
8466       else if ((op & 0xf0) == 0x90)
8467         {
8468           if (op == 0x9d || op == 0x9f)
8469             printf (_("     [Reserved]"));
8470           else
8471             printf ("     vsp = r%d", op & 0x0f);
8472         }
8473       else if ((op & 0xf0) == 0xa0)
8474         {
8475           int end = 4 + (op & 0x07);
8476           bfd_boolean first = TRUE;
8477           int i;
8478
8479           printf ("     pop {");
8480           for (i = 4; i <= end; i++)
8481             {
8482               if (first)
8483                 first = FALSE;
8484               else
8485                 printf (", ");
8486               printf ("r%d", i);
8487             }
8488           if (op & 0x08)
8489             {
8490               if (!first)
8491                 printf (", ");
8492               printf ("r14");
8493             }
8494           printf ("}");
8495         }
8496       else if (op == 0xb0)
8497         printf (_("     finish"));
8498       else if (op == 0xb1)
8499         {
8500           GET_OP (op2);
8501           if (op2 == 0 || (op2 & 0xf0) != 0)
8502             printf (_("[Spare]"));
8503           else
8504             {
8505               unsigned int mask = op2 & 0x0f;
8506               bfd_boolean first = TRUE;
8507               int i;
8508
8509               printf ("pop {");
8510               for (i = 0; i < 12; i++)
8511                 if (mask & (1 << i))
8512                   {
8513                     if (first)
8514                       first = FALSE;
8515                     else
8516                       printf (", ");
8517                     printf ("r%d", i);
8518                   }
8519               printf ("}");
8520             }
8521         }
8522       else if (op == 0xb2)
8523         {
8524           unsigned char buf[9];
8525           unsigned int i, len;
8526           unsigned long offset;
8527
8528           for (i = 0; i < sizeof (buf); i++)
8529             {
8530               GET_OP (buf[i]);
8531               if ((buf[i] & 0x80) == 0)
8532                 break;
8533             }
8534           if (i == sizeof (buf))
8535             {
8536               error (_("corrupt change to vsp"));
8537               res = FALSE;
8538             }
8539           else
8540             {
8541               offset = read_uleb128 (buf, &len, buf + i + 1);
8542               assert (len == i + 1);
8543               offset = offset * 4 + 0x204;
8544               printf ("vsp = vsp + %ld", offset);
8545             }
8546         }
8547       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8548         {
8549           unsigned int first, last;
8550
8551           GET_OP (op2);
8552           first = op2 >> 4;
8553           last = op2 & 0x0f;
8554           if (op == 0xc8)
8555             first = first + 16;
8556           printf ("pop {D%d", first);
8557           if (last)
8558             printf ("-D%d", first + last);
8559           printf ("}");
8560         }
8561       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8562         {
8563           unsigned int count = op & 0x07;
8564
8565           printf ("pop {D8");
8566           if (count)
8567             printf ("-D%d", 8 + count);
8568           printf ("}");
8569         }
8570       else if (op >= 0xc0 && op <= 0xc5)
8571         {
8572           unsigned int count = op & 0x07;
8573
8574           printf ("     pop {wR10");
8575           if (count)
8576             printf ("-wR%d", 10 + count);
8577           printf ("}");
8578         }
8579       else if (op == 0xc6)
8580         {
8581           unsigned int first, last;
8582
8583           GET_OP (op2);
8584           first = op2 >> 4;
8585           last = op2 & 0x0f;
8586           printf ("pop {wR%d", first);
8587           if (last)
8588             printf ("-wR%d", first + last);
8589           printf ("}");
8590         }
8591       else if (op == 0xc7)
8592         {
8593           GET_OP (op2);
8594           if (op2 == 0 || (op2 & 0xf0) != 0)
8595             printf (_("[Spare]"));
8596           else
8597             {
8598               unsigned int mask = op2 & 0x0f;
8599               bfd_boolean first = TRUE;
8600               int i;
8601
8602               printf ("pop {");
8603               for (i = 0; i < 4; i++)
8604                 if (mask & (1 << i))
8605                   {
8606                     if (first)
8607                       first = FALSE;
8608                     else
8609                       printf (", ");
8610                     printf ("wCGR%d", i);
8611                   }
8612               printf ("}");
8613             }
8614         }
8615       else
8616         {
8617           printf (_("     [unsupported opcode]"));
8618           res = FALSE;
8619         }
8620
8621       printf ("\n");
8622     }
8623
8624   return res;
8625 }
8626
8627 static bfd_boolean
8628 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8629                               struct arm_unw_aux_info *  aux,
8630                               unsigned int               word,
8631                               unsigned int               remaining,
8632                               unsigned int               more_words,
8633                               bfd_vma                    data_offset,
8634                               Elf_Internal_Shdr *        data_sec,
8635                               struct arm_section *       data_arm_sec)
8636 {
8637   struct absaddr addr;
8638
8639   /* Decode the unwinding instructions.  */
8640   while (1)
8641     {
8642       unsigned int op, op2;
8643
8644       ADVANCE;
8645       if (remaining == 0)
8646         break;
8647       remaining--;
8648       op = word >> 24;
8649       word <<= 8;
8650
8651       printf ("  0x%02x ", op);
8652
8653       if ((op & 0xc0) == 0x00)
8654         {
8655           int offset = ((op & 0x3f) << 3) + 8;
8656           printf ("     sp = sp + %d", offset);
8657         }
8658       else if ((op & 0xc0) == 0x80)
8659         {
8660           GET_OP (op2);
8661           if (op == 0x80 && op2 == 0)
8662             printf (_("Refuse to unwind"));
8663           else
8664             {
8665               unsigned int mask = ((op & 0x1f) << 8) | op2;
8666               if (op & 0x20)
8667                 printf ("pop compact {");
8668               else
8669                 printf ("pop {");
8670
8671               decode_tic6x_unwind_regmask (mask);
8672               printf("}");
8673             }
8674         }
8675       else if ((op & 0xf0) == 0xc0)
8676         {
8677           unsigned int reg;
8678           unsigned int nregs;
8679           unsigned int i;
8680           const char *name;
8681           struct
8682           {
8683             unsigned int offset;
8684             unsigned int reg;
8685           } regpos[16];
8686
8687           /* Scan entire instruction first so that GET_OP output is not
8688              interleaved with disassembly.  */
8689           nregs = 0;
8690           for (i = 0; nregs < (op & 0xf); i++)
8691             {
8692               GET_OP (op2);
8693               reg = op2 >> 4;
8694               if (reg != 0xf)
8695                 {
8696                   regpos[nregs].offset = i * 2;
8697                   regpos[nregs].reg = reg;
8698                   nregs++;
8699                 }
8700
8701               reg = op2 & 0xf;
8702               if (reg != 0xf)
8703                 {
8704                   regpos[nregs].offset = i * 2 + 1;
8705                   regpos[nregs].reg = reg;
8706                   nregs++;
8707                 }
8708             }
8709
8710           printf (_("pop frame {"));
8711           reg = nregs - 1;
8712           for (i = i * 2; i > 0; i--)
8713             {
8714               if (regpos[reg].offset == i - 1)
8715                 {
8716                   name = tic6x_unwind_regnames[regpos[reg].reg];
8717                   if (reg > 0)
8718                     reg--;
8719                 }
8720               else
8721                 name = _("[pad]");
8722
8723               fputs (name, stdout);
8724               if (i > 1)
8725                 printf (", ");
8726             }
8727
8728           printf ("}");
8729         }
8730       else if (op == 0xd0)
8731         printf ("     MOV FP, SP");
8732       else if (op == 0xd1)
8733         printf ("     __c6xabi_pop_rts");
8734       else if (op == 0xd2)
8735         {
8736           unsigned char buf[9];
8737           unsigned int i, len;
8738           unsigned long offset;
8739
8740           for (i = 0; i < sizeof (buf); i++)
8741             {
8742               GET_OP (buf[i]);
8743               if ((buf[i] & 0x80) == 0)
8744                 break;
8745             }
8746           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8747           if (i == sizeof (buf))
8748             {
8749               warn (_("Corrupt stack pointer adjustment detected\n"));
8750               return FALSE;
8751             }
8752
8753           offset = read_uleb128 (buf, &len, buf + i + 1);
8754           assert (len == i + 1);
8755           offset = offset * 8 + 0x408;
8756           printf (_("sp = sp + %ld"), offset);
8757         }
8758       else if ((op & 0xf0) == 0xe0)
8759         {
8760           if ((op & 0x0f) == 7)
8761             printf ("     RETURN");
8762           else
8763             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8764         }
8765       else
8766         {
8767           printf (_("     [unsupported opcode]"));
8768         }
8769       putchar ('\n');
8770     }
8771
8772   return TRUE;
8773 }
8774
8775 static bfd_vma
8776 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8777 {
8778   bfd_vma offset;
8779
8780   offset = word & 0x7fffffff;
8781   if (offset & 0x40000000)
8782     offset |= ~ (bfd_vma) 0x7fffffff;
8783
8784   if (filedata->file_header.e_machine == EM_TI_C6000)
8785     offset <<= 1;
8786
8787   return offset + where;
8788 }
8789
8790 static bfd_boolean
8791 decode_arm_unwind (Filedata *                 filedata,
8792                    struct arm_unw_aux_info *  aux,
8793                    unsigned int               word,
8794                    unsigned int               remaining,
8795                    bfd_vma                    data_offset,
8796                    Elf_Internal_Shdr *        data_sec,
8797                    struct arm_section *       data_arm_sec)
8798 {
8799   int per_index;
8800   unsigned int more_words = 0;
8801   struct absaddr addr;
8802   bfd_vma sym_name = (bfd_vma) -1;
8803   bfd_boolean res = TRUE;
8804
8805   if (remaining == 0)
8806     {
8807       /* Fetch the first word.
8808          Note - when decoding an object file the address extracted
8809          here will always be 0.  So we also pass in the sym_name
8810          parameter so that we can find the symbol associated with
8811          the personality routine.  */
8812       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8813                                      & word, & addr, & sym_name))
8814         return FALSE;
8815
8816       remaining = 4;
8817     }
8818
8819   if ((word & 0x80000000) == 0)
8820     {
8821       /* Expand prel31 for personality routine.  */
8822       bfd_vma fn;
8823       const char *procname;
8824
8825       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8826       printf (_("  Personality routine: "));
8827       if (fn == 0
8828           && addr.section == SHN_UNDEF && addr.offset == 0
8829           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8830         {
8831           procname = aux->strtab + sym_name;
8832           print_vma (fn, PREFIX_HEX);
8833           if (procname)
8834             {
8835               fputs (" <", stdout);
8836               fputs (procname, stdout);
8837               fputc ('>', stdout);
8838             }
8839         }
8840       else
8841         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8842       fputc ('\n', stdout);
8843
8844       /* The GCC personality routines use the standard compact
8845          encoding, starting with one byte giving the number of
8846          words.  */
8847       if (procname != NULL
8848           && (const_strneq (procname, "__gcc_personality_v0")
8849               || const_strneq (procname, "__gxx_personality_v0")
8850               || const_strneq (procname, "__gcj_personality_v0")
8851               || const_strneq (procname, "__gnu_objc_personality_v0")))
8852         {
8853           remaining = 0;
8854           more_words = 1;
8855           ADVANCE;
8856           if (!remaining)
8857             {
8858               printf (_("  [Truncated data]\n"));
8859               return FALSE;
8860             }
8861           more_words = word >> 24;
8862           word <<= 8;
8863           remaining--;
8864           per_index = -1;
8865         }
8866       else
8867         return TRUE;
8868     }
8869   else
8870     {
8871       /* ARM EHABI Section 6.3:
8872
8873          An exception-handling table entry for the compact model looks like:
8874
8875            31 30-28 27-24 23-0
8876            -- ----- ----- ----
8877             1   0   index Data for personalityRoutine[index]    */
8878
8879       if (filedata->file_header.e_machine == EM_ARM
8880           && (word & 0x70000000))
8881         {
8882           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8883           res = FALSE;
8884         }
8885
8886       per_index = (word >> 24) & 0x7f;
8887       printf (_("  Compact model index: %d\n"), per_index);
8888       if (per_index == 0)
8889         {
8890           more_words = 0;
8891           word <<= 8;
8892           remaining--;
8893         }
8894       else if (per_index < 3)
8895         {
8896           more_words = (word >> 16) & 0xff;
8897           word <<= 16;
8898           remaining -= 2;
8899         }
8900     }
8901
8902   switch (filedata->file_header.e_machine)
8903     {
8904     case EM_ARM:
8905       if (per_index < 3)
8906         {
8907           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8908                                             data_offset, data_sec, data_arm_sec))
8909             res = FALSE;
8910         }
8911       else
8912         {
8913           warn (_("Unknown ARM compact model index encountered\n"));
8914           printf (_("  [reserved]\n"));
8915           res = FALSE;
8916         }
8917       break;
8918
8919     case EM_TI_C6000:
8920       if (per_index < 3)
8921         {
8922           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8923                                               data_offset, data_sec, data_arm_sec))
8924             res = FALSE;
8925         }
8926       else if (per_index < 5)
8927         {
8928           if (((word >> 17) & 0x7f) == 0x7f)
8929             printf (_("  Restore stack from frame pointer\n"));
8930           else
8931             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8932           printf (_("  Registers restored: "));
8933           if (per_index == 4)
8934             printf (" (compact) ");
8935           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8936           putchar ('\n');
8937           printf (_("  Return register: %s\n"),
8938                   tic6x_unwind_regnames[word & 0xf]);
8939         }
8940       else
8941         printf (_("  [reserved (%d)]\n"), per_index);
8942       break;
8943
8944     default:
8945       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8946              filedata->file_header.e_machine);
8947       res = FALSE;
8948     }
8949
8950   /* Decode the descriptors.  Not implemented.  */
8951
8952   return res;
8953 }
8954
8955 static bfd_boolean
8956 dump_arm_unwind (Filedata *                 filedata,
8957                  struct arm_unw_aux_info *  aux,
8958                  Elf_Internal_Shdr *        exidx_sec)
8959 {
8960   struct arm_section exidx_arm_sec, extab_arm_sec;
8961   unsigned int i, exidx_len;
8962   unsigned long j, nfuns;
8963   bfd_boolean res = TRUE;
8964
8965   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8966   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8967   exidx_len = exidx_sec->sh_size / 8;
8968
8969   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8970   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8971     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8972       aux->funtab[nfuns++] = aux->symtab[j];
8973   aux->nfuns = nfuns;
8974   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8975
8976   for (i = 0; i < exidx_len; i++)
8977     {
8978       unsigned int exidx_fn, exidx_entry;
8979       struct absaddr fn_addr, entry_addr;
8980       bfd_vma fn;
8981
8982       fputc ('\n', stdout);
8983
8984       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8985                                      8 * i, & exidx_fn, & fn_addr, NULL)
8986           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8987                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8988         {
8989           free (aux->funtab);
8990           arm_free_section (& exidx_arm_sec);
8991           arm_free_section (& extab_arm_sec);
8992           return FALSE;
8993         }
8994
8995       /* ARM EHABI, Section 5:
8996          An index table entry consists of 2 words.
8997          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8998       if (exidx_fn & 0x80000000)
8999         {
9000           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9001           res = FALSE;
9002         }
9003
9004       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9005
9006       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9007       fputs (": ", stdout);
9008
9009       if (exidx_entry == 1)
9010         {
9011           print_vma (exidx_entry, PREFIX_HEX);
9012           fputs (" [cantunwind]\n", stdout);
9013         }
9014       else if (exidx_entry & 0x80000000)
9015         {
9016           print_vma (exidx_entry, PREFIX_HEX);
9017           fputc ('\n', stdout);
9018           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9019         }
9020       else
9021         {
9022           bfd_vma table, table_offset = 0;
9023           Elf_Internal_Shdr *table_sec;
9024
9025           fputs ("@", stdout);
9026           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9027           print_vma (table, PREFIX_HEX);
9028           printf ("\n");
9029
9030           /* Locate the matching .ARM.extab.  */
9031           if (entry_addr.section != SHN_UNDEF
9032               && entry_addr.section < filedata->file_header.e_shnum)
9033             {
9034               table_sec = filedata->section_headers + entry_addr.section;
9035               table_offset = entry_addr.offset;
9036               /* PR 18879 */
9037               if (table_offset > table_sec->sh_size
9038                   || ((bfd_signed_vma) table_offset) < 0)
9039                 {
9040                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9041                         (unsigned long) table_offset,
9042                         printable_section_name (filedata, table_sec));
9043                   res = FALSE;
9044                   continue;
9045                 }
9046             }
9047           else
9048             {
9049               table_sec = find_section_by_address (filedata, table);
9050               if (table_sec != NULL)
9051                 table_offset = table - table_sec->sh_addr;
9052             }
9053
9054           if (table_sec == NULL)
9055             {
9056               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9057                     (unsigned long) table);
9058               res = FALSE;
9059               continue;
9060             }
9061
9062           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9063                                    &extab_arm_sec))
9064             res = FALSE;
9065         }
9066     }
9067
9068   printf ("\n");
9069
9070   free (aux->funtab);
9071   arm_free_section (&exidx_arm_sec);
9072   arm_free_section (&extab_arm_sec);
9073
9074   return res;
9075 }
9076
9077 /* Used for both ARM and C6X unwinding tables.  */
9078
9079 static bfd_boolean
9080 arm_process_unwind (Filedata * filedata)
9081 {
9082   struct arm_unw_aux_info aux;
9083   Elf_Internal_Shdr *unwsec = NULL;
9084   Elf_Internal_Shdr *strsec;
9085   Elf_Internal_Shdr *sec;
9086   unsigned long i;
9087   unsigned int sec_type;
9088   bfd_boolean res = TRUE;
9089
9090   switch (filedata->file_header.e_machine)
9091     {
9092     case EM_ARM:
9093       sec_type = SHT_ARM_EXIDX;
9094       break;
9095
9096     case EM_TI_C6000:
9097       sec_type = SHT_C6000_UNWIND;
9098       break;
9099
9100     default:
9101       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9102              filedata->file_header.e_machine);
9103       return FALSE;
9104     }
9105
9106   if (filedata->string_table == NULL)
9107     return FALSE;
9108
9109   memset (& aux, 0, sizeof (aux));
9110   aux.filedata = filedata;
9111
9112   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9113     {
9114       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9115         {
9116           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9117
9118           strsec = filedata->section_headers + sec->sh_link;
9119
9120           /* PR binutils/17531 file: 011-12666-0.004.  */
9121           if (aux.strtab != NULL)
9122             {
9123               error (_("Multiple string tables found in file.\n"));
9124               free (aux.strtab);
9125               res = FALSE;
9126             }
9127           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9128                                  1, strsec->sh_size, _("string table"));
9129           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9130         }
9131       else if (sec->sh_type == sec_type)
9132         unwsec = sec;
9133     }
9134
9135   if (unwsec == NULL)
9136     printf (_("\nThere are no unwind sections in this file.\n"));
9137   else
9138     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9139       {
9140         if (sec->sh_type == sec_type)
9141           {
9142             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9143             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9144                               "contains %lu entry:\n",
9145                               "\nUnwind section '%s' at offset 0x%lx "
9146                               "contains %lu entries:\n",
9147                               num_unwind),
9148                     printable_section_name (filedata, sec),
9149                     (unsigned long) sec->sh_offset,
9150                     num_unwind);
9151
9152             if (! dump_arm_unwind (filedata, &aux, sec))
9153               res = FALSE;
9154           }
9155       }
9156
9157   if (aux.symtab)
9158     free (aux.symtab);
9159   if (aux.strtab)
9160     free ((char *) aux.strtab);
9161
9162   return res;
9163 }
9164
9165 static bfd_boolean
9166 process_unwind (Filedata * filedata)
9167 {
9168   struct unwind_handler
9169   {
9170     unsigned int machtype;
9171     bfd_boolean (* handler)(Filedata *);
9172   } handlers[] =
9173   {
9174     { EM_ARM, arm_process_unwind },
9175     { EM_IA_64, ia64_process_unwind },
9176     { EM_PARISC, hppa_process_unwind },
9177     { EM_TI_C6000, arm_process_unwind },
9178     { 0, NULL }
9179   };
9180   int i;
9181
9182   if (!do_unwind)
9183     return TRUE;
9184
9185   for (i = 0; handlers[i].handler != NULL; i++)
9186     if (filedata->file_header.e_machine == handlers[i].machtype)
9187       return handlers[i].handler (filedata);
9188
9189   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9190           get_machine_name (filedata->file_header.e_machine));
9191   return TRUE;
9192 }
9193
9194 static void
9195 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9196 {
9197   switch (entry->d_tag)
9198     {
9199     case DT_MIPS_FLAGS:
9200       if (entry->d_un.d_val == 0)
9201         printf (_("NONE"));
9202       else
9203         {
9204           static const char * opts[] =
9205           {
9206             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9207             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9208             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9209             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9210             "RLD_ORDER_SAFE"
9211           };
9212           unsigned int cnt;
9213           bfd_boolean first = TRUE;
9214
9215           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9216             if (entry->d_un.d_val & (1 << cnt))
9217               {
9218                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9219                 first = FALSE;
9220               }
9221         }
9222       break;
9223
9224     case DT_MIPS_IVERSION:
9225       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9226         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9227       else
9228         {
9229           char buf[40];
9230           sprintf_vma (buf, entry->d_un.d_ptr);
9231           /* Note: coded this way so that there is a single string for translation.  */
9232           printf (_("<corrupt: %s>"), buf);
9233         }
9234       break;
9235
9236     case DT_MIPS_TIME_STAMP:
9237       {
9238         char timebuf[128];
9239         struct tm * tmp;
9240         time_t atime = entry->d_un.d_val;
9241
9242         tmp = gmtime (&atime);
9243         /* PR 17531: file: 6accc532.  */
9244         if (tmp == NULL)
9245           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9246         else
9247           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9248                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9249                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9250         printf (_("Time Stamp: %s"), timebuf);
9251       }
9252       break;
9253
9254     case DT_MIPS_RLD_VERSION:
9255     case DT_MIPS_LOCAL_GOTNO:
9256     case DT_MIPS_CONFLICTNO:
9257     case DT_MIPS_LIBLISTNO:
9258     case DT_MIPS_SYMTABNO:
9259     case DT_MIPS_UNREFEXTNO:
9260     case DT_MIPS_HIPAGENO:
9261     case DT_MIPS_DELTA_CLASS_NO:
9262     case DT_MIPS_DELTA_INSTANCE_NO:
9263     case DT_MIPS_DELTA_RELOC_NO:
9264     case DT_MIPS_DELTA_SYM_NO:
9265     case DT_MIPS_DELTA_CLASSSYM_NO:
9266     case DT_MIPS_COMPACT_SIZE:
9267       print_vma (entry->d_un.d_val, DEC);
9268       break;
9269
9270     default:
9271       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9272     }
9273     putchar ('\n');
9274 }
9275
9276 static void
9277 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9278 {
9279   switch (entry->d_tag)
9280     {
9281     case DT_HP_DLD_FLAGS:
9282       {
9283         static struct
9284         {
9285           long int bit;
9286           const char * str;
9287         }
9288         flags[] =
9289         {
9290           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9291           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9292           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9293           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9294           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9295           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9296           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9297           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9298           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9299           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9300           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9301           { DT_HP_GST, "HP_GST" },
9302           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9303           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9304           { DT_HP_NODELETE, "HP_NODELETE" },
9305           { DT_HP_GROUP, "HP_GROUP" },
9306           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9307         };
9308         bfd_boolean first = TRUE;
9309         size_t cnt;
9310         bfd_vma val = entry->d_un.d_val;
9311
9312         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9313           if (val & flags[cnt].bit)
9314             {
9315               if (! first)
9316                 putchar (' ');
9317               fputs (flags[cnt].str, stdout);
9318               first = FALSE;
9319               val ^= flags[cnt].bit;
9320             }
9321
9322         if (val != 0 || first)
9323           {
9324             if (! first)
9325               putchar (' ');
9326             print_vma (val, HEX);
9327           }
9328       }
9329       break;
9330
9331     default:
9332       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9333       break;
9334     }
9335   putchar ('\n');
9336 }
9337
9338 #ifdef BFD64
9339
9340 /* VMS vs Unix time offset and factor.  */
9341
9342 #define VMS_EPOCH_OFFSET 35067168000000000LL
9343 #define VMS_GRANULARITY_FACTOR 10000000
9344
9345 /* Display a VMS time in a human readable format.  */
9346
9347 static void
9348 print_vms_time (bfd_int64_t vmstime)
9349 {
9350   struct tm *tm;
9351   time_t unxtime;
9352
9353   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9354   tm = gmtime (&unxtime);
9355   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9356           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9357           tm->tm_hour, tm->tm_min, tm->tm_sec);
9358 }
9359 #endif /* BFD64 */
9360
9361 static void
9362 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9363 {
9364   switch (entry->d_tag)
9365     {
9366     case DT_IA_64_PLT_RESERVE:
9367       /* First 3 slots reserved.  */
9368       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9369       printf (" -- ");
9370       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9371       break;
9372
9373     case DT_IA_64_VMS_LINKTIME:
9374 #ifdef BFD64
9375       print_vms_time (entry->d_un.d_val);
9376 #endif
9377       break;
9378
9379     case DT_IA_64_VMS_LNKFLAGS:
9380       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9381       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9382         printf (" CALL_DEBUG");
9383       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9384         printf (" NOP0BUFS");
9385       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9386         printf (" P0IMAGE");
9387       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9388         printf (" MKTHREADS");
9389       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9390         printf (" UPCALLS");
9391       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9392         printf (" IMGSTA");
9393       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9394         printf (" INITIALIZE");
9395       if (entry->d_un.d_val & VMS_LF_MAIN)
9396         printf (" MAIN");
9397       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9398         printf (" EXE_INIT");
9399       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9400         printf (" TBK_IN_IMG");
9401       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9402         printf (" DBG_IN_IMG");
9403       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9404         printf (" TBK_IN_DSF");
9405       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9406         printf (" DBG_IN_DSF");
9407       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9408         printf (" SIGNATURES");
9409       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9410         printf (" REL_SEG_OFF");
9411       break;
9412
9413     default:
9414       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9415       break;
9416     }
9417   putchar ('\n');
9418 }
9419
9420 static bfd_boolean
9421 get_32bit_dynamic_section (Filedata * filedata)
9422 {
9423   Elf32_External_Dyn * edyn;
9424   Elf32_External_Dyn * ext;
9425   Elf_Internal_Dyn * entry;
9426
9427   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9428                                           dynamic_size, _("dynamic section"));
9429   if (!edyn)
9430     return FALSE;
9431
9432   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9433      might not have the luxury of section headers.  Look for the DT_NULL
9434      terminator to determine the number of entries.  */
9435   for (ext = edyn, dynamic_nent = 0;
9436        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9437        ext++)
9438     {
9439       dynamic_nent++;
9440       if (BYTE_GET (ext->d_tag) == DT_NULL)
9441         break;
9442     }
9443
9444   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9445                                                   sizeof (* entry));
9446   if (dynamic_section == NULL)
9447     {
9448       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9449              (unsigned long) dynamic_nent);
9450       free (edyn);
9451       return FALSE;
9452     }
9453
9454   for (ext = edyn, entry = dynamic_section;
9455        entry < dynamic_section + dynamic_nent;
9456        ext++, entry++)
9457     {
9458       entry->d_tag      = BYTE_GET (ext->d_tag);
9459       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9460     }
9461
9462   free (edyn);
9463
9464   return TRUE;
9465 }
9466
9467 static bfd_boolean
9468 get_64bit_dynamic_section (Filedata * filedata)
9469 {
9470   Elf64_External_Dyn * edyn;
9471   Elf64_External_Dyn * ext;
9472   Elf_Internal_Dyn * entry;
9473
9474   /* Read in the data.  */
9475   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9476                                           dynamic_size, _("dynamic section"));
9477   if (!edyn)
9478     return FALSE;
9479
9480   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9481      might not have the luxury of section headers.  Look for the DT_NULL
9482      terminator to determine the number of entries.  */
9483   for (ext = edyn, dynamic_nent = 0;
9484        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9485        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9486        ext++)
9487     {
9488       dynamic_nent++;
9489       if (BYTE_GET (ext->d_tag) == DT_NULL)
9490         break;
9491     }
9492
9493   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9494                                                   sizeof (* entry));
9495   if (dynamic_section == NULL)
9496     {
9497       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9498              (unsigned long) dynamic_nent);
9499       free (edyn);
9500       return FALSE;
9501     }
9502
9503   /* Convert from external to internal formats.  */
9504   for (ext = edyn, entry = dynamic_section;
9505        entry < dynamic_section + dynamic_nent;
9506        ext++, entry++)
9507     {
9508       entry->d_tag      = BYTE_GET (ext->d_tag);
9509       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9510     }
9511
9512   free (edyn);
9513
9514   return TRUE;
9515 }
9516
9517 static void
9518 print_dynamic_flags (bfd_vma flags)
9519 {
9520   bfd_boolean first = TRUE;
9521
9522   while (flags)
9523     {
9524       bfd_vma flag;
9525
9526       flag = flags & - flags;
9527       flags &= ~ flag;
9528
9529       if (first)
9530         first = FALSE;
9531       else
9532         putc (' ', stdout);
9533
9534       switch (flag)
9535         {
9536         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9537         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9538         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9539         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9540         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9541         default:                fputs (_("unknown"), stdout); break;
9542         }
9543     }
9544   puts ("");
9545 }
9546
9547 /* Parse and display the contents of the dynamic section.  */
9548
9549 static bfd_boolean
9550 process_dynamic_section (Filedata * filedata)
9551 {
9552   Elf_Internal_Dyn * entry;
9553
9554   if (dynamic_size == 0)
9555     {
9556       if (do_dynamic)
9557         printf (_("\nThere is no dynamic section in this file.\n"));
9558
9559       return TRUE;
9560     }
9561
9562   if (is_32bit_elf)
9563     {
9564       if (! get_32bit_dynamic_section (filedata))
9565         return FALSE;
9566     }
9567   else
9568     {
9569       if (! get_64bit_dynamic_section (filedata))
9570         return FALSE;
9571     }
9572
9573   /* Find the appropriate symbol table.  */
9574   if (dynamic_symbols == NULL)
9575     {
9576       for (entry = dynamic_section;
9577            entry < dynamic_section + dynamic_nent;
9578            ++entry)
9579         {
9580           Elf_Internal_Shdr section;
9581
9582           if (entry->d_tag != DT_SYMTAB)
9583             continue;
9584
9585           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9586
9587           /* Since we do not know how big the symbol table is,
9588              we default to reading in the entire file (!) and
9589              processing that.  This is overkill, I know, but it
9590              should work.  */
9591           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9592           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9593             {
9594               /* See PR 21379 for a reproducer.  */
9595               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9596               return FALSE;
9597             }
9598
9599           if (archive_file_offset != 0)
9600             section.sh_size = archive_file_size - section.sh_offset;
9601           else
9602             section.sh_size = filedata->file_size - section.sh_offset;
9603
9604           if (is_32bit_elf)
9605             section.sh_entsize = sizeof (Elf32_External_Sym);
9606           else
9607             section.sh_entsize = sizeof (Elf64_External_Sym);
9608           section.sh_name = filedata->string_table_length;
9609
9610           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9611           if (num_dynamic_syms < 1)
9612             {
9613               error (_("Unable to determine the number of symbols to load\n"));
9614               continue;
9615             }
9616         }
9617     }
9618
9619   /* Similarly find a string table.  */
9620   if (dynamic_strings == NULL)
9621     {
9622       for (entry = dynamic_section;
9623            entry < dynamic_section + dynamic_nent;
9624            ++entry)
9625         {
9626           unsigned long offset;
9627           long str_tab_len;
9628
9629           if (entry->d_tag != DT_STRTAB)
9630             continue;
9631
9632           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9633
9634           /* Since we do not know how big the string table is,
9635              we default to reading in the entire file (!) and
9636              processing that.  This is overkill, I know, but it
9637              should work.  */
9638
9639           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9640
9641           if (archive_file_offset != 0)
9642             str_tab_len = archive_file_size - offset;
9643           else
9644             str_tab_len = filedata->file_size - offset;
9645
9646           if (str_tab_len < 1)
9647             {
9648               error
9649                 (_("Unable to determine the length of the dynamic string table\n"));
9650               continue;
9651             }
9652
9653           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9654                                                str_tab_len,
9655                                                _("dynamic string table"));
9656           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9657           break;
9658         }
9659     }
9660
9661   /* And find the syminfo section if available.  */
9662   if (dynamic_syminfo == NULL)
9663     {
9664       unsigned long syminsz = 0;
9665
9666       for (entry = dynamic_section;
9667            entry < dynamic_section + dynamic_nent;
9668            ++entry)
9669         {
9670           if (entry->d_tag == DT_SYMINENT)
9671             {
9672               /* Note: these braces are necessary to avoid a syntax
9673                  error from the SunOS4 C compiler.  */
9674               /* PR binutils/17531: A corrupt file can trigger this test.
9675                  So do not use an assert, instead generate an error message.  */
9676               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9677                 error (_("Bad value (%d) for SYMINENT entry\n"),
9678                        (int) entry->d_un.d_val);
9679             }
9680           else if (entry->d_tag == DT_SYMINSZ)
9681             syminsz = entry->d_un.d_val;
9682           else if (entry->d_tag == DT_SYMINFO)
9683             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9684                                                       syminsz);
9685         }
9686
9687       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9688         {
9689           Elf_External_Syminfo * extsyminfo;
9690           Elf_External_Syminfo * extsym;
9691           Elf_Internal_Syminfo * syminfo;
9692
9693           /* There is a syminfo section.  Read the data.  */
9694           extsyminfo = (Elf_External_Syminfo *)
9695               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9696                         _("symbol information"));
9697           if (!extsyminfo)
9698             return FALSE;
9699
9700           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9701           if (dynamic_syminfo == NULL)
9702             {
9703               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9704                      (unsigned long) syminsz);
9705               return FALSE;
9706             }
9707
9708           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9709           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9710                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9711                ++syminfo, ++extsym)
9712             {
9713               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9714               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9715             }
9716
9717           free (extsyminfo);
9718         }
9719     }
9720
9721   if (do_dynamic && dynamic_addr)
9722     printf (ngettext ("\nDynamic section at offset 0x%lx "
9723                       "contains %lu entry:\n",
9724                       "\nDynamic section at offset 0x%lx "
9725                       "contains %lu entries:\n",
9726                       dynamic_nent),
9727             dynamic_addr, (unsigned long) dynamic_nent);
9728   if (do_dynamic)
9729     printf (_("  Tag        Type                         Name/Value\n"));
9730
9731   for (entry = dynamic_section;
9732        entry < dynamic_section + dynamic_nent;
9733        entry++)
9734     {
9735       if (do_dynamic)
9736         {
9737           const char * dtype;
9738
9739           putchar (' ');
9740           print_vma (entry->d_tag, FULL_HEX);
9741           dtype = get_dynamic_type (filedata, entry->d_tag);
9742           printf (" (%s)%*s", dtype,
9743                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9744         }
9745
9746       switch (entry->d_tag)
9747         {
9748         case DT_FLAGS:
9749           if (do_dynamic)
9750             print_dynamic_flags (entry->d_un.d_val);
9751           break;
9752
9753         case DT_AUXILIARY:
9754         case DT_FILTER:
9755         case DT_CONFIG:
9756         case DT_DEPAUDIT:
9757         case DT_AUDIT:
9758           if (do_dynamic)
9759             {
9760               switch (entry->d_tag)
9761                 {
9762                 case DT_AUXILIARY:
9763                   printf (_("Auxiliary library"));
9764                   break;
9765
9766                 case DT_FILTER:
9767                   printf (_("Filter library"));
9768                   break;
9769
9770                 case DT_CONFIG:
9771                   printf (_("Configuration file"));
9772                   break;
9773
9774                 case DT_DEPAUDIT:
9775                   printf (_("Dependency audit library"));
9776                   break;
9777
9778                 case DT_AUDIT:
9779                   printf (_("Audit library"));
9780                   break;
9781                 }
9782
9783               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9784                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9785               else
9786                 {
9787                   printf (": ");
9788                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9789                   putchar ('\n');
9790                 }
9791             }
9792           break;
9793
9794         case DT_FEATURE:
9795           if (do_dynamic)
9796             {
9797               printf (_("Flags:"));
9798
9799               if (entry->d_un.d_val == 0)
9800                 printf (_(" None\n"));
9801               else
9802                 {
9803                   unsigned long int val = entry->d_un.d_val;
9804
9805                   if (val & DTF_1_PARINIT)
9806                     {
9807                       printf (" PARINIT");
9808                       val ^= DTF_1_PARINIT;
9809                     }
9810                   if (val & DTF_1_CONFEXP)
9811                     {
9812                       printf (" CONFEXP");
9813                       val ^= DTF_1_CONFEXP;
9814                     }
9815                   if (val != 0)
9816                     printf (" %lx", val);
9817                   puts ("");
9818                 }
9819             }
9820           break;
9821
9822         case DT_POSFLAG_1:
9823           if (do_dynamic)
9824             {
9825               printf (_("Flags:"));
9826
9827               if (entry->d_un.d_val == 0)
9828                 printf (_(" None\n"));
9829               else
9830                 {
9831                   unsigned long int val = entry->d_un.d_val;
9832
9833                   if (val & DF_P1_LAZYLOAD)
9834                     {
9835                       printf (" LAZYLOAD");
9836                       val ^= DF_P1_LAZYLOAD;
9837                     }
9838                   if (val & DF_P1_GROUPPERM)
9839                     {
9840                       printf (" GROUPPERM");
9841                       val ^= DF_P1_GROUPPERM;
9842                     }
9843                   if (val != 0)
9844                     printf (" %lx", val);
9845                   puts ("");
9846                 }
9847             }
9848           break;
9849
9850         case DT_FLAGS_1:
9851           if (do_dynamic)
9852             {
9853               printf (_("Flags:"));
9854               if (entry->d_un.d_val == 0)
9855                 printf (_(" None\n"));
9856               else
9857                 {
9858                   unsigned long int val = entry->d_un.d_val;
9859
9860                   if (val & DF_1_NOW)
9861                     {
9862                       printf (" NOW");
9863                       val ^= DF_1_NOW;
9864                     }
9865                   if (val & DF_1_GLOBAL)
9866                     {
9867                       printf (" GLOBAL");
9868                       val ^= DF_1_GLOBAL;
9869                     }
9870                   if (val & DF_1_GROUP)
9871                     {
9872                       printf (" GROUP");
9873                       val ^= DF_1_GROUP;
9874                     }
9875                   if (val & DF_1_NODELETE)
9876                     {
9877                       printf (" NODELETE");
9878                       val ^= DF_1_NODELETE;
9879                     }
9880                   if (val & DF_1_LOADFLTR)
9881                     {
9882                       printf (" LOADFLTR");
9883                       val ^= DF_1_LOADFLTR;
9884                     }
9885                   if (val & DF_1_INITFIRST)
9886                     {
9887                       printf (" INITFIRST");
9888                       val ^= DF_1_INITFIRST;
9889                     }
9890                   if (val & DF_1_NOOPEN)
9891                     {
9892                       printf (" NOOPEN");
9893                       val ^= DF_1_NOOPEN;
9894                     }
9895                   if (val & DF_1_ORIGIN)
9896                     {
9897                       printf (" ORIGIN");
9898                       val ^= DF_1_ORIGIN;
9899                     }
9900                   if (val & DF_1_DIRECT)
9901                     {
9902                       printf (" DIRECT");
9903                       val ^= DF_1_DIRECT;
9904                     }
9905                   if (val & DF_1_TRANS)
9906                     {
9907                       printf (" TRANS");
9908                       val ^= DF_1_TRANS;
9909                     }
9910                   if (val & DF_1_INTERPOSE)
9911                     {
9912                       printf (" INTERPOSE");
9913                       val ^= DF_1_INTERPOSE;
9914                     }
9915                   if (val & DF_1_NODEFLIB)
9916                     {
9917                       printf (" NODEFLIB");
9918                       val ^= DF_1_NODEFLIB;
9919                     }
9920                   if (val & DF_1_NODUMP)
9921                     {
9922                       printf (" NODUMP");
9923                       val ^= DF_1_NODUMP;
9924                     }
9925                   if (val & DF_1_CONFALT)
9926                     {
9927                       printf (" CONFALT");
9928                       val ^= DF_1_CONFALT;
9929                     }
9930                   if (val & DF_1_ENDFILTEE)
9931                     {
9932                       printf (" ENDFILTEE");
9933                       val ^= DF_1_ENDFILTEE;
9934                     }
9935                   if (val & DF_1_DISPRELDNE)
9936                     {
9937                       printf (" DISPRELDNE");
9938                       val ^= DF_1_DISPRELDNE;
9939                     }
9940                   if (val & DF_1_DISPRELPND)
9941                     {
9942                       printf (" DISPRELPND");
9943                       val ^= DF_1_DISPRELPND;
9944                     }
9945                   if (val & DF_1_NODIRECT)
9946                     {
9947                       printf (" NODIRECT");
9948                       val ^= DF_1_NODIRECT;
9949                     }
9950                   if (val & DF_1_IGNMULDEF)
9951                     {
9952                       printf (" IGNMULDEF");
9953                       val ^= DF_1_IGNMULDEF;
9954                     }
9955                   if (val & DF_1_NOKSYMS)
9956                     {
9957                       printf (" NOKSYMS");
9958                       val ^= DF_1_NOKSYMS;
9959                     }
9960                   if (val & DF_1_NOHDR)
9961                     {
9962                       printf (" NOHDR");
9963                       val ^= DF_1_NOHDR;
9964                     }
9965                   if (val & DF_1_EDITED)
9966                     {
9967                       printf (" EDITED");
9968                       val ^= DF_1_EDITED;
9969                     }
9970                   if (val & DF_1_NORELOC)
9971                     {
9972                       printf (" NORELOC");
9973                       val ^= DF_1_NORELOC;
9974                     }
9975                   if (val & DF_1_SYMINTPOSE)
9976                     {
9977                       printf (" SYMINTPOSE");
9978                       val ^= DF_1_SYMINTPOSE;
9979                     }
9980                   if (val & DF_1_GLOBAUDIT)
9981                     {
9982                       printf (" GLOBAUDIT");
9983                       val ^= DF_1_GLOBAUDIT;
9984                     }
9985                   if (val & DF_1_SINGLETON)
9986                     {
9987                       printf (" SINGLETON");
9988                       val ^= DF_1_SINGLETON;
9989                     }
9990                   if (val & DF_1_STUB)
9991                     {
9992                       printf (" STUB");
9993                       val ^= DF_1_STUB;
9994                     }
9995                   if (val & DF_1_PIE)
9996                     {
9997                       printf (" PIE");
9998                       val ^= DF_1_PIE;
9999                     }
10000                   if (val & DF_1_KMOD)
10001                     {
10002                       printf (" KMOD");
10003                       val ^= DF_1_KMOD;
10004                     }
10005                   if (val & DF_1_WEAKFILTER)
10006                     {
10007                       printf (" WEAKFILTER");
10008                       val ^= DF_1_WEAKFILTER;
10009                     }
10010                   if (val & DF_1_NOCOMMON)
10011                     {
10012                       printf (" NOCOMMON");
10013                       val ^= DF_1_NOCOMMON;
10014                     }
10015                   if (val != 0)
10016                     printf (" %lx", val);
10017                   puts ("");
10018                 }
10019             }
10020           break;
10021
10022         case DT_PLTREL:
10023           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10024           if (do_dynamic)
10025             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10026           break;
10027
10028         case DT_NULL    :
10029         case DT_NEEDED  :
10030         case DT_PLTGOT  :
10031         case DT_HASH    :
10032         case DT_STRTAB  :
10033         case DT_SYMTAB  :
10034         case DT_RELA    :
10035         case DT_INIT    :
10036         case DT_FINI    :
10037         case DT_SONAME  :
10038         case DT_RPATH   :
10039         case DT_SYMBOLIC:
10040         case DT_REL     :
10041         case DT_DEBUG   :
10042         case DT_TEXTREL :
10043         case DT_JMPREL  :
10044         case DT_RUNPATH :
10045           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10046
10047           if (do_dynamic)
10048             {
10049               char * name;
10050
10051               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10052                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10053               else
10054                 name = NULL;
10055
10056               if (name)
10057                 {
10058                   switch (entry->d_tag)
10059                     {
10060                     case DT_NEEDED:
10061                       printf (_("Shared library: [%s]"), name);
10062
10063                       if (streq (name, program_interpreter))
10064                         printf (_(" program interpreter"));
10065                       break;
10066
10067                     case DT_SONAME:
10068                       printf (_("Library soname: [%s]"), name);
10069                       break;
10070
10071                     case DT_RPATH:
10072                       printf (_("Library rpath: [%s]"), name);
10073                       break;
10074
10075                     case DT_RUNPATH:
10076                       printf (_("Library runpath: [%s]"), name);
10077                       break;
10078
10079                     default:
10080                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10081                       break;
10082                     }
10083                 }
10084               else
10085                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10086
10087               putchar ('\n');
10088             }
10089           break;
10090
10091         case DT_PLTRELSZ:
10092         case DT_RELASZ  :
10093         case DT_STRSZ   :
10094         case DT_RELSZ   :
10095         case DT_RELAENT :
10096         case DT_SYMENT  :
10097         case DT_RELENT  :
10098           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10099           /* Fall through.  */
10100         case DT_PLTPADSZ:
10101         case DT_MOVEENT :
10102         case DT_MOVESZ  :
10103         case DT_INIT_ARRAYSZ:
10104         case DT_FINI_ARRAYSZ:
10105         case DT_GNU_CONFLICTSZ:
10106         case DT_GNU_LIBLISTSZ:
10107           if (do_dynamic)
10108             {
10109               print_vma (entry->d_un.d_val, UNSIGNED);
10110               printf (_(" (bytes)\n"));
10111             }
10112           break;
10113
10114         case DT_VERDEFNUM:
10115         case DT_VERNEEDNUM:
10116         case DT_RELACOUNT:
10117         case DT_RELCOUNT:
10118           if (do_dynamic)
10119             {
10120               print_vma (entry->d_un.d_val, UNSIGNED);
10121               putchar ('\n');
10122             }
10123           break;
10124
10125         case DT_SYMINSZ:
10126         case DT_SYMINENT:
10127         case DT_SYMINFO:
10128         case DT_USED:
10129         case DT_INIT_ARRAY:
10130         case DT_FINI_ARRAY:
10131           if (do_dynamic)
10132             {
10133               if (entry->d_tag == DT_USED
10134                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10135                 {
10136                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10137
10138                   if (*name)
10139                     {
10140                       printf (_("Not needed object: [%s]\n"), name);
10141                       break;
10142                     }
10143                 }
10144
10145               print_vma (entry->d_un.d_val, PREFIX_HEX);
10146               putchar ('\n');
10147             }
10148           break;
10149
10150         case DT_BIND_NOW:
10151           /* The value of this entry is ignored.  */
10152           if (do_dynamic)
10153             putchar ('\n');
10154           break;
10155
10156         case DT_GNU_PRELINKED:
10157           if (do_dynamic)
10158             {
10159               struct tm * tmp;
10160               time_t atime = entry->d_un.d_val;
10161
10162               tmp = gmtime (&atime);
10163               /* PR 17533 file: 041-1244816-0.004.  */
10164               if (tmp == NULL)
10165                 printf (_("<corrupt time val: %lx"),
10166                         (unsigned long) atime);
10167               else
10168                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10169                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10170                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10171
10172             }
10173           break;
10174
10175         case DT_GNU_HASH:
10176           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10177           if (do_dynamic)
10178             {
10179               print_vma (entry->d_un.d_val, PREFIX_HEX);
10180               putchar ('\n');
10181             }
10182           break;
10183
10184         default:
10185           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10186             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10187               entry->d_un.d_val;
10188
10189           if (do_dynamic)
10190             {
10191               switch (filedata->file_header.e_machine)
10192                 {
10193                 case EM_MIPS:
10194                 case EM_MIPS_RS3_LE:
10195                   dynamic_section_mips_val (entry);
10196                   break;
10197                 case EM_PARISC:
10198                   dynamic_section_parisc_val (entry);
10199                   break;
10200                 case EM_IA_64:
10201                   dynamic_section_ia64_val (entry);
10202                   break;
10203                 default:
10204                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10205                   putchar ('\n');
10206                 }
10207             }
10208           break;
10209         }
10210     }
10211
10212   return TRUE;
10213 }
10214
10215 static char *
10216 get_ver_flags (unsigned int flags)
10217 {
10218   static char buff[128];
10219
10220   buff[0] = 0;
10221
10222   if (flags == 0)
10223     return _("none");
10224
10225   if (flags & VER_FLG_BASE)
10226     strcat (buff, "BASE");
10227
10228   if (flags & VER_FLG_WEAK)
10229     {
10230       if (flags & VER_FLG_BASE)
10231         strcat (buff, " | ");
10232
10233       strcat (buff, "WEAK");
10234     }
10235
10236   if (flags & VER_FLG_INFO)
10237     {
10238       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10239         strcat (buff, " | ");
10240
10241       strcat (buff, "INFO");
10242     }
10243
10244   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10245     {
10246       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10247         strcat (buff, " | ");
10248
10249       strcat (buff, _("<unknown>"));
10250     }
10251
10252   return buff;
10253 }
10254
10255 /* Display the contents of the version sections.  */
10256
10257 static bfd_boolean
10258 process_version_sections (Filedata * filedata)
10259 {
10260   Elf_Internal_Shdr * section;
10261   unsigned i;
10262   bfd_boolean found = FALSE;
10263
10264   if (! do_version)
10265     return TRUE;
10266
10267   for (i = 0, section = filedata->section_headers;
10268        i < filedata->file_header.e_shnum;
10269        i++, section++)
10270     {
10271       switch (section->sh_type)
10272         {
10273         case SHT_GNU_verdef:
10274           {
10275             Elf_External_Verdef * edefs;
10276             unsigned long idx;
10277             unsigned long cnt;
10278             char * endbuf;
10279
10280             found = TRUE;
10281
10282             printf (ngettext ("\nVersion definition section '%s' "
10283                               "contains %u entry:\n",
10284                               "\nVersion definition section '%s' "
10285                               "contains %u entries:\n",
10286                               section->sh_info),
10287                     printable_section_name (filedata, section),
10288                     section->sh_info);
10289
10290             printf (_("  Addr: 0x"));
10291             printf_vma (section->sh_addr);
10292             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10293                     (unsigned long) section->sh_offset, section->sh_link,
10294                     printable_section_name_from_index (filedata, section->sh_link));
10295
10296             edefs = (Elf_External_Verdef *)
10297                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10298                           _("version definition section"));
10299             if (!edefs)
10300               break;
10301             endbuf = (char *) edefs + section->sh_size;
10302
10303             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10304               {
10305                 char * vstart;
10306                 Elf_External_Verdef * edef;
10307                 Elf_Internal_Verdef ent;
10308                 Elf_External_Verdaux * eaux;
10309                 Elf_Internal_Verdaux aux;
10310                 unsigned long isum;
10311                 int j;
10312
10313                 vstart = ((char *) edefs) + idx;
10314                 if (vstart + sizeof (*edef) > endbuf)
10315                   break;
10316
10317                 edef = (Elf_External_Verdef *) vstart;
10318
10319                 ent.vd_version = BYTE_GET (edef->vd_version);
10320                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10321                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10322                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10323                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10324                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10325                 ent.vd_next    = BYTE_GET (edef->vd_next);
10326
10327                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10328                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10329
10330                 printf (_("  Index: %d  Cnt: %d  "),
10331                         ent.vd_ndx, ent.vd_cnt);
10332
10333                 /* Check for overflow.  */
10334                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10335                   break;
10336
10337                 vstart += ent.vd_aux;
10338
10339                 if (vstart + sizeof (*eaux) > endbuf)
10340                   break;
10341                 eaux = (Elf_External_Verdaux *) vstart;
10342
10343                 aux.vda_name = BYTE_GET (eaux->vda_name);
10344                 aux.vda_next = BYTE_GET (eaux->vda_next);
10345
10346                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10347                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10348                 else
10349                   printf (_("Name index: %ld\n"), aux.vda_name);
10350
10351                 isum = idx + ent.vd_aux;
10352
10353                 for (j = 1; j < ent.vd_cnt; j++)
10354                   {
10355                     if (aux.vda_next < sizeof (*eaux)
10356                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10357                       {
10358                         warn (_("Invalid vda_next field of %lx\n"),
10359                               aux.vda_next);
10360                         j = ent.vd_cnt;
10361                         break;
10362                       }
10363                     /* Check for overflow.  */
10364                     if (aux.vda_next > (size_t) (endbuf - vstart))
10365                       break;
10366
10367                     isum   += aux.vda_next;
10368                     vstart += aux.vda_next;
10369
10370                     if (vstart + sizeof (*eaux) > endbuf)
10371                       break;
10372                     eaux = (Elf_External_Verdaux *) vstart;
10373
10374                     aux.vda_name = BYTE_GET (eaux->vda_name);
10375                     aux.vda_next = BYTE_GET (eaux->vda_next);
10376
10377                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10378                       printf (_("  %#06lx: Parent %d: %s\n"),
10379                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10380                     else
10381                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10382                               isum, j, aux.vda_name);
10383                   }
10384
10385                 if (j < ent.vd_cnt)
10386                   printf (_("  Version def aux past end of section\n"));
10387
10388                 /* PR 17531:
10389                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10390                 if (ent.vd_next < sizeof (*edef)
10391                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10392                   {
10393                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10394                     cnt = section->sh_info;
10395                     break;
10396                   }
10397                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10398                   break;
10399
10400                 idx += ent.vd_next;
10401               }
10402
10403             if (cnt < section->sh_info)
10404               printf (_("  Version definition past end of section\n"));
10405
10406             free (edefs);
10407           }
10408           break;
10409
10410         case SHT_GNU_verneed:
10411           {
10412             Elf_External_Verneed * eneed;
10413             unsigned long idx;
10414             unsigned long cnt;
10415             char * endbuf;
10416
10417             found = TRUE;
10418
10419             printf (ngettext ("\nVersion needs section '%s' "
10420                               "contains %u entry:\n",
10421                               "\nVersion needs section '%s' "
10422                               "contains %u entries:\n",
10423                               section->sh_info),
10424                     printable_section_name (filedata, section), section->sh_info);
10425
10426             printf (_(" Addr: 0x"));
10427             printf_vma (section->sh_addr);
10428             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10429                     (unsigned long) section->sh_offset, section->sh_link,
10430                     printable_section_name_from_index (filedata, section->sh_link));
10431
10432             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10433                                                        section->sh_offset, 1,
10434                                                        section->sh_size,
10435                                                        _("Version Needs section"));
10436             if (!eneed)
10437               break;
10438             endbuf = (char *) eneed + section->sh_size;
10439
10440             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10441               {
10442                 Elf_External_Verneed * entry;
10443                 Elf_Internal_Verneed ent;
10444                 unsigned long isum;
10445                 int j;
10446                 char * vstart;
10447
10448                 vstart = ((char *) eneed) + idx;
10449                 if (vstart + sizeof (*entry) > endbuf)
10450                   break;
10451
10452                 entry = (Elf_External_Verneed *) vstart;
10453
10454                 ent.vn_version = BYTE_GET (entry->vn_version);
10455                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10456                 ent.vn_file    = BYTE_GET (entry->vn_file);
10457                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10458                 ent.vn_next    = BYTE_GET (entry->vn_next);
10459
10460                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10461
10462                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10463                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10464                 else
10465                   printf (_("  File: %lx"), ent.vn_file);
10466
10467                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10468
10469                 /* Check for overflow.  */
10470                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10471                   break;
10472                 vstart += ent.vn_aux;
10473
10474                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10475                   {
10476                     Elf_External_Vernaux * eaux;
10477                     Elf_Internal_Vernaux aux;
10478
10479                     if (vstart + sizeof (*eaux) > endbuf)
10480                       break;
10481                     eaux = (Elf_External_Vernaux *) vstart;
10482
10483                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10484                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10485                     aux.vna_other = BYTE_GET (eaux->vna_other);
10486                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10487                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10488
10489                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10490                       printf (_("  %#06lx:   Name: %s"),
10491                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10492                     else
10493                       printf (_("  %#06lx:   Name index: %lx"),
10494                               isum, aux.vna_name);
10495
10496                     printf (_("  Flags: %s  Version: %d\n"),
10497                             get_ver_flags (aux.vna_flags), aux.vna_other);
10498
10499                     if (aux.vna_next < sizeof (*eaux)
10500                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10501                       {
10502                         warn (_("Invalid vna_next field of %lx\n"),
10503                               aux.vna_next);
10504                         j = ent.vn_cnt;
10505                         break;
10506                       }
10507                     /* Check for overflow.  */
10508                     if (aux.vna_next > (size_t) (endbuf - vstart))
10509                       break;
10510                     isum   += aux.vna_next;
10511                     vstart += aux.vna_next;
10512                   }
10513
10514                 if (j < ent.vn_cnt)
10515                   warn (_("Missing Version Needs auxillary information\n"));
10516
10517                 if (ent.vn_next < sizeof (*entry)
10518                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10519                   {
10520                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10521                     cnt = section->sh_info;
10522                     break;
10523                   }
10524                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10525                   break;
10526                 idx += ent.vn_next;
10527               }
10528
10529             if (cnt < section->sh_info)
10530               warn (_("Missing Version Needs information\n"));
10531
10532             free (eneed);
10533           }
10534           break;
10535
10536         case SHT_GNU_versym:
10537           {
10538             Elf_Internal_Shdr * link_section;
10539             size_t total;
10540             unsigned int cnt;
10541             unsigned char * edata;
10542             unsigned short * data;
10543             char * strtab;
10544             Elf_Internal_Sym * symbols;
10545             Elf_Internal_Shdr * string_sec;
10546             unsigned long num_syms;
10547             long off;
10548
10549             if (section->sh_link >= filedata->file_header.e_shnum)
10550               break;
10551
10552             link_section = filedata->section_headers + section->sh_link;
10553             total = section->sh_size / sizeof (Elf_External_Versym);
10554
10555             if (link_section->sh_link >= filedata->file_header.e_shnum)
10556               break;
10557
10558             found = TRUE;
10559
10560             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10561             if (symbols == NULL)
10562               break;
10563
10564             string_sec = filedata->section_headers + link_section->sh_link;
10565
10566             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10567                                         string_sec->sh_size,
10568                                         _("version string table"));
10569             if (!strtab)
10570               {
10571                 free (symbols);
10572                 break;
10573               }
10574
10575             printf (ngettext ("\nVersion symbols section '%s' "
10576                               "contains %lu entry:\n",
10577                               "\nVersion symbols section '%s' "
10578                               "contains %lu entries:\n",
10579                               total),
10580                     printable_section_name (filedata, section), (unsigned long) total);
10581
10582             printf (_(" Addr: "));
10583             printf_vma (section->sh_addr);
10584             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10585                     (unsigned long) section->sh_offset, section->sh_link,
10586                     printable_section_name (filedata, link_section));
10587
10588             off = offset_from_vma (filedata,
10589                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10590                                    total * sizeof (short));
10591             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10592                                                 sizeof (short),
10593                                                 _("version symbol data"));
10594             if (!edata)
10595               {
10596                 free (strtab);
10597                 free (symbols);
10598                 break;
10599               }
10600
10601             data = (short unsigned int *) cmalloc (total, sizeof (short));
10602
10603             for (cnt = total; cnt --;)
10604               data[cnt] = byte_get (edata + cnt * sizeof (short),
10605                                     sizeof (short));
10606
10607             free (edata);
10608
10609             for (cnt = 0; cnt < total; cnt += 4)
10610               {
10611                 int j, nn;
10612                 char *name;
10613                 char *invalid = _("*invalid*");
10614
10615                 printf ("  %03x:", cnt);
10616
10617                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10618                   switch (data[cnt + j])
10619                     {
10620                     case 0:
10621                       fputs (_("   0 (*local*)    "), stdout);
10622                       break;
10623
10624                     case 1:
10625                       fputs (_("   1 (*global*)   "), stdout);
10626                       break;
10627
10628                     default:
10629                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10630                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10631
10632                       /* If this index value is greater than the size of the symbols
10633                          array, break to avoid an out-of-bounds read.  */
10634                       if ((unsigned long)(cnt + j) >= num_syms)
10635                         {
10636                           warn (_("invalid index into symbol array\n"));
10637                           break;
10638                         }
10639
10640                       name = NULL;
10641                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10642                         {
10643                           Elf_Internal_Verneed ivn;
10644                           unsigned long offset;
10645
10646                           offset = offset_from_vma
10647                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10648                              sizeof (Elf_External_Verneed));
10649
10650                           do
10651                             {
10652                               Elf_Internal_Vernaux ivna;
10653                               Elf_External_Verneed evn;
10654                               Elf_External_Vernaux evna;
10655                               unsigned long a_off;
10656
10657                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10658                                             _("version need")) == NULL)
10659                                 break;
10660
10661                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10662                               ivn.vn_next = BYTE_GET (evn.vn_next);
10663
10664                               a_off = offset + ivn.vn_aux;
10665
10666                               do
10667                                 {
10668                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10669                                                 1, _("version need aux (2)")) == NULL)
10670                                     {
10671                                       ivna.vna_next  = 0;
10672                                       ivna.vna_other = 0;
10673                                     }
10674                                   else
10675                                     {
10676                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10677                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10678                                     }
10679
10680                                   a_off += ivna.vna_next;
10681                                 }
10682                               while (ivna.vna_other != data[cnt + j]
10683                                      && ivna.vna_next != 0);
10684
10685                               if (ivna.vna_other == data[cnt + j])
10686                                 {
10687                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10688
10689                                   if (ivna.vna_name >= string_sec->sh_size)
10690                                     name = invalid;
10691                                   else
10692                                     name = strtab + ivna.vna_name;
10693                                   break;
10694                                 }
10695
10696                               offset += ivn.vn_next;
10697                             }
10698                           while (ivn.vn_next);
10699                         }
10700
10701                       if (data[cnt + j] != 0x8001
10702                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10703                         {
10704                           Elf_Internal_Verdef ivd;
10705                           Elf_External_Verdef evd;
10706                           unsigned long offset;
10707
10708                           offset = offset_from_vma
10709                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10710                              sizeof evd);
10711
10712                           do
10713                             {
10714                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10715                                             _("version def")) == NULL)
10716                                 {
10717                                   ivd.vd_next = 0;
10718                                   /* PR 17531: file: 046-1082287-0.004.  */
10719                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10720                                   break;
10721                                 }
10722                               else
10723                                 {
10724                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10725                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10726                                 }
10727
10728                               offset += ivd.vd_next;
10729                             }
10730                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10731                                  && ivd.vd_next != 0);
10732
10733                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10734                             {
10735                               Elf_External_Verdaux evda;
10736                               Elf_Internal_Verdaux ivda;
10737
10738                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10739
10740                               if (get_data (&evda, filedata,
10741                                             offset - ivd.vd_next + ivd.vd_aux,
10742                                             sizeof (evda), 1,
10743                                             _("version def aux")) == NULL)
10744                                 break;
10745
10746                               ivda.vda_name = BYTE_GET (evda.vda_name);
10747
10748                               if (ivda.vda_name >= string_sec->sh_size)
10749                                 name = invalid;
10750                               else if (name != NULL && name != invalid)
10751                                 name = _("*both*");
10752                               else
10753                                 name = strtab + ivda.vda_name;
10754                             }
10755                         }
10756                       if (name != NULL)
10757                         nn += printf ("(%s%-*s",
10758                                       name,
10759                                       12 - (int) strlen (name),
10760                                       ")");
10761
10762                       if (nn < 18)
10763                         printf ("%*c", 18 - nn, ' ');
10764                     }
10765
10766                 putchar ('\n');
10767               }
10768
10769             free (data);
10770             free (strtab);
10771             free (symbols);
10772           }
10773           break;
10774
10775         default:
10776           break;
10777         }
10778     }
10779
10780   if (! found)
10781     printf (_("\nNo version information found in this file.\n"));
10782
10783   return TRUE;
10784 }
10785
10786 static const char *
10787 get_symbol_binding (Filedata * filedata, unsigned int binding)
10788 {
10789   static char buff[32];
10790
10791   switch (binding)
10792     {
10793     case STB_LOCAL:     return "LOCAL";
10794     case STB_GLOBAL:    return "GLOBAL";
10795     case STB_WEAK:      return "WEAK";
10796     default:
10797       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10798         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10799                   binding);
10800       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10801         {
10802           if (binding == STB_GNU_UNIQUE
10803               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10804                   /* GNU is still using the default value 0.  */
10805                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10806             return "UNIQUE";
10807           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10808         }
10809       else
10810         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10811       return buff;
10812     }
10813 }
10814
10815 static const char *
10816 get_symbol_type (Filedata * filedata, unsigned int type)
10817 {
10818   static char buff[32];
10819
10820   switch (type)
10821     {
10822     case STT_NOTYPE:    return "NOTYPE";
10823     case STT_OBJECT:    return "OBJECT";
10824     case STT_FUNC:      return "FUNC";
10825     case STT_SECTION:   return "SECTION";
10826     case STT_FILE:      return "FILE";
10827     case STT_COMMON:    return "COMMON";
10828     case STT_TLS:       return "TLS";
10829     case STT_RELC:      return "RELC";
10830     case STT_SRELC:     return "SRELC";
10831     default:
10832       if (type >= STT_LOPROC && type <= STT_HIPROC)
10833         {
10834           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10835             return "THUMB_FUNC";
10836
10837           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10838             return "REGISTER";
10839
10840           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10841             return "PARISC_MILLI";
10842
10843           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10844         }
10845       else if (type >= STT_LOOS && type <= STT_HIOS)
10846         {
10847           if (filedata->file_header.e_machine == EM_PARISC)
10848             {
10849               if (type == STT_HP_OPAQUE)
10850                 return "HP_OPAQUE";
10851               if (type == STT_HP_STUB)
10852                 return "HP_STUB";
10853             }
10854
10855           if (type == STT_GNU_IFUNC
10856               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10857                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10858                   /* GNU is still using the default value 0.  */
10859                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10860             return "IFUNC";
10861
10862           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10863         }
10864       else
10865         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10866       return buff;
10867     }
10868 }
10869
10870 static const char *
10871 get_symbol_visibility (unsigned int visibility)
10872 {
10873   switch (visibility)
10874     {
10875     case STV_DEFAULT:   return "DEFAULT";
10876     case STV_INTERNAL:  return "INTERNAL";
10877     case STV_HIDDEN:    return "HIDDEN";
10878     case STV_PROTECTED: return "PROTECTED";
10879     default:
10880       error (_("Unrecognized visibility value: %u"), visibility);
10881       return _("<unknown>");
10882     }
10883 }
10884
10885 static const char *
10886 get_solaris_symbol_visibility (unsigned int visibility)
10887 {
10888   switch (visibility)
10889     {
10890     case 4: return "EXPORTED";
10891     case 5: return "SINGLETON";
10892     case 6: return "ELIMINATE";
10893     default: return get_symbol_visibility (visibility);
10894     }
10895 }
10896
10897 static const char *
10898 get_mips_symbol_other (unsigned int other)
10899 {
10900   switch (other)
10901     {
10902     case STO_OPTIONAL:      return "OPTIONAL";
10903     case STO_MIPS_PLT:      return "MIPS PLT";
10904     case STO_MIPS_PIC:      return "MIPS PIC";
10905     case STO_MICROMIPS:     return "MICROMIPS";
10906     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10907     case STO_MIPS16:        return "MIPS16";
10908     default:                return NULL;
10909     }
10910 }
10911
10912 static const char *
10913 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10914 {
10915   if (is_ia64_vms (filedata))
10916     {
10917       static char res[32];
10918
10919       res[0] = 0;
10920
10921       /* Function types is for images and .STB files only.  */
10922       switch (filedata->file_header.e_type)
10923         {
10924         case ET_DYN:
10925         case ET_EXEC:
10926           switch (VMS_ST_FUNC_TYPE (other))
10927             {
10928             case VMS_SFT_CODE_ADDR:
10929               strcat (res, " CA");
10930               break;
10931             case VMS_SFT_SYMV_IDX:
10932               strcat (res, " VEC");
10933               break;
10934             case VMS_SFT_FD:
10935               strcat (res, " FD");
10936               break;
10937             case VMS_SFT_RESERVE:
10938               strcat (res, " RSV");
10939               break;
10940             default:
10941               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10942                     VMS_ST_FUNC_TYPE (other));
10943               strcat (res, " <unknown>");
10944               break;
10945             }
10946           break;
10947         default:
10948           break;
10949         }
10950       switch (VMS_ST_LINKAGE (other))
10951         {
10952         case VMS_STL_IGNORE:
10953           strcat (res, " IGN");
10954           break;
10955         case VMS_STL_RESERVE:
10956           strcat (res, " RSV");
10957           break;
10958         case VMS_STL_STD:
10959           strcat (res, " STD");
10960           break;
10961         case VMS_STL_LNK:
10962           strcat (res, " LNK");
10963           break;
10964         default:
10965           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10966                 VMS_ST_LINKAGE (other));
10967           strcat (res, " <unknown>");
10968           break;
10969         }
10970
10971       if (res[0] != 0)
10972         return res + 1;
10973       else
10974         return res;
10975     }
10976   return NULL;
10977 }
10978
10979 static const char *
10980 get_ppc64_symbol_other (unsigned int other)
10981 {
10982   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10983     {
10984       static char buf[32];
10985       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10986                 PPC64_LOCAL_ENTRY_OFFSET (other));
10987       return buf;
10988     }
10989   return NULL;
10990 }
10991
10992 static const char *
10993 get_symbol_other (Filedata * filedata, unsigned int other)
10994 {
10995   const char * result = NULL;
10996   static char buff [32];
10997
10998   if (other == 0)
10999     return "";
11000
11001   switch (filedata->file_header.e_machine)
11002     {
11003     case EM_MIPS:
11004       result = get_mips_symbol_other (other);
11005       break;
11006     case EM_IA_64:
11007       result = get_ia64_symbol_other (filedata, other);
11008       break;
11009     case EM_PPC64:
11010       result = get_ppc64_symbol_other (other);
11011       break;
11012     default:
11013       result = NULL;
11014       break;
11015     }
11016
11017   if (result)
11018     return result;
11019
11020   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11021   return buff;
11022 }
11023
11024 static const char *
11025 get_symbol_index_type (Filedata * filedata, unsigned int type)
11026 {
11027   static char buff[32];
11028
11029   switch (type)
11030     {
11031     case SHN_UNDEF:     return "UND";
11032     case SHN_ABS:       return "ABS";
11033     case SHN_COMMON:    return "COM";
11034     default:
11035       if (type == SHN_IA_64_ANSI_COMMON
11036           && filedata->file_header.e_machine == EM_IA_64
11037           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11038         return "ANSI_COM";
11039       else if ((filedata->file_header.e_machine == EM_X86_64
11040                 || filedata->file_header.e_machine == EM_L1OM
11041                 || filedata->file_header.e_machine == EM_K1OM)
11042                && type == SHN_X86_64_LCOMMON)
11043         return "LARGE_COM";
11044       else if ((type == SHN_MIPS_SCOMMON
11045                 && filedata->file_header.e_machine == EM_MIPS)
11046                || (type == SHN_TIC6X_SCOMMON
11047                    && filedata->file_header.e_machine == EM_TI_C6000))
11048         return "SCOM";
11049       else if (type == SHN_MIPS_SUNDEFINED
11050                && filedata->file_header.e_machine == EM_MIPS)
11051         return "SUND";
11052       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11053         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11054       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11055         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11056       else if (type >= SHN_LORESERVE)
11057         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11058       else if (type >= filedata->file_header.e_shnum)
11059         sprintf (buff, _("bad section index[%3d]"), type);
11060       else
11061         sprintf (buff, "%3d", type);
11062       break;
11063     }
11064
11065   return buff;
11066 }
11067
11068 static bfd_vma *
11069 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11070 {
11071   unsigned char * e_data;
11072   bfd_vma * i_data;
11073
11074   /* If the size_t type is smaller than the bfd_size_type, eg because
11075      you are building a 32-bit tool on a 64-bit host, then make sure
11076      that when (number) is cast to (size_t) no information is lost.  */
11077   if (sizeof (size_t) < sizeof (bfd_size_type)
11078       && (bfd_size_type) ((size_t) number) != number)
11079     {
11080       error (_("Size truncation prevents reading %s elements of size %u\n"),
11081              bfd_vmatoa ("u", number), ent_size);
11082       return NULL;
11083     }
11084
11085   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11086      attempting to allocate memory when the read is bound to fail.  */
11087   if (ent_size * number > filedata->file_size)
11088     {
11089       error (_("Invalid number of dynamic entries: %s\n"),
11090              bfd_vmatoa ("u", number));
11091       return NULL;
11092     }
11093
11094   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11095   if (e_data == NULL)
11096     {
11097       error (_("Out of memory reading %s dynamic entries\n"),
11098              bfd_vmatoa ("u", number));
11099       return NULL;
11100     }
11101
11102   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11103     {
11104       error (_("Unable to read in %s bytes of dynamic data\n"),
11105              bfd_vmatoa ("u", number * ent_size));
11106       free (e_data);
11107       return NULL;
11108     }
11109
11110   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11111   if (i_data == NULL)
11112     {
11113       error (_("Out of memory allocating space for %s dynamic entries\n"),
11114              bfd_vmatoa ("u", number));
11115       free (e_data);
11116       return NULL;
11117     }
11118
11119   while (number--)
11120     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11121
11122   free (e_data);
11123
11124   return i_data;
11125 }
11126
11127 static void
11128 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11129 {
11130   Elf_Internal_Sym * psym;
11131   int n;
11132
11133   n = print_vma (si, DEC_5);
11134   if (n < 5)
11135     fputs (&"     "[n], stdout);
11136   printf (" %3lu: ", hn);
11137
11138   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11139     {
11140       printf (_("<No info available for dynamic symbol number %lu>\n"),
11141               (unsigned long) si);
11142       return;
11143     }
11144
11145   psym = dynamic_symbols + si;
11146   print_vma (psym->st_value, LONG_HEX);
11147   putchar (' ');
11148   print_vma (psym->st_size, DEC_5);
11149
11150   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11151   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11152
11153   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11154     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11155   else
11156     {
11157       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11158
11159       printf (" %-7s",  get_symbol_visibility (vis));
11160       /* Check to see if any other bits in the st_other field are set.
11161          Note - displaying this information disrupts the layout of the
11162          table being generated, but for the moment this case is very
11163          rare.  */
11164       if (psym->st_other ^ vis)
11165         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11166     }
11167
11168   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11169   if (VALID_DYNAMIC_NAME (psym->st_name))
11170     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11171   else
11172     printf (_(" <corrupt: %14ld>"), psym->st_name);
11173   putchar ('\n');
11174 }
11175
11176 static const char *
11177 get_symbol_version_string (Filedata *                   filedata,
11178                            bfd_boolean                  is_dynsym,
11179                            const char *                 strtab,
11180                            unsigned long int            strtab_size,
11181                            unsigned int                 si,
11182                            Elf_Internal_Sym *           psym,
11183                            enum versioned_symbol_info * sym_info,
11184                            unsigned short *             vna_other)
11185 {
11186   unsigned char data[2];
11187   unsigned short vers_data;
11188   unsigned long offset;
11189
11190   if (!is_dynsym
11191       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11192     return NULL;
11193
11194   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11195                             sizeof data + si * sizeof (vers_data));
11196
11197   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11198                 sizeof (data), 1, _("version data")) == NULL)
11199     return NULL;
11200
11201   vers_data = byte_get (data, 2);
11202
11203   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11204     return NULL;
11205
11206   /* Usually we'd only see verdef for defined symbols, and verneed for
11207      undefined symbols.  However, symbols defined by the linker in
11208      .dynbss for variables copied from a shared library in order to
11209      avoid text relocations are defined yet have verneed.  We could
11210      use a heuristic to detect the special case, for example, check
11211      for verneed first on symbols defined in SHT_NOBITS sections, but
11212      it is simpler and more reliable to just look for both verdef and
11213      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11214
11215   if (psym->st_shndx != SHN_UNDEF
11216       && vers_data != 0x8001
11217       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11218     {
11219       Elf_Internal_Verdef ivd;
11220       Elf_Internal_Verdaux ivda;
11221       Elf_External_Verdaux evda;
11222       unsigned long off;
11223
11224       off = offset_from_vma (filedata,
11225                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11226                              sizeof (Elf_External_Verdef));
11227
11228       do
11229         {
11230           Elf_External_Verdef evd;
11231
11232           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11233                         _("version def")) == NULL)
11234             {
11235               ivd.vd_ndx = 0;
11236               ivd.vd_aux = 0;
11237               ivd.vd_next = 0;
11238             }
11239           else
11240             {
11241               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11242               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11243               ivd.vd_next = BYTE_GET (evd.vd_next);
11244             }
11245
11246           off += ivd.vd_next;
11247         }
11248       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11249
11250       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11251         {
11252           off -= ivd.vd_next;
11253           off += ivd.vd_aux;
11254
11255           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11256                         _("version def aux")) != NULL)
11257             {
11258               ivda.vda_name = BYTE_GET (evda.vda_name);
11259
11260               if (psym->st_name != ivda.vda_name)
11261                 {
11262                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11263                                ? symbol_hidden : symbol_public);
11264                   return (ivda.vda_name < strtab_size
11265                           ? strtab + ivda.vda_name : _("<corrupt>"));
11266                 }
11267             }
11268         }
11269     }
11270
11271   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11272     {
11273       Elf_External_Verneed evn;
11274       Elf_Internal_Verneed ivn;
11275       Elf_Internal_Vernaux ivna;
11276
11277       offset = offset_from_vma (filedata,
11278                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11279                                 sizeof evn);
11280       do
11281         {
11282           unsigned long vna_off;
11283
11284           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11285                         _("version need")) == NULL)
11286             {
11287               ivna.vna_next = 0;
11288               ivna.vna_other = 0;
11289               ivna.vna_name = 0;
11290               break;
11291             }
11292
11293           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11294           ivn.vn_next = BYTE_GET (evn.vn_next);
11295
11296           vna_off = offset + ivn.vn_aux;
11297
11298           do
11299             {
11300               Elf_External_Vernaux evna;
11301
11302               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11303                             _("version need aux (3)")) == NULL)
11304                 {
11305                   ivna.vna_next = 0;
11306                   ivna.vna_other = 0;
11307                   ivna.vna_name = 0;
11308                 }
11309               else
11310                 {
11311                   ivna.vna_other = BYTE_GET (evna.vna_other);
11312                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11313                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11314                 }
11315
11316               vna_off += ivna.vna_next;
11317             }
11318           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11319
11320           if (ivna.vna_other == vers_data)
11321             break;
11322
11323           offset += ivn.vn_next;
11324         }
11325       while (ivn.vn_next != 0);
11326
11327       if (ivna.vna_other == vers_data)
11328         {
11329           *sym_info = symbol_undefined;
11330           *vna_other = ivna.vna_other;
11331           return (ivna.vna_name < strtab_size
11332                   ? strtab + ivna.vna_name : _("<corrupt>"));
11333         }
11334     }
11335   return NULL;
11336 }
11337
11338 /* Dump the symbol table.  */
11339 static bfd_boolean
11340 process_symbol_table (Filedata * filedata)
11341 {
11342   Elf_Internal_Shdr * section;
11343   bfd_size_type nbuckets = 0;
11344   bfd_size_type nchains = 0;
11345   bfd_vma * buckets = NULL;
11346   bfd_vma * chains = NULL;
11347   bfd_vma ngnubuckets = 0;
11348   bfd_vma * gnubuckets = NULL;
11349   bfd_vma * gnuchains = NULL;
11350   bfd_vma gnusymidx = 0;
11351   bfd_size_type ngnuchains = 0;
11352
11353   if (!do_syms && !do_dyn_syms && !do_histogram)
11354     return TRUE;
11355
11356   if (dynamic_info[DT_HASH]
11357       && (do_histogram
11358           || (do_using_dynamic
11359               && !do_dyn_syms
11360               && dynamic_strings != NULL)))
11361     {
11362       unsigned char nb[8];
11363       unsigned char nc[8];
11364       unsigned int hash_ent_size = 4;
11365
11366       if ((filedata->file_header.e_machine == EM_ALPHA
11367            || filedata->file_header.e_machine == EM_S390
11368            || filedata->file_header.e_machine == EM_S390_OLD)
11369           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11370         hash_ent_size = 8;
11371
11372       if (fseek (filedata->handle,
11373                  (archive_file_offset
11374                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11375                                      sizeof nb + sizeof nc)),
11376                  SEEK_SET))
11377         {
11378           error (_("Unable to seek to start of dynamic information\n"));
11379           goto no_hash;
11380         }
11381
11382       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11383         {
11384           error (_("Failed to read in number of buckets\n"));
11385           goto no_hash;
11386         }
11387
11388       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11389         {
11390           error (_("Failed to read in number of chains\n"));
11391           goto no_hash;
11392         }
11393
11394       nbuckets = byte_get (nb, hash_ent_size);
11395       nchains  = byte_get (nc, hash_ent_size);
11396
11397       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11398       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11399
11400     no_hash:
11401       if (buckets == NULL || chains == NULL)
11402         {
11403           if (do_using_dynamic)
11404             return FALSE;
11405           free (buckets);
11406           free (chains);
11407           buckets = NULL;
11408           chains = NULL;
11409           nbuckets = 0;
11410           nchains = 0;
11411         }
11412     }
11413
11414   if (dynamic_info_DT_GNU_HASH
11415       && (do_histogram
11416           || (do_using_dynamic
11417               && !do_dyn_syms
11418               && dynamic_strings != NULL)))
11419     {
11420       unsigned char nb[16];
11421       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11422       bfd_vma buckets_vma;
11423
11424       if (fseek (filedata->handle,
11425                  (archive_file_offset
11426                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11427                                      sizeof nb)),
11428                  SEEK_SET))
11429         {
11430           error (_("Unable to seek to start of dynamic information\n"));
11431           goto no_gnu_hash;
11432         }
11433
11434       if (fread (nb, 16, 1, filedata->handle) != 1)
11435         {
11436           error (_("Failed to read in number of buckets\n"));
11437           goto no_gnu_hash;
11438         }
11439
11440       ngnubuckets = byte_get (nb, 4);
11441       gnusymidx = byte_get (nb + 4, 4);
11442       bitmaskwords = byte_get (nb + 8, 4);
11443       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11444       if (is_32bit_elf)
11445         buckets_vma += bitmaskwords * 4;
11446       else
11447         buckets_vma += bitmaskwords * 8;
11448
11449       if (fseek (filedata->handle,
11450                  (archive_file_offset
11451                   + offset_from_vma (filedata, buckets_vma, 4)),
11452                  SEEK_SET))
11453         {
11454           error (_("Unable to seek to start of dynamic information\n"));
11455           goto no_gnu_hash;
11456         }
11457
11458       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11459
11460       if (gnubuckets == NULL)
11461         goto no_gnu_hash;
11462
11463       for (i = 0; i < ngnubuckets; i++)
11464         if (gnubuckets[i] != 0)
11465           {
11466             if (gnubuckets[i] < gnusymidx)
11467               return FALSE;
11468
11469             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11470               maxchain = gnubuckets[i];
11471           }
11472
11473       if (maxchain == 0xffffffff)
11474         goto no_gnu_hash;
11475
11476       maxchain -= gnusymidx;
11477
11478       if (fseek (filedata->handle,
11479                  (archive_file_offset
11480                   + offset_from_vma (filedata, buckets_vma
11481                                            + 4 * (ngnubuckets + maxchain), 4)),
11482                  SEEK_SET))
11483         {
11484           error (_("Unable to seek to start of dynamic information\n"));
11485           goto no_gnu_hash;
11486         }
11487
11488       do
11489         {
11490           if (fread (nb, 4, 1, filedata->handle) != 1)
11491             {
11492               error (_("Failed to determine last chain length\n"));
11493               goto no_gnu_hash;
11494             }
11495
11496           if (maxchain + 1 == 0)
11497             goto no_gnu_hash;
11498
11499           ++maxchain;
11500         }
11501       while ((byte_get (nb, 4) & 1) == 0);
11502
11503       if (fseek (filedata->handle,
11504                  (archive_file_offset
11505                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11506                  SEEK_SET))
11507         {
11508           error (_("Unable to seek to start of dynamic information\n"));
11509           goto no_gnu_hash;
11510         }
11511
11512       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11513       ngnuchains = maxchain;
11514
11515     no_gnu_hash:
11516       if (gnuchains == NULL)
11517         {
11518           free (gnubuckets);
11519           gnubuckets = NULL;
11520           ngnubuckets = 0;
11521           if (do_using_dynamic)
11522             return FALSE;
11523         }
11524     }
11525
11526   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11527       && do_syms
11528       && do_using_dynamic
11529       && dynamic_strings != NULL
11530       && dynamic_symbols != NULL)
11531     {
11532       unsigned long hn;
11533
11534       if (dynamic_info[DT_HASH])
11535         {
11536           bfd_vma si;
11537           char *visited;
11538
11539           printf (_("\nSymbol table for image:\n"));
11540           if (is_32bit_elf)
11541             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11542           else
11543             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11544
11545           visited = xcmalloc (nchains, 1);
11546           memset (visited, 0, nchains);
11547           for (hn = 0; hn < nbuckets; hn++)
11548             {
11549               for (si = buckets[hn]; si > 0; si = chains[si])
11550                 {
11551                   print_dynamic_symbol (filedata, si, hn);
11552                   if (si >= nchains || visited[si])
11553                     {
11554                       error (_("histogram chain is corrupt\n"));
11555                       break;
11556                     }
11557                   visited[si] = 1;
11558                 }
11559             }
11560           free (visited);
11561         }
11562
11563       if (dynamic_info_DT_GNU_HASH)
11564         {
11565           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11566           if (is_32bit_elf)
11567             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11568           else
11569             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11570
11571           for (hn = 0; hn < ngnubuckets; ++hn)
11572             if (gnubuckets[hn] != 0)
11573               {
11574                 bfd_vma si = gnubuckets[hn];
11575                 bfd_vma off = si - gnusymidx;
11576
11577                 do
11578                   {
11579                     print_dynamic_symbol (filedata, si, hn);
11580                     si++;
11581                   }
11582                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11583               }
11584         }
11585     }
11586   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11587            && filedata->section_headers != NULL)
11588     {
11589       unsigned int i;
11590
11591       for (i = 0, section = filedata->section_headers;
11592            i < filedata->file_header.e_shnum;
11593            i++, section++)
11594         {
11595           unsigned int si;
11596           char * strtab = NULL;
11597           unsigned long int strtab_size = 0;
11598           Elf_Internal_Sym * symtab;
11599           Elf_Internal_Sym * psym;
11600           unsigned long num_syms;
11601
11602           if ((section->sh_type != SHT_SYMTAB
11603                && section->sh_type != SHT_DYNSYM)
11604               || (!do_syms
11605                   && section->sh_type == SHT_SYMTAB))
11606             continue;
11607
11608           if (section->sh_entsize == 0)
11609             {
11610               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11611                       printable_section_name (filedata, section));
11612               continue;
11613             }
11614
11615           num_syms = section->sh_size / section->sh_entsize;
11616           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11617                             "\nSymbol table '%s' contains %lu entries:\n",
11618                             num_syms),
11619                   printable_section_name (filedata, section),
11620                   num_syms);
11621
11622           if (is_32bit_elf)
11623             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11624           else
11625             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11626
11627           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11628           if (symtab == NULL)
11629             continue;
11630
11631           if (section->sh_link == filedata->file_header.e_shstrndx)
11632             {
11633               strtab = filedata->string_table;
11634               strtab_size = filedata->string_table_length;
11635             }
11636           else if (section->sh_link < filedata->file_header.e_shnum)
11637             {
11638               Elf_Internal_Shdr * string_sec;
11639
11640               string_sec = filedata->section_headers + section->sh_link;
11641
11642               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11643                                           1, string_sec->sh_size,
11644                                           _("string table"));
11645               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11646             }
11647
11648           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11649             {
11650               const char *version_string;
11651               enum versioned_symbol_info sym_info;
11652               unsigned short vna_other;
11653
11654               printf ("%6d: ", si);
11655               print_vma (psym->st_value, LONG_HEX);
11656               putchar (' ');
11657               print_vma (psym->st_size, DEC_5);
11658               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11659               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11660               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11661                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11662               else
11663                 {
11664                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11665
11666                   printf (" %-7s", get_symbol_visibility (vis));
11667                   /* Check to see if any other bits in the st_other field are set.
11668                      Note - displaying this information disrupts the layout of the
11669                      table being generated, but for the moment this case is very rare.  */
11670                   if (psym->st_other ^ vis)
11671                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11672                 }
11673               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11674               print_symbol (25, psym->st_name < strtab_size
11675                             ? strtab + psym->st_name : _("<corrupt>"));
11676
11677               version_string
11678                 = get_symbol_version_string (filedata,
11679                                              section->sh_type == SHT_DYNSYM,
11680                                              strtab, strtab_size, si,
11681                                              psym, &sym_info, &vna_other);
11682               if (version_string)
11683                 {
11684                   if (sym_info == symbol_undefined)
11685                     printf ("@%s (%d)", version_string, vna_other);
11686                   else
11687                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11688                             version_string);
11689                 }
11690
11691               putchar ('\n');
11692
11693               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11694                   && si >= section->sh_info
11695                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11696                   && filedata->file_header.e_machine != EM_MIPS
11697                   /* Solaris binaries have been found to violate this requirement as
11698                      well.  Not sure if this is a bug or an ABI requirement.  */
11699                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11700                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11701                       si, printable_section_name (filedata, section), section->sh_info);
11702             }
11703
11704           free (symtab);
11705           if (strtab != filedata->string_table)
11706             free (strtab);
11707         }
11708     }
11709   else if (do_syms)
11710     printf
11711       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11712
11713   if (do_histogram && buckets != NULL)
11714     {
11715       unsigned long * lengths;
11716       unsigned long * counts;
11717       unsigned long hn;
11718       bfd_vma si;
11719       unsigned long maxlength = 0;
11720       unsigned long nzero_counts = 0;
11721       unsigned long nsyms = 0;
11722       char *visited;
11723
11724       printf (ngettext ("\nHistogram for bucket list length "
11725                         "(total of %lu bucket):\n",
11726                         "\nHistogram for bucket list length "
11727                         "(total of %lu buckets):\n",
11728                         (unsigned long) nbuckets),
11729               (unsigned long) nbuckets);
11730
11731       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11732       if (lengths == NULL)
11733         {
11734           error (_("Out of memory allocating space for histogram buckets\n"));
11735           return FALSE;
11736         }
11737       visited = xcmalloc (nchains, 1);
11738       memset (visited, 0, nchains);
11739
11740       printf (_(" Length  Number     %% of total  Coverage\n"));
11741       for (hn = 0; hn < nbuckets; ++hn)
11742         {
11743           for (si = buckets[hn]; si > 0; si = chains[si])
11744             {
11745               ++nsyms;
11746               if (maxlength < ++lengths[hn])
11747                 ++maxlength;
11748               if (si >= nchains || visited[si])
11749                 {
11750                   error (_("histogram chain is corrupt\n"));
11751                   break;
11752                 }
11753               visited[si] = 1;
11754             }
11755         }
11756       free (visited);
11757
11758       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11759       if (counts == NULL)
11760         {
11761           free (lengths);
11762           error (_("Out of memory allocating space for histogram counts\n"));
11763           return FALSE;
11764         }
11765
11766       for (hn = 0; hn < nbuckets; ++hn)
11767         ++counts[lengths[hn]];
11768
11769       if (nbuckets > 0)
11770         {
11771           unsigned long i;
11772           printf ("      0  %-10lu (%5.1f%%)\n",
11773                   counts[0], (counts[0] * 100.0) / nbuckets);
11774           for (i = 1; i <= maxlength; ++i)
11775             {
11776               nzero_counts += counts[i] * i;
11777               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11778                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11779                       (nzero_counts * 100.0) / nsyms);
11780             }
11781         }
11782
11783       free (counts);
11784       free (lengths);
11785     }
11786
11787   if (buckets != NULL)
11788     {
11789       free (buckets);
11790       free (chains);
11791     }
11792
11793   if (do_histogram && gnubuckets != NULL)
11794     {
11795       unsigned long * lengths;
11796       unsigned long * counts;
11797       unsigned long hn;
11798       unsigned long maxlength = 0;
11799       unsigned long nzero_counts = 0;
11800       unsigned long nsyms = 0;
11801
11802       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11803                         "(total of %lu bucket):\n",
11804                         "\nHistogram for `.gnu.hash' bucket list length "
11805                         "(total of %lu buckets):\n",
11806                         (unsigned long) ngnubuckets),
11807               (unsigned long) ngnubuckets);
11808
11809       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11810       if (lengths == NULL)
11811         {
11812           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11813           return FALSE;
11814         }
11815
11816       printf (_(" Length  Number     %% of total  Coverage\n"));
11817
11818       for (hn = 0; hn < ngnubuckets; ++hn)
11819         if (gnubuckets[hn] != 0)
11820           {
11821             bfd_vma off, length = 1;
11822
11823             for (off = gnubuckets[hn] - gnusymidx;
11824                  /* PR 17531 file: 010-77222-0.004.  */
11825                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11826                  ++off)
11827               ++length;
11828             lengths[hn] = length;
11829             if (length > maxlength)
11830               maxlength = length;
11831             nsyms += length;
11832           }
11833
11834       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11835       if (counts == NULL)
11836         {
11837           free (lengths);
11838           error (_("Out of memory allocating space for gnu histogram counts\n"));
11839           return FALSE;
11840         }
11841
11842       for (hn = 0; hn < ngnubuckets; ++hn)
11843         ++counts[lengths[hn]];
11844
11845       if (ngnubuckets > 0)
11846         {
11847           unsigned long j;
11848           printf ("      0  %-10lu (%5.1f%%)\n",
11849                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11850           for (j = 1; j <= maxlength; ++j)
11851             {
11852               nzero_counts += counts[j] * j;
11853               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11854                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11855                       (nzero_counts * 100.0) / nsyms);
11856             }
11857         }
11858
11859       free (counts);
11860       free (lengths);
11861       free (gnubuckets);
11862       free (gnuchains);
11863     }
11864
11865   return TRUE;
11866 }
11867
11868 static bfd_boolean
11869 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11870 {
11871   unsigned int i;
11872
11873   if (dynamic_syminfo == NULL
11874       || !do_dynamic)
11875     /* No syminfo, this is ok.  */
11876     return TRUE;
11877
11878   /* There better should be a dynamic symbol section.  */
11879   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11880     return FALSE;
11881
11882   if (dynamic_addr)
11883     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11884                       "contains %d entry:\n",
11885                       "\nDynamic info segment at offset 0x%lx "
11886                       "contains %d entries:\n",
11887                       dynamic_syminfo_nent),
11888             dynamic_syminfo_offset, dynamic_syminfo_nent);
11889
11890   printf (_(" Num: Name                           BoundTo     Flags\n"));
11891   for (i = 0; i < dynamic_syminfo_nent; ++i)
11892     {
11893       unsigned short int flags = dynamic_syminfo[i].si_flags;
11894
11895       printf ("%4d: ", i);
11896       if (i >= num_dynamic_syms)
11897         printf (_("<corrupt index>"));
11898       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11899         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11900       else
11901         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11902       putchar (' ');
11903
11904       switch (dynamic_syminfo[i].si_boundto)
11905         {
11906         case SYMINFO_BT_SELF:
11907           fputs ("SELF       ", stdout);
11908           break;
11909         case SYMINFO_BT_PARENT:
11910           fputs ("PARENT     ", stdout);
11911           break;
11912         default:
11913           if (dynamic_syminfo[i].si_boundto > 0
11914               && dynamic_syminfo[i].si_boundto < dynamic_nent
11915               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11916             {
11917               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11918               putchar (' ' );
11919             }
11920           else
11921             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11922           break;
11923         }
11924
11925       if (flags & SYMINFO_FLG_DIRECT)
11926         printf (" DIRECT");
11927       if (flags & SYMINFO_FLG_PASSTHRU)
11928         printf (" PASSTHRU");
11929       if (flags & SYMINFO_FLG_COPY)
11930         printf (" COPY");
11931       if (flags & SYMINFO_FLG_LAZYLOAD)
11932         printf (" LAZYLOAD");
11933
11934       puts ("");
11935     }
11936
11937   return TRUE;
11938 }
11939
11940 #define IN_RANGE(START,END,ADDR,OFF)            \
11941   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11942
11943 /* Check to see if the given reloc needs to be handled in a target specific
11944    manner.  If so then process the reloc and return TRUE otherwise return
11945    FALSE.
11946
11947    If called with reloc == NULL, then this is a signal that reloc processing
11948    for the current section has finished, and any saved state should be
11949    discarded.  */
11950
11951 static bfd_boolean
11952 target_specific_reloc_handling (Filedata *           filedata,
11953                                 Elf_Internal_Rela *  reloc,
11954                                 unsigned char *      start,
11955                                 unsigned char *      end,
11956                                 Elf_Internal_Sym *   symtab,
11957                                 unsigned long        num_syms)
11958 {
11959   unsigned int reloc_type = 0;
11960   unsigned long sym_index = 0;
11961
11962   if (reloc)
11963     {
11964       reloc_type = get_reloc_type (filedata, reloc->r_info);
11965       sym_index = get_reloc_symindex (reloc->r_info);
11966     }
11967
11968   switch (filedata->file_header.e_machine)
11969     {
11970     case EM_MSP430:
11971     case EM_MSP430_OLD:
11972       {
11973         static Elf_Internal_Sym * saved_sym = NULL;
11974
11975         if (reloc == NULL)
11976           {
11977             saved_sym = NULL;
11978             return TRUE;
11979           }
11980
11981         switch (reloc_type)
11982           {
11983           case 10: /* R_MSP430_SYM_DIFF */
11984             if (uses_msp430x_relocs (filedata))
11985               break;
11986             /* Fall through.  */
11987           case 21: /* R_MSP430X_SYM_DIFF */
11988             /* PR 21139.  */
11989             if (sym_index >= num_syms)
11990               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11991                      sym_index);
11992             else
11993               saved_sym = symtab + sym_index;
11994             return TRUE;
11995
11996           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11997           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11998             goto handle_sym_diff;
11999
12000           case 5: /* R_MSP430_16_BYTE */
12001           case 9: /* R_MSP430_8 */
12002             if (uses_msp430x_relocs (filedata))
12003               break;
12004             goto handle_sym_diff;
12005
12006           case 2: /* R_MSP430_ABS16 */
12007           case 15: /* R_MSP430X_ABS16 */
12008             if (! uses_msp430x_relocs (filedata))
12009               break;
12010             goto handle_sym_diff;
12011
12012           handle_sym_diff:
12013             if (saved_sym != NULL)
12014               {
12015                 int reloc_size = reloc_type == 1 ? 4 : 2;
12016                 bfd_vma value;
12017
12018                 if (sym_index >= num_syms)
12019                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12020                          sym_index);
12021                 else
12022                   {
12023                     value = reloc->r_addend + (symtab[sym_index].st_value
12024                                                - saved_sym->st_value);
12025
12026                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12027                       byte_put (start + reloc->r_offset, value, reloc_size);
12028                     else
12029                       /* PR 21137 */
12030                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12031                              (long) reloc->r_offset);
12032                   }
12033
12034                 saved_sym = NULL;
12035                 return TRUE;
12036               }
12037             break;
12038
12039           default:
12040             if (saved_sym != NULL)
12041               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12042             break;
12043           }
12044         break;
12045       }
12046
12047     case EM_MN10300:
12048     case EM_CYGNUS_MN10300:
12049       {
12050         static Elf_Internal_Sym * saved_sym = NULL;
12051
12052         if (reloc == NULL)
12053           {
12054             saved_sym = NULL;
12055             return TRUE;
12056           }
12057
12058         switch (reloc_type)
12059           {
12060           case 34: /* R_MN10300_ALIGN */
12061             return TRUE;
12062           case 33: /* R_MN10300_SYM_DIFF */
12063             if (sym_index >= num_syms)
12064               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12065                      sym_index);
12066             else
12067               saved_sym = symtab + sym_index;
12068             return TRUE;
12069
12070           case 1: /* R_MN10300_32 */
12071           case 2: /* R_MN10300_16 */
12072             if (saved_sym != NULL)
12073               {
12074                 int reloc_size = reloc_type == 1 ? 4 : 2;
12075                 bfd_vma value;
12076
12077                 if (sym_index >= num_syms)
12078                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12079                          sym_index);
12080                 else
12081                   {
12082                     value = reloc->r_addend + (symtab[sym_index].st_value
12083                                                - saved_sym->st_value);
12084
12085                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12086                       byte_put (start + reloc->r_offset, value, reloc_size);
12087                     else
12088                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12089                              (long) reloc->r_offset);
12090                   }
12091
12092                 saved_sym = NULL;
12093                 return TRUE;
12094               }
12095             break;
12096           default:
12097             if (saved_sym != NULL)
12098               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12099             break;
12100           }
12101         break;
12102       }
12103
12104     case EM_RL78:
12105       {
12106         static bfd_vma saved_sym1 = 0;
12107         static bfd_vma saved_sym2 = 0;
12108         static bfd_vma value;
12109
12110         if (reloc == NULL)
12111           {
12112             saved_sym1 = saved_sym2 = 0;
12113             return TRUE;
12114           }
12115
12116         switch (reloc_type)
12117           {
12118           case 0x80: /* R_RL78_SYM.  */
12119             saved_sym1 = saved_sym2;
12120             if (sym_index >= num_syms)
12121               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12122                      sym_index);
12123             else
12124               {
12125                 saved_sym2 = symtab[sym_index].st_value;
12126                 saved_sym2 += reloc->r_addend;
12127               }
12128             return TRUE;
12129
12130           case 0x83: /* R_RL78_OPsub.  */
12131             value = saved_sym1 - saved_sym2;
12132             saved_sym2 = saved_sym1 = 0;
12133             return TRUE;
12134             break;
12135
12136           case 0x41: /* R_RL78_ABS32.  */
12137             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12138               byte_put (start + reloc->r_offset, value, 4);
12139             else
12140               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12141                      (long) reloc->r_offset);
12142             value = 0;
12143             return TRUE;
12144
12145           case 0x43: /* R_RL78_ABS16.  */
12146             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12147               byte_put (start + reloc->r_offset, value, 2);
12148             else
12149               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12150                      (long) reloc->r_offset);
12151             value = 0;
12152             return TRUE;
12153
12154           default:
12155             break;
12156           }
12157         break;
12158       }
12159     }
12160
12161   return FALSE;
12162 }
12163
12164 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12165    DWARF debug sections.  This is a target specific test.  Note - we do not
12166    go through the whole including-target-headers-multiple-times route, (as
12167    we have already done with <elf/h8.h>) because this would become very
12168    messy and even then this function would have to contain target specific
12169    information (the names of the relocs instead of their numeric values).
12170    FIXME: This is not the correct way to solve this problem.  The proper way
12171    is to have target specific reloc sizing and typing functions created by
12172    the reloc-macros.h header, in the same way that it already creates the
12173    reloc naming functions.  */
12174
12175 static bfd_boolean
12176 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12177 {
12178   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12179   switch (filedata->file_header.e_machine)
12180     {
12181     case EM_386:
12182     case EM_IAMCU:
12183       return reloc_type == 1; /* R_386_32.  */
12184     case EM_68K:
12185       return reloc_type == 1; /* R_68K_32.  */
12186     case EM_AARCH64:
12187       return (reloc_type == 258
12188               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12189     case EM_ADAPTEVA_EPIPHANY:
12190       return reloc_type == 3;
12191     case EM_ALPHA:
12192       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12193     case EM_ARC:
12194       return reloc_type == 1; /* R_ARC_32.  */
12195     case EM_ARC_COMPACT:
12196     case EM_ARC_COMPACT2:
12197       return reloc_type == 4; /* R_ARC_32.  */
12198     case EM_ARM:
12199       return reloc_type == 2; /* R_ARM_ABS32 */
12200     case EM_AVR_OLD:
12201     case EM_AVR:
12202       return reloc_type == 1;
12203     case EM_BLACKFIN:
12204       return reloc_type == 0x12; /* R_byte4_data.  */
12205     case EM_CRIS:
12206       return reloc_type == 3; /* R_CRIS_32.  */
12207     case EM_CR16:
12208       return reloc_type == 3; /* R_CR16_NUM32.  */
12209     case EM_CRX:
12210       return reloc_type == 15; /* R_CRX_NUM32.  */
12211     case EM_CYGNUS_FRV:
12212       return reloc_type == 1;
12213     case EM_CYGNUS_D10V:
12214     case EM_D10V:
12215       return reloc_type == 6; /* R_D10V_32.  */
12216     case EM_CYGNUS_D30V:
12217     case EM_D30V:
12218       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12219     case EM_DLX:
12220       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12221     case EM_CYGNUS_FR30:
12222     case EM_FR30:
12223       return reloc_type == 3; /* R_FR30_32.  */
12224     case EM_FT32:
12225       return reloc_type == 1; /* R_FT32_32.  */
12226     case EM_H8S:
12227     case EM_H8_300:
12228     case EM_H8_300H:
12229       return reloc_type == 1; /* R_H8_DIR32.  */
12230     case EM_IA_64:
12231       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12232               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12233               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12234               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12235     case EM_IP2K_OLD:
12236     case EM_IP2K:
12237       return reloc_type == 2; /* R_IP2K_32.  */
12238     case EM_IQ2000:
12239       return reloc_type == 2; /* R_IQ2000_32.  */
12240     case EM_LATTICEMICO32:
12241       return reloc_type == 3; /* R_LM32_32.  */
12242     case EM_M32C_OLD:
12243     case EM_M32C:
12244       return reloc_type == 3; /* R_M32C_32.  */
12245     case EM_M32R:
12246       return reloc_type == 34; /* R_M32R_32_RELA.  */
12247     case EM_68HC11:
12248     case EM_68HC12:
12249       return reloc_type == 6; /* R_M68HC11_32.  */
12250     case EM_MCORE:
12251       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12252     case EM_CYGNUS_MEP:
12253       return reloc_type == 4; /* R_MEP_32.  */
12254     case EM_METAG:
12255       return reloc_type == 2; /* R_METAG_ADDR32.  */
12256     case EM_MICROBLAZE:
12257       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12258     case EM_MIPS:
12259       return reloc_type == 2; /* R_MIPS_32.  */
12260     case EM_MMIX:
12261       return reloc_type == 4; /* R_MMIX_32.  */
12262     case EM_CYGNUS_MN10200:
12263     case EM_MN10200:
12264       return reloc_type == 1; /* R_MN10200_32.  */
12265     case EM_CYGNUS_MN10300:
12266     case EM_MN10300:
12267       return reloc_type == 1; /* R_MN10300_32.  */
12268     case EM_MOXIE:
12269       return reloc_type == 1; /* R_MOXIE_32.  */
12270     case EM_MSP430_OLD:
12271     case EM_MSP430:
12272       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12273     case EM_MT:
12274       return reloc_type == 2; /* R_MT_32.  */
12275     case EM_NDS32:
12276       return reloc_type == 20; /* R_NDS32_RELA.  */
12277     case EM_ALTERA_NIOS2:
12278       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12279     case EM_NIOS32:
12280       return reloc_type == 1; /* R_NIOS_32.  */
12281     case EM_OR1K:
12282       return reloc_type == 1; /* R_OR1K_32.  */
12283     case EM_PARISC:
12284       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12285               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12286     case EM_PJ:
12287     case EM_PJ_OLD:
12288       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12289     case EM_PPC64:
12290       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12291     case EM_PPC:
12292       return reloc_type == 1; /* R_PPC_ADDR32.  */
12293     case EM_TI_PRU:
12294       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12295     case EM_RISCV:
12296       return reloc_type == 1; /* R_RISCV_32.  */
12297     case EM_RL78:
12298       return reloc_type == 1; /* R_RL78_DIR32.  */
12299     case EM_RX:
12300       return reloc_type == 1; /* R_RX_DIR32.  */
12301     case EM_S370:
12302       return reloc_type == 1; /* R_I370_ADDR31.  */
12303     case EM_S390_OLD:
12304     case EM_S390:
12305       return reloc_type == 4; /* R_S390_32.  */
12306     case EM_SCORE:
12307       return reloc_type == 8; /* R_SCORE_ABS32.  */
12308     case EM_SH:
12309       return reloc_type == 1; /* R_SH_DIR32.  */
12310     case EM_SPARC32PLUS:
12311     case EM_SPARCV9:
12312     case EM_SPARC:
12313       return reloc_type == 3 /* R_SPARC_32.  */
12314         || reloc_type == 23; /* R_SPARC_UA32.  */
12315     case EM_SPU:
12316       return reloc_type == 6; /* R_SPU_ADDR32 */
12317     case EM_TI_C6000:
12318       return reloc_type == 1; /* R_C6000_ABS32.  */
12319     case EM_TILEGX:
12320       return reloc_type == 2; /* R_TILEGX_32.  */
12321     case EM_TILEPRO:
12322       return reloc_type == 1; /* R_TILEPRO_32.  */
12323     case EM_CYGNUS_V850:
12324     case EM_V850:
12325       return reloc_type == 6; /* R_V850_ABS32.  */
12326     case EM_V800:
12327       return reloc_type == 0x33; /* R_V810_WORD.  */
12328     case EM_VAX:
12329       return reloc_type == 1; /* R_VAX_32.  */
12330     case EM_VISIUM:
12331       return reloc_type == 3;  /* R_VISIUM_32. */
12332     case EM_WEBASSEMBLY:
12333       return reloc_type == 1;  /* R_WASM32_32.  */
12334     case EM_X86_64:
12335     case EM_L1OM:
12336     case EM_K1OM:
12337       return reloc_type == 10; /* R_X86_64_32.  */
12338     case EM_XC16X:
12339     case EM_C166:
12340       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12341     case EM_XGATE:
12342       return reloc_type == 4; /* R_XGATE_32.  */
12343     case EM_XSTORMY16:
12344       return reloc_type == 1; /* R_XSTROMY16_32.  */
12345     case EM_XTENSA_OLD:
12346     case EM_XTENSA:
12347       return reloc_type == 1; /* R_XTENSA_32.  */
12348     default:
12349       {
12350         static unsigned int prev_warn = 0;
12351
12352         /* Avoid repeating the same warning multiple times.  */
12353         if (prev_warn != filedata->file_header.e_machine)
12354           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12355                  filedata->file_header.e_machine);
12356         prev_warn = filedata->file_header.e_machine;
12357         return FALSE;
12358       }
12359     }
12360 }
12361
12362 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12363    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12364
12365 static bfd_boolean
12366 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12367 {
12368   switch (filedata->file_header.e_machine)
12369   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12370     {
12371     case EM_386:
12372     case EM_IAMCU:
12373       return reloc_type == 2;  /* R_386_PC32.  */
12374     case EM_68K:
12375       return reloc_type == 4;  /* R_68K_PC32.  */
12376     case EM_AARCH64:
12377       return reloc_type == 261; /* R_AARCH64_PREL32 */
12378     case EM_ADAPTEVA_EPIPHANY:
12379       return reloc_type == 6;
12380     case EM_ALPHA:
12381       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12382     case EM_ARC_COMPACT:
12383     case EM_ARC_COMPACT2:
12384       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12385     case EM_ARM:
12386       return reloc_type == 3;  /* R_ARM_REL32 */
12387     case EM_AVR_OLD:
12388     case EM_AVR:
12389       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12390     case EM_MICROBLAZE:
12391       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12392     case EM_OR1K:
12393       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12394     case EM_PARISC:
12395       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12396     case EM_PPC:
12397       return reloc_type == 26; /* R_PPC_REL32.  */
12398     case EM_PPC64:
12399       return reloc_type == 26; /* R_PPC64_REL32.  */
12400     case EM_S390_OLD:
12401     case EM_S390:
12402       return reloc_type == 5;  /* R_390_PC32.  */
12403     case EM_SH:
12404       return reloc_type == 2;  /* R_SH_REL32.  */
12405     case EM_SPARC32PLUS:
12406     case EM_SPARCV9:
12407     case EM_SPARC:
12408       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12409     case EM_SPU:
12410       return reloc_type == 13; /* R_SPU_REL32.  */
12411     case EM_TILEGX:
12412       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12413     case EM_TILEPRO:
12414       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12415     case EM_VISIUM:
12416       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12417     case EM_X86_64:
12418     case EM_L1OM:
12419     case EM_K1OM:
12420       return reloc_type == 2;  /* R_X86_64_PC32.  */
12421     case EM_XTENSA_OLD:
12422     case EM_XTENSA:
12423       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12424     default:
12425       /* Do not abort or issue an error message here.  Not all targets use
12426          pc-relative 32-bit relocs in their DWARF debug information and we
12427          have already tested for target coverage in is_32bit_abs_reloc.  A
12428          more helpful warning message will be generated by apply_relocations
12429          anyway, so just return.  */
12430       return FALSE;
12431     }
12432 }
12433
12434 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12435    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12436
12437 static bfd_boolean
12438 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12439 {
12440   switch (filedata->file_header.e_machine)
12441     {
12442     case EM_AARCH64:
12443       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12444     case EM_ALPHA:
12445       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12446     case EM_IA_64:
12447       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12448               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12449     case EM_PARISC:
12450       return reloc_type == 80; /* R_PARISC_DIR64.  */
12451     case EM_PPC64:
12452       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12453     case EM_RISCV:
12454       return reloc_type == 2; /* R_RISCV_64.  */
12455     case EM_SPARC32PLUS:
12456     case EM_SPARCV9:
12457     case EM_SPARC:
12458       return reloc_type == 32 /* R_SPARC_64.  */
12459         || reloc_type == 54; /* R_SPARC_UA64.  */
12460     case EM_X86_64:
12461     case EM_L1OM:
12462     case EM_K1OM:
12463       return reloc_type == 1; /* R_X86_64_64.  */
12464     case EM_S390_OLD:
12465     case EM_S390:
12466       return reloc_type == 22;  /* R_S390_64.  */
12467     case EM_TILEGX:
12468       return reloc_type == 1; /* R_TILEGX_64.  */
12469     case EM_MIPS:
12470       return reloc_type == 18;  /* R_MIPS_64.  */
12471     default:
12472       return FALSE;
12473     }
12474 }
12475
12476 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12477    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12478
12479 static bfd_boolean
12480 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12481 {
12482   switch (filedata->file_header.e_machine)
12483     {
12484     case EM_AARCH64:
12485       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12486     case EM_ALPHA:
12487       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12488     case EM_IA_64:
12489       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12490               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12491     case EM_PARISC:
12492       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12493     case EM_PPC64:
12494       return reloc_type == 44; /* R_PPC64_REL64.  */
12495     case EM_SPARC32PLUS:
12496     case EM_SPARCV9:
12497     case EM_SPARC:
12498       return reloc_type == 46; /* R_SPARC_DISP64.  */
12499     case EM_X86_64:
12500     case EM_L1OM:
12501     case EM_K1OM:
12502       return reloc_type == 24; /* R_X86_64_PC64.  */
12503     case EM_S390_OLD:
12504     case EM_S390:
12505       return reloc_type == 23;  /* R_S390_PC64.  */
12506     case EM_TILEGX:
12507       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12508     default:
12509       return FALSE;
12510     }
12511 }
12512
12513 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12514    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12515
12516 static bfd_boolean
12517 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12518 {
12519   switch (filedata->file_header.e_machine)
12520     {
12521     case EM_CYGNUS_MN10200:
12522     case EM_MN10200:
12523       return reloc_type == 4; /* R_MN10200_24.  */
12524     case EM_FT32:
12525       return reloc_type == 5; /* R_FT32_20.  */
12526     default:
12527       return FALSE;
12528     }
12529 }
12530
12531 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12532    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12533
12534 static bfd_boolean
12535 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12536 {
12537   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12538   switch (filedata->file_header.e_machine)
12539     {
12540     case EM_ARC:
12541     case EM_ARC_COMPACT:
12542     case EM_ARC_COMPACT2:
12543       return reloc_type == 2; /* R_ARC_16.  */
12544     case EM_ADAPTEVA_EPIPHANY:
12545       return reloc_type == 5;
12546     case EM_AVR_OLD:
12547     case EM_AVR:
12548       return reloc_type == 4; /* R_AVR_16.  */
12549     case EM_CYGNUS_D10V:
12550     case EM_D10V:
12551       return reloc_type == 3; /* R_D10V_16.  */
12552     case EM_FT32:
12553       return reloc_type == 2; /* R_FT32_16.  */
12554     case EM_H8S:
12555     case EM_H8_300:
12556     case EM_H8_300H:
12557       return reloc_type == R_H8_DIR16;
12558     case EM_IP2K_OLD:
12559     case EM_IP2K:
12560       return reloc_type == 1; /* R_IP2K_16.  */
12561     case EM_M32C_OLD:
12562     case EM_M32C:
12563       return reloc_type == 1; /* R_M32C_16 */
12564     case EM_CYGNUS_MN10200:
12565     case EM_MN10200:
12566       return reloc_type == 2; /* R_MN10200_16.  */
12567     case EM_CYGNUS_MN10300:
12568     case EM_MN10300:
12569       return reloc_type == 2; /* R_MN10300_16.  */
12570     case EM_MSP430:
12571       if (uses_msp430x_relocs (filedata))
12572         return reloc_type == 2; /* R_MSP430_ABS16.  */
12573       /* Fall through.  */
12574     case EM_MSP430_OLD:
12575       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12576     case EM_NDS32:
12577       return reloc_type == 19; /* R_NDS32_RELA.  */
12578     case EM_ALTERA_NIOS2:
12579       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12580     case EM_NIOS32:
12581       return reloc_type == 9; /* R_NIOS_16.  */
12582     case EM_OR1K:
12583       return reloc_type == 2; /* R_OR1K_16.  */
12584     case EM_TI_PRU:
12585       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12586     case EM_TI_C6000:
12587       return reloc_type == 2; /* R_C6000_ABS16.  */
12588     case EM_VISIUM:
12589       return reloc_type == 2; /* R_VISIUM_16. */
12590     case EM_XC16X:
12591     case EM_C166:
12592       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12593     case EM_XGATE:
12594       return reloc_type == 3; /* R_XGATE_16.  */
12595     default:
12596       return FALSE;
12597     }
12598 }
12599
12600 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12601    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12602
12603 static bfd_boolean
12604 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12605 {
12606   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12607   switch (filedata->file_header.e_machine)
12608     {
12609     case EM_RISCV:
12610       return reloc_type == 35; /* R_RISCV_ADD32.  */
12611     default:
12612       return FALSE;
12613     }
12614 }
12615
12616 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12617    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12618
12619 static bfd_boolean
12620 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12621 {
12622   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12623   switch (filedata->file_header.e_machine)
12624     {
12625     case EM_RISCV:
12626       return reloc_type == 39; /* R_RISCV_SUB32.  */
12627     default:
12628       return FALSE;
12629     }
12630 }
12631
12632 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12633    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12634
12635 static bfd_boolean
12636 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12637 {
12638   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12639   switch (filedata->file_header.e_machine)
12640     {
12641     case EM_RISCV:
12642       return reloc_type == 36; /* R_RISCV_ADD64.  */
12643     default:
12644       return FALSE;
12645     }
12646 }
12647
12648 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12649    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12650
12651 static bfd_boolean
12652 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12653 {
12654   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12655   switch (filedata->file_header.e_machine)
12656     {
12657     case EM_RISCV:
12658       return reloc_type == 40; /* R_RISCV_SUB64.  */
12659     default:
12660       return FALSE;
12661     }
12662 }
12663
12664 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12665    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12666
12667 static bfd_boolean
12668 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12669 {
12670   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12671   switch (filedata->file_header.e_machine)
12672     {
12673     case EM_RISCV:
12674       return reloc_type == 34; /* R_RISCV_ADD16.  */
12675     default:
12676       return FALSE;
12677     }
12678 }
12679
12680 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12681    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12682
12683 static bfd_boolean
12684 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12685 {
12686   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12687   switch (filedata->file_header.e_machine)
12688     {
12689     case EM_RISCV:
12690       return reloc_type == 38; /* R_RISCV_SUB16.  */
12691     default:
12692       return FALSE;
12693     }
12694 }
12695
12696 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12697    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12698
12699 static bfd_boolean
12700 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12701 {
12702   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12703   switch (filedata->file_header.e_machine)
12704     {
12705     case EM_RISCV:
12706       return reloc_type == 33; /* R_RISCV_ADD8.  */
12707     default:
12708       return FALSE;
12709     }
12710 }
12711
12712 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12713    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12714
12715 static bfd_boolean
12716 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12717 {
12718   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12719   switch (filedata->file_header.e_machine)
12720     {
12721     case EM_RISCV:
12722       return reloc_type == 37; /* R_RISCV_SUB8.  */
12723     default:
12724       return FALSE;
12725     }
12726 }
12727
12728 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12729    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12730
12731 static bfd_boolean
12732 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12733 {
12734   switch (filedata->file_header.e_machine)
12735     {
12736     case EM_386:     /* R_386_NONE.  */
12737     case EM_68K:     /* R_68K_NONE.  */
12738     case EM_ADAPTEVA_EPIPHANY:
12739     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12740     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12741     case EM_ARC:     /* R_ARC_NONE.  */
12742     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12743     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12744     case EM_ARM:     /* R_ARM_NONE.  */
12745     case EM_C166:    /* R_XC16X_NONE.  */
12746     case EM_CRIS:    /* R_CRIS_NONE.  */
12747     case EM_FT32:    /* R_FT32_NONE.  */
12748     case EM_IA_64:   /* R_IA64_NONE.  */
12749     case EM_K1OM:    /* R_X86_64_NONE.  */
12750     case EM_L1OM:    /* R_X86_64_NONE.  */
12751     case EM_M32R:    /* R_M32R_NONE.  */
12752     case EM_MIPS:    /* R_MIPS_NONE.  */
12753     case EM_MN10300: /* R_MN10300_NONE.  */
12754     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12755     case EM_NIOS32:  /* R_NIOS_NONE.  */
12756     case EM_OR1K:    /* R_OR1K_NONE. */
12757     case EM_PARISC:  /* R_PARISC_NONE.  */
12758     case EM_PPC64:   /* R_PPC64_NONE.  */
12759     case EM_PPC:     /* R_PPC_NONE.  */
12760     case EM_RISCV:   /* R_RISCV_NONE.  */
12761     case EM_S390:    /* R_390_NONE.  */
12762     case EM_S390_OLD:
12763     case EM_SH:      /* R_SH_NONE.  */
12764     case EM_SPARC32PLUS:
12765     case EM_SPARC:   /* R_SPARC_NONE.  */
12766     case EM_SPARCV9:
12767     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12768     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12769     case EM_TI_C6000:/* R_C6000_NONE.  */
12770     case EM_X86_64:  /* R_X86_64_NONE.  */
12771     case EM_XC16X:
12772     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12773       return reloc_type == 0;
12774
12775     case EM_AARCH64:
12776       return reloc_type == 0 || reloc_type == 256;
12777     case EM_AVR_OLD:
12778     case EM_AVR:
12779       return (reloc_type == 0 /* R_AVR_NONE.  */
12780               || reloc_type == 30 /* R_AVR_DIFF8.  */
12781               || reloc_type == 31 /* R_AVR_DIFF16.  */
12782               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12783     case EM_METAG:
12784       return reloc_type == 3; /* R_METAG_NONE.  */
12785     case EM_NDS32:
12786       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12787               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12788               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12789               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12790               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12791     case EM_TI_PRU:
12792       return (reloc_type == 0       /* R_PRU_NONE.  */
12793               || reloc_type == 65   /* R_PRU_DIFF8.  */
12794               || reloc_type == 66   /* R_PRU_DIFF16.  */
12795               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12796     case EM_XTENSA_OLD:
12797     case EM_XTENSA:
12798       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12799               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12800               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12801               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12802     }
12803   return FALSE;
12804 }
12805
12806 /* Returns TRUE if there is a relocation against
12807    section NAME at OFFSET bytes.  */
12808
12809 bfd_boolean
12810 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12811 {
12812   Elf_Internal_Rela * relocs;
12813   Elf_Internal_Rela * rp;
12814
12815   if (dsec == NULL || dsec->reloc_info == NULL)
12816     return FALSE;
12817
12818   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12819
12820   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12821     if (rp->r_offset == offset)
12822       return TRUE;
12823
12824    return FALSE;
12825 }
12826
12827 /* Apply relocations to a section.
12828    Returns TRUE upon success, FALSE otherwise.
12829    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12830    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12831    will be set to the number of relocs loaded.
12832
12833    Note: So far support has been added only for those relocations
12834    which can be found in debug sections. FIXME: Add support for
12835    more relocations ?  */
12836
12837 static bfd_boolean
12838 apply_relocations (Filedata *                 filedata,
12839                    const Elf_Internal_Shdr *  section,
12840                    unsigned char *            start,
12841                    bfd_size_type              size,
12842                    void **                    relocs_return,
12843                    unsigned long *            num_relocs_return)
12844 {
12845   Elf_Internal_Shdr * relsec;
12846   unsigned char * end = start + size;
12847   bfd_boolean res = TRUE;
12848
12849   if (relocs_return != NULL)
12850     {
12851       * (Elf_Internal_Rela **) relocs_return = NULL;
12852       * num_relocs_return = 0;
12853     }
12854
12855   if (filedata->file_header.e_type != ET_REL)
12856     /* No relocs to apply.  */
12857     return TRUE;
12858
12859   /* Find the reloc section associated with the section.  */
12860   for (relsec = filedata->section_headers;
12861        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12862        ++relsec)
12863     {
12864       bfd_boolean is_rela;
12865       unsigned long num_relocs;
12866       Elf_Internal_Rela * relocs;
12867       Elf_Internal_Rela * rp;
12868       Elf_Internal_Shdr * symsec;
12869       Elf_Internal_Sym * symtab;
12870       unsigned long num_syms;
12871       Elf_Internal_Sym * sym;
12872
12873       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12874           || relsec->sh_info >= filedata->file_header.e_shnum
12875           || filedata->section_headers + relsec->sh_info != section
12876           || relsec->sh_size == 0
12877           || relsec->sh_link >= filedata->file_header.e_shnum)
12878         continue;
12879
12880       is_rela = relsec->sh_type == SHT_RELA;
12881
12882       if (is_rela)
12883         {
12884           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12885                                   relsec->sh_size, & relocs, & num_relocs))
12886             return FALSE;
12887         }
12888       else
12889         {
12890           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12891                                  relsec->sh_size, & relocs, & num_relocs))
12892             return FALSE;
12893         }
12894
12895       /* SH uses RELA but uses in place value instead of the addend field.  */
12896       if (filedata->file_header.e_machine == EM_SH)
12897         is_rela = FALSE;
12898
12899       symsec = filedata->section_headers + relsec->sh_link;
12900       if (symsec->sh_type != SHT_SYMTAB
12901           && symsec->sh_type != SHT_DYNSYM)
12902         return FALSE;
12903       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12904
12905       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12906         {
12907           bfd_vma         addend;
12908           unsigned int    reloc_type;
12909           unsigned int    reloc_size;
12910           bfd_boolean     reloc_inplace = FALSE;
12911           bfd_boolean     reloc_subtract = FALSE;
12912           unsigned char * rloc;
12913           unsigned long   sym_index;
12914
12915           reloc_type = get_reloc_type (filedata, rp->r_info);
12916
12917           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12918             continue;
12919           else if (is_none_reloc (filedata, reloc_type))
12920             continue;
12921           else if (is_32bit_abs_reloc (filedata, reloc_type)
12922                    || is_32bit_pcrel_reloc (filedata, reloc_type))
12923             reloc_size = 4;
12924           else if (is_64bit_abs_reloc (filedata, reloc_type)
12925                    || is_64bit_pcrel_reloc (filedata, reloc_type))
12926             reloc_size = 8;
12927           else if (is_24bit_abs_reloc (filedata, reloc_type))
12928             reloc_size = 3;
12929           else if (is_16bit_abs_reloc (filedata, reloc_type))
12930             reloc_size = 2;
12931           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12932                                                                  reloc_type))
12933                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
12934             {
12935               reloc_size = 4;
12936               reloc_inplace = TRUE;
12937             }
12938           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
12939                                                                  reloc_type))
12940                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
12941             {
12942               reloc_size = 8;
12943               reloc_inplace = TRUE;
12944             }
12945           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
12946                                                                  reloc_type))
12947                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
12948             {
12949               reloc_size = 2;
12950               reloc_inplace = TRUE;
12951             }
12952           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
12953                                                                 reloc_type))
12954                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
12955             {
12956               reloc_size = 1;
12957               reloc_inplace = TRUE;
12958             }
12959           else
12960             {
12961               static unsigned int prev_reloc = 0;
12962
12963               if (reloc_type != prev_reloc)
12964                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12965                       reloc_type, printable_section_name (filedata, section));
12966               prev_reloc = reloc_type;
12967               res = FALSE;
12968               continue;
12969             }
12970
12971           rloc = start + rp->r_offset;
12972           if ((rloc + reloc_size) > end || (rloc < start))
12973             {
12974               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12975                     (unsigned long) rp->r_offset,
12976                     printable_section_name (filedata, section));
12977               res = FALSE;
12978               continue;
12979             }
12980
12981           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12982           if (sym_index >= num_syms)
12983             {
12984               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12985                     sym_index, printable_section_name (filedata, section));
12986               res = FALSE;
12987               continue;
12988             }
12989           sym = symtab + sym_index;
12990
12991           /* If the reloc has a symbol associated with it,
12992              make sure that it is of an appropriate type.
12993
12994              Relocations against symbols without type can happen.
12995              Gcc -feliminate-dwarf2-dups may generate symbols
12996              without type for debug info.
12997
12998              Icc generates relocations against function symbols
12999              instead of local labels.
13000
13001              Relocations against object symbols can happen, eg when
13002              referencing a global array.  For an example of this see
13003              the _clz.o binary in libgcc.a.  */
13004           if (sym != symtab
13005               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13006               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13007             {
13008               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13009                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13010                     printable_section_name (filedata, relsec),
13011                     (long int)(rp - relocs));
13012               res = FALSE;
13013               continue;
13014             }
13015
13016           addend = 0;
13017           if (is_rela)
13018             addend += rp->r_addend;
13019           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13020              partial_inplace.  */
13021           if (!is_rela
13022               || (filedata->file_header.e_machine == EM_XTENSA
13023                   && reloc_type == 1)
13024               || ((filedata->file_header.e_machine == EM_PJ
13025                    || filedata->file_header.e_machine == EM_PJ_OLD)
13026                   && reloc_type == 1)
13027               || ((filedata->file_header.e_machine == EM_D30V
13028                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13029                   && reloc_type == 12)
13030               || reloc_inplace)
13031             addend += byte_get (rloc, reloc_size);
13032
13033           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13034               || is_64bit_pcrel_reloc (filedata, reloc_type))
13035             {
13036               /* On HPPA, all pc-relative relocations are biased by 8.  */
13037               if (filedata->file_header.e_machine == EM_PARISC)
13038                 addend -= 8;
13039               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13040                         reloc_size);
13041             }
13042           else if (reloc_subtract)
13043             byte_put (rloc, addend - sym->st_value, reloc_size);
13044           else
13045             byte_put (rloc, addend + sym->st_value, reloc_size);
13046         }
13047
13048       free (symtab);
13049       /* Let the target specific reloc processing code know that
13050          we have finished with these relocs.  */
13051       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13052
13053       if (relocs_return)
13054         {
13055           * (Elf_Internal_Rela **) relocs_return = relocs;
13056           * num_relocs_return = num_relocs;
13057         }
13058       else
13059         free (relocs);
13060
13061       break;
13062     }
13063
13064   return res;
13065 }
13066
13067 #ifdef SUPPORT_DISASSEMBLY
13068 static bfd_boolean
13069 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13070 {
13071   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13072
13073   /* FIXME: XXX -- to be done --- XXX */
13074
13075   return TRUE;
13076 }
13077 #endif
13078
13079 /* Reads in the contents of SECTION from FILE, returning a pointer
13080    to a malloc'ed buffer or NULL if something went wrong.  */
13081
13082 static char *
13083 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13084 {
13085   bfd_size_type num_bytes = section->sh_size;
13086
13087   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13088     {
13089       printf (_("Section '%s' has no data to dump.\n"),
13090               printable_section_name (filedata, section));
13091       return NULL;
13092     }
13093
13094   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13095                              _("section contents"));
13096 }
13097
13098 /* Uncompresses a section that was compressed using zlib, in place.  */
13099
13100 static bfd_boolean
13101 uncompress_section_contents (unsigned char **   buffer,
13102                              dwarf_size_type    uncompressed_size,
13103                              dwarf_size_type *  size)
13104 {
13105   dwarf_size_type compressed_size = *size;
13106   unsigned char * compressed_buffer = *buffer;
13107   unsigned char * uncompressed_buffer;
13108   z_stream strm;
13109   int rc;
13110
13111   /* It is possible the section consists of several compressed
13112      buffers concatenated together, so we uncompress in a loop.  */
13113   /* PR 18313: The state field in the z_stream structure is supposed
13114      to be invisible to the user (ie us), but some compilers will
13115      still complain about it being used without initialisation.  So
13116      we first zero the entire z_stream structure and then set the fields
13117      that we need.  */
13118   memset (& strm, 0, sizeof strm);
13119   strm.avail_in = compressed_size;
13120   strm.next_in = (Bytef *) compressed_buffer;
13121   strm.avail_out = uncompressed_size;
13122   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13123
13124   rc = inflateInit (& strm);
13125   while (strm.avail_in > 0)
13126     {
13127       if (rc != Z_OK)
13128         goto fail;
13129       strm.next_out = ((Bytef *) uncompressed_buffer
13130                        + (uncompressed_size - strm.avail_out));
13131       rc = inflate (&strm, Z_FINISH);
13132       if (rc != Z_STREAM_END)
13133         goto fail;
13134       rc = inflateReset (& strm);
13135     }
13136   rc = inflateEnd (& strm);
13137   if (rc != Z_OK
13138       || strm.avail_out != 0)
13139     goto fail;
13140
13141   *buffer = uncompressed_buffer;
13142   *size = uncompressed_size;
13143   return TRUE;
13144
13145  fail:
13146   free (uncompressed_buffer);
13147   /* Indicate decompression failure.  */
13148   *buffer = NULL;
13149   return FALSE;
13150 }
13151
13152 static bfd_boolean
13153 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13154 {
13155   Elf_Internal_Shdr *  relsec;
13156   bfd_size_type        num_bytes;
13157   unsigned char *      data;
13158   unsigned char *      end;
13159   unsigned char *      real_start;
13160   unsigned char *      start;
13161   bfd_boolean          some_strings_shown;
13162
13163   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13164   if (start == NULL)
13165     /* PR 21820: Do not fail if the section was empty.  */
13166     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13167
13168   num_bytes = section->sh_size;
13169
13170   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13171
13172   if (decompress_dumps)
13173     {
13174       dwarf_size_type new_size = num_bytes;
13175       dwarf_size_type uncompressed_size = 0;
13176
13177       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13178         {
13179           Elf_Internal_Chdr chdr;
13180           unsigned int compression_header_size
13181             = get_compression_header (& chdr, (unsigned char *) start,
13182                                       num_bytes);
13183
13184           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13185             {
13186               warn (_("section '%s' has unsupported compress type: %d\n"),
13187                     printable_section_name (filedata, section), chdr.ch_type);
13188               return FALSE;
13189             }
13190           else if (chdr.ch_addralign != section->sh_addralign)
13191             {
13192               warn (_("compressed section '%s' is corrupted\n"),
13193                     printable_section_name (filedata, section));
13194               return FALSE;
13195             }
13196           uncompressed_size = chdr.ch_size;
13197           start += compression_header_size;
13198           new_size -= compression_header_size;
13199         }
13200       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13201         {
13202           /* Read the zlib header.  In this case, it should be "ZLIB"
13203              followed by the uncompressed section size, 8 bytes in
13204              big-endian order.  */
13205           uncompressed_size = start[4]; uncompressed_size <<= 8;
13206           uncompressed_size += start[5]; uncompressed_size <<= 8;
13207           uncompressed_size += start[6]; uncompressed_size <<= 8;
13208           uncompressed_size += start[7]; uncompressed_size <<= 8;
13209           uncompressed_size += start[8]; uncompressed_size <<= 8;
13210           uncompressed_size += start[9]; uncompressed_size <<= 8;
13211           uncompressed_size += start[10]; uncompressed_size <<= 8;
13212           uncompressed_size += start[11];
13213           start += 12;
13214           new_size -= 12;
13215         }
13216
13217       if (uncompressed_size)
13218         {
13219           if (uncompress_section_contents (& start,
13220                                            uncompressed_size, & new_size))
13221             num_bytes = new_size;
13222           else
13223             {
13224               error (_("Unable to decompress section %s\n"),
13225                      printable_section_name (filedata, section));
13226               return FALSE;
13227             }
13228         }
13229       else
13230         start = real_start;
13231     }
13232
13233   /* If the section being dumped has relocations against it the user might
13234      be expecting these relocations to have been applied.  Check for this
13235      case and issue a warning message in order to avoid confusion.
13236      FIXME: Maybe we ought to have an option that dumps a section with
13237      relocs applied ?  */
13238   for (relsec = filedata->section_headers;
13239        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13240        ++relsec)
13241     {
13242       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13243           || relsec->sh_info >= filedata->file_header.e_shnum
13244           || filedata->section_headers + relsec->sh_info != section
13245           || relsec->sh_size == 0
13246           || relsec->sh_link >= filedata->file_header.e_shnum)
13247         continue;
13248
13249       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13250       break;
13251     }
13252
13253   data = start;
13254   end  = start + num_bytes;
13255   some_strings_shown = FALSE;
13256
13257   while (data < end)
13258     {
13259       while (!ISPRINT (* data))
13260         if (++ data >= end)
13261           break;
13262
13263       if (data < end)
13264         {
13265           size_t maxlen = end - data;
13266
13267 #ifndef __MSVCRT__
13268           /* PR 11128: Use two separate invocations in order to work
13269              around bugs in the Solaris 8 implementation of printf.  */
13270           printf ("  [%6tx]  ", data - start);
13271 #else
13272           printf ("  [%6Ix]  ", (size_t) (data - start));
13273 #endif
13274           if (maxlen > 0)
13275             {
13276               print_symbol ((int) maxlen, (const char *) data);
13277               putchar ('\n');
13278               data += strnlen ((const char *) data, maxlen);
13279             }
13280           else
13281             {
13282               printf (_("<corrupt>\n"));
13283               data = end;
13284             }
13285           some_strings_shown = TRUE;
13286         }
13287     }
13288
13289   if (! some_strings_shown)
13290     printf (_("  No strings found in this section."));
13291
13292   free (real_start);
13293
13294   putchar ('\n');
13295   return TRUE;
13296 }
13297
13298 static bfd_boolean
13299 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13300                        Filedata *           filedata,
13301                        bfd_boolean          relocate)
13302 {
13303   Elf_Internal_Shdr * relsec;
13304   bfd_size_type       bytes;
13305   bfd_size_type       section_size;
13306   bfd_vma             addr;
13307   unsigned char *     data;
13308   unsigned char *     real_start;
13309   unsigned char *     start;
13310
13311   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13312   if (start == NULL)
13313     /* PR 21820: Do not fail if the section was empty.  */
13314     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13315
13316   section_size = section->sh_size;
13317
13318   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13319
13320   if (decompress_dumps)
13321     {
13322       dwarf_size_type new_size = section_size;
13323       dwarf_size_type uncompressed_size = 0;
13324
13325       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13326         {
13327           Elf_Internal_Chdr chdr;
13328           unsigned int compression_header_size
13329             = get_compression_header (& chdr, start, section_size);
13330
13331           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13332             {
13333               warn (_("section '%s' has unsupported compress type: %d\n"),
13334                     printable_section_name (filedata, section), chdr.ch_type);
13335               return FALSE;
13336             }
13337           else if (chdr.ch_addralign != section->sh_addralign)
13338             {
13339               warn (_("compressed section '%s' is corrupted\n"),
13340                     printable_section_name (filedata, section));
13341               return FALSE;
13342             }
13343           uncompressed_size = chdr.ch_size;
13344           start += compression_header_size;
13345           new_size -= compression_header_size;
13346         }
13347       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13348         {
13349           /* Read the zlib header.  In this case, it should be "ZLIB"
13350              followed by the uncompressed section size, 8 bytes in
13351              big-endian order.  */
13352           uncompressed_size = start[4]; uncompressed_size <<= 8;
13353           uncompressed_size += start[5]; uncompressed_size <<= 8;
13354           uncompressed_size += start[6]; uncompressed_size <<= 8;
13355           uncompressed_size += start[7]; uncompressed_size <<= 8;
13356           uncompressed_size += start[8]; uncompressed_size <<= 8;
13357           uncompressed_size += start[9]; uncompressed_size <<= 8;
13358           uncompressed_size += start[10]; uncompressed_size <<= 8;
13359           uncompressed_size += start[11];
13360           start += 12;
13361           new_size -= 12;
13362         }
13363
13364       if (uncompressed_size)
13365         {
13366           if (uncompress_section_contents (& start, uncompressed_size,
13367                                            & new_size))
13368             {
13369               section_size = new_size;
13370             }
13371           else
13372             {
13373               error (_("Unable to decompress section %s\n"),
13374                      printable_section_name (filedata, section));
13375               /* FIXME: Print the section anyway ?  */
13376               return FALSE;
13377             }
13378         }
13379       else
13380         start = real_start;
13381     }
13382
13383   if (relocate)
13384     {
13385       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13386         return FALSE;
13387     }
13388   else
13389     {
13390       /* If the section being dumped has relocations against it the user might
13391          be expecting these relocations to have been applied.  Check for this
13392          case and issue a warning message in order to avoid confusion.
13393          FIXME: Maybe we ought to have an option that dumps a section with
13394          relocs applied ?  */
13395       for (relsec = filedata->section_headers;
13396            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13397            ++relsec)
13398         {
13399           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13400               || relsec->sh_info >= filedata->file_header.e_shnum
13401               || filedata->section_headers + relsec->sh_info != section
13402               || relsec->sh_size == 0
13403               || relsec->sh_link >= filedata->file_header.e_shnum)
13404             continue;
13405
13406           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13407           break;
13408         }
13409     }
13410
13411   addr = section->sh_addr;
13412   bytes = section_size;
13413   data = start;
13414
13415   while (bytes)
13416     {
13417       int j;
13418       int k;
13419       int lbytes;
13420
13421       lbytes = (bytes > 16 ? 16 : bytes);
13422
13423       printf ("  0x%8.8lx ", (unsigned long) addr);
13424
13425       for (j = 0; j < 16; j++)
13426         {
13427           if (j < lbytes)
13428             printf ("%2.2x", data[j]);
13429           else
13430             printf ("  ");
13431
13432           if ((j & 3) == 3)
13433             printf (" ");
13434         }
13435
13436       for (j = 0; j < lbytes; j++)
13437         {
13438           k = data[j];
13439           if (k >= ' ' && k < 0x7f)
13440             printf ("%c", k);
13441           else
13442             printf (".");
13443         }
13444
13445       putchar ('\n');
13446
13447       data  += lbytes;
13448       addr  += lbytes;
13449       bytes -= lbytes;
13450     }
13451
13452   free (real_start);
13453
13454   putchar ('\n');
13455   return TRUE;
13456 }
13457
13458 static bfd_boolean
13459 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13460                              const Elf_Internal_Shdr *        sec,
13461                              void *                           data)
13462 {
13463   struct dwarf_section * section = &debug_displays [debug].section;
13464   char buf [64];
13465   Filedata * filedata = (Filedata *) data;
13466
13467   if (section->start != NULL)
13468     {
13469       /* If it is already loaded, do nothing.  */
13470       if (streq (section->filename, filedata->file_name))
13471         return TRUE;
13472       free (section->start);
13473     }
13474
13475   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13476   section->address = sec->sh_addr;
13477   section->user_data = NULL;
13478   section->filename = filedata->file_name;
13479   section->start = (unsigned char *) get_data (NULL, filedata,
13480                                                sec->sh_offset, 1,
13481                                                sec->sh_size, buf);
13482   if (section->start == NULL)
13483     section->size = 0;
13484   else
13485     {
13486       unsigned char *start = section->start;
13487       dwarf_size_type size = sec->sh_size;
13488       dwarf_size_type uncompressed_size = 0;
13489
13490       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13491         {
13492           Elf_Internal_Chdr chdr;
13493           unsigned int compression_header_size;
13494
13495           if (size < (is_32bit_elf
13496                       ? sizeof (Elf32_External_Chdr)
13497                       : sizeof (Elf64_External_Chdr)))
13498             {
13499               warn (_("compressed section %s is too small to contain a compression header"),
13500                     section->name);
13501               return FALSE;
13502             }
13503
13504           compression_header_size = get_compression_header (&chdr, start, size);
13505
13506           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13507             {
13508               warn (_("section '%s' has unsupported compress type: %d\n"),
13509                     section->name, chdr.ch_type);
13510               return FALSE;
13511             }
13512           else if (chdr.ch_addralign != sec->sh_addralign)
13513             {
13514               warn (_("compressed section '%s' is corrupted\n"),
13515                     section->name);
13516               return FALSE;
13517             }
13518           uncompressed_size = chdr.ch_size;
13519           start += compression_header_size;
13520           size -= compression_header_size;
13521         }
13522       else if (size > 12 && streq ((char *) start, "ZLIB"))
13523         {
13524           /* Read the zlib header.  In this case, it should be "ZLIB"
13525              followed by the uncompressed section size, 8 bytes in
13526              big-endian order.  */
13527           uncompressed_size = start[4]; uncompressed_size <<= 8;
13528           uncompressed_size += start[5]; uncompressed_size <<= 8;
13529           uncompressed_size += start[6]; uncompressed_size <<= 8;
13530           uncompressed_size += start[7]; uncompressed_size <<= 8;
13531           uncompressed_size += start[8]; uncompressed_size <<= 8;
13532           uncompressed_size += start[9]; uncompressed_size <<= 8;
13533           uncompressed_size += start[10]; uncompressed_size <<= 8;
13534           uncompressed_size += start[11];
13535           start += 12;
13536           size -= 12;
13537         }
13538
13539       if (uncompressed_size)
13540         {
13541           if (uncompress_section_contents (&start, uncompressed_size,
13542                                            &size))
13543             {
13544               /* Free the compressed buffer, update the section buffer
13545                  and the section size if uncompress is successful.  */
13546               free (section->start);
13547               section->start = start;
13548             }
13549           else
13550             {
13551               error (_("Unable to decompress section %s\n"),
13552                      printable_section_name (filedata, sec));
13553               return FALSE;
13554             }
13555         }
13556
13557       section->size = size;
13558     }
13559
13560   if (section->start == NULL)
13561     return FALSE;
13562
13563   if (debug_displays [debug].relocate)
13564     {
13565       if (! apply_relocations (filedata, sec, section->start, section->size,
13566                                & section->reloc_info, & section->num_relocs))
13567         return FALSE;
13568     }
13569   else
13570     {
13571       section->reloc_info = NULL;
13572       section->num_relocs = 0;
13573     }
13574
13575   return TRUE;
13576 }
13577
13578 /* If this is not NULL, load_debug_section will only look for sections
13579    within the list of sections given here.  */
13580 static unsigned int * section_subset = NULL;
13581
13582 bfd_boolean
13583 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13584 {
13585   struct dwarf_section * section = &debug_displays [debug].section;
13586   Elf_Internal_Shdr * sec;
13587   Filedata * filedata = (Filedata *) data;
13588
13589   /* Without section headers we cannot find any sections.  */
13590   if (filedata->section_headers == NULL)
13591     return FALSE;
13592
13593   if (filedata->string_table == NULL
13594       && filedata->file_header.e_shstrndx != SHN_UNDEF
13595       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13596     {
13597       Elf_Internal_Shdr * strs;
13598
13599       /* Read in the string table, so that we have section names to scan.  */
13600       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13601
13602       if (strs != NULL && strs->sh_size != 0)
13603         {
13604           filedata->string_table
13605             = (char *) get_data (NULL, filedata, strs->sh_offset,
13606                                  1, strs->sh_size, _("string table"));
13607
13608           filedata->string_table_length
13609             = filedata->string_table != NULL ? strs->sh_size : 0;
13610         }
13611     }
13612
13613   /* Locate the debug section.  */
13614   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13615   if (sec != NULL)
13616     section->name = section->uncompressed_name;
13617   else
13618     {
13619       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13620       if (sec != NULL)
13621         section->name = section->compressed_name;
13622     }
13623   if (sec == NULL)
13624     return FALSE;
13625
13626   /* If we're loading from a subset of sections, and we've loaded
13627      a section matching this name before, it's likely that it's a
13628      different one.  */
13629   if (section_subset != NULL)
13630     free_debug_section (debug);
13631
13632   return load_specific_debug_section (debug, sec, data);
13633 }
13634
13635 void
13636 free_debug_section (enum dwarf_section_display_enum debug)
13637 {
13638   struct dwarf_section * section = &debug_displays [debug].section;
13639
13640   if (section->start == NULL)
13641     return;
13642
13643   free ((char *) section->start);
13644   section->start = NULL;
13645   section->address = 0;
13646   section->size = 0;
13647 }
13648
13649 static bfd_boolean
13650 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13651 {
13652   char * name = SECTION_NAME (section);
13653   const char * print_name = printable_section_name (filedata, section);
13654   bfd_size_type length;
13655   bfd_boolean result = TRUE;
13656   int i;
13657
13658   length = section->sh_size;
13659   if (length == 0)
13660     {
13661       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13662       return TRUE;
13663     }
13664   if (section->sh_type == SHT_NOBITS)
13665     {
13666       /* There is no point in dumping the contents of a debugging section
13667          which has the NOBITS type - the bits in the file will be random.
13668          This can happen when a file containing a .eh_frame section is
13669          stripped with the --only-keep-debug command line option.  */
13670       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13671               print_name);
13672       return FALSE;
13673     }
13674
13675   if (const_strneq (name, ".gnu.linkonce.wi."))
13676     name = ".debug_info";
13677
13678   /* See if we know how to display the contents of this section.  */
13679   for (i = 0; i < max; i++)
13680     {
13681       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13682       struct dwarf_section_display *   display = debug_displays + i;
13683       struct dwarf_section *           sec = & display->section;
13684
13685       if (streq (sec->uncompressed_name, name)
13686           || (id == line && const_strneq (name, ".debug_line."))
13687           || streq (sec->compressed_name, name))
13688         {
13689           bfd_boolean secondary = (section != find_section (filedata, name));
13690
13691           if (secondary)
13692             free_debug_section (id);
13693
13694           if (i == line && const_strneq (name, ".debug_line."))
13695             sec->name = name;
13696           else if (streq (sec->uncompressed_name, name))
13697             sec->name = sec->uncompressed_name;
13698           else
13699             sec->name = sec->compressed_name;
13700
13701           if (load_specific_debug_section (id, section, filedata))
13702             {
13703               /* If this debug section is part of a CU/TU set in a .dwp file,
13704                  restrict load_debug_section to the sections in that set.  */
13705               section_subset = find_cu_tu_set (filedata, shndx);
13706
13707               result &= display->display (sec, filedata);
13708
13709               section_subset = NULL;
13710
13711               if (secondary || (id != info && id != abbrev))
13712                 free_debug_section (id);
13713             }
13714           break;
13715         }
13716     }
13717
13718   if (i == max)
13719     {
13720       printf (_("Unrecognized debug section: %s\n"), print_name);
13721       result = FALSE;
13722     }
13723
13724   return result;
13725 }
13726
13727 /* Set DUMP_SECTS for all sections where dumps were requested
13728    based on section name.  */
13729
13730 static void
13731 initialise_dumps_byname (Filedata * filedata)
13732 {
13733   struct dump_list_entry * cur;
13734
13735   for (cur = dump_sects_byname; cur; cur = cur->next)
13736     {
13737       unsigned int i;
13738       bfd_boolean any = FALSE;
13739
13740       for (i = 0; i < filedata->file_header.e_shnum; i++)
13741         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13742           {
13743             request_dump_bynumber (filedata, i, cur->type);
13744             any = TRUE;
13745           }
13746
13747       if (!any)
13748         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13749               cur->name);
13750     }
13751 }
13752
13753 static bfd_boolean
13754 process_section_contents (Filedata * filedata)
13755 {
13756   Elf_Internal_Shdr * section;
13757   unsigned int i;
13758   bfd_boolean res = TRUE;
13759
13760   if (! do_dump)
13761     return TRUE;
13762
13763   initialise_dumps_byname (filedata);
13764
13765   for (i = 0, section = filedata->section_headers;
13766        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13767        i++, section++)
13768     {
13769       dump_type dump = filedata->dump_sects[i];
13770
13771 #ifdef SUPPORT_DISASSEMBLY
13772       if (dump & DISASS_DUMP)
13773         {
13774           if (! disassemble_section (section, filedata))
13775             res = FALSE;
13776         }
13777 #endif
13778       if (dump & HEX_DUMP)
13779         {
13780           if (! dump_section_as_bytes (section, filedata, FALSE))
13781             res = FALSE;
13782         }
13783
13784       if (dump & RELOC_DUMP)
13785         {
13786           if (! dump_section_as_bytes (section, filedata, TRUE))
13787             res = FALSE;
13788         }
13789
13790       if (dump & STRING_DUMP)
13791         {
13792           if (! dump_section_as_strings (section, filedata))
13793             res = FALSE;
13794         }
13795
13796       if (dump & DEBUG_DUMP)
13797         {
13798           if (! display_debug_section (i, section, filedata))
13799             res = FALSE;
13800         }
13801     }
13802
13803   /* Check to see if the user requested a
13804      dump of a section that does not exist.  */
13805   while (i < filedata->num_dump_sects)
13806     {
13807       if (filedata->dump_sects[i])
13808         {
13809           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13810           res = FALSE;
13811         }
13812       i++;
13813     }
13814
13815   return res;
13816 }
13817
13818 static void
13819 process_mips_fpe_exception (int mask)
13820 {
13821   if (mask)
13822     {
13823       bfd_boolean first = TRUE;
13824
13825       if (mask & OEX_FPU_INEX)
13826         fputs ("INEX", stdout), first = FALSE;
13827       if (mask & OEX_FPU_UFLO)
13828         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13829       if (mask & OEX_FPU_OFLO)
13830         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13831       if (mask & OEX_FPU_DIV0)
13832         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13833       if (mask & OEX_FPU_INVAL)
13834         printf ("%sINVAL", first ? "" : "|");
13835     }
13836   else
13837     fputs ("0", stdout);
13838 }
13839
13840 /* Display's the value of TAG at location P.  If TAG is
13841    greater than 0 it is assumed to be an unknown tag, and
13842    a message is printed to this effect.  Otherwise it is
13843    assumed that a message has already been printed.
13844
13845    If the bottom bit of TAG is set it assumed to have a
13846    string value, otherwise it is assumed to have an integer
13847    value.
13848
13849    Returns an updated P pointing to the first unread byte
13850    beyond the end of TAG's value.
13851
13852    Reads at or beyond END will not be made.  */
13853
13854 static unsigned char *
13855 display_tag_value (signed int tag,
13856                    unsigned char * p,
13857                    const unsigned char * const end)
13858 {
13859   unsigned long val;
13860
13861   if (tag > 0)
13862     printf ("  Tag_unknown_%d: ", tag);
13863
13864   if (p >= end)
13865     {
13866       warn (_("<corrupt tag>\n"));
13867     }
13868   else if (tag & 1)
13869     {
13870       /* PR 17531 file: 027-19978-0.004.  */
13871       size_t maxlen = (end - p) - 1;
13872
13873       putchar ('"');
13874       if (maxlen > 0)
13875         {
13876           print_symbol ((int) maxlen, (const char *) p);
13877           p += strnlen ((char *) p, maxlen) + 1;
13878         }
13879       else
13880         {
13881           printf (_("<corrupt string tag>"));
13882           p = (unsigned char *) end;
13883         }
13884       printf ("\"\n");
13885     }
13886   else
13887     {
13888       unsigned int len;
13889
13890       val = read_uleb128 (p, &len, end);
13891       p += len;
13892       printf ("%ld (0x%lx)\n", val, val);
13893     }
13894
13895   assert (p <= end);
13896   return p;
13897 }
13898
13899 /* ARC ABI attributes section.  */
13900
13901 static unsigned char *
13902 display_arc_attribute (unsigned char * p,
13903                        const unsigned char * const end)
13904 {
13905   unsigned int tag;
13906   unsigned int len;
13907   unsigned int val;
13908
13909   tag = read_uleb128 (p, &len, end);
13910   p += len;
13911
13912   switch (tag)
13913     {
13914     case Tag_ARC_PCS_config:
13915       val = read_uleb128 (p, &len, end);
13916       p += len;
13917       printf ("  Tag_ARC_PCS_config: ");
13918       switch (val)
13919         {
13920         case 0:
13921           printf (_("Absent/Non standard\n"));
13922           break;
13923         case 1:
13924           printf (_("Bare metal/mwdt\n"));
13925           break;
13926         case 2:
13927           printf (_("Bare metal/newlib\n"));
13928           break;
13929         case 3:
13930           printf (_("Linux/uclibc\n"));
13931           break;
13932         case 4:
13933           printf (_("Linux/glibc\n"));
13934           break;
13935         default:
13936           printf (_("Unknown\n"));
13937           break;
13938         }
13939       break;
13940
13941     case Tag_ARC_CPU_base:
13942       val = read_uleb128 (p, &len, end);
13943       p += len;
13944       printf ("  Tag_ARC_CPU_base: ");
13945       switch (val)
13946         {
13947         default:
13948         case TAG_CPU_NONE:
13949           printf (_("Absent\n"));
13950           break;
13951         case TAG_CPU_ARC6xx:
13952           printf ("ARC6xx\n");
13953           break;
13954         case TAG_CPU_ARC7xx:
13955           printf ("ARC7xx\n");
13956           break;
13957         case TAG_CPU_ARCEM:
13958           printf ("ARCEM\n");
13959           break;
13960         case TAG_CPU_ARCHS:
13961           printf ("ARCHS\n");
13962           break;
13963         }
13964       break;
13965
13966     case Tag_ARC_CPU_variation:
13967       val = read_uleb128 (p, &len, end);
13968       p += len;
13969       printf ("  Tag_ARC_CPU_variation: ");
13970       switch (val)
13971         {
13972         default:
13973           if (val > 0 && val < 16)
13974               printf ("Core%d\n", val);
13975           else
13976               printf ("Unknown\n");
13977           break;
13978
13979         case 0:
13980           printf (_("Absent\n"));
13981           break;
13982         }
13983       break;
13984
13985     case Tag_ARC_CPU_name:
13986       printf ("  Tag_ARC_CPU_name: ");
13987       p = display_tag_value (-1, p, end);
13988       break;
13989
13990     case Tag_ARC_ABI_rf16:
13991       val = read_uleb128 (p, &len, end);
13992       p += len;
13993       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13994       break;
13995
13996     case Tag_ARC_ABI_osver:
13997       val = read_uleb128 (p, &len, end);
13998       p += len;
13999       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14000       break;
14001
14002     case Tag_ARC_ABI_pic:
14003     case Tag_ARC_ABI_sda:
14004       val = read_uleb128 (p, &len, end);
14005       p += len;
14006       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14007               : "  Tag_ARC_ABI_pic: ");
14008       switch (val)
14009         {
14010         case 0:
14011           printf (_("Absent\n"));
14012           break;
14013         case 1:
14014           printf ("MWDT\n");
14015           break;
14016         case 2:
14017           printf ("GNU\n");
14018           break;
14019         default:
14020           printf (_("Unknown\n"));
14021           break;
14022         }
14023       break;
14024
14025     case Tag_ARC_ABI_tls:
14026       val = read_uleb128 (p, &len, end);
14027       p += len;
14028       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14029       break;
14030
14031     case Tag_ARC_ABI_enumsize:
14032       val = read_uleb128 (p, &len, end);
14033       p += len;
14034       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14035               _("smallest"));
14036       break;
14037
14038     case Tag_ARC_ABI_exceptions:
14039       val = read_uleb128 (p, &len, end);
14040       p += len;
14041       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14042               : _("default"));
14043       break;
14044
14045     case Tag_ARC_ABI_double_size:
14046       val = read_uleb128 (p, &len, end);
14047       p += len;
14048       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14049       break;
14050
14051     case Tag_ARC_ISA_config:
14052       printf ("  Tag_ARC_ISA_config: ");
14053       p = display_tag_value (-1, p, end);
14054       break;
14055
14056     case Tag_ARC_ISA_apex:
14057       printf ("  Tag_ARC_ISA_apex: ");
14058       p = display_tag_value (-1, p, end);
14059       break;
14060
14061     case Tag_ARC_ISA_mpy_option:
14062       val = read_uleb128 (p, &len, end);
14063       p += len;
14064       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14065       break;
14066
14067     default:
14068       return display_tag_value (tag & 1, p, end);
14069     }
14070
14071   return p;
14072 }
14073
14074 /* ARM EABI attributes section.  */
14075 typedef struct
14076 {
14077   unsigned int tag;
14078   const char * name;
14079   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14080   unsigned int type;
14081   const char ** table;
14082 } arm_attr_public_tag;
14083
14084 static const char * arm_attr_tag_CPU_arch[] =
14085   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14086    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14087    "v8-M.mainline"};
14088 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14089 static const char * arm_attr_tag_THUMB_ISA_use[] =
14090   {"No", "Thumb-1", "Thumb-2", "Yes"};
14091 static const char * arm_attr_tag_FP_arch[] =
14092   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14093    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14094 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14095 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14096   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14097    "NEON for ARMv8.1"};
14098 static const char * arm_attr_tag_PCS_config[] =
14099   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14100    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14101 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14102   {"V6", "SB", "TLS", "Unused"};
14103 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14104   {"Absolute", "PC-relative", "SB-relative", "None"};
14105 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14106   {"Absolute", "PC-relative", "None"};
14107 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14108   {"None", "direct", "GOT-indirect"};
14109 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14110   {"None", "??? 1", "2", "??? 3", "4"};
14111 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14112 static const char * arm_attr_tag_ABI_FP_denormal[] =
14113   {"Unused", "Needed", "Sign only"};
14114 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14115 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14116 static const char * arm_attr_tag_ABI_FP_number_model[] =
14117   {"Unused", "Finite", "RTABI", "IEEE 754"};
14118 static const char * arm_attr_tag_ABI_enum_size[] =
14119   {"Unused", "small", "int", "forced to int"};
14120 static const char * arm_attr_tag_ABI_HardFP_use[] =
14121   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14122 static const char * arm_attr_tag_ABI_VFP_args[] =
14123   {"AAPCS", "VFP registers", "custom", "compatible"};
14124 static const char * arm_attr_tag_ABI_WMMX_args[] =
14125   {"AAPCS", "WMMX registers", "custom"};
14126 static const char * arm_attr_tag_ABI_optimization_goals[] =
14127   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14128     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14129 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14130   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14131     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14132 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14133 static const char * arm_attr_tag_FP_HP_extension[] =
14134   {"Not Allowed", "Allowed"};
14135 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14136   {"None", "IEEE 754", "Alternative Format"};
14137 static const char * arm_attr_tag_DSP_extension[] =
14138   {"Follow architecture", "Allowed"};
14139 static const char * arm_attr_tag_MPextension_use[] =
14140   {"Not Allowed", "Allowed"};
14141 static const char * arm_attr_tag_DIV_use[] =
14142   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14143     "Allowed in v7-A with integer division extension"};
14144 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14145 static const char * arm_attr_tag_Virtualization_use[] =
14146   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14147     "TrustZone and Virtualization Extensions"};
14148 static const char * arm_attr_tag_MPextension_use_legacy[] =
14149   {"Not Allowed", "Allowed"};
14150
14151 #define LOOKUP(id, name) \
14152   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14153 static arm_attr_public_tag arm_attr_public_tags[] =
14154 {
14155   {4, "CPU_raw_name", 1, NULL},
14156   {5, "CPU_name", 1, NULL},
14157   LOOKUP(6, CPU_arch),
14158   {7, "CPU_arch_profile", 0, NULL},
14159   LOOKUP(8, ARM_ISA_use),
14160   LOOKUP(9, THUMB_ISA_use),
14161   LOOKUP(10, FP_arch),
14162   LOOKUP(11, WMMX_arch),
14163   LOOKUP(12, Advanced_SIMD_arch),
14164   LOOKUP(13, PCS_config),
14165   LOOKUP(14, ABI_PCS_R9_use),
14166   LOOKUP(15, ABI_PCS_RW_data),
14167   LOOKUP(16, ABI_PCS_RO_data),
14168   LOOKUP(17, ABI_PCS_GOT_use),
14169   LOOKUP(18, ABI_PCS_wchar_t),
14170   LOOKUP(19, ABI_FP_rounding),
14171   LOOKUP(20, ABI_FP_denormal),
14172   LOOKUP(21, ABI_FP_exceptions),
14173   LOOKUP(22, ABI_FP_user_exceptions),
14174   LOOKUP(23, ABI_FP_number_model),
14175   {24, "ABI_align_needed", 0, NULL},
14176   {25, "ABI_align_preserved", 0, NULL},
14177   LOOKUP(26, ABI_enum_size),
14178   LOOKUP(27, ABI_HardFP_use),
14179   LOOKUP(28, ABI_VFP_args),
14180   LOOKUP(29, ABI_WMMX_args),
14181   LOOKUP(30, ABI_optimization_goals),
14182   LOOKUP(31, ABI_FP_optimization_goals),
14183   {32, "compatibility", 0, NULL},
14184   LOOKUP(34, CPU_unaligned_access),
14185   LOOKUP(36, FP_HP_extension),
14186   LOOKUP(38, ABI_FP_16bit_format),
14187   LOOKUP(42, MPextension_use),
14188   LOOKUP(44, DIV_use),
14189   LOOKUP(46, DSP_extension),
14190   {64, "nodefaults", 0, NULL},
14191   {65, "also_compatible_with", 0, NULL},
14192   LOOKUP(66, T2EE_use),
14193   {67, "conformance", 1, NULL},
14194   LOOKUP(68, Virtualization_use),
14195   LOOKUP(70, MPextension_use_legacy)
14196 };
14197 #undef LOOKUP
14198
14199 static unsigned char *
14200 display_arm_attribute (unsigned char * p,
14201                        const unsigned char * const end)
14202 {
14203   unsigned int tag;
14204   unsigned int len;
14205   unsigned int val;
14206   arm_attr_public_tag * attr;
14207   unsigned i;
14208   unsigned int type;
14209
14210   tag = read_uleb128 (p, &len, end);
14211   p += len;
14212   attr = NULL;
14213   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14214     {
14215       if (arm_attr_public_tags[i].tag == tag)
14216         {
14217           attr = &arm_attr_public_tags[i];
14218           break;
14219         }
14220     }
14221
14222   if (attr)
14223     {
14224       printf ("  Tag_%s: ", attr->name);
14225       switch (attr->type)
14226         {
14227         case 0:
14228           switch (tag)
14229             {
14230             case 7: /* Tag_CPU_arch_profile.  */
14231               val = read_uleb128 (p, &len, end);
14232               p += len;
14233               switch (val)
14234                 {
14235                 case 0: printf (_("None\n")); break;
14236                 case 'A': printf (_("Application\n")); break;
14237                 case 'R': printf (_("Realtime\n")); break;
14238                 case 'M': printf (_("Microcontroller\n")); break;
14239                 case 'S': printf (_("Application or Realtime\n")); break;
14240                 default: printf ("??? (%d)\n", val); break;
14241                 }
14242               break;
14243
14244             case 24: /* Tag_align_needed.  */
14245               val = read_uleb128 (p, &len, end);
14246               p += len;
14247               switch (val)
14248                 {
14249                 case 0: printf (_("None\n")); break;
14250                 case 1: printf (_("8-byte\n")); break;
14251                 case 2: printf (_("4-byte\n")); break;
14252                 case 3: printf ("??? 3\n"); break;
14253                 default:
14254                   if (val <= 12)
14255                     printf (_("8-byte and up to %d-byte extended\n"),
14256                             1 << val);
14257                   else
14258                     printf ("??? (%d)\n", val);
14259                   break;
14260                 }
14261               break;
14262
14263             case 25: /* Tag_align_preserved.  */
14264               val = read_uleb128 (p, &len, end);
14265               p += len;
14266               switch (val)
14267                 {
14268                 case 0: printf (_("None\n")); break;
14269                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14270                 case 2: printf (_("8-byte\n")); break;
14271                 case 3: printf ("??? 3\n"); break;
14272                 default:
14273                   if (val <= 12)
14274                     printf (_("8-byte and up to %d-byte extended\n"),
14275                             1 << val);
14276                   else
14277                     printf ("??? (%d)\n", val);
14278                   break;
14279                 }
14280               break;
14281
14282             case 32: /* Tag_compatibility.  */
14283               {
14284                 val = read_uleb128 (p, &len, end);
14285                 p += len;
14286                 printf (_("flag = %d, vendor = "), val);
14287                 if (p < end - 1)
14288                   {
14289                     size_t maxlen = (end - p) - 1;
14290
14291                     print_symbol ((int) maxlen, (const char *) p);
14292                     p += strnlen ((char *) p, maxlen) + 1;
14293                   }
14294                 else
14295                   {
14296                     printf (_("<corrupt>"));
14297                     p = (unsigned char *) end;
14298                   }
14299                 putchar ('\n');
14300               }
14301               break;
14302
14303             case 64: /* Tag_nodefaults.  */
14304               /* PR 17531: file: 001-505008-0.01.  */
14305               if (p < end)
14306                 p++;
14307               printf (_("True\n"));
14308               break;
14309
14310             case 65: /* Tag_also_compatible_with.  */
14311               val = read_uleb128 (p, &len, end);
14312               p += len;
14313               if (val == 6 /* Tag_CPU_arch.  */)
14314                 {
14315                   val = read_uleb128 (p, &len, end);
14316                   p += len;
14317                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14318                     printf ("??? (%d)\n", val);
14319                   else
14320                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14321                 }
14322               else
14323                 printf ("???\n");
14324               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14325                 ;
14326               break;
14327
14328             default:
14329               printf (_("<unknown: %d>\n"), tag);
14330               break;
14331             }
14332           return p;
14333
14334         case 1:
14335           return display_tag_value (-1, p, end);
14336         case 2:
14337           return display_tag_value (0, p, end);
14338
14339         default:
14340           assert (attr->type & 0x80);
14341           val = read_uleb128 (p, &len, end);
14342           p += len;
14343           type = attr->type & 0x7f;
14344           if (val >= type)
14345             printf ("??? (%d)\n", val);
14346           else
14347             printf ("%s\n", attr->table[val]);
14348           return p;
14349         }
14350     }
14351
14352   return display_tag_value (tag, p, end);
14353 }
14354
14355 static unsigned char *
14356 display_gnu_attribute (unsigned char * p,
14357                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14358                        const unsigned char * const end)
14359 {
14360   int tag;
14361   unsigned int len;
14362   unsigned int val;
14363
14364   tag = read_uleb128 (p, &len, end);
14365   p += len;
14366
14367   /* Tag_compatibility is the only generic GNU attribute defined at
14368      present.  */
14369   if (tag == 32)
14370     {
14371       val = read_uleb128 (p, &len, end);
14372       p += len;
14373
14374       printf (_("flag = %d, vendor = "), val);
14375       if (p == end)
14376         {
14377           printf (_("<corrupt>\n"));
14378           warn (_("corrupt vendor attribute\n"));
14379         }
14380       else
14381         {
14382           if (p < end - 1)
14383             {
14384               size_t maxlen = (end - p) - 1;
14385
14386               print_symbol ((int) maxlen, (const char *) p);
14387               p += strnlen ((char *) p, maxlen) + 1;
14388             }
14389           else
14390             {
14391               printf (_("<corrupt>"));
14392               p = (unsigned char *) end;
14393             }
14394           putchar ('\n');
14395         }
14396       return p;
14397     }
14398
14399   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14400     return display_proc_gnu_attribute (p, tag, end);
14401
14402   return display_tag_value (tag, p, end);
14403 }
14404
14405 static unsigned char *
14406 display_power_gnu_attribute (unsigned char * p,
14407                              unsigned int tag,
14408                              const unsigned char * const end)
14409 {
14410   unsigned int len;
14411   unsigned int val;
14412
14413   if (tag == Tag_GNU_Power_ABI_FP)
14414     {
14415       val = read_uleb128 (p, &len, end);
14416       p += len;
14417       printf ("  Tag_GNU_Power_ABI_FP: ");
14418       if (len == 0)
14419         {
14420           printf (_("<corrupt>\n"));
14421           return p;
14422         }
14423
14424       if (val > 15)
14425         printf ("(%#x), ", val);
14426
14427       switch (val & 3)
14428         {
14429         case 0:
14430           printf (_("unspecified hard/soft float, "));
14431           break;
14432         case 1:
14433           printf (_("hard float, "));
14434           break;
14435         case 2:
14436           printf (_("soft float, "));
14437           break;
14438         case 3:
14439           printf (_("single-precision hard float, "));
14440           break;
14441         }
14442
14443       switch (val & 0xC)
14444         {
14445         case 0:
14446           printf (_("unspecified long double\n"));
14447           break;
14448         case 4:
14449           printf (_("128-bit IBM long double\n"));
14450           break;
14451         case 8:
14452           printf (_("64-bit long double\n"));
14453           break;
14454         case 12:
14455           printf (_("128-bit IEEE long double\n"));
14456           break;
14457         }
14458       return p;
14459     }
14460
14461   if (tag == Tag_GNU_Power_ABI_Vector)
14462     {
14463       val = read_uleb128 (p, &len, end);
14464       p += len;
14465       printf ("  Tag_GNU_Power_ABI_Vector: ");
14466       if (len == 0)
14467         {
14468           printf (_("<corrupt>\n"));
14469           return p;
14470         }
14471
14472       if (val > 3)
14473         printf ("(%#x), ", val);
14474
14475       switch (val & 3)
14476         {
14477         case 0:
14478           printf (_("unspecified\n"));
14479           break;
14480         case 1:
14481           printf (_("generic\n"));
14482           break;
14483         case 2:
14484           printf ("AltiVec\n");
14485           break;
14486         case 3:
14487           printf ("SPE\n");
14488           break;
14489         }
14490       return p;
14491     }
14492
14493   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14494     {
14495       val = read_uleb128 (p, &len, end);
14496       p += len;
14497       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14498       if (len == 0)
14499         {
14500           printf (_("<corrupt>\n"));
14501           return p;
14502         }
14503
14504       if (val > 2)
14505         printf ("(%#x), ", val);
14506
14507       switch (val & 3)
14508         {
14509         case 0:
14510           printf (_("unspecified\n"));
14511           break;
14512         case 1:
14513           printf ("r3/r4\n");
14514           break;
14515         case 2:
14516           printf (_("memory\n"));
14517           break;
14518         case 3:
14519           printf ("???\n");
14520           break;
14521         }
14522       return p;
14523     }
14524
14525   return display_tag_value (tag & 1, p, end);
14526 }
14527
14528 static unsigned char *
14529 display_s390_gnu_attribute (unsigned char * p,
14530                             unsigned int tag,
14531                             const unsigned char * const end)
14532 {
14533   unsigned int len;
14534   int val;
14535
14536   if (tag == Tag_GNU_S390_ABI_Vector)
14537     {
14538       val = read_uleb128 (p, &len, end);
14539       p += len;
14540       printf ("  Tag_GNU_S390_ABI_Vector: ");
14541
14542       switch (val)
14543         {
14544         case 0:
14545           printf (_("any\n"));
14546           break;
14547         case 1:
14548           printf (_("software\n"));
14549           break;
14550         case 2:
14551           printf (_("hardware\n"));
14552           break;
14553         default:
14554           printf ("??? (%d)\n", val);
14555           break;
14556         }
14557       return p;
14558    }
14559
14560   return display_tag_value (tag & 1, p, end);
14561 }
14562
14563 static void
14564 display_sparc_hwcaps (unsigned int mask)
14565 {
14566   if (mask)
14567     {
14568       bfd_boolean first = TRUE;
14569
14570       if (mask & ELF_SPARC_HWCAP_MUL32)
14571         fputs ("mul32", stdout), first = FALSE;
14572       if (mask & ELF_SPARC_HWCAP_DIV32)
14573         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14574       if (mask & ELF_SPARC_HWCAP_FSMULD)
14575         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14576       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14577         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14578       if (mask & ELF_SPARC_HWCAP_POPC)
14579         printf ("%spopc", first ? "" : "|"), first = FALSE;
14580       if (mask & ELF_SPARC_HWCAP_VIS)
14581         printf ("%svis", first ? "" : "|"), first = FALSE;
14582       if (mask & ELF_SPARC_HWCAP_VIS2)
14583         printf ("%svis2", first ? "" : "|"), first = FALSE;
14584       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14585         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14586       if (mask & ELF_SPARC_HWCAP_FMAF)
14587         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14588       if (mask & ELF_SPARC_HWCAP_VIS3)
14589         printf ("%svis3", first ? "" : "|"), first = FALSE;
14590       if (mask & ELF_SPARC_HWCAP_HPC)
14591         printf ("%shpc", first ? "" : "|"), first = FALSE;
14592       if (mask & ELF_SPARC_HWCAP_RANDOM)
14593         printf ("%srandom", first ? "" : "|"), first = FALSE;
14594       if (mask & ELF_SPARC_HWCAP_TRANS)
14595         printf ("%strans", first ? "" : "|"), first = FALSE;
14596       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14597         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14598       if (mask & ELF_SPARC_HWCAP_IMA)
14599         printf ("%sima", first ? "" : "|"), first = FALSE;
14600       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14601         printf ("%scspare", first ? "" : "|"), first = FALSE;
14602     }
14603   else
14604     fputc ('0', stdout);
14605   fputc ('\n', stdout);
14606 }
14607
14608 static void
14609 display_sparc_hwcaps2 (unsigned int mask)
14610 {
14611   if (mask)
14612     {
14613       bfd_boolean first = TRUE;
14614
14615       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14616         fputs ("fjathplus", stdout), first = FALSE;
14617       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14618         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14619       if (mask & ELF_SPARC_HWCAP2_ADP)
14620         printf ("%sadp", first ? "" : "|"), first = FALSE;
14621       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14622         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14623       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14624         printf ("%smwait", first ? "" : "|"), first = FALSE;
14625       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14626         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14627       if (mask & ELF_SPARC_HWCAP2_XMONT)
14628         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14629       if (mask & ELF_SPARC_HWCAP2_NSEC)
14630         printf ("%snsec", first ? "" : "|"), first = FALSE;
14631       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14632         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14633       if (mask & ELF_SPARC_HWCAP2_FJDES)
14634         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14635       if (mask & ELF_SPARC_HWCAP2_FJAES)
14636         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14637     }
14638   else
14639     fputc ('0', stdout);
14640   fputc ('\n', stdout);
14641 }
14642
14643 static unsigned char *
14644 display_sparc_gnu_attribute (unsigned char * p,
14645                              unsigned int tag,
14646                              const unsigned char * const end)
14647 {
14648   unsigned int len;
14649   int val;
14650
14651   if (tag == Tag_GNU_Sparc_HWCAPS)
14652     {
14653       val = read_uleb128 (p, &len, end);
14654       p += len;
14655       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14656       display_sparc_hwcaps (val);
14657       return p;
14658     }
14659   if (tag == Tag_GNU_Sparc_HWCAPS2)
14660     {
14661       val = read_uleb128 (p, &len, end);
14662       p += len;
14663       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14664       display_sparc_hwcaps2 (val);
14665       return p;
14666     }
14667
14668   return display_tag_value (tag, p, end);
14669 }
14670
14671 static void
14672 print_mips_fp_abi_value (unsigned int val)
14673 {
14674   switch (val)
14675     {
14676     case Val_GNU_MIPS_ABI_FP_ANY:
14677       printf (_("Hard or soft float\n"));
14678       break;
14679     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14680       printf (_("Hard float (double precision)\n"));
14681       break;
14682     case Val_GNU_MIPS_ABI_FP_SINGLE:
14683       printf (_("Hard float (single precision)\n"));
14684       break;
14685     case Val_GNU_MIPS_ABI_FP_SOFT:
14686       printf (_("Soft float\n"));
14687       break;
14688     case Val_GNU_MIPS_ABI_FP_OLD_64:
14689       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14690       break;
14691     case Val_GNU_MIPS_ABI_FP_XX:
14692       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14693       break;
14694     case Val_GNU_MIPS_ABI_FP_64:
14695       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14696       break;
14697     case Val_GNU_MIPS_ABI_FP_64A:
14698       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14699       break;
14700     case Val_GNU_MIPS_ABI_FP_NAN2008:
14701       printf (_("NaN 2008 compatibility\n"));
14702       break;
14703     default:
14704       printf ("??? (%d)\n", val);
14705       break;
14706     }
14707 }
14708
14709 static unsigned char *
14710 display_mips_gnu_attribute (unsigned char * p,
14711                             unsigned int tag,
14712                             const unsigned char * const end)
14713 {
14714   if (tag == Tag_GNU_MIPS_ABI_FP)
14715     {
14716       unsigned int len;
14717       unsigned int val;
14718
14719       val = read_uleb128 (p, &len, end);
14720       p += len;
14721       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14722
14723       print_mips_fp_abi_value (val);
14724
14725       return p;
14726    }
14727
14728   if (tag == Tag_GNU_MIPS_ABI_MSA)
14729     {
14730       unsigned int len;
14731       unsigned int val;
14732
14733       val = read_uleb128 (p, &len, end);
14734       p += len;
14735       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14736
14737       switch (val)
14738         {
14739         case Val_GNU_MIPS_ABI_MSA_ANY:
14740           printf (_("Any MSA or not\n"));
14741           break;
14742         case Val_GNU_MIPS_ABI_MSA_128:
14743           printf (_("128-bit MSA\n"));
14744           break;
14745         default:
14746           printf ("??? (%d)\n", val);
14747           break;
14748         }
14749       return p;
14750     }
14751
14752   return display_tag_value (tag & 1, p, end);
14753 }
14754
14755 static unsigned char *
14756 display_tic6x_attribute (unsigned char * p,
14757                          const unsigned char * const end)
14758 {
14759   unsigned int tag;
14760   unsigned int len;
14761   int val;
14762
14763   tag = read_uleb128 (p, &len, end);
14764   p += len;
14765
14766   switch (tag)
14767     {
14768     case Tag_ISA:
14769       val = read_uleb128 (p, &len, end);
14770       p += len;
14771       printf ("  Tag_ISA: ");
14772
14773       switch (val)
14774         {
14775         case C6XABI_Tag_ISA_none:
14776           printf (_("None\n"));
14777           break;
14778         case C6XABI_Tag_ISA_C62X:
14779           printf ("C62x\n");
14780           break;
14781         case C6XABI_Tag_ISA_C67X:
14782           printf ("C67x\n");
14783           break;
14784         case C6XABI_Tag_ISA_C67XP:
14785           printf ("C67x+\n");
14786           break;
14787         case C6XABI_Tag_ISA_C64X:
14788           printf ("C64x\n");
14789           break;
14790         case C6XABI_Tag_ISA_C64XP:
14791           printf ("C64x+\n");
14792           break;
14793         case C6XABI_Tag_ISA_C674X:
14794           printf ("C674x\n");
14795           break;
14796         default:
14797           printf ("??? (%d)\n", val);
14798           break;
14799         }
14800       return p;
14801
14802     case Tag_ABI_wchar_t:
14803       val = read_uleb128 (p, &len, end);
14804       p += len;
14805       printf ("  Tag_ABI_wchar_t: ");
14806       switch (val)
14807         {
14808         case 0:
14809           printf (_("Not used\n"));
14810           break;
14811         case 1:
14812           printf (_("2 bytes\n"));
14813           break;
14814         case 2:
14815           printf (_("4 bytes\n"));
14816           break;
14817         default:
14818           printf ("??? (%d)\n", val);
14819           break;
14820         }
14821       return p;
14822
14823     case Tag_ABI_stack_align_needed:
14824       val = read_uleb128 (p, &len, end);
14825       p += len;
14826       printf ("  Tag_ABI_stack_align_needed: ");
14827       switch (val)
14828         {
14829         case 0:
14830           printf (_("8-byte\n"));
14831           break;
14832         case 1:
14833           printf (_("16-byte\n"));
14834           break;
14835         default:
14836           printf ("??? (%d)\n", val);
14837           break;
14838         }
14839       return p;
14840
14841     case Tag_ABI_stack_align_preserved:
14842       val = read_uleb128 (p, &len, end);
14843       p += len;
14844       printf ("  Tag_ABI_stack_align_preserved: ");
14845       switch (val)
14846         {
14847         case 0:
14848           printf (_("8-byte\n"));
14849           break;
14850         case 1:
14851           printf (_("16-byte\n"));
14852           break;
14853         default:
14854           printf ("??? (%d)\n", val);
14855           break;
14856         }
14857       return p;
14858
14859     case Tag_ABI_DSBT:
14860       val = read_uleb128 (p, &len, end);
14861       p += len;
14862       printf ("  Tag_ABI_DSBT: ");
14863       switch (val)
14864         {
14865         case 0:
14866           printf (_("DSBT addressing not used\n"));
14867           break;
14868         case 1:
14869           printf (_("DSBT addressing used\n"));
14870           break;
14871         default:
14872           printf ("??? (%d)\n", val);
14873           break;
14874         }
14875       return p;
14876
14877     case Tag_ABI_PID:
14878       val = read_uleb128 (p, &len, end);
14879       p += len;
14880       printf ("  Tag_ABI_PID: ");
14881       switch (val)
14882         {
14883         case 0:
14884           printf (_("Data addressing position-dependent\n"));
14885           break;
14886         case 1:
14887           printf (_("Data addressing position-independent, GOT near DP\n"));
14888           break;
14889         case 2:
14890           printf (_("Data addressing position-independent, GOT far from DP\n"));
14891           break;
14892         default:
14893           printf ("??? (%d)\n", val);
14894           break;
14895         }
14896       return p;
14897
14898     case Tag_ABI_PIC:
14899       val = read_uleb128 (p, &len, end);
14900       p += len;
14901       printf ("  Tag_ABI_PIC: ");
14902       switch (val)
14903         {
14904         case 0:
14905           printf (_("Code addressing position-dependent\n"));
14906           break;
14907         case 1:
14908           printf (_("Code addressing position-independent\n"));
14909           break;
14910         default:
14911           printf ("??? (%d)\n", val);
14912           break;
14913         }
14914       return p;
14915
14916     case Tag_ABI_array_object_alignment:
14917       val = read_uleb128 (p, &len, end);
14918       p += len;
14919       printf ("  Tag_ABI_array_object_alignment: ");
14920       switch (val)
14921         {
14922         case 0:
14923           printf (_("8-byte\n"));
14924           break;
14925         case 1:
14926           printf (_("4-byte\n"));
14927           break;
14928         case 2:
14929           printf (_("16-byte\n"));
14930           break;
14931         default:
14932           printf ("??? (%d)\n", val);
14933           break;
14934         }
14935       return p;
14936
14937     case Tag_ABI_array_object_align_expected:
14938       val = read_uleb128 (p, &len, end);
14939       p += len;
14940       printf ("  Tag_ABI_array_object_align_expected: ");
14941       switch (val)
14942         {
14943         case 0:
14944           printf (_("8-byte\n"));
14945           break;
14946         case 1:
14947           printf (_("4-byte\n"));
14948           break;
14949         case 2:
14950           printf (_("16-byte\n"));
14951           break;
14952         default:
14953           printf ("??? (%d)\n", val);
14954           break;
14955         }
14956       return p;
14957
14958     case Tag_ABI_compatibility:
14959       {
14960         val = read_uleb128 (p, &len, end);
14961         p += len;
14962         printf ("  Tag_ABI_compatibility: ");
14963         printf (_("flag = %d, vendor = "), val);
14964         if (p < end - 1)
14965           {
14966             size_t maxlen = (end - p) - 1;
14967
14968             print_symbol ((int) maxlen, (const char *) p);
14969             p += strnlen ((char *) p, maxlen) + 1;
14970           }
14971         else
14972           {
14973             printf (_("<corrupt>"));
14974             p = (unsigned char *) end;
14975           }
14976         putchar ('\n');
14977         return p;
14978       }
14979
14980     case Tag_ABI_conformance:
14981       {
14982         printf ("  Tag_ABI_conformance: \"");
14983         if (p < end - 1)
14984           {
14985             size_t maxlen = (end - p) - 1;
14986
14987             print_symbol ((int) maxlen, (const char *) p);
14988             p += strnlen ((char *) p, maxlen) + 1;
14989           }
14990         else
14991           {
14992             printf (_("<corrupt>"));
14993             p = (unsigned char *) end;
14994           }
14995         printf ("\"\n");
14996         return p;
14997       }
14998     }
14999
15000   return display_tag_value (tag, p, end);
15001 }
15002
15003 static void
15004 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15005 {
15006   unsigned long addr = 0;
15007   size_t bytes = end - p;
15008
15009   assert (end > p);
15010   while (bytes)
15011     {
15012       int j;
15013       int k;
15014       int lbytes = (bytes > 16 ? 16 : bytes);
15015
15016       printf ("  0x%8.8lx ", addr);
15017
15018       for (j = 0; j < 16; j++)
15019         {
15020           if (j < lbytes)
15021             printf ("%2.2x", p[j]);
15022           else
15023             printf ("  ");
15024
15025           if ((j & 3) == 3)
15026             printf (" ");
15027         }
15028
15029       for (j = 0; j < lbytes; j++)
15030         {
15031           k = p[j];
15032           if (k >= ' ' && k < 0x7f)
15033             printf ("%c", k);
15034           else
15035             printf (".");
15036         }
15037
15038       putchar ('\n');
15039
15040       p  += lbytes;
15041       bytes -= lbytes;
15042       addr += lbytes;
15043     }
15044
15045   putchar ('\n');
15046 }
15047
15048 static unsigned char *
15049 display_msp430x_attribute (unsigned char * p,
15050                            const unsigned char * const end)
15051 {
15052   unsigned int len;
15053   unsigned int val;
15054   unsigned int tag;
15055
15056   tag = read_uleb128 (p, & len, end);
15057   p += len;
15058
15059   switch (tag)
15060     {
15061     case OFBA_MSPABI_Tag_ISA:
15062       val = read_uleb128 (p, &len, end);
15063       p += len;
15064       printf ("  Tag_ISA: ");
15065       switch (val)
15066         {
15067         case 0: printf (_("None\n")); break;
15068         case 1: printf (_("MSP430\n")); break;
15069         case 2: printf (_("MSP430X\n")); break;
15070         default: printf ("??? (%d)\n", val); break;
15071         }
15072       break;
15073
15074     case OFBA_MSPABI_Tag_Code_Model:
15075       val = read_uleb128 (p, &len, end);
15076       p += len;
15077       printf ("  Tag_Code_Model: ");
15078       switch (val)
15079         {
15080         case 0: printf (_("None\n")); break;
15081         case 1: printf (_("Small\n")); break;
15082         case 2: printf (_("Large\n")); break;
15083         default: printf ("??? (%d)\n", val); break;
15084         }
15085       break;
15086
15087     case OFBA_MSPABI_Tag_Data_Model:
15088       val = read_uleb128 (p, &len, end);
15089       p += len;
15090       printf ("  Tag_Data_Model: ");
15091       switch (val)
15092         {
15093         case 0: printf (_("None\n")); break;
15094         case 1: printf (_("Small\n")); break;
15095         case 2: printf (_("Large\n")); break;
15096         case 3: printf (_("Restricted Large\n")); break;
15097         default: printf ("??? (%d)\n", val); break;
15098         }
15099       break;
15100
15101     default:
15102       printf (_("  <unknown tag %d>: "), tag);
15103
15104       if (tag & 1)
15105         {
15106           putchar ('"');
15107           if (p < end - 1)
15108             {
15109               size_t maxlen = (end - p) - 1;
15110
15111               print_symbol ((int) maxlen, (const char *) p);
15112               p += strnlen ((char *) p, maxlen) + 1;
15113             }
15114           else
15115             {
15116               printf (_("<corrupt>"));
15117               p = (unsigned char *) end;
15118             }
15119           printf ("\"\n");
15120         }
15121       else
15122         {
15123           val = read_uleb128 (p, &len, end);
15124           p += len;
15125           printf ("%d (0x%x)\n", val, val);
15126         }
15127       break;
15128    }
15129
15130   assert (p <= end);
15131   return p;
15132 }
15133
15134 static bfd_boolean
15135 process_attributes (Filedata * filedata,
15136                     const char * public_name,
15137                     unsigned int proc_type,
15138                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15139                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15140 {
15141   Elf_Internal_Shdr * sect;
15142   unsigned i;
15143   bfd_boolean res = TRUE;
15144
15145   /* Find the section header so that we get the size.  */
15146   for (i = 0, sect = filedata->section_headers;
15147        i < filedata->file_header.e_shnum;
15148        i++, sect++)
15149     {
15150       unsigned char * contents;
15151       unsigned char * p;
15152
15153       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15154         continue;
15155
15156       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15157                                              sect->sh_size, _("attributes"));
15158       if (contents == NULL)
15159         {
15160           res = FALSE;
15161           continue;
15162         }
15163
15164       p = contents;
15165       /* The first character is the version of the attributes.
15166          Currently only version 1, (aka 'A') is recognised here.  */
15167       if (*p != 'A')
15168         {
15169           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15170           res = FALSE;
15171         }
15172       else
15173         {
15174           bfd_vma section_len;
15175
15176           section_len = sect->sh_size - 1;
15177           p++;
15178
15179           while (section_len > 0)
15180             {
15181               bfd_vma attr_len;
15182               unsigned int namelen;
15183               bfd_boolean public_section;
15184               bfd_boolean gnu_section;
15185
15186               if (section_len <= 4)
15187                 {
15188                   error (_("Tag section ends prematurely\n"));
15189                   res = FALSE;
15190                   break;
15191                 }
15192               attr_len = byte_get (p, 4);
15193               p += 4;
15194
15195               if (attr_len > section_len)
15196                 {
15197                   error (_("Bad attribute length (%u > %u)\n"),
15198                           (unsigned) attr_len, (unsigned) section_len);
15199                   attr_len = section_len;
15200                   res = FALSE;
15201                 }
15202               /* PR 17531: file: 001-101425-0.004  */
15203               else if (attr_len < 5)
15204                 {
15205                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15206                   res = FALSE;
15207                   break;
15208                 }
15209
15210               section_len -= attr_len;
15211               attr_len -= 4;
15212
15213               namelen = strnlen ((char *) p, attr_len) + 1;
15214               if (namelen == 0 || namelen >= attr_len)
15215                 {
15216                   error (_("Corrupt attribute section name\n"));
15217                   res = FALSE;
15218                   break;
15219                 }
15220
15221               printf (_("Attribute Section: "));
15222               print_symbol (INT_MAX, (const char *) p);
15223               putchar ('\n');
15224
15225               if (public_name && streq ((char *) p, public_name))
15226                 public_section = TRUE;
15227               else
15228                 public_section = FALSE;
15229
15230               if (streq ((char *) p, "gnu"))
15231                 gnu_section = TRUE;
15232               else
15233                 gnu_section = FALSE;
15234
15235               p += namelen;
15236               attr_len -= namelen;
15237
15238               while (attr_len > 0 && p < contents + sect->sh_size)
15239                 {
15240                   int tag;
15241                   int val;
15242                   bfd_vma size;
15243                   unsigned char * end;
15244
15245                   /* PR binutils/17531: Safe handling of corrupt files.  */
15246                   if (attr_len < 6)
15247                     {
15248                       error (_("Unused bytes at end of section\n"));
15249                       res = FALSE;
15250                       section_len = 0;
15251                       break;
15252                     }
15253
15254                   tag = *(p++);
15255                   size = byte_get (p, 4);
15256                   if (size > attr_len)
15257                     {
15258                       error (_("Bad subsection length (%u > %u)\n"),
15259                               (unsigned) size, (unsigned) attr_len);
15260                       res = FALSE;
15261                       size = attr_len;
15262                     }
15263                   /* PR binutils/17531: Safe handling of corrupt files.  */
15264                   if (size < 6)
15265                     {
15266                       error (_("Bad subsection length (%u < 6)\n"),
15267                               (unsigned) size);
15268                       res = FALSE;
15269                       section_len = 0;
15270                       break;
15271                     }
15272
15273                   attr_len -= size;
15274                   end = p + size - 1;
15275                   assert (end <= contents + sect->sh_size);
15276                   p += 4;
15277
15278                   switch (tag)
15279                     {
15280                     case 1:
15281                       printf (_("File Attributes\n"));
15282                       break;
15283                     case 2:
15284                       printf (_("Section Attributes:"));
15285                       goto do_numlist;
15286                     case 3:
15287                       printf (_("Symbol Attributes:"));
15288                       /* Fall through.  */
15289                     do_numlist:
15290                       for (;;)
15291                         {
15292                           unsigned int j;
15293
15294                           val = read_uleb128 (p, &j, end);
15295                           p += j;
15296                           if (val == 0)
15297                             break;
15298                           printf (" %d", val);
15299                         }
15300                       printf ("\n");
15301                       break;
15302                     default:
15303                       printf (_("Unknown tag: %d\n"), tag);
15304                       public_section = FALSE;
15305                       break;
15306                     }
15307
15308                   if (public_section && display_pub_attribute != NULL)
15309                     {
15310                       while (p < end)
15311                         p = display_pub_attribute (p, end);
15312                       assert (p == end);
15313                     }
15314                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15315                     {
15316                       while (p < end)
15317                         p = display_gnu_attribute (p,
15318                                                    display_proc_gnu_attribute,
15319                                                    end);
15320                       assert (p == end);
15321                     }
15322                   else if (p < end)
15323                     {
15324                       printf (_("  Unknown attribute:\n"));
15325                       display_raw_attribute (p, end);
15326                       p = end;
15327                     }
15328                   else
15329                     attr_len = 0;
15330                 }
15331             }
15332         }
15333
15334       free (contents);
15335     }
15336
15337   return res;
15338 }
15339
15340 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15341    Print the Address, Access and Initial fields of an entry at VMA ADDR
15342    and return the VMA of the next entry, or -1 if there was a problem.
15343    Does not read from DATA_END or beyond.  */
15344
15345 static bfd_vma
15346 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15347                       unsigned char * data_end)
15348 {
15349   printf ("  ");
15350   print_vma (addr, LONG_HEX);
15351   printf (" ");
15352   if (addr < pltgot + 0xfff0)
15353     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15354   else
15355     printf ("%10s", "");
15356   printf (" ");
15357   if (data == NULL)
15358     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15359   else
15360     {
15361       bfd_vma entry;
15362       unsigned char * from = data + addr - pltgot;
15363
15364       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15365         {
15366           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15367           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15368           return (bfd_vma) -1;
15369         }
15370       else
15371         {
15372           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15373           print_vma (entry, LONG_HEX);
15374         }
15375     }
15376   return addr + (is_32bit_elf ? 4 : 8);
15377 }
15378
15379 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15380    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15381    ADDR and return the VMA of the next entry.  */
15382
15383 static bfd_vma
15384 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15385 {
15386   printf ("  ");
15387   print_vma (addr, LONG_HEX);
15388   printf (" ");
15389   if (data == NULL)
15390     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15391   else
15392     {
15393       bfd_vma entry;
15394
15395       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15396       print_vma (entry, LONG_HEX);
15397     }
15398   return addr + (is_32bit_elf ? 4 : 8);
15399 }
15400
15401 static void
15402 print_mips_ases (unsigned int mask)
15403 {
15404   if (mask & AFL_ASE_DSP)
15405     fputs ("\n\tDSP ASE", stdout);
15406   if (mask & AFL_ASE_DSPR2)
15407     fputs ("\n\tDSP R2 ASE", stdout);
15408   if (mask & AFL_ASE_DSPR3)
15409     fputs ("\n\tDSP R3 ASE", stdout);
15410   if (mask & AFL_ASE_EVA)
15411     fputs ("\n\tEnhanced VA Scheme", stdout);
15412   if (mask & AFL_ASE_MCU)
15413     fputs ("\n\tMCU (MicroController) ASE", stdout);
15414   if (mask & AFL_ASE_MDMX)
15415     fputs ("\n\tMDMX ASE", stdout);
15416   if (mask & AFL_ASE_MIPS3D)
15417     fputs ("\n\tMIPS-3D ASE", stdout);
15418   if (mask & AFL_ASE_MT)
15419     fputs ("\n\tMT ASE", stdout);
15420   if (mask & AFL_ASE_SMARTMIPS)
15421     fputs ("\n\tSmartMIPS ASE", stdout);
15422   if (mask & AFL_ASE_VIRT)
15423     fputs ("\n\tVZ ASE", stdout);
15424   if (mask & AFL_ASE_MSA)
15425     fputs ("\n\tMSA ASE", stdout);
15426   if (mask & AFL_ASE_MIPS16)
15427     fputs ("\n\tMIPS16 ASE", stdout);
15428   if (mask & AFL_ASE_MICROMIPS)
15429     fputs ("\n\tMICROMIPS ASE", stdout);
15430   if (mask & AFL_ASE_XPA)
15431     fputs ("\n\tXPA ASE", stdout);
15432   if (mask & AFL_ASE_MIPS16E2)
15433     fputs ("\n\tMIPS16e2 ASE", stdout);
15434   if (mask == 0)
15435     fprintf (stdout, "\n\t%s", _("None"));
15436   else if ((mask & ~AFL_ASE_MASK) != 0)
15437     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15438 }
15439
15440 static void
15441 print_mips_isa_ext (unsigned int isa_ext)
15442 {
15443   switch (isa_ext)
15444     {
15445     case 0:
15446       fputs (_("None"), stdout);
15447       break;
15448     case AFL_EXT_XLR:
15449       fputs ("RMI XLR", stdout);
15450       break;
15451     case AFL_EXT_OCTEON3:
15452       fputs ("Cavium Networks Octeon3", stdout);
15453       break;
15454     case AFL_EXT_OCTEON2:
15455       fputs ("Cavium Networks Octeon2", stdout);
15456       break;
15457     case AFL_EXT_OCTEONP:
15458       fputs ("Cavium Networks OcteonP", stdout);
15459       break;
15460     case AFL_EXT_LOONGSON_3A:
15461       fputs ("Loongson 3A", stdout);
15462       break;
15463     case AFL_EXT_OCTEON:
15464       fputs ("Cavium Networks Octeon", stdout);
15465       break;
15466     case AFL_EXT_5900:
15467       fputs ("Toshiba R5900", stdout);
15468       break;
15469     case AFL_EXT_4650:
15470       fputs ("MIPS R4650", stdout);
15471       break;
15472     case AFL_EXT_4010:
15473       fputs ("LSI R4010", stdout);
15474       break;
15475     case AFL_EXT_4100:
15476       fputs ("NEC VR4100", stdout);
15477       break;
15478     case AFL_EXT_3900:
15479       fputs ("Toshiba R3900", stdout);
15480       break;
15481     case AFL_EXT_10000:
15482       fputs ("MIPS R10000", stdout);
15483       break;
15484     case AFL_EXT_SB1:
15485       fputs ("Broadcom SB-1", stdout);
15486       break;
15487     case AFL_EXT_4111:
15488       fputs ("NEC VR4111/VR4181", stdout);
15489       break;
15490     case AFL_EXT_4120:
15491       fputs ("NEC VR4120", stdout);
15492       break;
15493     case AFL_EXT_5400:
15494       fputs ("NEC VR5400", stdout);
15495       break;
15496     case AFL_EXT_5500:
15497       fputs ("NEC VR5500", stdout);
15498       break;
15499     case AFL_EXT_LOONGSON_2E:
15500       fputs ("ST Microelectronics Loongson 2E", stdout);
15501       break;
15502     case AFL_EXT_LOONGSON_2F:
15503       fputs ("ST Microelectronics Loongson 2F", stdout);
15504       break;
15505     case AFL_EXT_INTERAPTIV_MR2:
15506       fputs ("Imagination interAptiv MR2", stdout);
15507       break;
15508     default:
15509       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15510     }
15511 }
15512
15513 static signed int
15514 get_mips_reg_size (int reg_size)
15515 {
15516   return (reg_size == AFL_REG_NONE) ? 0
15517          : (reg_size == AFL_REG_32) ? 32
15518          : (reg_size == AFL_REG_64) ? 64
15519          : (reg_size == AFL_REG_128) ? 128
15520          : -1;
15521 }
15522
15523 static bfd_boolean
15524 process_mips_specific (Filedata * filedata)
15525 {
15526   Elf_Internal_Dyn * entry;
15527   Elf_Internal_Shdr *sect = NULL;
15528   size_t liblist_offset = 0;
15529   size_t liblistno = 0;
15530   size_t conflictsno = 0;
15531   size_t options_offset = 0;
15532   size_t conflicts_offset = 0;
15533   size_t pltrelsz = 0;
15534   size_t pltrel = 0;
15535   bfd_vma pltgot = 0;
15536   bfd_vma mips_pltgot = 0;
15537   bfd_vma jmprel = 0;
15538   bfd_vma local_gotno = 0;
15539   bfd_vma gotsym = 0;
15540   bfd_vma symtabno = 0;
15541   bfd_boolean res = TRUE;
15542
15543   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15544                             display_mips_gnu_attribute))
15545     res = FALSE;
15546
15547   sect = find_section (filedata, ".MIPS.abiflags");
15548
15549   if (sect != NULL)
15550     {
15551       Elf_External_ABIFlags_v0 *abiflags_ext;
15552       Elf_Internal_ABIFlags_v0 abiflags_in;
15553
15554       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15555         {
15556           error (_("Corrupt MIPS ABI Flags section.\n"));
15557           res = FALSE;
15558         }
15559       else
15560         {
15561           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15562                                    sect->sh_size, _("MIPS ABI Flags section"));
15563           if (abiflags_ext)
15564             {
15565               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15566               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15567               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15568               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15569               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15570               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15571               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15572               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15573               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15574               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15575               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15576
15577               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15578               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15579               if (abiflags_in.isa_rev > 1)
15580                 printf ("r%d", abiflags_in.isa_rev);
15581               printf ("\nGPR size: %d",
15582                       get_mips_reg_size (abiflags_in.gpr_size));
15583               printf ("\nCPR1 size: %d",
15584                       get_mips_reg_size (abiflags_in.cpr1_size));
15585               printf ("\nCPR2 size: %d",
15586                       get_mips_reg_size (abiflags_in.cpr2_size));
15587               fputs ("\nFP ABI: ", stdout);
15588               print_mips_fp_abi_value (abiflags_in.fp_abi);
15589               fputs ("ISA Extension: ", stdout);
15590               print_mips_isa_ext (abiflags_in.isa_ext);
15591               fputs ("\nASEs:", stdout);
15592               print_mips_ases (abiflags_in.ases);
15593               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15594               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15595               fputc ('\n', stdout);
15596               free (abiflags_ext);
15597             }
15598         }
15599     }
15600
15601   /* We have a lot of special sections.  Thanks SGI!  */
15602   if (dynamic_section == NULL)
15603     {
15604       /* No dynamic information available.  See if there is static GOT.  */
15605       sect = find_section (filedata, ".got");
15606       if (sect != NULL)
15607         {
15608           unsigned char *data_end;
15609           unsigned char *data;
15610           bfd_vma ent, end;
15611           int addr_size;
15612
15613           pltgot = sect->sh_addr;
15614
15615           ent = pltgot;
15616           addr_size = (is_32bit_elf ? 4 : 8);
15617           end = pltgot + sect->sh_size;
15618
15619           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15620                                              end - pltgot, 1,
15621                                              _("Global Offset Table data"));
15622           /* PR 12855: Null data is handled gracefully throughout.  */
15623           data_end = data + (end - pltgot);
15624
15625           printf (_("\nStatic GOT:\n"));
15626           printf (_(" Canonical gp value: "));
15627           print_vma (ent + 0x7ff0, LONG_HEX);
15628           printf ("\n\n");
15629
15630           /* In a dynamic binary GOT[0] is reserved for the dynamic
15631              loader to store the lazy resolver pointer, however in
15632              a static binary it may well have been omitted and GOT
15633              reduced to a table of addresses.
15634              PR 21344: Check for the entry being fully available
15635              before fetching it.  */
15636           if (data
15637               && data + ent - pltgot + addr_size <= data_end
15638               && byte_get (data + ent - pltgot, addr_size) == 0)
15639             {
15640               printf (_(" Reserved entries:\n"));
15641               printf (_("  %*s %10s %*s\n"),
15642                       addr_size * 2, _("Address"), _("Access"),
15643                       addr_size * 2, _("Value"));
15644               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15645               printf ("\n");
15646               if (ent == (bfd_vma) -1)
15647                 goto sgot_print_fail;
15648
15649               /* Check for the MSB of GOT[1] being set, identifying a
15650                  GNU object.  This entry will be used by some runtime
15651                  loaders, to store the module pointer.  Otherwise this
15652                  is an ordinary local entry.
15653                  PR 21344: Check for the entry being fully available
15654                  before fetching it.  */
15655               if (data
15656                   && data + ent - pltgot + addr_size <= data_end
15657                   && (byte_get (data + ent - pltgot, addr_size)
15658                       >> (addr_size * 8 - 1)) != 0)
15659                 {
15660                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15661                   printf ("\n");
15662                   if (ent == (bfd_vma) -1)
15663                     goto sgot_print_fail;
15664                 }
15665               printf ("\n");
15666             }
15667
15668           if (data != NULL && ent < end)
15669             {
15670               printf (_(" Local entries:\n"));
15671               printf ("  %*s %10s %*s\n",
15672                       addr_size * 2, _("Address"), _("Access"),
15673                       addr_size * 2, _("Value"));
15674               while (ent < end)
15675                 {
15676                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15677                   printf ("\n");
15678                   if (ent == (bfd_vma) -1)
15679                     goto sgot_print_fail;
15680                 }
15681               printf ("\n");
15682             }
15683
15684         sgot_print_fail:
15685           if (data)
15686             free (data);
15687         }
15688       return res;
15689     }
15690
15691   for (entry = dynamic_section;
15692        /* PR 17531 file: 012-50589-0.004.  */
15693        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15694        ++entry)
15695     switch (entry->d_tag)
15696       {
15697       case DT_MIPS_LIBLIST:
15698         liblist_offset
15699           = offset_from_vma (filedata, entry->d_un.d_val,
15700                              liblistno * sizeof (Elf32_External_Lib));
15701         break;
15702       case DT_MIPS_LIBLISTNO:
15703         liblistno = entry->d_un.d_val;
15704         break;
15705       case DT_MIPS_OPTIONS:
15706         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15707         break;
15708       case DT_MIPS_CONFLICT:
15709         conflicts_offset
15710           = offset_from_vma (filedata, entry->d_un.d_val,
15711                              conflictsno * sizeof (Elf32_External_Conflict));
15712         break;
15713       case DT_MIPS_CONFLICTNO:
15714         conflictsno = entry->d_un.d_val;
15715         break;
15716       case DT_PLTGOT:
15717         pltgot = entry->d_un.d_ptr;
15718         break;
15719       case DT_MIPS_LOCAL_GOTNO:
15720         local_gotno = entry->d_un.d_val;
15721         break;
15722       case DT_MIPS_GOTSYM:
15723         gotsym = entry->d_un.d_val;
15724         break;
15725       case DT_MIPS_SYMTABNO:
15726         symtabno = entry->d_un.d_val;
15727         break;
15728       case DT_MIPS_PLTGOT:
15729         mips_pltgot = entry->d_un.d_ptr;
15730         break;
15731       case DT_PLTREL:
15732         pltrel = entry->d_un.d_val;
15733         break;
15734       case DT_PLTRELSZ:
15735         pltrelsz = entry->d_un.d_val;
15736         break;
15737       case DT_JMPREL:
15738         jmprel = entry->d_un.d_ptr;
15739         break;
15740       default:
15741         break;
15742       }
15743
15744   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15745     {
15746       Elf32_External_Lib * elib;
15747       size_t cnt;
15748
15749       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15750                                               liblistno,
15751                                               sizeof (Elf32_External_Lib),
15752                                               _("liblist section data"));
15753       if (elib)
15754         {
15755           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15756                             "\nSection '.liblist' contains %lu entries:\n",
15757                             (unsigned long) liblistno),
15758                   (unsigned long) liblistno);
15759           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15760                  stdout);
15761
15762           for (cnt = 0; cnt < liblistno; ++cnt)
15763             {
15764               Elf32_Lib liblist;
15765               time_t atime;
15766               char timebuf[128];
15767               struct tm * tmp;
15768
15769               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15770               atime = BYTE_GET (elib[cnt].l_time_stamp);
15771               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15772               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15773               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15774
15775               tmp = gmtime (&atime);
15776               snprintf (timebuf, sizeof (timebuf),
15777                         "%04u-%02u-%02uT%02u:%02u:%02u",
15778                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15779                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15780
15781               printf ("%3lu: ", (unsigned long) cnt);
15782               if (VALID_DYNAMIC_NAME (liblist.l_name))
15783                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15784               else
15785                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15786               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15787                       liblist.l_version);
15788
15789               if (liblist.l_flags == 0)
15790                 puts (_(" NONE"));
15791               else
15792                 {
15793                   static const struct
15794                   {
15795                     const char * name;
15796                     int bit;
15797                   }
15798                   l_flags_vals[] =
15799                   {
15800                     { " EXACT_MATCH", LL_EXACT_MATCH },
15801                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15802                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15803                     { " EXPORTS", LL_EXPORTS },
15804                     { " DELAY_LOAD", LL_DELAY_LOAD },
15805                     { " DELTA", LL_DELTA }
15806                   };
15807                   int flags = liblist.l_flags;
15808                   size_t fcnt;
15809
15810                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15811                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15812                       {
15813                         fputs (l_flags_vals[fcnt].name, stdout);
15814                         flags ^= l_flags_vals[fcnt].bit;
15815                       }
15816                   if (flags != 0)
15817                     printf (" %#x", (unsigned int) flags);
15818
15819                   puts ("");
15820                 }
15821             }
15822
15823           free (elib);
15824         }
15825       else
15826         res = FALSE;
15827     }
15828
15829   if (options_offset != 0)
15830     {
15831       Elf_External_Options * eopt;
15832       Elf_Internal_Options * iopt;
15833       Elf_Internal_Options * option;
15834       size_t offset;
15835       int cnt;
15836       sect = filedata->section_headers;
15837
15838       /* Find the section header so that we get the size.  */
15839       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15840       /* PR 17533 file: 012-277276-0.004.  */
15841       if (sect == NULL)
15842         {
15843           error (_("No MIPS_OPTIONS header found\n"));
15844           return FALSE;
15845         }
15846
15847       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15848                                                 sect->sh_size, _("options"));
15849       if (eopt)
15850         {
15851           iopt = (Elf_Internal_Options *)
15852               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15853           if (iopt == NULL)
15854             {
15855               error (_("Out of memory allocating space for MIPS options\n"));
15856               return FALSE;
15857             }
15858
15859           offset = cnt = 0;
15860           option = iopt;
15861
15862           while (offset <= sect->sh_size - sizeof (* eopt))
15863             {
15864               Elf_External_Options * eoption;
15865
15866               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15867
15868               option->kind = BYTE_GET (eoption->kind);
15869               option->size = BYTE_GET (eoption->size);
15870               option->section = BYTE_GET (eoption->section);
15871               option->info = BYTE_GET (eoption->info);
15872
15873               /* PR 17531: file: ffa0fa3b.  */
15874               if (option->size < sizeof (* eopt)
15875                   || offset + option->size > sect->sh_size)
15876                 {
15877                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15878                   return FALSE;
15879                 }
15880               offset += option->size;
15881
15882               ++option;
15883               ++cnt;
15884             }
15885
15886           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15887                             "\nSection '%s' contains %d entries:\n",
15888                             cnt),
15889                   printable_section_name (filedata, sect), cnt);
15890
15891           option = iopt;
15892           offset = 0;
15893
15894           while (cnt-- > 0)
15895             {
15896               size_t len;
15897
15898               switch (option->kind)
15899                 {
15900                 case ODK_NULL:
15901                   /* This shouldn't happen.  */
15902                   printf (" NULL       %d %lx", option->section, option->info);
15903                   break;
15904                 case ODK_REGINFO:
15905                   printf (" REGINFO    ");
15906                   if (filedata->file_header.e_machine == EM_MIPS)
15907                     {
15908                       /* 32bit form.  */
15909                       Elf32_External_RegInfo * ereg;
15910                       Elf32_RegInfo reginfo;
15911
15912                       ereg = (Elf32_External_RegInfo *) (option + 1);
15913                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15914                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15915                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15916                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15917                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15918                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15919
15920                       printf ("GPR %08lx  GP 0x%lx\n",
15921                               reginfo.ri_gprmask,
15922                               (unsigned long) reginfo.ri_gp_value);
15923                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15924                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15925                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15926                     }
15927                   else
15928                     {
15929                       /* 64 bit form.  */
15930                       Elf64_External_RegInfo * ereg;
15931                       Elf64_Internal_RegInfo reginfo;
15932
15933                       ereg = (Elf64_External_RegInfo *) (option + 1);
15934                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15935                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15936                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15937                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15938                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15939                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15940
15941                       printf ("GPR %08lx  GP 0x",
15942                               reginfo.ri_gprmask);
15943                       printf_vma (reginfo.ri_gp_value);
15944                       printf ("\n");
15945
15946                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15947                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15948                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15949                     }
15950                   ++option;
15951                   continue;
15952                 case ODK_EXCEPTIONS:
15953                   fputs (" EXCEPTIONS fpe_min(", stdout);
15954                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15955                   fputs (") fpe_max(", stdout);
15956                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15957                   fputs (")", stdout);
15958
15959                   if (option->info & OEX_PAGE0)
15960                     fputs (" PAGE0", stdout);
15961                   if (option->info & OEX_SMM)
15962                     fputs (" SMM", stdout);
15963                   if (option->info & OEX_FPDBUG)
15964                     fputs (" FPDBUG", stdout);
15965                   if (option->info & OEX_DISMISS)
15966                     fputs (" DISMISS", stdout);
15967                   break;
15968                 case ODK_PAD:
15969                   fputs (" PAD       ", stdout);
15970                   if (option->info & OPAD_PREFIX)
15971                     fputs (" PREFIX", stdout);
15972                   if (option->info & OPAD_POSTFIX)
15973                     fputs (" POSTFIX", stdout);
15974                   if (option->info & OPAD_SYMBOL)
15975                     fputs (" SYMBOL", stdout);
15976                   break;
15977                 case ODK_HWPATCH:
15978                   fputs (" HWPATCH   ", stdout);
15979                   if (option->info & OHW_R4KEOP)
15980                     fputs (" R4KEOP", stdout);
15981                   if (option->info & OHW_R8KPFETCH)
15982                     fputs (" R8KPFETCH", stdout);
15983                   if (option->info & OHW_R5KEOP)
15984                     fputs (" R5KEOP", stdout);
15985                   if (option->info & OHW_R5KCVTL)
15986                     fputs (" R5KCVTL", stdout);
15987                   break;
15988                 case ODK_FILL:
15989                   fputs (" FILL       ", stdout);
15990                   /* XXX Print content of info word?  */
15991                   break;
15992                 case ODK_TAGS:
15993                   fputs (" TAGS       ", stdout);
15994                   /* XXX Print content of info word?  */
15995                   break;
15996                 case ODK_HWAND:
15997                   fputs (" HWAND     ", stdout);
15998                   if (option->info & OHWA0_R4KEOP_CHECKED)
15999                     fputs (" R4KEOP_CHECKED", stdout);
16000                   if (option->info & OHWA0_R4KEOP_CLEAN)
16001                     fputs (" R4KEOP_CLEAN", stdout);
16002                   break;
16003                 case ODK_HWOR:
16004                   fputs (" HWOR      ", stdout);
16005                   if (option->info & OHWA0_R4KEOP_CHECKED)
16006                     fputs (" R4KEOP_CHECKED", stdout);
16007                   if (option->info & OHWA0_R4KEOP_CLEAN)
16008                     fputs (" R4KEOP_CLEAN", stdout);
16009                   break;
16010                 case ODK_GP_GROUP:
16011                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16012                           option->info & OGP_GROUP,
16013                           (option->info & OGP_SELF) >> 16);
16014                   break;
16015                 case ODK_IDENT:
16016                   printf (" IDENT     %#06lx  self-contained %#06lx",
16017                           option->info & OGP_GROUP,
16018                           (option->info & OGP_SELF) >> 16);
16019                   break;
16020                 default:
16021                   /* This shouldn't happen.  */
16022                   printf (" %3d ???     %d %lx",
16023                           option->kind, option->section, option->info);
16024                   break;
16025                 }
16026
16027               len = sizeof (* eopt);
16028               while (len < option->size)
16029                 {
16030                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16031
16032                   if (ISPRINT (datum))
16033                     printf ("%c", datum);
16034                   else
16035                     printf ("\\%03o", datum);
16036                   len ++;
16037                 }
16038               fputs ("\n", stdout);
16039
16040               offset += option->size;
16041               ++option;
16042             }
16043
16044           free (eopt);
16045         }
16046       else
16047         res = FALSE;
16048     }
16049
16050   if (conflicts_offset != 0 && conflictsno != 0)
16051     {
16052       Elf32_Conflict * iconf;
16053       size_t cnt;
16054
16055       if (dynamic_symbols == NULL)
16056         {
16057           error (_("conflict list found without a dynamic symbol table\n"));
16058           return FALSE;
16059         }
16060
16061       /* PR 21345 - print a slightly more helpful error message
16062          if we are sure that the cmalloc will fail.  */
16063       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16064         {
16065           error (_("Overlarge number of conflicts detected: %lx\n"),
16066                  (long) conflictsno);
16067           return FALSE;
16068         }
16069
16070       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16071       if (iconf == NULL)
16072         {
16073           error (_("Out of memory allocating space for dynamic conflicts\n"));
16074           return FALSE;
16075         }
16076
16077       if (is_32bit_elf)
16078         {
16079           Elf32_External_Conflict * econf32;
16080
16081           econf32 = (Elf32_External_Conflict *)
16082               get_data (NULL, filedata, conflicts_offset, conflictsno,
16083                         sizeof (* econf32), _("conflict"));
16084           if (!econf32)
16085             return FALSE;
16086
16087           for (cnt = 0; cnt < conflictsno; ++cnt)
16088             iconf[cnt] = BYTE_GET (econf32[cnt]);
16089
16090           free (econf32);
16091         }
16092       else
16093         {
16094           Elf64_External_Conflict * econf64;
16095
16096           econf64 = (Elf64_External_Conflict *)
16097               get_data (NULL, filedata, conflicts_offset, conflictsno,
16098                         sizeof (* econf64), _("conflict"));
16099           if (!econf64)
16100             return FALSE;
16101
16102           for (cnt = 0; cnt < conflictsno; ++cnt)
16103             iconf[cnt] = BYTE_GET (econf64[cnt]);
16104
16105           free (econf64);
16106         }
16107
16108       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16109                         "\nSection '.conflict' contains %lu entries:\n",
16110                         (unsigned long) conflictsno),
16111               (unsigned long) conflictsno);
16112       puts (_("  Num:    Index       Value  Name"));
16113
16114       for (cnt = 0; cnt < conflictsno; ++cnt)
16115         {
16116           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16117
16118           if (iconf[cnt] >= num_dynamic_syms)
16119             printf (_("<corrupt symbol index>"));
16120           else
16121             {
16122               Elf_Internal_Sym * psym;
16123
16124               psym = & dynamic_symbols[iconf[cnt]];
16125               print_vma (psym->st_value, FULL_HEX);
16126               putchar (' ');
16127               if (VALID_DYNAMIC_NAME (psym->st_name))
16128                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16129               else
16130                 printf (_("<corrupt: %14ld>"), psym->st_name);
16131             }
16132           putchar ('\n');
16133         }
16134
16135       free (iconf);
16136     }
16137
16138   if (pltgot != 0 && local_gotno != 0)
16139     {
16140       bfd_vma ent, local_end, global_end;
16141       size_t i, offset;
16142       unsigned char * data;
16143       unsigned char * data_end;
16144       int addr_size;
16145
16146       ent = pltgot;
16147       addr_size = (is_32bit_elf ? 4 : 8);
16148       local_end = pltgot + local_gotno * addr_size;
16149
16150       /* PR binutils/17533 file: 012-111227-0.004  */
16151       if (symtabno < gotsym)
16152         {
16153           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16154                  (unsigned long) gotsym, (unsigned long) symtabno);
16155           return FALSE;
16156         }
16157
16158       global_end = local_end + (symtabno - gotsym) * addr_size;
16159       /* PR 17531: file: 54c91a34.  */
16160       if (global_end < local_end)
16161         {
16162           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16163           return FALSE;
16164         }
16165
16166       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16167       data = (unsigned char *) get_data (NULL, filedata, offset,
16168                                          global_end - pltgot, 1,
16169                                          _("Global Offset Table data"));
16170       /* PR 12855: Null data is handled gracefully throughout.  */
16171       data_end = data + (global_end - pltgot);
16172
16173       printf (_("\nPrimary GOT:\n"));
16174       printf (_(" Canonical gp value: "));
16175       print_vma (pltgot + 0x7ff0, LONG_HEX);
16176       printf ("\n\n");
16177
16178       printf (_(" Reserved entries:\n"));
16179       printf (_("  %*s %10s %*s Purpose\n"),
16180               addr_size * 2, _("Address"), _("Access"),
16181               addr_size * 2, _("Initial"));
16182       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16183       printf (_(" Lazy resolver\n"));
16184       if (ent == (bfd_vma) -1)
16185         goto got_print_fail;
16186
16187       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16188          This entry will be used by some runtime loaders, to store the
16189          module pointer.  Otherwise this is an ordinary local entry.
16190          PR 21344: Check for the entry being fully available before
16191          fetching it.  */
16192       if (data
16193           && data + ent - pltgot + addr_size <= data_end
16194           && (byte_get (data + ent - pltgot, addr_size)
16195               >> (addr_size * 8 - 1)) != 0)
16196         {
16197           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16198           printf (_(" Module pointer (GNU extension)\n"));
16199           if (ent == (bfd_vma) -1)
16200             goto got_print_fail;
16201         }
16202       printf ("\n");
16203
16204       if (data != NULL && ent < local_end)
16205         {
16206           printf (_(" Local entries:\n"));
16207           printf ("  %*s %10s %*s\n",
16208                   addr_size * 2, _("Address"), _("Access"),
16209                   addr_size * 2, _("Initial"));
16210           while (ent < local_end)
16211             {
16212               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16213               printf ("\n");
16214               if (ent == (bfd_vma) -1)
16215                 goto got_print_fail;
16216             }
16217           printf ("\n");
16218         }
16219
16220       if (data != NULL && gotsym < symtabno)
16221         {
16222           int sym_width;
16223
16224           printf (_(" Global entries:\n"));
16225           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16226                   addr_size * 2, _("Address"),
16227                   _("Access"),
16228                   addr_size * 2, _("Initial"),
16229                   addr_size * 2, _("Sym.Val."),
16230                   _("Type"),
16231                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16232                   _("Ndx"), _("Name"));
16233
16234           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16235
16236           for (i = gotsym; i < symtabno; i++)
16237             {
16238               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16239               printf (" ");
16240
16241               if (dynamic_symbols == NULL)
16242                 printf (_("<no dynamic symbols>"));
16243               else if (i < num_dynamic_syms)
16244                 {
16245                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16246
16247                   print_vma (psym->st_value, LONG_HEX);
16248                   printf (" %-7s %3s ",
16249                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16250                           get_symbol_index_type (filedata, psym->st_shndx));
16251
16252                   if (VALID_DYNAMIC_NAME (psym->st_name))
16253                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16254                   else
16255                     printf (_("<corrupt: %14ld>"), psym->st_name);
16256                 }
16257               else
16258                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16259                         (unsigned long) i);
16260
16261               printf ("\n");
16262               if (ent == (bfd_vma) -1)
16263                 break;
16264             }
16265           printf ("\n");
16266         }
16267
16268     got_print_fail:
16269       if (data)
16270         free (data);
16271     }
16272
16273   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16274     {
16275       bfd_vma ent, end;
16276       size_t offset, rel_offset;
16277       unsigned long count, i;
16278       unsigned char * data;
16279       int addr_size, sym_width;
16280       Elf_Internal_Rela * rels;
16281
16282       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16283       if (pltrel == DT_RELA)
16284         {
16285           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16286             return FALSE;
16287         }
16288       else
16289         {
16290           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16291             return FALSE;
16292         }
16293
16294       ent = mips_pltgot;
16295       addr_size = (is_32bit_elf ? 4 : 8);
16296       end = mips_pltgot + (2 + count) * addr_size;
16297
16298       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16299       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16300                                          1, _("Procedure Linkage Table data"));
16301       if (data == NULL)
16302         return FALSE;
16303
16304       printf ("\nPLT GOT:\n\n");
16305       printf (_(" Reserved entries:\n"));
16306       printf (_("  %*s %*s Purpose\n"),
16307               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16308       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16309       printf (_(" PLT lazy resolver\n"));
16310       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16311       printf (_(" Module pointer\n"));
16312       printf ("\n");
16313
16314       printf (_(" Entries:\n"));
16315       printf ("  %*s %*s %*s %-7s %3s %s\n",
16316               addr_size * 2, _("Address"),
16317               addr_size * 2, _("Initial"),
16318               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16319       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16320       for (i = 0; i < count; i++)
16321         {
16322           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16323
16324           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16325           printf (" ");
16326
16327           if (idx >= num_dynamic_syms)
16328             printf (_("<corrupt symbol index: %lu>"), idx);
16329           else
16330             {
16331               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16332
16333               print_vma (psym->st_value, LONG_HEX);
16334               printf (" %-7s %3s ",
16335                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16336                       get_symbol_index_type (filedata, psym->st_shndx));
16337               if (VALID_DYNAMIC_NAME (psym->st_name))
16338                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16339               else
16340                 printf (_("<corrupt: %14ld>"), psym->st_name);
16341             }
16342           printf ("\n");
16343         }
16344       printf ("\n");
16345
16346       if (data)
16347         free (data);
16348       free (rels);
16349     }
16350
16351   return res;
16352 }
16353
16354 static bfd_boolean
16355 process_nds32_specific (Filedata * filedata)
16356 {
16357   Elf_Internal_Shdr *sect = NULL;
16358
16359   sect = find_section (filedata, ".nds32_e_flags");
16360   if (sect != NULL)
16361     {
16362       unsigned int *flag;
16363
16364       printf ("\nNDS32 elf flags section:\n");
16365       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16366                        sect->sh_size, _("NDS32 elf flags section"));
16367
16368       if (! flag)
16369         return FALSE;
16370
16371       switch ((*flag) & 0x3)
16372         {
16373         case 0:
16374           printf ("(VEC_SIZE):\tNo entry.\n");
16375           break;
16376         case 1:
16377           printf ("(VEC_SIZE):\t4 bytes\n");
16378           break;
16379         case 2:
16380           printf ("(VEC_SIZE):\t16 bytes\n");
16381           break;
16382         case 3:
16383           printf ("(VEC_SIZE):\treserved\n");
16384           break;
16385         }
16386     }
16387
16388   return TRUE;
16389 }
16390
16391 static bfd_boolean
16392 process_gnu_liblist (Filedata * filedata)
16393 {
16394   Elf_Internal_Shdr * section;
16395   Elf_Internal_Shdr * string_sec;
16396   Elf32_External_Lib * elib;
16397   char * strtab;
16398   size_t strtab_size;
16399   size_t cnt;
16400   unsigned long num_liblist;
16401   unsigned i;
16402   bfd_boolean res = TRUE;
16403
16404   if (! do_arch)
16405     return TRUE;
16406
16407   for (i = 0, section = filedata->section_headers;
16408        i < filedata->file_header.e_shnum;
16409        i++, section++)
16410     {
16411       switch (section->sh_type)
16412         {
16413         case SHT_GNU_LIBLIST:
16414           if (section->sh_link >= filedata->file_header.e_shnum)
16415             break;
16416
16417           elib = (Elf32_External_Lib *)
16418               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16419                         _("liblist section data"));
16420
16421           if (elib == NULL)
16422             {
16423               res = FALSE;
16424               break;
16425             }
16426
16427           string_sec = filedata->section_headers + section->sh_link;
16428           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16429                                       string_sec->sh_size,
16430                                       _("liblist string table"));
16431           if (strtab == NULL
16432               || section->sh_entsize != sizeof (Elf32_External_Lib))
16433             {
16434               free (elib);
16435               free (strtab);
16436               res = FALSE;
16437               break;
16438             }
16439           strtab_size = string_sec->sh_size;
16440
16441           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16442           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16443                             "\nLibrary list section '%s' contains %lu entries:\n",
16444                             num_liblist),
16445                   printable_section_name (filedata, section),
16446                   num_liblist);
16447
16448           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16449
16450           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16451                ++cnt)
16452             {
16453               Elf32_Lib liblist;
16454               time_t atime;
16455               char timebuf[128];
16456               struct tm * tmp;
16457
16458               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16459               atime = BYTE_GET (elib[cnt].l_time_stamp);
16460               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16461               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16462               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16463
16464               tmp = gmtime (&atime);
16465               snprintf (timebuf, sizeof (timebuf),
16466                         "%04u-%02u-%02uT%02u:%02u:%02u",
16467                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16468                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16469
16470               printf ("%3lu: ", (unsigned long) cnt);
16471               if (do_wide)
16472                 printf ("%-20s", liblist.l_name < strtab_size
16473                         ? strtab + liblist.l_name : _("<corrupt>"));
16474               else
16475                 printf ("%-20.20s", liblist.l_name < strtab_size
16476                         ? strtab + liblist.l_name : _("<corrupt>"));
16477               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16478                       liblist.l_version, liblist.l_flags);
16479             }
16480
16481           free (elib);
16482           free (strtab);
16483         }
16484     }
16485
16486   return res;
16487 }
16488
16489 static const char *
16490 get_note_type (Filedata * filedata, unsigned e_type)
16491 {
16492   static char buff[64];
16493
16494   if (filedata->file_header.e_type == ET_CORE)
16495     switch (e_type)
16496       {
16497       case NT_AUXV:
16498         return _("NT_AUXV (auxiliary vector)");
16499       case NT_PRSTATUS:
16500         return _("NT_PRSTATUS (prstatus structure)");
16501       case NT_FPREGSET:
16502         return _("NT_FPREGSET (floating point registers)");
16503       case NT_PRPSINFO:
16504         return _("NT_PRPSINFO (prpsinfo structure)");
16505       case NT_TASKSTRUCT:
16506         return _("NT_TASKSTRUCT (task structure)");
16507       case NT_PRXFPREG:
16508         return _("NT_PRXFPREG (user_xfpregs structure)");
16509       case NT_PPC_VMX:
16510         return _("NT_PPC_VMX (ppc Altivec registers)");
16511       case NT_PPC_VSX:
16512         return _("NT_PPC_VSX (ppc VSX registers)");
16513       case NT_PPC_TAR:
16514         return _("NT_PPC_TAR (ppc TAR register)");
16515       case NT_PPC_PPR:
16516         return _("NT_PPC_PPR (ppc PPR register)");
16517       case NT_PPC_DSCR:
16518         return _("NT_PPC_DSCR (ppc DSCR register)");
16519       case NT_PPC_EBB:
16520         return _("NT_PPC_EBB (ppc EBB registers)");
16521       case NT_PPC_PMU:
16522         return _("NT_PPC_PMU (ppc PMU registers)");
16523       case NT_PPC_TM_CGPR:
16524         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16525       case NT_PPC_TM_CFPR:
16526         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16527       case NT_PPC_TM_CVMX:
16528         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16529       case NT_PPC_TM_CVSX:
16530         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16531       case NT_PPC_TM_SPR:
16532         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16533       case NT_PPC_TM_CTAR:
16534         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16535       case NT_PPC_TM_CPPR:
16536         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16537       case NT_PPC_TM_CDSCR:
16538         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16539       case NT_386_TLS:
16540         return _("NT_386_TLS (x86 TLS information)");
16541       case NT_386_IOPERM:
16542         return _("NT_386_IOPERM (x86 I/O permissions)");
16543       case NT_X86_XSTATE:
16544         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16545       case NT_S390_HIGH_GPRS:
16546         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16547       case NT_S390_TIMER:
16548         return _("NT_S390_TIMER (s390 timer register)");
16549       case NT_S390_TODCMP:
16550         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16551       case NT_S390_TODPREG:
16552         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16553       case NT_S390_CTRS:
16554         return _("NT_S390_CTRS (s390 control registers)");
16555       case NT_S390_PREFIX:
16556         return _("NT_S390_PREFIX (s390 prefix register)");
16557       case NT_S390_LAST_BREAK:
16558         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16559       case NT_S390_SYSTEM_CALL:
16560         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16561       case NT_S390_TDB:
16562         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16563       case NT_S390_VXRS_LOW:
16564         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16565       case NT_S390_VXRS_HIGH:
16566         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16567       case NT_S390_GS_CB:
16568         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16569       case NT_S390_GS_BC:
16570         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16571       case NT_ARM_VFP:
16572         return _("NT_ARM_VFP (arm VFP registers)");
16573       case NT_ARM_TLS:
16574         return _("NT_ARM_TLS (AArch TLS registers)");
16575       case NT_ARM_HW_BREAK:
16576         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16577       case NT_ARM_HW_WATCH:
16578         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16579       case NT_PSTATUS:
16580         return _("NT_PSTATUS (pstatus structure)");
16581       case NT_FPREGS:
16582         return _("NT_FPREGS (floating point registers)");
16583       case NT_PSINFO:
16584         return _("NT_PSINFO (psinfo structure)");
16585       case NT_LWPSTATUS:
16586         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16587       case NT_LWPSINFO:
16588         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16589       case NT_WIN32PSTATUS:
16590         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16591       case NT_SIGINFO:
16592         return _("NT_SIGINFO (siginfo_t data)");
16593       case NT_FILE:
16594         return _("NT_FILE (mapped files)");
16595       default:
16596         break;
16597       }
16598   else
16599     switch (e_type)
16600       {
16601       case NT_VERSION:
16602         return _("NT_VERSION (version)");
16603       case NT_ARCH:
16604         return _("NT_ARCH (architecture)");
16605       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16606         return _("OPEN");
16607       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16608         return _("func");
16609       default:
16610         break;
16611       }
16612
16613   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16614   return buff;
16615 }
16616
16617 static bfd_boolean
16618 print_core_note (Elf_Internal_Note *pnote)
16619 {
16620   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16621   bfd_vma count, page_size;
16622   unsigned char *descdata, *filenames, *descend;
16623
16624   if (pnote->type != NT_FILE)
16625     {
16626       if (do_wide)
16627         printf ("\n");
16628       return TRUE;
16629     }
16630
16631 #ifndef BFD64
16632   if (!is_32bit_elf)
16633     {
16634       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16635       /* Still "successful".  */
16636       return TRUE;
16637     }
16638 #endif
16639
16640   if (pnote->descsz < 2 * addr_size)
16641     {
16642       error (_("    Malformed note - too short for header\n"));
16643       return FALSE;
16644     }
16645
16646   descdata = (unsigned char *) pnote->descdata;
16647   descend = descdata + pnote->descsz;
16648
16649   if (descdata[pnote->descsz - 1] != '\0')
16650     {
16651       error (_("    Malformed note - does not end with \\0\n"));
16652       return FALSE;
16653     }
16654
16655   count = byte_get (descdata, addr_size);
16656   descdata += addr_size;
16657
16658   page_size = byte_get (descdata, addr_size);
16659   descdata += addr_size;
16660
16661   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16662       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16663     {
16664       error (_("    Malformed note - too short for supplied file count\n"));
16665       return FALSE;
16666     }
16667
16668   printf (_("    Page size: "));
16669   print_vma (page_size, DEC);
16670   printf ("\n");
16671
16672   printf (_("    %*s%*s%*s\n"),
16673           (int) (2 + 2 * addr_size), _("Start"),
16674           (int) (4 + 2 * addr_size), _("End"),
16675           (int) (4 + 2 * addr_size), _("Page Offset"));
16676   filenames = descdata + count * 3 * addr_size;
16677   while (count-- > 0)
16678     {
16679       bfd_vma start, end, file_ofs;
16680
16681       if (filenames == descend)
16682         {
16683           error (_("    Malformed note - filenames end too early\n"));
16684           return FALSE;
16685         }
16686
16687       start = byte_get (descdata, addr_size);
16688       descdata += addr_size;
16689       end = byte_get (descdata, addr_size);
16690       descdata += addr_size;
16691       file_ofs = byte_get (descdata, addr_size);
16692       descdata += addr_size;
16693
16694       printf ("    ");
16695       print_vma (start, FULL_HEX);
16696       printf ("  ");
16697       print_vma (end, FULL_HEX);
16698       printf ("  ");
16699       print_vma (file_ofs, FULL_HEX);
16700       printf ("\n        %s\n", filenames);
16701
16702       filenames += 1 + strlen ((char *) filenames);
16703     }
16704
16705   return TRUE;
16706 }
16707
16708 static const char *
16709 get_gnu_elf_note_type (unsigned e_type)
16710 {
16711   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16712   switch (e_type)
16713     {
16714     case NT_GNU_ABI_TAG:
16715       return _("NT_GNU_ABI_TAG (ABI version tag)");
16716     case NT_GNU_HWCAP:
16717       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16718     case NT_GNU_BUILD_ID:
16719       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16720     case NT_GNU_GOLD_VERSION:
16721       return _("NT_GNU_GOLD_VERSION (gold version)");
16722     case NT_GNU_PROPERTY_TYPE_0:
16723       return _("NT_GNU_PROPERTY_TYPE_0");
16724     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16725       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16726     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16727       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16728     default:
16729       {
16730         static char buff[64];
16731
16732         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16733         return buff;
16734       }
16735     }
16736 }
16737
16738 static void
16739 decode_x86_isa (unsigned int bitmask)
16740 {
16741   while (bitmask)
16742     {
16743       unsigned int bit = bitmask & (- bitmask);
16744
16745       bitmask &= ~ bit;
16746       switch (bit)
16747         {
16748         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16749         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16750         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16751         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16752         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16753         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16754         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16755         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16756         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16757         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16758         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16759         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16760         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16761         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16762         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16763         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16764         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16765         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16766         default: printf (_("<unknown: %x>"), bit); break;
16767         }
16768       if (bitmask)
16769         printf (", ");
16770     }
16771 }
16772
16773 static void
16774 decode_x86_feature (unsigned int type, unsigned int bitmask)
16775 {
16776   while (bitmask)
16777     {
16778       unsigned int bit = bitmask & (- bitmask);
16779
16780       bitmask &= ~ bit;
16781       switch (bit)
16782         {
16783         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16784           switch (type)
16785             {
16786             case GNU_PROPERTY_X86_FEATURE_1_AND:
16787               printf ("IBT");
16788               break;
16789             default:
16790               /* This should never happen.  */
16791               abort ();
16792             }
16793           break;
16794         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16795           switch (type)
16796             {
16797             case GNU_PROPERTY_X86_FEATURE_1_AND:
16798               printf ("SHSTK");
16799               break;
16800             default:
16801               /* This should never happen.  */
16802               abort ();
16803             }
16804           break;
16805         default:
16806           printf (_("<unknown: %x>"), bit);
16807           break;
16808         }
16809       if (bitmask)
16810         printf (", ");
16811     }
16812 }
16813
16814 static void
16815 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16816 {
16817   unsigned char * ptr = (unsigned char *) pnote->descdata;
16818   unsigned char * ptr_end = ptr + pnote->descsz;
16819   unsigned int    size = is_32bit_elf ? 4 : 8;
16820
16821   printf (_("      Properties: "));
16822
16823   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16824     {
16825       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16826       return;
16827     }
16828
16829   while (ptr < ptr_end)
16830     {
16831       unsigned int j;
16832       unsigned int type;
16833       unsigned int datasz;
16834
16835       if ((size_t) (ptr_end - ptr) < 8)
16836         {
16837           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16838           break;
16839         }
16840
16841       type = byte_get (ptr, 4);
16842       datasz = byte_get (ptr + 4, 4);
16843
16844       ptr += 8;
16845
16846       if (datasz > (size_t) (ptr_end - ptr))
16847         {
16848           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16849                   type, datasz);
16850           break;
16851         }
16852
16853       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16854         {
16855           if (filedata->file_header.e_machine == EM_X86_64
16856               || filedata->file_header.e_machine == EM_IAMCU
16857               || filedata->file_header.e_machine == EM_386)
16858             {
16859               switch (type)
16860                 {
16861                 case GNU_PROPERTY_X86_ISA_1_USED:
16862                   printf ("x86 ISA used: ");
16863                   if (datasz != 4)
16864                     printf (_("<corrupt length: %#x> "), datasz);
16865                   else
16866                     decode_x86_isa (byte_get (ptr, 4));
16867                   goto next;
16868
16869                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16870                   printf ("x86 ISA needed: ");
16871                   if (datasz != 4)
16872                     printf (_("<corrupt length: %#x> "), datasz);
16873                   else
16874                     decode_x86_isa (byte_get (ptr, 4));
16875                   goto next;
16876
16877                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16878                   printf ("x86 feature: ");
16879                   if (datasz != 4)
16880                     printf (_("<corrupt length: %#x> "), datasz);
16881                   else
16882                     decode_x86_feature (type, byte_get (ptr, 4));
16883                   goto next;
16884
16885                 default:
16886                   break;
16887                 }
16888             }
16889         }
16890       else
16891         {
16892           switch (type)
16893             {
16894             case GNU_PROPERTY_STACK_SIZE:
16895               printf (_("stack size: "));
16896               if (datasz != size)
16897                 printf (_("<corrupt length: %#x> "), datasz);
16898               else
16899                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16900               goto next;
16901
16902             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16903               printf ("no copy on protected ");
16904               if (datasz)
16905                 printf (_("<corrupt length: %#x> "), datasz);
16906               goto next;
16907
16908             default:
16909               break;
16910             }
16911         }
16912
16913       if (type < GNU_PROPERTY_LOPROC)
16914         printf (_("<unknown type %#x data: "), type);
16915       else if (type < GNU_PROPERTY_LOUSER)
16916         printf (_("<procesor-specific type %#x data: "), type);
16917       else
16918         printf (_("<application-specific type %#x data: "), type);
16919       for (j = 0; j < datasz; ++j)
16920         printf ("%02x ", ptr[j] & 0xff);
16921       printf (">");
16922
16923 next:
16924       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16925       if (ptr == ptr_end)
16926         break;
16927
16928       if (do_wide)
16929         printf (", ");
16930       else
16931         printf ("\n\t");
16932     }
16933
16934   printf ("\n");
16935 }
16936
16937 static bfd_boolean
16938 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
16939 {
16940   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16941   switch (pnote->type)
16942     {
16943     case NT_GNU_BUILD_ID:
16944       {
16945         unsigned long i;
16946
16947         printf (_("    Build ID: "));
16948         for (i = 0; i < pnote->descsz; ++i)
16949           printf ("%02x", pnote->descdata[i] & 0xff);
16950         printf ("\n");
16951       }
16952       break;
16953
16954     case NT_GNU_ABI_TAG:
16955       {
16956         unsigned long os, major, minor, subminor;
16957         const char *osname;
16958
16959         /* PR 17531: file: 030-599401-0.004.  */
16960         if (pnote->descsz < 16)
16961           {
16962             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16963             break;
16964           }
16965
16966         os = byte_get ((unsigned char *) pnote->descdata, 4);
16967         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16968         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16969         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16970
16971         switch (os)
16972           {
16973           case GNU_ABI_TAG_LINUX:
16974             osname = "Linux";
16975             break;
16976           case GNU_ABI_TAG_HURD:
16977             osname = "Hurd";
16978             break;
16979           case GNU_ABI_TAG_SOLARIS:
16980             osname = "Solaris";
16981             break;
16982           case GNU_ABI_TAG_FREEBSD:
16983             osname = "FreeBSD";
16984             break;
16985           case GNU_ABI_TAG_NETBSD:
16986             osname = "NetBSD";
16987             break;
16988           case GNU_ABI_TAG_SYLLABLE:
16989             osname = "Syllable";
16990             break;
16991           case GNU_ABI_TAG_NACL:
16992             osname = "NaCl";
16993             break;
16994           default:
16995             osname = "Unknown";
16996             break;
16997           }
16998
16999         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17000                 major, minor, subminor);
17001       }
17002       break;
17003
17004     case NT_GNU_GOLD_VERSION:
17005       {
17006         unsigned long i;
17007
17008         printf (_("    Version: "));
17009         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17010           printf ("%c", pnote->descdata[i]);
17011         printf ("\n");
17012       }
17013       break;
17014
17015     case NT_GNU_HWCAP:
17016       {
17017         unsigned long num_entries, mask;
17018
17019         /* Hardware capabilities information.  Word 0 is the number of entries.
17020            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17021            is a series of entries, where each entry is a single byte followed
17022            by a nul terminated string.  The byte gives the bit number to test
17023            if enabled in the bitmask.  */
17024         printf (_("      Hardware Capabilities: "));
17025         if (pnote->descsz < 8)
17026           {
17027             error (_("<corrupt GNU_HWCAP>\n"));
17028             return FALSE;
17029           }
17030         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17031         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17032         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17033         /* FIXME: Add code to display the entries... */
17034       }
17035       break;
17036
17037     case NT_GNU_PROPERTY_TYPE_0:
17038       print_gnu_property_note (filedata, pnote);
17039       break;
17040
17041     default:
17042       /* Handle unrecognised types.  An error message should have already been
17043          created by get_gnu_elf_note_type(), so all that we need to do is to
17044          display the data.  */
17045       {
17046         unsigned long i;
17047
17048         printf (_("    Description data: "));
17049         for (i = 0; i < pnote->descsz; ++i)
17050           printf ("%02x ", pnote->descdata[i] & 0xff);
17051         printf ("\n");
17052       }
17053       break;
17054     }
17055
17056   return TRUE;
17057 }
17058
17059 static const char *
17060 get_v850_elf_note_type (enum v850_notes n_type)
17061 {
17062   static char buff[64];
17063
17064   switch (n_type)
17065     {
17066     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17067     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17068     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17069     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17070     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17071     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17072     default:
17073       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17074       return buff;
17075     }
17076 }
17077
17078 static bfd_boolean
17079 print_v850_note (Elf_Internal_Note * pnote)
17080 {
17081   unsigned int val;
17082
17083   if (pnote->descsz != 4)
17084     return FALSE;
17085
17086   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17087
17088   if (val == 0)
17089     {
17090       printf (_("not set\n"));
17091       return TRUE;
17092     }
17093
17094   switch (pnote->type)
17095     {
17096     case V850_NOTE_ALIGNMENT:
17097       switch (val)
17098         {
17099         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17100         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17101         }
17102       break;
17103
17104     case V850_NOTE_DATA_SIZE:
17105       switch (val)
17106         {
17107         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17108         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17109         }
17110       break;
17111
17112     case V850_NOTE_FPU_INFO:
17113       switch (val)
17114         {
17115         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17116         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17117         }
17118       break;
17119
17120     case V850_NOTE_MMU_INFO:
17121     case V850_NOTE_CACHE_INFO:
17122     case V850_NOTE_SIMD_INFO:
17123       if (val == EF_RH850_SIMD)
17124         {
17125           printf (_("yes\n"));
17126           return TRUE;
17127         }
17128       break;
17129
17130     default:
17131       /* An 'unknown note type' message will already have been displayed.  */
17132       break;
17133     }
17134
17135   printf (_("unknown value: %x\n"), val);
17136   return FALSE;
17137 }
17138
17139 static bfd_boolean
17140 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17141 {
17142   unsigned int version;
17143
17144   switch (pnote->type)
17145     {
17146     case NT_NETBSD_IDENT:
17147       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17148       if ((version / 10000) % 100)
17149         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17150                 version, version / 100000000, (version / 1000000) % 100,
17151                 (version / 10000) % 100 > 26 ? "Z" : "",
17152                 'A' + (version / 10000) % 26);
17153       else
17154         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17155                 version, version / 100000000, (version / 1000000) % 100,
17156                 (version / 100) % 100);
17157       return TRUE;
17158
17159     case NT_NETBSD_MARCH:
17160       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17161               pnote->descdata);
17162       return TRUE;
17163
17164     default:
17165       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17166               pnote->type);
17167       return FALSE;
17168     }
17169 }
17170
17171 static const char *
17172 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17173 {
17174   switch (e_type)
17175     {
17176     case NT_FREEBSD_THRMISC:
17177       return _("NT_THRMISC (thrmisc structure)");
17178     case NT_FREEBSD_PROCSTAT_PROC:
17179       return _("NT_PROCSTAT_PROC (proc data)");
17180     case NT_FREEBSD_PROCSTAT_FILES:
17181       return _("NT_PROCSTAT_FILES (files data)");
17182     case NT_FREEBSD_PROCSTAT_VMMAP:
17183       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17184     case NT_FREEBSD_PROCSTAT_GROUPS:
17185       return _("NT_PROCSTAT_GROUPS (groups data)");
17186     case NT_FREEBSD_PROCSTAT_UMASK:
17187       return _("NT_PROCSTAT_UMASK (umask data)");
17188     case NT_FREEBSD_PROCSTAT_RLIMIT:
17189       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17190     case NT_FREEBSD_PROCSTAT_OSREL:
17191       return _("NT_PROCSTAT_OSREL (osreldate data)");
17192     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17193       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17194     case NT_FREEBSD_PROCSTAT_AUXV:
17195       return _("NT_PROCSTAT_AUXV (auxv data)");
17196     case NT_FREEBSD_PTLWPINFO:
17197       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17198     }
17199   return get_note_type (filedata, e_type);
17200 }
17201
17202 static const char *
17203 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17204 {
17205   static char buff[64];
17206
17207   if (e_type == NT_NETBSDCORE_PROCINFO)
17208     return _("NetBSD procinfo structure");
17209
17210   /* As of Jan 2002 there are no other machine-independent notes
17211      defined for NetBSD core files.  If the note type is less
17212      than the start of the machine-dependent note types, we don't
17213      understand it.  */
17214
17215   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17216     {
17217       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17218       return buff;
17219     }
17220
17221   switch (filedata->file_header.e_machine)
17222     {
17223     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17224        and PT_GETFPREGS == mach+2.  */
17225
17226     case EM_OLD_ALPHA:
17227     case EM_ALPHA:
17228     case EM_SPARC:
17229     case EM_SPARC32PLUS:
17230     case EM_SPARCV9:
17231       switch (e_type)
17232         {
17233         case NT_NETBSDCORE_FIRSTMACH + 0:
17234           return _("PT_GETREGS (reg structure)");
17235         case NT_NETBSDCORE_FIRSTMACH + 2:
17236           return _("PT_GETFPREGS (fpreg structure)");
17237         default:
17238           break;
17239         }
17240       break;
17241
17242     /* On all other arch's, PT_GETREGS == mach+1 and
17243        PT_GETFPREGS == mach+3.  */
17244     default:
17245       switch (e_type)
17246         {
17247         case NT_NETBSDCORE_FIRSTMACH + 1:
17248           return _("PT_GETREGS (reg structure)");
17249         case NT_NETBSDCORE_FIRSTMACH + 3:
17250           return _("PT_GETFPREGS (fpreg structure)");
17251         default:
17252           break;
17253         }
17254     }
17255
17256   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17257             e_type - NT_NETBSDCORE_FIRSTMACH);
17258   return buff;
17259 }
17260
17261 static const char *
17262 get_stapsdt_note_type (unsigned e_type)
17263 {
17264   static char buff[64];
17265
17266   switch (e_type)
17267     {
17268     case NT_STAPSDT:
17269       return _("NT_STAPSDT (SystemTap probe descriptors)");
17270
17271     default:
17272       break;
17273     }
17274
17275   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17276   return buff;
17277 }
17278
17279 static bfd_boolean
17280 print_stapsdt_note (Elf_Internal_Note *pnote)
17281 {
17282   int addr_size = is_32bit_elf ? 4 : 8;
17283   char *data = pnote->descdata;
17284   char *data_end = pnote->descdata + pnote->descsz;
17285   bfd_vma pc, base_addr, semaphore;
17286   char *provider, *probe, *arg_fmt;
17287
17288   pc = byte_get ((unsigned char *) data, addr_size);
17289   data += addr_size;
17290   base_addr = byte_get ((unsigned char *) data, addr_size);
17291   data += addr_size;
17292   semaphore = byte_get ((unsigned char *) data, addr_size);
17293   data += addr_size;
17294
17295   provider = data;
17296   data += strlen (data) + 1;
17297   probe = data;
17298   data += strlen (data) + 1;
17299   arg_fmt = data;
17300   data += strlen (data) + 1;
17301
17302   printf (_("    Provider: %s\n"), provider);
17303   printf (_("    Name: %s\n"), probe);
17304   printf (_("    Location: "));
17305   print_vma (pc, FULL_HEX);
17306   printf (_(", Base: "));
17307   print_vma (base_addr, FULL_HEX);
17308   printf (_(", Semaphore: "));
17309   print_vma (semaphore, FULL_HEX);
17310   printf ("\n");
17311   printf (_("    Arguments: %s\n"), arg_fmt);
17312
17313   return data == data_end;
17314 }
17315
17316 static const char *
17317 get_ia64_vms_note_type (unsigned e_type)
17318 {
17319   static char buff[64];
17320
17321   switch (e_type)
17322     {
17323     case NT_VMS_MHD:
17324       return _("NT_VMS_MHD (module header)");
17325     case NT_VMS_LNM:
17326       return _("NT_VMS_LNM (language name)");
17327     case NT_VMS_SRC:
17328       return _("NT_VMS_SRC (source files)");
17329     case NT_VMS_TITLE:
17330       return "NT_VMS_TITLE";
17331     case NT_VMS_EIDC:
17332       return _("NT_VMS_EIDC (consistency check)");
17333     case NT_VMS_FPMODE:
17334       return _("NT_VMS_FPMODE (FP mode)");
17335     case NT_VMS_LINKTIME:
17336       return "NT_VMS_LINKTIME";
17337     case NT_VMS_IMGNAM:
17338       return _("NT_VMS_IMGNAM (image name)");
17339     case NT_VMS_IMGID:
17340       return _("NT_VMS_IMGID (image id)");
17341     case NT_VMS_LINKID:
17342       return _("NT_VMS_LINKID (link id)");
17343     case NT_VMS_IMGBID:
17344       return _("NT_VMS_IMGBID (build id)");
17345     case NT_VMS_GSTNAM:
17346       return _("NT_VMS_GSTNAM (sym table name)");
17347     case NT_VMS_ORIG_DYN:
17348       return "NT_VMS_ORIG_DYN";
17349     case NT_VMS_PATCHTIME:
17350       return "NT_VMS_PATCHTIME";
17351     default:
17352       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17353       return buff;
17354     }
17355 }
17356
17357 static bfd_boolean
17358 print_ia64_vms_note (Elf_Internal_Note * pnote)
17359 {
17360   switch (pnote->type)
17361     {
17362     case NT_VMS_MHD:
17363       if (pnote->descsz > 36)
17364         {
17365           size_t l = strlen (pnote->descdata + 34);
17366           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17367           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17368           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17369           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17370         }
17371       else
17372         printf (_("    Invalid size\n"));
17373       break;
17374     case NT_VMS_LNM:
17375       printf (_("   Language: %s\n"), pnote->descdata);
17376       break;
17377 #ifdef BFD64
17378     case NT_VMS_FPMODE:
17379       printf (_("   Floating Point mode: "));
17380       printf ("0x%016" BFD_VMA_FMT "x\n",
17381               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17382       break;
17383     case NT_VMS_LINKTIME:
17384       printf (_("   Link time: "));
17385       print_vms_time
17386         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17387       printf ("\n");
17388       break;
17389     case NT_VMS_PATCHTIME:
17390       printf (_("   Patch time: "));
17391       print_vms_time
17392         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17393       printf ("\n");
17394       break;
17395     case NT_VMS_ORIG_DYN:
17396       printf (_("   Major id: %u,  minor id: %u\n"),
17397               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17398               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17399       printf (_("   Last modified  : "));
17400       print_vms_time
17401         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17402       printf (_("\n   Link flags  : "));
17403       printf ("0x%016" BFD_VMA_FMT "x\n",
17404               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17405       printf (_("   Header flags: 0x%08x\n"),
17406               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17407       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17408       break;
17409 #endif
17410     case NT_VMS_IMGNAM:
17411       printf (_("    Image name: %s\n"), pnote->descdata);
17412       break;
17413     case NT_VMS_GSTNAM:
17414       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17415       break;
17416     case NT_VMS_IMGID:
17417       printf (_("    Image id: %s\n"), pnote->descdata);
17418       break;
17419     case NT_VMS_LINKID:
17420       printf (_("    Linker id: %s\n"), pnote->descdata);
17421       break;
17422     default:
17423       return FALSE;
17424     }
17425   return TRUE;
17426 }
17427
17428 /* Find the symbol associated with a build attribute that is attached
17429    to address OFFSET.  If PNAME is non-NULL then store the name of
17430    the symbol (if found) in the provided pointer,  Returns NULL if a
17431    symbol could not be found.  */
17432
17433 static Elf_Internal_Sym *
17434 get_symbol_for_build_attribute (Filedata *       filedata,
17435                                 unsigned long    offset,
17436                                 bfd_boolean      is_open_attr,
17437                                 const char **    pname)
17438 {
17439   static Filedata *         saved_filedata = NULL;
17440   static char *             strtab;
17441   static unsigned long      strtablen;
17442   static Elf_Internal_Sym * symtab;
17443   static unsigned long      nsyms;
17444   Elf_Internal_Sym *        saved_sym = NULL;
17445   Elf_Internal_Sym *        sym;
17446
17447   if (filedata->section_headers != NULL
17448       && (saved_filedata == NULL || filedata != saved_filedata))
17449     {
17450       Elf_Internal_Shdr * symsec;
17451
17452       /* Load the symbol and string sections.  */
17453       for (symsec = filedata->section_headers;
17454            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17455            symsec ++)
17456         {
17457           if (symsec->sh_type == SHT_SYMTAB)
17458             {
17459               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17460
17461               if (symsec->sh_link < filedata->file_header.e_shnum)
17462                 {
17463                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17464
17465                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17466                                               1, strtab_sec->sh_size,
17467                                               _("string table"));
17468                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17469                 }
17470             }
17471         }
17472       saved_filedata = filedata;
17473     }
17474
17475   if (symtab == NULL || strtab == NULL)
17476     return NULL;
17477
17478   /* Find a symbol whose value matches offset.  */
17479   for (sym = symtab; sym < symtab + nsyms; sym ++)
17480     if (sym->st_value == offset)
17481       {
17482         if (sym->st_name >= strtablen)
17483           /* Huh ?  This should not happen.  */
17484           continue;
17485
17486         if (strtab[sym->st_name] == 0)
17487           continue;
17488
17489         /* The AArch64 and ARM architectures define mapping symbols
17490            (eg $d, $x, $t) which we want to ignore.  */
17491         if (strtab[sym->st_name] == '$'
17492             && strtab[sym->st_name + 1] != 0
17493             && strtab[sym->st_name + 2] == 0)
17494           continue;
17495
17496         if (is_open_attr)
17497           {
17498             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17499                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17500                FUNC symbols entirely.  */
17501             switch (ELF_ST_TYPE (sym->st_info))
17502               {
17503               case STT_OBJECT:
17504               case STT_FILE:
17505                 saved_sym = sym;
17506                 if (sym->st_size)
17507                   {
17508                     /* If the symbol has a size associated
17509                        with it then we can stop searching.  */
17510                     sym = symtab + nsyms;
17511                   }
17512                 continue;
17513
17514               case STT_FUNC:
17515                 /* Ignore function symbols.  */
17516                 continue;
17517
17518               default:
17519                 break;
17520               }
17521
17522             switch (ELF_ST_BIND (sym->st_info))
17523               {
17524               case STB_GLOBAL:
17525                 if (saved_sym == NULL
17526                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17527                   saved_sym = sym;
17528                 break;
17529
17530               case STB_LOCAL:
17531                 if (saved_sym == NULL)
17532                   saved_sym = sym;
17533                 break;
17534
17535               default:
17536                 break;
17537               }
17538           }
17539         else
17540           {
17541             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17542               continue;
17543
17544             saved_sym = sym;
17545             break;
17546           }
17547       }
17548
17549   if (saved_sym && pname)
17550     * pname = strtab + saved_sym->st_name;
17551
17552   return saved_sym;
17553 }
17554
17555 static bfd_boolean
17556 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17557                                        Filedata *           filedata)
17558 {
17559   static unsigned long  global_offset = 0;
17560   static unsigned long  global_end = 0;
17561   static unsigned long  func_offset = 0;
17562   static unsigned long  func_end = 0;
17563
17564   Elf_Internal_Sym *    sym;
17565   const char *          name;
17566   unsigned long         start;
17567   unsigned long         end;
17568   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17569
17570   switch (pnote->descsz)
17571     {
17572     case 0:
17573       /* A zero-length description means that the range of
17574          the previous note of the same type should be used.  */
17575       if (is_open_attr)
17576         {
17577           if (global_end > global_offset)
17578             printf (_("    Applies to region from %#lx to %#lx\n"),
17579                     global_offset, global_end);
17580           else
17581             printf (_("    Applies to region from %#lx\n"), global_offset);
17582         }
17583       else
17584         {
17585           if (func_end > func_offset)
17586             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17587           else
17588             printf (_("    Applies to region from %#lx\n"), func_offset);
17589         }
17590       return TRUE;
17591
17592     case 4:
17593       start = byte_get ((unsigned char *) pnote->descdata, 4);
17594       end = 0;
17595       break;
17596
17597     case 8:
17598       if (is_32bit_elf)
17599         {
17600           /* FIXME: We should check that version 3+ notes are being used here...  */
17601           start = byte_get ((unsigned char *) pnote->descdata, 4);
17602           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17603         }
17604       else
17605         {
17606           start = byte_get ((unsigned char *) pnote->descdata, 8);
17607           end = 0;
17608         }
17609       break;
17610
17611     case 16:
17612       start = byte_get ((unsigned char *) pnote->descdata, 8);
17613       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17614       break;
17615
17616     default:
17617       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17618       printf (_("    <invalid descsz>"));
17619       return FALSE;
17620     }
17621
17622   name = NULL;
17623   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17624   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17625      in order to avoid them being confused with the start address of the
17626      first function in the file...  */
17627   if (sym == NULL && is_open_attr)
17628     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
17629                                           & name);
17630
17631   if (end == 0 && sym != NULL && sym->st_size > 0)
17632     end = start + sym->st_size;
17633
17634   if (is_open_attr)
17635     {
17636       /* FIXME: Need to properly allow for section alignment.  16 is just the alignment used on x86_64.  */
17637       if (global_end > 0 && start > BFD_ALIGN (global_end, 16))
17638         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17639               global_end + 1, start - 1);
17640
17641       printf (_("    Applies to region from %#lx"), start);
17642       global_offset = start;
17643
17644       if (end)
17645         {
17646           printf (_(" to %#lx"), end);
17647           global_end = end;
17648         }
17649     }
17650   else
17651     {
17652       printf (_("    Applies to region from %#lx"), start);
17653       func_offset = start;
17654
17655       if (end)
17656         {
17657           printf (_(" to %#lx"), end);
17658           func_end = end;
17659         }
17660     }
17661
17662   if (sym && name)
17663     printf (_(" (%s)"), name);
17664
17665   printf ("\n");
17666   return TRUE;
17667 }
17668
17669 static bfd_boolean
17670 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17671 {
17672   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17673   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17674   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17675   char         name_type;
17676   char         name_attribute;
17677   const char * expected_types;
17678   const char * name = pnote->namedata;
17679   const char * text;
17680   signed int   left;
17681
17682   if (name == NULL || pnote->namesz < 2)
17683     {
17684       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17685       print_symbol (-20, _("  <corrupt name>"));
17686       return FALSE;
17687     }
17688
17689   if (do_wide)
17690     left = 28;
17691   else
17692     left = 20;
17693
17694   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17695   if (name[0] == 'G' && name[1] == 'A')
17696     {
17697       if (pnote->namesz < 4)
17698         {
17699           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17700           print_symbol (-20, _("  <corrupt name>"));
17701           return FALSE;
17702         }
17703
17704       printf ("GA");
17705       name += 2;
17706       left -= 2;
17707     }
17708
17709   switch ((name_type = * name))
17710     {
17711     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17712     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17713     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17714     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17715       printf ("%c", * name);
17716       left --;
17717       break;
17718     default:
17719       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17720       print_symbol (-20, _("<unknown name type>"));
17721       return FALSE;
17722     }
17723
17724   ++ name;
17725   text = NULL;
17726
17727   switch ((name_attribute = * name))
17728     {
17729     case GNU_BUILD_ATTRIBUTE_VERSION:
17730       text = _("<version>");
17731       expected_types = string_expected;
17732       ++ name;
17733       break;
17734     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17735       text = _("<stack prot>");
17736       expected_types = "!+*";
17737       ++ name;
17738       break;
17739     case GNU_BUILD_ATTRIBUTE_RELRO:
17740       text = _("<relro>");
17741       expected_types = bool_expected;
17742       ++ name;
17743       break;
17744     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17745       text = _("<stack size>");
17746       expected_types = number_expected;
17747       ++ name;
17748       break;
17749     case GNU_BUILD_ATTRIBUTE_TOOL:
17750       text = _("<tool>");
17751       expected_types = string_expected;
17752       ++ name;
17753       break;
17754     case GNU_BUILD_ATTRIBUTE_ABI:
17755       text = _("<ABI>");
17756       expected_types = "$*";
17757       ++ name;
17758       break;
17759     case GNU_BUILD_ATTRIBUTE_PIC:
17760       text = _("<PIC>");
17761       expected_types = number_expected;
17762       ++ name;
17763       break;
17764     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17765       text = _("<short enum>");
17766       expected_types = bool_expected;
17767       ++ name;
17768       break;
17769     default:
17770       if (ISPRINT (* name))
17771         {
17772           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17773
17774           if (len > left && ! do_wide)
17775             len = left;
17776           printf ("%.*s:", len, name);
17777           left -= len;
17778           name += len;
17779         }
17780       else
17781         {
17782           static char tmpbuf [128];
17783
17784           error (_("unrecognised byte in name field: %d\n"), * name);
17785           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17786           text = tmpbuf;
17787           name ++;
17788         }
17789       expected_types = "*$!+";
17790       break;
17791     }
17792
17793   if (text)
17794     left -= printf ("%s", text);
17795
17796   if (strchr (expected_types, name_type) == NULL)
17797     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17798
17799   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17800     {
17801       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17802              (unsigned long) pnote->namesz,
17803              (long) (name - pnote->namedata));
17804       return FALSE;
17805     }
17806
17807   if (left < 1 && ! do_wide)
17808     return TRUE;
17809
17810   switch (name_type)
17811     {
17812     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17813       {
17814         unsigned int        bytes;
17815         unsigned long long  val = 0;
17816         unsigned int        shift = 0;
17817         char *              decoded = NULL;
17818
17819         bytes = pnote->namesz - (name - pnote->namedata);
17820         if (bytes > 0)
17821           /* The -1 is because the name field is always 0 terminated, and we
17822              want to be able to ensure that the shift in the while loop below
17823              will not overflow.  */
17824           -- bytes;
17825
17826         if (bytes > sizeof (val))
17827           {
17828             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17829                    bytes);
17830             bytes = sizeof (val);
17831           }
17832         /* We do not bother to warn if bytes == 0 as this can
17833            happen with some early versions of the gcc plugin.  */
17834
17835         while (bytes --)
17836           {
17837             unsigned long byte = (* name ++) & 0xff;
17838
17839             val |= byte << shift;
17840             shift += 8;
17841           }
17842
17843         switch (name_attribute)
17844           {
17845           case GNU_BUILD_ATTRIBUTE_PIC:
17846             switch (val)
17847               {
17848               case 0: decoded = "static"; break;
17849               case 1: decoded = "pic"; break;
17850               case 2: decoded = "PIC"; break;
17851               case 3: decoded = "pie"; break;
17852               case 4: decoded = "PIE"; break;
17853               default: break;
17854               }
17855             break;
17856           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17857             switch (val)
17858               {
17859                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17860               case 0: decoded = "off"; break;
17861               case 1: decoded = "on"; break;
17862               case 2: decoded = "all"; break;
17863               case 3: decoded = "strong"; break;
17864               case 4: decoded = "explicit"; break;
17865               default: break;
17866               }
17867             break;
17868           default:
17869             break;
17870           }
17871
17872         if (decoded != NULL)
17873           {
17874             print_symbol (-left, decoded);
17875             left = 0;
17876           }
17877         else if (val == 0)
17878           {
17879             printf ("0x0");
17880             left -= 3;
17881           }
17882         else
17883           {
17884             if (do_wide)
17885               left -= printf ("0x%llx", val);
17886             else
17887               left -= printf ("0x%-.*llx", left, val);
17888           }
17889       }
17890       break;
17891     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17892       left -= print_symbol (- left, name);
17893       break;
17894     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17895       left -= print_symbol (- left, "true");
17896       break;
17897     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17898       left -= print_symbol (- left, "false");
17899       break;
17900     }
17901
17902   if (do_wide && left > 0)
17903     printf ("%-*s", left, " ");
17904
17905   return TRUE;
17906 }
17907
17908 /* Note that by the ELF standard, the name field is already null byte
17909    terminated, and namesz includes the terminating null byte.
17910    I.E. the value of namesz for the name "FSF" is 4.
17911
17912    If the value of namesz is zero, there is no name present.  */
17913
17914 static bfd_boolean
17915 process_note (Elf_Internal_Note *  pnote,
17916               Filedata *           filedata)
17917 {
17918   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17919   const char * nt;
17920
17921   if (pnote->namesz == 0)
17922     /* If there is no note name, then use the default set of
17923        note type strings.  */
17924     nt = get_note_type (filedata, pnote->type);
17925
17926   else if (const_strneq (pnote->namedata, "GNU"))
17927     /* GNU-specific object file notes.  */
17928     nt = get_gnu_elf_note_type (pnote->type);
17929
17930   else if (const_strneq (pnote->namedata, "FreeBSD"))
17931     /* FreeBSD-specific core file notes.  */
17932     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17933
17934   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17935     /* NetBSD-specific core file notes.  */
17936     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17937
17938   else if (const_strneq (pnote->namedata, "NetBSD"))
17939     /* NetBSD-specific core file notes.  */
17940     return process_netbsd_elf_note (pnote);
17941
17942   else if (strneq (pnote->namedata, "SPU/", 4))
17943     {
17944       /* SPU-specific core file notes.  */
17945       nt = pnote->namedata + 4;
17946       name = "SPU";
17947     }
17948
17949   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17950     /* VMS/ia64-specific file notes.  */
17951     nt = get_ia64_vms_note_type (pnote->type);
17952
17953   else if (const_strneq (pnote->namedata, "stapsdt"))
17954     nt = get_stapsdt_note_type (pnote->type);
17955
17956   else
17957     /* Don't recognize this note name; just use the default set of
17958        note type strings.  */
17959     nt = get_note_type (filedata, pnote->type);
17960
17961   printf ("  ");
17962
17963   if (((const_strneq (pnote->namedata, "GA")
17964         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17965        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17966       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17967           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17968     print_gnu_build_attribute_name (pnote);
17969   else
17970     print_symbol (-20, name);
17971
17972   if (do_wide)
17973     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17974   else
17975     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17976
17977   if (const_strneq (pnote->namedata, "IPF/VMS"))
17978     return print_ia64_vms_note (pnote);
17979   else if (const_strneq (pnote->namedata, "GNU"))
17980     return print_gnu_note (filedata, pnote);
17981   else if (const_strneq (pnote->namedata, "stapsdt"))
17982     return print_stapsdt_note (pnote);
17983   else if (const_strneq (pnote->namedata, "CORE"))
17984     return print_core_note (pnote);
17985   else if (((const_strneq (pnote->namedata, "GA")
17986              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17987             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17988            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17989                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17990     return print_gnu_build_attribute_description (pnote, filedata);
17991
17992   if (pnote->descsz)
17993     {
17994       unsigned long i;
17995
17996       printf (_("   description data: "));
17997       for (i = 0; i < pnote->descsz; i++)
17998         printf ("%02x ", pnote->descdata[i]);
17999       if (!do_wide)
18000         printf ("\n");
18001     }
18002
18003   if (do_wide)
18004     printf ("\n");
18005
18006   return TRUE;
18007 }
18008
18009 static bfd_boolean
18010 process_notes_at (Filedata *           filedata,
18011                   Elf_Internal_Shdr *  section,
18012                   bfd_vma              offset,
18013                   bfd_vma              length,
18014                   bfd_vma              align)
18015 {
18016   Elf_External_Note * pnotes;
18017   Elf_External_Note * external;
18018   char *              end;
18019   bfd_boolean         res = TRUE;
18020
18021   if (length <= 0)
18022     return FALSE;
18023
18024   if (section)
18025     {
18026       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18027       if (pnotes)
18028         {
18029           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18030             return FALSE;
18031         }
18032     }
18033   else
18034     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18035                                              _("notes"));
18036
18037   if (pnotes == NULL)
18038     return FALSE;
18039
18040   external = pnotes;
18041
18042   if (section)
18043     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18044   else
18045     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18046             (unsigned long) offset, (unsigned long) length);
18047
18048   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18049      specifies that notes should be aligned to 4 bytes in 32-bit
18050      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18051      we also support 4 byte alignment in 64-bit objects.  If section
18052      alignment is less than 4, we treate alignment as 4 bytes.   */
18053   if (align < 4)
18054     align = 4;
18055   else if (align != 4 && align != 8)
18056     {
18057       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18058             (long) align);
18059       return FALSE;
18060     }
18061
18062   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18063
18064   end = (char *) pnotes + length;
18065   while ((char *) external < end)
18066     {
18067       Elf_Internal_Note inote;
18068       size_t min_notesz;
18069       char * next;
18070       char * temp = NULL;
18071       size_t data_remaining = end - (char *) external;
18072
18073       if (!is_ia64_vms (filedata))
18074         {
18075           /* PR binutils/15191
18076              Make sure that there is enough data to read.  */
18077           min_notesz = offsetof (Elf_External_Note, name);
18078           if (data_remaining < min_notesz)
18079             {
18080               warn (ngettext ("Corrupt note: only %ld byte remains, "
18081                               "not enough for a full note\n",
18082                               "Corrupt note: only %ld bytes remain, "
18083                               "not enough for a full note\n",
18084                               data_remaining),
18085                     (long) data_remaining);
18086               break;
18087             }
18088           data_remaining -= min_notesz;
18089
18090           inote.type     = BYTE_GET (external->type);
18091           inote.namesz   = BYTE_GET (external->namesz);
18092           inote.namedata = external->name;
18093           inote.descsz   = BYTE_GET (external->descsz);
18094           inote.descdata = ((char *) external
18095                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18096           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18097           next = ((char *) external
18098                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18099         }
18100       else
18101         {
18102           Elf64_External_VMS_Note *vms_external;
18103
18104           /* PR binutils/15191
18105              Make sure that there is enough data to read.  */
18106           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18107           if (data_remaining < min_notesz)
18108             {
18109               warn (ngettext ("Corrupt note: only %ld byte remains, "
18110                               "not enough for a full note\n",
18111                               "Corrupt note: only %ld bytes remain, "
18112                               "not enough for a full note\n",
18113                               data_remaining),
18114                     (long) data_remaining);
18115               break;
18116             }
18117           data_remaining -= min_notesz;
18118
18119           vms_external = (Elf64_External_VMS_Note *) external;
18120           inote.type     = BYTE_GET (vms_external->type);
18121           inote.namesz   = BYTE_GET (vms_external->namesz);
18122           inote.namedata = vms_external->name;
18123           inote.descsz   = BYTE_GET (vms_external->descsz);
18124           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18125           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18126           next = inote.descdata + align_power (inote.descsz, 3);
18127         }
18128
18129       /* PR 17531: file: 3443835e.  */
18130       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18131       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18132           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18133           || (size_t) (next - inote.descdata) < inote.descsz
18134           || ((size_t) (next - inote.descdata)
18135               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18136         {
18137           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18138                 (unsigned long) ((char *) external - (char *) pnotes));
18139           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18140                 inote.type, inote.namesz, inote.descsz, (int) align);
18141           break;
18142         }
18143
18144       external = (Elf_External_Note *) next;
18145
18146       /* Verify that name is null terminated.  It appears that at least
18147          one version of Linux (RedHat 6.0) generates corefiles that don't
18148          comply with the ELF spec by failing to include the null byte in
18149          namesz.  */
18150       if (inote.namedata[inote.namesz - 1] != '\0')
18151         {
18152           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18153             {
18154               temp = (char *) malloc (inote.namesz + 1);
18155               if (temp == NULL)
18156                 {
18157                   error (_("Out of memory allocating space for inote name\n"));
18158                   res = FALSE;
18159                   break;
18160                 }
18161
18162               memcpy (temp, inote.namedata, inote.namesz);
18163               inote.namedata = temp;
18164             }
18165           inote.namedata[inote.namesz] = 0;
18166         }
18167
18168       if (! process_note (& inote, filedata))
18169         res = FALSE;
18170
18171       if (temp != NULL)
18172         {
18173           free (temp);
18174           temp = NULL;
18175         }
18176     }
18177
18178   free (pnotes);
18179
18180   return res;
18181 }
18182
18183 static bfd_boolean
18184 process_corefile_note_segments (Filedata * filedata)
18185 {
18186   Elf_Internal_Phdr * segment;
18187   unsigned int i;
18188   bfd_boolean res = TRUE;
18189
18190   if (! get_program_headers (filedata))
18191     return TRUE;
18192
18193   for (i = 0, segment = filedata->program_headers;
18194        i < filedata->file_header.e_phnum;
18195        i++, segment++)
18196     {
18197       if (segment->p_type == PT_NOTE)
18198         if (! process_notes_at (filedata, NULL,
18199                                 (bfd_vma) segment->p_offset,
18200                                 (bfd_vma) segment->p_filesz,
18201                                 (bfd_vma) segment->p_align))
18202           res = FALSE;
18203     }
18204
18205   return res;
18206 }
18207
18208 static bfd_boolean
18209 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18210 {
18211   Elf_External_Note * pnotes;
18212   Elf_External_Note * external;
18213   char * end;
18214   bfd_boolean res = TRUE;
18215
18216   if (length <= 0)
18217     return FALSE;
18218
18219   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18220                                            _("v850 notes"));
18221   if (pnotes == NULL)
18222     return FALSE;
18223
18224   external = pnotes;
18225   end = (char*) pnotes + length;
18226
18227   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18228           (unsigned long) offset, (unsigned long) length);
18229
18230   while ((char *) external + sizeof (Elf_External_Note) < end)
18231     {
18232       Elf_External_Note * next;
18233       Elf_Internal_Note inote;
18234
18235       inote.type     = BYTE_GET (external->type);
18236       inote.namesz   = BYTE_GET (external->namesz);
18237       inote.namedata = external->name;
18238       inote.descsz   = BYTE_GET (external->descsz);
18239       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18240       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18241
18242       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18243         {
18244           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18245           inote.descdata = inote.namedata;
18246           inote.namesz   = 0;
18247         }
18248
18249       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18250
18251       if (   ((char *) next > end)
18252           || ((char *) next <  (char *) pnotes))
18253         {
18254           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18255                 (unsigned long) ((char *) external - (char *) pnotes));
18256           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18257                 inote.type, inote.namesz, inote.descsz);
18258           break;
18259         }
18260
18261       external = next;
18262
18263       /* Prevent out-of-bounds indexing.  */
18264       if (   inote.namedata + inote.namesz > end
18265           || inote.namedata + inote.namesz < inote.namedata)
18266         {
18267           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18268                 (unsigned long) ((char *) external - (char *) pnotes));
18269           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18270                 inote.type, inote.namesz, inote.descsz);
18271           break;
18272         }
18273
18274       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18275
18276       if (! print_v850_note (& inote))
18277         {
18278           res = FALSE;
18279           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18280                   inote.namesz, inote.descsz);
18281         }
18282     }
18283
18284   free (pnotes);
18285
18286   return res;
18287 }
18288
18289 static bfd_boolean
18290 process_note_sections (Filedata * filedata)
18291 {
18292   Elf_Internal_Shdr * section;
18293   unsigned long i;
18294   unsigned int n = 0;
18295   bfd_boolean res = TRUE;
18296
18297   for (i = 0, section = filedata->section_headers;
18298        i < filedata->file_header.e_shnum && section != NULL;
18299        i++, section++)
18300     {
18301       if (section->sh_type == SHT_NOTE)
18302         {
18303           if (! process_notes_at (filedata, section,
18304                                   (bfd_vma) section->sh_offset,
18305                                   (bfd_vma) section->sh_size,
18306                                   (bfd_vma) section->sh_addralign))
18307             res = FALSE;
18308           n++;
18309         }
18310
18311       if ((   filedata->file_header.e_machine == EM_V800
18312            || filedata->file_header.e_machine == EM_V850
18313            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18314           && section->sh_type == SHT_RENESAS_INFO)
18315         {
18316           if (! process_v850_notes (filedata,
18317                                     (bfd_vma) section->sh_offset,
18318                                     (bfd_vma) section->sh_size))
18319             res = FALSE;
18320           n++;
18321         }
18322     }
18323
18324   if (n == 0)
18325     /* Try processing NOTE segments instead.  */
18326     return process_corefile_note_segments (filedata);
18327
18328   return res;
18329 }
18330
18331 static bfd_boolean
18332 process_notes (Filedata * filedata)
18333 {
18334   /* If we have not been asked to display the notes then do nothing.  */
18335   if (! do_notes)
18336     return TRUE;
18337
18338   if (filedata->file_header.e_type != ET_CORE)
18339     return process_note_sections (filedata);
18340
18341   /* No program headers means no NOTE segment.  */
18342   if (filedata->file_header.e_phnum > 0)
18343     return process_corefile_note_segments (filedata);
18344
18345   printf (_("No note segments present in the core file.\n"));
18346   return TRUE;
18347 }
18348
18349 static unsigned char *
18350 display_public_gnu_attributes (unsigned char * start,
18351                                const unsigned char * const end)
18352 {
18353   printf (_("  Unknown GNU attribute: %s\n"), start);
18354
18355   start += strnlen ((char *) start, end - start);
18356   display_raw_attribute (start, end);
18357
18358   return (unsigned char *) end;
18359 }
18360
18361 static unsigned char *
18362 display_generic_attribute (unsigned char * start,
18363                            unsigned int tag,
18364                            const unsigned char * const end)
18365 {
18366   if (tag == 0)
18367     return (unsigned char *) end;
18368
18369   return display_tag_value (tag, start, end);
18370 }
18371
18372 static bfd_boolean
18373 process_arch_specific (Filedata * filedata)
18374 {
18375   if (! do_arch)
18376     return TRUE;
18377
18378   switch (filedata->file_header.e_machine)
18379     {
18380     case EM_ARC:
18381     case EM_ARC_COMPACT:
18382     case EM_ARC_COMPACT2:
18383       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18384                                  display_arc_attribute,
18385                                  display_generic_attribute);
18386     case EM_ARM:
18387       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18388                                  display_arm_attribute,
18389                                  display_generic_attribute);
18390
18391     case EM_MIPS:
18392     case EM_MIPS_RS3_LE:
18393       return process_mips_specific (filedata);
18394
18395     case EM_MSP430:
18396      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18397                                 display_msp430x_attribute,
18398                                 display_generic_attribute);
18399
18400     case EM_NDS32:
18401       return process_nds32_specific (filedata);
18402
18403     case EM_PPC:
18404     case EM_PPC64:
18405       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18406                                  display_power_gnu_attribute);
18407
18408     case EM_S390:
18409     case EM_S390_OLD:
18410       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18411                                  display_s390_gnu_attribute);
18412
18413     case EM_SPARC:
18414     case EM_SPARC32PLUS:
18415     case EM_SPARCV9:
18416       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18417                                  display_sparc_gnu_attribute);
18418
18419     case EM_TI_C6000:
18420       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18421                                  display_tic6x_attribute,
18422                                  display_generic_attribute);
18423
18424     default:
18425       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18426                                  display_public_gnu_attributes,
18427                                  display_generic_attribute);
18428     }
18429 }
18430
18431 static bfd_boolean
18432 get_file_header (Filedata * filedata)
18433 {
18434   /* Read in the identity array.  */
18435   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18436     return FALSE;
18437
18438   /* Determine how to read the rest of the header.  */
18439   switch (filedata->file_header.e_ident[EI_DATA])
18440     {
18441     default:
18442     case ELFDATANONE:
18443     case ELFDATA2LSB:
18444       byte_get = byte_get_little_endian;
18445       byte_put = byte_put_little_endian;
18446       break;
18447     case ELFDATA2MSB:
18448       byte_get = byte_get_big_endian;
18449       byte_put = byte_put_big_endian;
18450       break;
18451     }
18452
18453   /* For now we only support 32 bit and 64 bit ELF files.  */
18454   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18455
18456   /* Read in the rest of the header.  */
18457   if (is_32bit_elf)
18458     {
18459       Elf32_External_Ehdr ehdr32;
18460
18461       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18462         return FALSE;
18463
18464       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18465       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18466       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18467       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18468       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18469       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18470       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18471       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18472       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18473       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18474       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18475       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18476       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18477     }
18478   else
18479     {
18480       Elf64_External_Ehdr ehdr64;
18481
18482       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18483          we will not be able to cope with the 64bit data found in
18484          64 ELF files.  Detect this now and abort before we start
18485          overwriting things.  */
18486       if (sizeof (bfd_vma) < 8)
18487         {
18488           error (_("This instance of readelf has been built without support for a\n\
18489 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18490           return FALSE;
18491         }
18492
18493       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18494         return FALSE;
18495
18496       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18497       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18498       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18499       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18500       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18501       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18502       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18503       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18504       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18505       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18506       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18507       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18508       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18509     }
18510
18511   if (filedata->file_header.e_shoff)
18512     {
18513       /* There may be some extensions in the first section header.  Don't
18514          bomb if we can't read it.  */
18515       if (is_32bit_elf)
18516         get_32bit_section_headers (filedata, TRUE);
18517       else
18518         get_64bit_section_headers (filedata, TRUE);
18519     }
18520
18521   return TRUE;
18522 }
18523
18524 static void
18525 close_file (Filedata * filedata)
18526 {
18527   if (filedata)
18528     {
18529       if (filedata->handle)
18530         fclose (filedata->handle);
18531       free (filedata);
18532     }
18533 }
18534
18535 void
18536 close_debug_file (void * data)
18537 {
18538   close_file ((Filedata *) data);
18539 }
18540
18541 static Filedata *
18542 open_file (const char * pathname)
18543 {
18544   struct stat  statbuf;
18545   Filedata *   filedata = NULL;
18546
18547   if (stat (pathname, & statbuf) < 0
18548       || ! S_ISREG (statbuf.st_mode))
18549     goto fail;
18550
18551   filedata = calloc (1, sizeof * filedata);
18552   if (filedata == NULL)
18553     goto fail;
18554
18555   filedata->handle = fopen (pathname, "rb");
18556   if (filedata->handle == NULL)
18557     goto fail;
18558
18559   filedata->file_size = (bfd_size_type) statbuf.st_size;
18560   filedata->file_name = pathname;
18561
18562   if (! get_file_header (filedata))
18563     goto fail;
18564
18565   if (filedata->file_header.e_shoff)
18566     {
18567       bfd_boolean res;
18568
18569       /* Read the section headers again, this time for real.  */
18570       if (is_32bit_elf)
18571         res = get_32bit_section_headers (filedata, FALSE);
18572       else
18573         res = get_64bit_section_headers (filedata, FALSE);
18574
18575       if (!res)
18576         goto fail;
18577     }
18578
18579   return filedata;
18580
18581  fail:
18582   if (filedata)
18583     {
18584       if (filedata->handle)
18585         fclose (filedata->handle);
18586       free (filedata);
18587     }
18588   return NULL;
18589 }
18590
18591 void *
18592 open_debug_file (const char * pathname)
18593 {
18594   return open_file (pathname);
18595 }
18596
18597 /* Process one ELF object file according to the command line options.
18598    This file may actually be stored in an archive.  The file is
18599    positioned at the start of the ELF object.  Returns TRUE if no
18600    problems were encountered, FALSE otherwise.  */
18601
18602 static bfd_boolean
18603 process_object (Filedata * filedata)
18604 {
18605   Filedata * separates;
18606   unsigned int i;
18607   bfd_boolean res = TRUE;
18608
18609   if (! get_file_header (filedata))
18610     {
18611       error (_("%s: Failed to read file header\n"), filedata->file_name);
18612       return FALSE;
18613     }
18614
18615   /* Initialise per file variables.  */
18616   for (i = ARRAY_SIZE (version_info); i--;)
18617     version_info[i] = 0;
18618
18619   for (i = ARRAY_SIZE (dynamic_info); i--;)
18620     dynamic_info[i] = 0;
18621   dynamic_info_DT_GNU_HASH = 0;
18622
18623   /* Process the file.  */
18624   if (show_name)
18625     printf (_("\nFile: %s\n"), filedata->file_name);
18626
18627   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18628      Note we do this even if cmdline_dump_sects is empty because we
18629      must make sure that the dump_sets array is zeroed out before each
18630      object file is processed.  */
18631   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18632     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18633
18634   if (cmdline.num_dump_sects > 0)
18635     {
18636       if (filedata->num_dump_sects == 0)
18637         /* A sneaky way of allocating the dump_sects array.  */
18638         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18639
18640       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18641       memcpy (filedata->dump_sects, cmdline.dump_sects,
18642               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18643     }
18644
18645   if (! process_file_header (filedata))
18646     return FALSE;
18647
18648   if (! process_section_headers (filedata))
18649     {
18650       /* Without loaded section headers we cannot process lots of things.  */
18651       do_unwind = do_version = do_dump = do_arch = FALSE;
18652
18653       if (! do_using_dynamic)
18654         do_syms = do_dyn_syms = do_reloc = FALSE;
18655     }
18656
18657   if (! process_section_groups (filedata))
18658     /* Without loaded section groups we cannot process unwind.  */
18659     do_unwind = FALSE;
18660
18661   if (process_program_headers (filedata))
18662     process_dynamic_section (filedata);
18663   else
18664     res = FALSE;
18665
18666   if (! process_relocs (filedata))
18667     res = FALSE;
18668
18669   if (! process_unwind (filedata))
18670     res = FALSE;
18671
18672   if (! process_symbol_table (filedata))
18673     res = FALSE;
18674
18675   if (! process_syminfo (filedata))
18676     res = FALSE;
18677
18678   if (! process_version_sections (filedata))
18679     res = FALSE;
18680
18681   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18682     separates = load_separate_debug_file (filedata, filedata->file_name);
18683   else
18684     separates = NULL;
18685
18686   if (! process_section_contents (filedata))
18687     res = FALSE;
18688
18689   if (separates)
18690     {
18691       if (! process_section_headers (separates))
18692         res = FALSE;
18693       else if (! process_section_contents (separates))
18694         res = FALSE;
18695     }
18696
18697   if (! process_notes (filedata))
18698     res = FALSE;
18699
18700   if (! process_gnu_liblist (filedata))
18701     res = FALSE;
18702
18703   if (! process_arch_specific (filedata))
18704     res = FALSE;
18705
18706   free (filedata->program_headers);
18707   filedata->program_headers = NULL;
18708
18709   free (filedata->section_headers);
18710   filedata->section_headers = NULL;
18711
18712   free (filedata->string_table);
18713   filedata->string_table = NULL;
18714   filedata->string_table_length = 0;
18715
18716   if (dynamic_strings)
18717     {
18718       free (dynamic_strings);
18719       dynamic_strings = NULL;
18720       dynamic_strings_length = 0;
18721     }
18722
18723   if (dynamic_symbols)
18724     {
18725       free (dynamic_symbols);
18726       dynamic_symbols = NULL;
18727       num_dynamic_syms = 0;
18728     }
18729
18730   if (dynamic_syminfo)
18731     {
18732       free (dynamic_syminfo);
18733       dynamic_syminfo = NULL;
18734     }
18735
18736   if (dynamic_section)
18737     {
18738       free (dynamic_section);
18739       dynamic_section = NULL;
18740     }
18741
18742   if (section_headers_groups)
18743     {
18744       free (section_headers_groups);
18745       section_headers_groups = NULL;
18746     }
18747
18748   if (section_groups)
18749     {
18750       struct group_list * g;
18751       struct group_list * next;
18752
18753       for (i = 0; i < group_count; i++)
18754         {
18755           for (g = section_groups [i].root; g != NULL; g = next)
18756             {
18757               next = g->next;
18758               free (g);
18759             }
18760         }
18761
18762       free (section_groups);
18763       section_groups = NULL;
18764     }
18765
18766   free_debug_memory ();
18767
18768   return res;
18769 }
18770
18771 /* Process an ELF archive.
18772    On entry the file is positioned just after the ARMAG string.
18773    Returns TRUE upon success, FALSE otherwise.  */
18774
18775 static bfd_boolean
18776 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18777 {
18778   struct archive_info arch;
18779   struct archive_info nested_arch;
18780   size_t got;
18781   bfd_boolean ret = TRUE;
18782
18783   show_name = TRUE;
18784
18785   /* The ARCH structure is used to hold information about this archive.  */
18786   arch.file_name = NULL;
18787   arch.file = NULL;
18788   arch.index_array = NULL;
18789   arch.sym_table = NULL;
18790   arch.longnames = NULL;
18791
18792   /* The NESTED_ARCH structure is used as a single-item cache of information
18793      about a nested archive (when members of a thin archive reside within
18794      another regular archive file).  */
18795   nested_arch.file_name = NULL;
18796   nested_arch.file = NULL;
18797   nested_arch.index_array = NULL;
18798   nested_arch.sym_table = NULL;
18799   nested_arch.longnames = NULL;
18800
18801   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18802                      is_thin_archive, do_archive_index) != 0)
18803     {
18804       ret = FALSE;
18805       goto out;
18806     }
18807
18808   if (do_archive_index)
18809     {
18810       if (arch.sym_table == NULL)
18811         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18812       else
18813         {
18814           unsigned long i, l;
18815           unsigned long current_pos;
18816
18817           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18818                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18819
18820           current_pos = ftell (filedata->handle);
18821
18822           for (i = l = 0; i < arch.index_num; i++)
18823             {
18824               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18825                 {
18826                   char * member_name;
18827
18828                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18829
18830                   if (member_name != NULL)
18831                     {
18832                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18833
18834                       if (qualified_name != NULL)
18835                         {
18836                           printf (_("Contents of binary %s at offset "), qualified_name);
18837                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18838                           putchar ('\n');
18839                           free (qualified_name);
18840                         }
18841                     }
18842                 }
18843
18844               if (l >= arch.sym_size)
18845                 {
18846                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18847                          filedata->file_name);
18848                   ret = FALSE;
18849                   break;
18850                 }
18851               /* PR 17531: file: 0b6630b2.  */
18852               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18853               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18854             }
18855
18856           if (arch.uses_64bit_indicies)
18857             l = (l + 7) & ~ 7;
18858           else
18859             l += l & 1;
18860
18861           if (l < arch.sym_size)
18862             {
18863               error (ngettext ("%s: %ld byte remains in the symbol table, "
18864                                "but without corresponding entries in "
18865                                "the index table\n",
18866                                "%s: %ld bytes remain in the symbol table, "
18867                                "but without corresponding entries in "
18868                                "the index table\n",
18869                                arch.sym_size - l),
18870                      filedata->file_name, arch.sym_size - l);
18871               ret = FALSE;
18872             }
18873
18874           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18875             {
18876               error (_("%s: failed to seek back to start of object files in the archive\n"),
18877                      filedata->file_name);
18878               ret = FALSE;
18879               goto out;
18880             }
18881         }
18882
18883       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18884           && !do_segments && !do_header && !do_dump && !do_version
18885           && !do_histogram && !do_debugging && !do_arch && !do_notes
18886           && !do_section_groups && !do_dyn_syms)
18887         {
18888           ret = TRUE; /* Archive index only.  */
18889           goto out;
18890         }
18891     }
18892
18893   while (1)
18894     {
18895       char * name;
18896       size_t namelen;
18897       char * qualified_name;
18898
18899       /* Read the next archive header.  */
18900       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18901         {
18902           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18903           return FALSE;
18904         }
18905       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18906       if (got != sizeof arch.arhdr)
18907         {
18908           if (got == 0)
18909             break;
18910           error (_("%s: failed to read archive header\n"), filedata->file_name);
18911           ret = FALSE;
18912           break;
18913         }
18914       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18915         {
18916           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18917           ret = FALSE;
18918           break;
18919         }
18920
18921       arch.next_arhdr_offset += sizeof arch.arhdr;
18922
18923       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18924       if (archive_file_size & 01)
18925         ++archive_file_size;
18926
18927       name = get_archive_member_name (&arch, &nested_arch);
18928       if (name == NULL)
18929         {
18930           error (_("%s: bad archive file name\n"), filedata->file_name);
18931           ret = FALSE;
18932           break;
18933         }
18934       namelen = strlen (name);
18935
18936       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18937       if (qualified_name == NULL)
18938         {
18939           error (_("%s: bad archive file name\n"), filedata->file_name);
18940           ret = FALSE;
18941           break;
18942         }
18943
18944       if (is_thin_archive && arch.nested_member_origin == 0)
18945         {
18946           /* This is a proxy for an external member of a thin archive.  */
18947           Filedata * member_filedata;
18948           char * member_file_name = adjust_relative_path
18949             (filedata->file_name, name, namelen);
18950
18951           if (member_file_name == NULL)
18952             {
18953               ret = FALSE;
18954               break;
18955             }
18956
18957           member_filedata = open_file (member_file_name);
18958           if (member_filedata == NULL)
18959             {
18960               error (_("Input file '%s' is not readable.\n"), member_file_name);
18961               free (member_file_name);
18962               ret = FALSE;
18963               break;
18964             }
18965
18966           archive_file_offset = arch.nested_member_origin;
18967           member_filedata->file_name = qualified_name;
18968
18969           if (! process_object (member_filedata))
18970             ret = FALSE;
18971
18972           close_file (member_filedata);
18973           free (member_file_name);
18974         }
18975       else if (is_thin_archive)
18976         {
18977           Filedata thin_filedata;
18978
18979           memset (&thin_filedata, 0, sizeof (thin_filedata));
18980
18981           /* PR 15140: Allow for corrupt thin archives.  */
18982           if (nested_arch.file == NULL)
18983             {
18984               error (_("%s: contains corrupt thin archive: %s\n"),
18985                      filedata->file_name, name);
18986               ret = FALSE;
18987               break;
18988             }
18989
18990           /* This is a proxy for a member of a nested archive.  */
18991           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18992
18993           /* The nested archive file will have been opened and setup by
18994              get_archive_member_name.  */
18995           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18996             {
18997               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18998               ret = FALSE;
18999               break;
19000             }
19001
19002           thin_filedata.handle = nested_arch.file;
19003           thin_filedata.file_name = qualified_name;
19004
19005           if (! process_object (& thin_filedata))
19006             ret = FALSE;
19007         }
19008       else
19009         {
19010           archive_file_offset = arch.next_arhdr_offset;
19011           arch.next_arhdr_offset += archive_file_size;
19012
19013           filedata->file_name = qualified_name;
19014           if (! process_object (filedata))
19015             ret = FALSE;
19016         }
19017
19018       if (filedata->dump_sects != NULL)
19019         {
19020           free (filedata->dump_sects);
19021           filedata->dump_sects = NULL;
19022           filedata->num_dump_sects = 0;
19023         }
19024
19025       free (qualified_name);
19026     }
19027
19028  out:
19029   if (nested_arch.file != NULL)
19030     fclose (nested_arch.file);
19031   release_archive (&nested_arch);
19032   release_archive (&arch);
19033
19034   return ret;
19035 }
19036
19037 static bfd_boolean
19038 process_file (char * file_name)
19039 {
19040   Filedata * filedata = NULL;
19041   struct stat statbuf;
19042   char armag[SARMAG];
19043   bfd_boolean ret = TRUE;
19044
19045   if (stat (file_name, &statbuf) < 0)
19046     {
19047       if (errno == ENOENT)
19048         error (_("'%s': No such file\n"), file_name);
19049       else
19050         error (_("Could not locate '%s'.  System error message: %s\n"),
19051                file_name, strerror (errno));
19052       return FALSE;
19053     }
19054
19055   if (! S_ISREG (statbuf.st_mode))
19056     {
19057       error (_("'%s' is not an ordinary file\n"), file_name);
19058       return FALSE;
19059     }
19060
19061   filedata = calloc (1, sizeof * filedata);
19062   if (filedata == NULL)
19063     {
19064       error (_("Out of memory allocating file data structure\n"));
19065       return FALSE;
19066     }
19067
19068   filedata->file_name = file_name;
19069   filedata->handle = fopen (file_name, "rb");
19070   if (filedata->handle == NULL)
19071     {
19072       error (_("Input file '%s' is not readable.\n"), file_name);
19073       free (filedata);
19074       return FALSE;
19075     }
19076
19077   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19078     {
19079       error (_("%s: Failed to read file's magic number\n"), file_name);
19080       fclose (filedata->handle);
19081       free (filedata);
19082       return FALSE;
19083     }
19084
19085   filedata->file_size = (bfd_size_type) statbuf.st_size;
19086
19087   if (memcmp (armag, ARMAG, SARMAG) == 0)
19088     {
19089       if (! process_archive (filedata, FALSE))
19090         ret = FALSE;
19091     }
19092   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19093     {
19094       if ( ! process_archive (filedata, TRUE))
19095         ret = FALSE;
19096     }
19097   else
19098     {
19099       if (do_archive_index)
19100         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19101                file_name);
19102
19103       rewind (filedata->handle);
19104       archive_file_size = archive_file_offset = 0;
19105
19106       if (! process_object (filedata))
19107         ret = FALSE;
19108     }
19109
19110   fclose (filedata->handle);
19111   free (filedata);
19112
19113   return ret;
19114 }
19115
19116 #ifdef SUPPORT_DISASSEMBLY
19117 /* Needed by the i386 disassembler.  For extra credit, someone could
19118    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19119    symbols.  */
19120
19121 void
19122 print_address (unsigned int addr, FILE * outfile)
19123 {
19124   fprintf (outfile,"0x%8.8x", addr);
19125 }
19126
19127 /* Needed by the i386 disassembler.  */
19128
19129 void
19130 db_task_printsym (unsigned int addr)
19131 {
19132   print_address (addr, stderr);
19133 }
19134 #endif
19135
19136 int
19137 main (int argc, char ** argv)
19138 {
19139   int err;
19140
19141 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19142   setlocale (LC_MESSAGES, "");
19143 #endif
19144 #if defined (HAVE_SETLOCALE)
19145   setlocale (LC_CTYPE, "");
19146 #endif
19147   bindtextdomain (PACKAGE, LOCALEDIR);
19148   textdomain (PACKAGE);
19149
19150   expandargv (&argc, &argv);
19151
19152   cmdline.file_name = "<cmdline>";
19153   parse_args (& cmdline, argc, argv);
19154
19155   if (optind < (argc - 1))
19156     show_name = TRUE;
19157   else if (optind >= argc)
19158     {
19159       warn (_("Nothing to do.\n"));
19160       usage (stderr);
19161     }
19162
19163   err = FALSE;
19164   while (optind < argc)
19165     if (! process_file (argv[optind++]))
19166       err = TRUE;
19167
19168   if (cmdline.dump_sects != NULL)
19169     free (cmdline.dump_sects);
19170
19171   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19172 }