binutils/dwarf.c

   1 /* dwarf.c -- display DWARF contents of a BFD binary file
   2    Copyright (C) 2005-2016 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "libiberty.h"
  23 #include "bfd.h"
  24 #include "bfd_stdint.h"
  25 #include "bucomm.h"
  26 #include "elfcomm.h"
  27 #include "elf/common.h"
  28 #include "dwarf2.h"
  29 #include "dwarf.h"
  30 #include "gdb/gdb-index.h"
  31
  32 static const char *regname (unsigned int regno, int row);
  33
  34 static int have_frame_base;
  35 static int need_base_address;
  36
  37 static unsigned int last_pointer_size = 0;
  38 static int warned_about_missing_comp_units = FALSE;
  39
  40 static unsigned int num_debug_info_entries = 0;
  41 static unsigned int alloc_num_debug_info_entries = 0;
  42 static debug_info *debug_information = NULL;
  43 /* Special value for num_debug_info_entries to indicate
  44    that the .debug_info section could not be loaded/parsed.  */
  45 #define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1
  46
  47 unsigned int eh_addr_size;
  48
  49 int do_debug_info;
  50 int do_debug_abbrevs;
  51 int do_debug_lines;
  52 int do_debug_pubnames;
  53 int do_debug_pubtypes;
  54 int do_debug_aranges;
  55 int do_debug_ranges;
  56 int do_debug_frames;
  57 int do_debug_frames_interp;
  58 int do_debug_macinfo;
  59 int do_debug_str;
  60 int do_debug_loc;
  61 int do_gdb_index;
  62 int do_trace_info;
  63 int do_trace_abbrevs;
  64 int do_trace_aranges;
  65 int do_debug_addr;
  66 int do_debug_cu_index;
  67 int do_wide;
  68
  69 int dwarf_cutoff_level = -1;
  70 unsigned long dwarf_start_die;
  71
  72 int dwarf_check = 0;
  73
  74 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
  75    sections.  For version 1 package files, each set is stored in SHNDX_POOL
  76    as a zero-terminated list of section indexes comprising one set of debug
  77    sections from a .dwo file.  */
  78
  79 static int cu_tu_indexes_read = 0;
  80 static unsigned int *shndx_pool = NULL;
  81 static unsigned int shndx_pool_size = 0;
  82 static unsigned int shndx_pool_used = 0;
  83
  84 /* For version 2 package files, each set contains an array of section offsets
  85    and an array of section sizes, giving the offset and size of the
  86    contribution from a CU or TU within one of the debug sections.
  87    When displaying debug info from a package file, we need to use these
  88    tables to locate the corresponding contributions to each section.  */
  89
  90 struct cu_tu_set
  91 {
  92   uint64_t signature;
  93   dwarf_vma section_offsets[DW_SECT_MAX];
  94   size_t section_sizes[DW_SECT_MAX];
  95 };
  96
  97 static int cu_count = 0;
  98 static int tu_count = 0;
  99 static struct cu_tu_set *cu_sets = NULL;
 100 static struct cu_tu_set *tu_sets = NULL;
 101
 102 static void load_cu_tu_indexes (void *file);
 103
 104 /* Values for do_debug_lines.  */
 105 #define FLAG_DEBUG_LINES_RAW     1
 106 #define FLAG_DEBUG_LINES_DECODED 2
 107
 108 static unsigned int
 109 size_of_encoded_value (int encoding)
 110 {
 111   switch (encoding & 0x7)
 112     {
 113     default:    /* ??? */
 114     case 0:     return eh_addr_size;
 115     case 2:     return 2;
 116     case 3:     return 4;
 117     case 4:     return 8;
 118     }
 119 }
 120
 121 static dwarf_vma
 122 get_encoded_value (unsigned char **pdata,
 123                    int encoding,
 124                    struct dwarf_section *section,
 125                    unsigned char * end)
 126 {
 127   unsigned char * data = * pdata;
 128   unsigned int size = size_of_encoded_value (encoding);
 129   dwarf_vma val;
 130
 131   if (data + size >= end)
 132     {
 133       warn (_("Encoded value extends past end of section\n"));
 134       * pdata = end;
 135       return 0;
 136     }
 137
 138   /* PR 17512: file: 002-829853-0.004.  */
 139   if (size > 8)
 140     {
 141       warn (_("Encoded size of %d is too large to read\n"), size);
 142       * pdata = end;
 143       return 0;
 144     }
 145
 146   /* PR 17512: file: 1085-5603-0.004.  */
 147   if (size == 0)
 148     {
 149       warn (_("Encoded size of 0 is too small to read\n"));
 150       * pdata = end;
 151       return 0;
 152     }
 153
 154   if (encoding & DW_EH_PE_signed)
 155     val = byte_get_signed (data, size);
 156   else
 157     val = byte_get (data, size);
 158
 159   if ((encoding & 0x70) == DW_EH_PE_pcrel)
 160     val += section->address + (data - section->start);
 161
 162   * pdata = data + size;
 163   return val;
 164 }
 165
 166 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
 167 # ifndef __MINGW32__
 168 #  define DWARF_VMA_FMT         "ll"
 169 #  define DWARF_VMA_FMT_LONG    "%16.16llx"
 170 # else
 171 #  define DWARF_VMA_FMT         "I64"
 172 #  define DWARF_VMA_FMT_LONG    "%016I64x"
 173 # endif
 174 #else
 175 # define DWARF_VMA_FMT          "l"
 176 # define DWARF_VMA_FMT_LONG     "%16.16lx"
 177 #endif
 178
 179 /* Convert a dwarf vma value into a string.  Returns a pointer to a static
 180    buffer containing the converted VALUE.  The value is converted according
 181    to the printf formating character FMTCH.  If NUM_BYTES is non-zero then
 182    it specifies the maximum number of bytes to be displayed in the converted
 183    value and FMTCH is ignored - hex is always used.  */
 184
 185 static const char *
 186 dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes)
 187 {
 188   /* As dwarf_vmatoa is used more then once in a printf call
 189      for output, we are cycling through an fixed array of pointers
 190      for return address.  */
 191   static int buf_pos = 0;
 192   static struct dwarf_vmatoa_buf
 193   {
 194     char place[64];
 195   } buf[16];
 196   char *ret;
 197
 198   ret = buf[buf_pos++].place;
 199   buf_pos %= ARRAY_SIZE (buf);
 200
 201   if (num_bytes)
 202     {
 203       /* Printf does not have a way of specifying a maximum field width for an
 204          integer value, so we print the full value into a buffer and then select
 205          the precision we need.  */
 206       snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value);
 207       if (num_bytes > 8)
 208         num_bytes = 8;
 209       return ret + (16 - 2 * num_bytes);
 210     }
 211   else
 212     {
 213       char fmt[32];
 214
 215       sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
 216       snprintf (ret, sizeof (buf[0].place), fmt, value);
 217       return ret;
 218     }
 219 }
 220
 221 static inline const char *
 222 dwarf_vmatoa (const char * fmtch, dwarf_vma value)
 223 {
 224   return dwarf_vmatoa_1 (fmtch, value, 0);
 225 }
 226
 227 /* Print a dwarf_vma value (typically an address, offset or length) in
 228    hexadecimal format, followed by a space.  The length of the VALUE (and
 229    hence the precision displayed) is determined by the NUM_BYTES parameter.  */
 230
 231 static void
 232 print_dwarf_vma (dwarf_vma value, unsigned num_bytes)
 233 {
 234   printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes));
 235 }
 236
 237 /* Format a 64-bit value, given as two 32-bit values, in hex.
 238    For reentrancy, this uses a buffer provided by the caller.  */
 239
 240 static const char *
 241 dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,
 242                 unsigned int buf_len)
 243 {
 244   int len = 0;
 245
 246   if (hvalue == 0)
 247     snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue);
 248   else
 249     {
 250       len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue);
 251       snprintf (buf + len, buf_len - len,
 252                 "%08" DWARF_VMA_FMT "x", lvalue);
 253     }
 254
 255   return buf;
 256 }
 257
 258 /* Read in a LEB128 encoded value starting at address DATA.
 259    If SIGN is true, return a signed LEB128 value.
 260    If LENGTH_RETURN is not NULL, return in it the number of bytes read.
 261    No bytes will be read at address END or beyond.  */
 262
 263 dwarf_vma
 264 read_leb128 (unsigned char *data,
 265              unsigned int *length_return,
 266              bfd_boolean sign,
 267              const unsigned char * const end)
 268 {
 269   dwarf_vma result = 0;
 270   unsigned int num_read = 0;
 271   unsigned int shift = 0;
 272   unsigned char byte = 0;
 273
 274   while (data < end)
 275     {
 276       byte = *data++;
 277       num_read++;
 278
 279       result |= ((dwarf_vma) (byte & 0x7f)) << shift;
 280
 281       shift += 7;
 282       if ((byte & 0x80) == 0)
 283         break;
 284
 285       /* PR 17512: file: 0ca183b8.
 286          FIXME: Should we signal this error somehow ?  */
 287       if (shift >= sizeof (result) * 8)
 288         break;
 289     }
 290
 291   if (length_return != NULL)
 292     *length_return = num_read;
 293
 294   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
 295     result |= -((dwarf_vma) 1 << shift);
 296
 297   return result;
 298 }
 299
 300 /* Create a signed version to avoid painful typecasts.  */
 301 static inline dwarf_signed_vma
 302 read_sleb128 (unsigned char * data,
 303               unsigned int *  length_return,
 304               const unsigned char * const end)
 305 {
 306   return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);
 307 }
 308
 309 static inline dwarf_vma
 310 read_uleb128 (unsigned char * data,
 311               unsigned int *  length_return,
 312               const unsigned char * const end)
 313 {
 314   return read_leb128 (data, length_return, FALSE, end);
 315 }
 316
 317 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END)    \
 318   do                                            \
 319     {                                           \
 320       unsigned int amount = (AMOUNT);           \
 321       if (sizeof (VAL) < amount)                \
 322         {                                       \
 323           error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\
 324                  amount, (int) sizeof (VAL));   \
 325           amount = sizeof (VAL);                \
 326         }                                       \
 327       if (((PTR) + amount) >= (END))            \
 328         {                                       \
 329           if ((PTR) < (END))                    \
 330             amount = (END) - (PTR);             \
 331           else                                  \
 332             amount = 0;                         \
 333         }                                       \
 334       if (amount == 0 || amount > 8)            \
 335         VAL = 0;                                \
 336       else                                      \
 337         VAL = byte_get ((PTR), amount);         \
 338     }                                           \
 339   while (0)
 340
 341 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END)    \
 342   do                                                    \
 343     {                                                   \
 344       SAFE_BYTE_GET (VAL, PTR, AMOUNT, END);            \
 345       PTR += AMOUNT;                                    \
 346     }                                                   \
 347   while (0)
 348
 349 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END)     \
 350   do                                                    \
 351     {                                                   \
 352       unsigned int amount = (AMOUNT);                   \
 353       if (((PTR) + amount) >= (END))                    \
 354         {                                               \
 355           if ((PTR) < (END))                            \
 356             amount = (END) - (PTR);                     \
 357           else                                          \
 358             amount = 0;                                 \
 359         }                                               \
 360       if (amount)                                       \
 361         VAL = byte_get_signed ((PTR), amount);          \
 362       else                                              \
 363         VAL = 0;                                        \
 364     }                                                   \
 365   while (0)
 366
 367 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END)     \
 368   do                                                            \
 369     {                                                           \
 370       SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END);             \
 371       PTR += AMOUNT;                                            \
 372     }                                                           \
 373   while (0)
 374
 375 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END)            \
 376   do                                                    \
 377     {                                                   \
 378       if (((PTR) + 8) <= (END))                         \
 379         {                                               \
 380           byte_get_64 ((PTR), (HIGH), (LOW));           \
 381         }                                               \
 382       else                                              \
 383         {                                               \
 384           * (LOW) = * (HIGH) = 0;                       \
 385         }                                               \
 386     }                                                   \
 387   while (0)
 388
 389 typedef struct State_Machine_Registers
 390 {
 391   dwarf_vma address;
 392   unsigned int file;
 393   unsigned int line;
 394   unsigned int column;
 395   int is_stmt;
 396   int basic_block;
 397   unsigned char op_index;
 398   unsigned char end_sequence;
 399 /* This variable hold the number of the last entry seen
 400    in the File Table.  */
 401   unsigned int last_file_entry;
 402 } SMR;
 403
 404 static SMR state_machine_regs;
 405
 406 static void
 407 reset_state_machine (int is_stmt)
 408 {
 409   state_machine_regs.address = 0;
 410   state_machine_regs.op_index = 0;
 411   state_machine_regs.file = 1;
 412   state_machine_regs.line = 1;
 413   state_machine_regs.column = 0;
 414   state_machine_regs.is_stmt = is_stmt;
 415   state_machine_regs.basic_block = 0;
 416   state_machine_regs.end_sequence = 0;
 417   state_machine_regs.last_file_entry = 0;
 418 }
 419
 420 /* Handled an extend line op.
 421    Returns the number of bytes read.  */
 422
 423 static int
 424 process_extended_line_op (unsigned char * data,
 425                           int is_stmt,
 426                           unsigned char * end)
 427 {
 428   unsigned char op_code;
 429   unsigned int bytes_read;
 430   unsigned int len;
 431   unsigned char *name;
 432   unsigned char *orig_data = data;
 433   dwarf_vma adr;
 434
 435   len = read_uleb128 (data, & bytes_read, end);
 436   data += bytes_read;
 437
 438   if (len == 0 || data == end || len > (uintptr_t) (end - data))
 439     {
 440       warn (_("Badly formed extended line op encountered!\n"));
 441       return bytes_read;
 442     }
 443
 444   len += bytes_read;
 445   op_code = *data++;
 446
 447   printf (_("  Extended opcode %d: "), op_code);
 448
 449   switch (op_code)
 450     {
 451     case DW_LNE_end_sequence:
 452       printf (_("End of Sequence\n\n"));
 453       reset_state_machine (is_stmt);
 454       break;
 455
 456     case DW_LNE_set_address:
 457       /* PR 17512: file: 002-100480-0.004.  */
 458       if (len - bytes_read - 1 > 8)
 459         {
 460           warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
 461                 len - bytes_read - 1);
 462           adr = 0;
 463         }
 464       else
 465         SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
 466       printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
 467       state_machine_regs.address = adr;
 468       state_machine_regs.op_index = 0;
 469       break;
 470
 471     case DW_LNE_define_file:
 472       printf (_("define new File Table entry\n"));
 473       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
 474       printf ("   %d\t", ++state_machine_regs.last_file_entry);
 475
 476       name = data;
 477       data += strnlen ((char *) data, end - data) + 1;
 478       printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
 479       data += bytes_read;
 480       printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
 481       data += bytes_read;
 482       printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
 483       data += bytes_read;
 484       printf ("%s\n\n", name);
 485
 486       if (((unsigned int) (data - orig_data) != len) || data == end)
 487         warn (_("DW_LNE_define_file: Bad opcode length\n"));
 488       break;
 489
 490     case DW_LNE_set_discriminator:
 491       printf (_("set Discriminator to %s\n"),
 492               dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
 493       break;
 494
 495     /* HP extensions.  */
 496     case DW_LNE_HP_negate_is_UV_update:
 497       printf ("DW_LNE_HP_negate_is_UV_update\n");
 498       break;
 499     case DW_LNE_HP_push_context:
 500       printf ("DW_LNE_HP_push_context\n");
 501       break;
 502     case DW_LNE_HP_pop_context:
 503       printf ("DW_LNE_HP_pop_context\n");
 504       break;
 505     case DW_LNE_HP_set_file_line_column:
 506       printf ("DW_LNE_HP_set_file_line_column\n");
 507       break;
 508     case DW_LNE_HP_set_routine_name:
 509       printf ("DW_LNE_HP_set_routine_name\n");
 510       break;
 511     case DW_LNE_HP_set_sequence:
 512       printf ("DW_LNE_HP_set_sequence\n");
 513       break;
 514     case DW_LNE_HP_negate_post_semantics:
 515       printf ("DW_LNE_HP_negate_post_semantics\n");
 516       break;
 517     case DW_LNE_HP_negate_function_exit:
 518       printf ("DW_LNE_HP_negate_function_exit\n");
 519       break;
 520     case DW_LNE_HP_negate_front_end_logical:
 521       printf ("DW_LNE_HP_negate_front_end_logical\n");
 522       break;
 523     case DW_LNE_HP_define_proc:
 524       printf ("DW_LNE_HP_define_proc\n");
 525       break;
 526     case DW_LNE_HP_source_file_correlation:
 527       {
 528         unsigned char *edata = data + len - bytes_read - 1;
 529
 530         printf ("DW_LNE_HP_source_file_correlation\n");
 531
 532         while (data < edata)
 533           {
 534             unsigned int opc;
 535
 536             opc = read_uleb128 (data, & bytes_read, edata);
 537             data += bytes_read;
 538
 539             switch (opc)
 540               {
 541               case DW_LNE_HP_SFC_formfeed:
 542                 printf ("    DW_LNE_HP_SFC_formfeed\n");
 543                 break;
 544               case DW_LNE_HP_SFC_set_listing_line:
 545                 printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
 546                         dwarf_vmatoa ("u",
 547                                       read_uleb128 (data, & bytes_read, edata)));
 548                 data += bytes_read;
 549                 break;
 550               case DW_LNE_HP_SFC_associate:
 551                 printf ("    DW_LNE_HP_SFC_associate ");
 552                 printf ("(%s",
 553                         dwarf_vmatoa ("u",
 554                                       read_uleb128 (data, & bytes_read, edata)));
 555                 data += bytes_read;
 556                 printf (",%s",
 557                         dwarf_vmatoa ("u",
 558                                       read_uleb128 (data, & bytes_read, edata)));
 559                 data += bytes_read;
 560                 printf (",%s)\n",
 561                         dwarf_vmatoa ("u",
 562                                       read_uleb128 (data, & bytes_read, edata)));
 563                 data += bytes_read;
 564                 break;
 565               default:
 566                 printf (_("    UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
 567                 data = edata;
 568                 break;
 569               }
 570           }
 571       }
 572       break;
 573
 574     default:
 575       {
 576         unsigned int rlen = len - bytes_read - 1;
 577
 578         if (op_code >= DW_LNE_lo_user
 579             /* The test against DW_LNW_hi_user is redundant due to
 580                the limited range of the unsigned char data type used
 581                for op_code.  */
 582             /*&& op_code <= DW_LNE_hi_user*/)
 583           printf (_("user defined: "));
 584         else
 585           printf (_("UNKNOWN: "));
 586         printf (_("length %d ["), rlen);
 587         for (; rlen; rlen--)
 588           printf (" %02x", *data++);
 589         printf ("]\n");
 590       }
 591       break;
 592     }
 593
 594   return len;
 595 }
 596
 597 static const unsigned char *
 598 fetch_indirect_string (dwarf_vma offset)
 599 {
 600   struct dwarf_section *section = &debug_displays [str].section;
 601
 602   if (section->start == NULL)
 603     return (const unsigned char *) _("<no .debug_str section>");
 604
 605   if (offset > section->size)
 606     {
 607       warn (_("DW_FORM_strp offset too big: %s\n"),
 608             dwarf_vmatoa ("x", offset));
 609       return (const unsigned char *) _("<offset is too big>");
 610     }
 611
 612   return (const unsigned char *) section->start + offset;
 613 }
 614
 615 static const char *
 616 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
 617                       dwarf_vma offset_size, int dwo)
 618 {
 619   enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
 620   enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
 621   struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
 622   struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
 623   dwarf_vma index_offset = idx * offset_size;
 624   dwarf_vma str_offset;
 625
 626   if (index_section->start == NULL)
 627     return (dwo ? _("<no .debug_str_offsets.dwo section>")
 628                 : _("<no .debug_str_offsets section>"));
 629
 630   if (this_set != NULL)
 631     index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];
 632   if (index_offset > index_section->size)
 633     {
 634       warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
 635             dwarf_vmatoa ("x", index_offset));
 636       return _("<index offset is too big>");
 637     }
 638
 639   if (str_section->start == NULL)
 640     return (dwo ? _("<no .debug_str.dwo section>")
 641                 : _("<no .debug_str section>"));
 642
 643   str_offset = byte_get (index_section->start + index_offset, offset_size);
 644   str_offset -= str_section->address;
 645   if (str_offset > str_section->size)
 646     {
 647       warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
 648             dwarf_vmatoa ("x", str_offset));
 649       return _("<indirect index offset is too big>");
 650     }
 651
 652   return (const char *) str_section->start + str_offset;
 653 }
 654
 655 static const char *
 656 fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
 657 {
 658   struct dwarf_section *section = &debug_displays [debug_addr].section;
 659
 660   if (section->start == NULL)
 661     return (_("<no .debug_addr section>"));
 662
 663   if (offset + bytes > section->size)
 664     {
 665       warn (_("Offset into section %s too big: %s\n"),
 666             section->name, dwarf_vmatoa ("x", offset));
 667       return "<offset too big>";
 668     }
 669
 670   return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
 671 }
 672
 673
 674 /* FIXME:  There are better and more efficient ways to handle
 675    these structures.  For now though, I just want something that
 676    is simple to implement.  */
 677 typedef struct abbrev_attr
 678 {
 679   unsigned long attribute;
 680   unsigned long form;
 681   struct abbrev_attr *next;
 682 }
 683 abbrev_attr;
 684
 685 typedef struct abbrev_entry
 686 {
 687   unsigned long entry;
 688   unsigned long tag;
 689   int children;
 690   struct abbrev_attr *first_attr;
 691   struct abbrev_attr *last_attr;
 692   struct abbrev_entry *next;
 693 }
 694 abbrev_entry;
 695
 696 static abbrev_entry *first_abbrev = NULL;
 697 static abbrev_entry *last_abbrev = NULL;
 698
 699 static void
 700 free_abbrevs (void)
 701 {
 702   abbrev_entry *abbrv;
 703
 704   for (abbrv = first_abbrev; abbrv;)
 705     {
 706       abbrev_entry *next_abbrev = abbrv->next;
 707       abbrev_attr *attr;
 708
 709       for (attr = abbrv->first_attr; attr;)
 710         {
 711           abbrev_attr *next_attr = attr->next;
 712
 713           free (attr);
 714           attr = next_attr;
 715         }
 716
 717       free (abbrv);
 718       abbrv = next_abbrev;
 719     }
 720
 721   last_abbrev = first_abbrev = NULL;
 722 }
 723
 724 static void
 725 add_abbrev (unsigned long number, unsigned long tag, int children)
 726 {
 727   abbrev_entry *entry;
 728
 729   entry = (abbrev_entry *) malloc (sizeof (*entry));
 730   if (entry == NULL)
 731     /* ugg */
 732     return;
 733
 734   entry->entry      = number;
 735   entry->tag        = tag;
 736   entry->children   = children;
 737   entry->first_attr = NULL;
 738   entry->last_attr  = NULL;
 739   entry->next       = NULL;
 740
 741   if (first_abbrev == NULL)
 742     first_abbrev = entry;
 743   else
 744     last_abbrev->next = entry;
 745
 746   last_abbrev = entry;
 747 }
 748
 749 static void
 750 add_abbrev_attr (unsigned long attribute, unsigned long form)
 751 {
 752   abbrev_attr *attr;
 753
 754   attr = (abbrev_attr *) malloc (sizeof (*attr));
 755   if (attr == NULL)
 756     /* ugg */
 757     return;
 758
 759   attr->attribute = attribute;
 760   attr->form      = form;
 761   attr->next      = NULL;
 762
 763   if (last_abbrev->first_attr == NULL)
 764     last_abbrev->first_attr = attr;
 765   else
 766     last_abbrev->last_attr->next = attr;
 767
 768   last_abbrev->last_attr = attr;
 769 }
 770
 771 /* Processes the (partial) contents of a .debug_abbrev section.
 772    Returns NULL if the end of the section was encountered.
 773    Returns the address after the last byte read if the end of
 774    an abbreviation set was found.  */
 775
 776 static unsigned char *
 777 process_abbrev_section (unsigned char *start, unsigned char *end)
 778 {
 779   if (first_abbrev != NULL)
 780     return NULL;
 781
 782   while (start < end)
 783     {
 784       unsigned int bytes_read;
 785       unsigned long entry;
 786       unsigned long tag;
 787       unsigned long attribute;
 788       int children;
 789
 790       entry = read_uleb128 (start, & bytes_read, end);
 791       start += bytes_read;
 792
 793       /* A single zero is supposed to end the section according
 794          to the standard.  If there's more, then signal that to
 795          the caller.  */
 796       if (start == end)
 797         return NULL;
 798       if (entry == 0)
 799         return start;
 800
 801       tag = read_uleb128 (start, & bytes_read, end);
 802       start += bytes_read;
 803       if (start == end)
 804         return NULL;
 805
 806       children = *start++;
 807
 808       add_abbrev (entry, tag, children);
 809
 810       do
 811         {
 812           unsigned long form;
 813
 814           attribute = read_uleb128 (start, & bytes_read, end);
 815           start += bytes_read;
 816           if (start == end)
 817             break;
 818
 819           form = read_uleb128 (start, & bytes_read, end);
 820           start += bytes_read;
 821           if (start == end)
 822             break;
 823
 824           add_abbrev_attr (attribute, form);
 825         }
 826       while (attribute != 0);
 827     }
 828
 829   /* Report the missing single zero which ends the section.  */
 830   error (_(".debug_abbrev section not zero terminated\n"));
 831
 832   return NULL;
 833 }
 834
 835 static const char *
 836 get_TAG_name (unsigned long tag)
 837 {
 838   const char *name = get_DW_TAG_name ((unsigned int)tag);
 839
 840   if (name == NULL)
 841     {
 842       static char buffer[100];
 843
 844       snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
 845       return buffer;
 846     }
 847
 848   return name;
 849 }
 850
 851 static const char *
 852 get_FORM_name (unsigned long form)
 853 {
 854   const char *name;
 855
 856   if (form == 0)
 857     return "DW_FORM value: 0";
 858
 859   name = get_DW_FORM_name (form);
 860   if (name == NULL)
 861     {
 862       static char buffer[100];
 863
 864       snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
 865       return buffer;
 866     }
 867
 868   return name;
 869 }
 870
 871 static unsigned char *
 872 display_block (unsigned char *data,
 873                dwarf_vma length,
 874                const unsigned char * const end)
 875 {
 876   dwarf_vma maxlen;
 877
 878   printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
 879   if (data > end)
 880     return (unsigned char *) end;
 881
 882   maxlen = (dwarf_vma) (end - data);
 883   length = length > maxlen ? maxlen : length;
 884
 885   while (length --)
 886     printf ("%lx ", (unsigned long) byte_get (data++, 1));
 887
 888   return data;
 889 }
 890
 891 static int
 892 decode_location_expression (unsigned char * data,
 893                             unsigned int pointer_size,
 894                             unsigned int offset_size,
 895                             int dwarf_version,
 896                             dwarf_vma length,
 897                             dwarf_vma cu_offset,
 898                             struct dwarf_section * section)
 899 {
 900   unsigned op;
 901   unsigned int bytes_read;
 902   dwarf_vma uvalue;
 903   dwarf_signed_vma svalue;
 904   unsigned char *end = data + length;
 905   int need_frame_base = 0;
 906
 907   while (data < end)
 908     {
 909       op = *data++;
 910
 911       switch (op)
 912         {
 913         case DW_OP_addr:
 914           SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
 915           printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));
 916           break;
 917         case DW_OP_deref:
 918           printf ("DW_OP_deref");
 919           break;
 920         case DW_OP_const1u:
 921           SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
 922           printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
 923           break;
 924         case DW_OP_const1s:
 925           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
 926           printf ("DW_OP_const1s: %ld", (long) svalue);
 927           break;
 928         case DW_OP_const2u:
 929           SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
 930           printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);
 931           break;
 932         case DW_OP_const2s:
 933           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
 934           printf ("DW_OP_const2s: %ld", (long) svalue);
 935           break;
 936         case DW_OP_const4u:
 937           SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
 938           printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);
 939           break;
 940         case DW_OP_const4s:
 941           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
 942           printf ("DW_OP_const4s: %ld", (long) svalue);
 943           break;
 944         case DW_OP_const8u:
 945           SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
 946           printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
 947           SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
 948           printf ("%lu", (unsigned long) uvalue);
 949           break;
 950         case DW_OP_const8s:
 951           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
 952           printf ("DW_OP_const8s: %ld ", (long) svalue);
 953           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
 954           printf ("%ld", (long) svalue);
 955           break;
 956         case DW_OP_constu:
 957           printf ("DW_OP_constu: %s",
 958                   dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
 959           data += bytes_read;
 960           break;
 961         case DW_OP_consts:
 962           printf ("DW_OP_consts: %s",
 963                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
 964           data += bytes_read;
 965           break;
 966         case DW_OP_dup:
 967           printf ("DW_OP_dup");
 968           break;
 969         case DW_OP_drop:
 970           printf ("DW_OP_drop");
 971           break;
 972         case DW_OP_over:
 973           printf ("DW_OP_over");
 974           break;
 975         case DW_OP_pick:
 976           SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
 977           printf ("DW_OP_pick: %ld", (unsigned long) uvalue);
 978           break;
 979         case DW_OP_swap:
 980           printf ("DW_OP_swap");
 981           break;
 982         case DW_OP_rot:
 983           printf ("DW_OP_rot");
 984           break;
 985         case DW_OP_xderef:
 986           printf ("DW_OP_xderef");
 987           break;
 988         case DW_OP_abs:
 989           printf ("DW_OP_abs");
 990           break;
 991         case DW_OP_and:
 992           printf ("DW_OP_and");
 993           break;
 994         case DW_OP_div:
 995           printf ("DW_OP_div");
 996           break;
 997         case DW_OP_minus:
 998           printf ("DW_OP_minus");
 999           break;
1000         case DW_OP_mod:
1001           printf ("DW_OP_mod");
1002           break;
1003         case DW_OP_mul:
1004           printf ("DW_OP_mul");
1005           break;
1006         case DW_OP_neg:
1007           printf ("DW_OP_neg");
1008           break;
1009         case DW_OP_not:
1010           printf ("DW_OP_not");
1011           break;
1012         case DW_OP_or:
1013           printf ("DW_OP_or");
1014           break;
1015         case DW_OP_plus:
1016           printf ("DW_OP_plus");
1017           break;
1018         case DW_OP_plus_uconst:
1019           printf ("DW_OP_plus_uconst: %s",
1020                   dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1021           data += bytes_read;
1022           break;
1023         case DW_OP_shl:
1024           printf ("DW_OP_shl");
1025           break;
1026         case DW_OP_shr:
1027           printf ("DW_OP_shr");
1028           break;
1029         case DW_OP_shra:
1030           printf ("DW_OP_shra");
1031           break;
1032         case DW_OP_xor:
1033           printf ("DW_OP_xor");
1034           break;
1035         case DW_OP_bra:
1036           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1037           printf ("DW_OP_bra: %ld", (long) svalue);
1038           break;
1039         case DW_OP_eq:
1040           printf ("DW_OP_eq");
1041           break;
1042         case DW_OP_ge:
1043           printf ("DW_OP_ge");
1044           break;
1045         case DW_OP_gt:
1046           printf ("DW_OP_gt");
1047           break;
1048         case DW_OP_le:
1049           printf ("DW_OP_le");
1050           break;
1051         case DW_OP_lt:
1052           printf ("DW_OP_lt");
1053           break;
1054         case DW_OP_ne:
1055           printf ("DW_OP_ne");
1056           break;
1057         case DW_OP_skip:
1058           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1059           printf ("DW_OP_skip: %ld", (long) svalue);
1060           break;
1061
1062         case DW_OP_lit0:
1063         case DW_OP_lit1:
1064         case DW_OP_lit2:
1065         case DW_OP_lit3:
1066         case DW_OP_lit4:
1067         case DW_OP_lit5:
1068         case DW_OP_lit6:
1069         case DW_OP_lit7:
1070         case DW_OP_lit8:
1071         case DW_OP_lit9:
1072         case DW_OP_lit10:
1073         case DW_OP_lit11:
1074         case DW_OP_lit12:
1075         case DW_OP_lit13:
1076         case DW_OP_lit14:
1077         case DW_OP_lit15:
1078         case DW_OP_lit16:
1079         case DW_OP_lit17:
1080         case DW_OP_lit18:
1081         case DW_OP_lit19:
1082         case DW_OP_lit20:
1083         case DW_OP_lit21:
1084         case DW_OP_lit22:
1085         case DW_OP_lit23:
1086         case DW_OP_lit24:
1087         case DW_OP_lit25:
1088         case DW_OP_lit26:
1089         case DW_OP_lit27:
1090         case DW_OP_lit28:
1091         case DW_OP_lit29:
1092         case DW_OP_lit30:
1093         case DW_OP_lit31:
1094           printf ("DW_OP_lit%d", op - DW_OP_lit0);
1095           break;
1096
1097         case DW_OP_reg0:
1098         case DW_OP_reg1:
1099         case DW_OP_reg2:
1100         case DW_OP_reg3:
1101         case DW_OP_reg4:
1102         case DW_OP_reg5:
1103         case DW_OP_reg6:
1104         case DW_OP_reg7:
1105         case DW_OP_reg8:
1106         case DW_OP_reg9:
1107         case DW_OP_reg10:
1108         case DW_OP_reg11:
1109         case DW_OP_reg12:
1110         case DW_OP_reg13:
1111         case DW_OP_reg14:
1112         case DW_OP_reg15:
1113         case DW_OP_reg16:
1114         case DW_OP_reg17:
1115         case DW_OP_reg18:
1116         case DW_OP_reg19:
1117         case DW_OP_reg20:
1118         case DW_OP_reg21:
1119         case DW_OP_reg22:
1120         case DW_OP_reg23:
1121         case DW_OP_reg24:
1122         case DW_OP_reg25:
1123         case DW_OP_reg26:
1124         case DW_OP_reg27:
1125         case DW_OP_reg28:
1126         case DW_OP_reg29:
1127         case DW_OP_reg30:
1128         case DW_OP_reg31:
1129           printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
1130                   regname (op - DW_OP_reg0, 1));
1131           break;
1132
1133         case DW_OP_breg0:
1134         case DW_OP_breg1:
1135         case DW_OP_breg2:
1136         case DW_OP_breg3:
1137         case DW_OP_breg4:
1138         case DW_OP_breg5:
1139         case DW_OP_breg6:
1140         case DW_OP_breg7:
1141         case DW_OP_breg8:
1142         case DW_OP_breg9:
1143         case DW_OP_breg10:
1144         case DW_OP_breg11:
1145         case DW_OP_breg12:
1146         case DW_OP_breg13:
1147         case DW_OP_breg14:
1148         case DW_OP_breg15:
1149         case DW_OP_breg16:
1150         case DW_OP_breg17:
1151         case DW_OP_breg18:
1152         case DW_OP_breg19:
1153         case DW_OP_breg20:
1154         case DW_OP_breg21:
1155         case DW_OP_breg22:
1156         case DW_OP_breg23:
1157         case DW_OP_breg24:
1158         case DW_OP_breg25:
1159         case DW_OP_breg26:
1160         case DW_OP_breg27:
1161         case DW_OP_breg28:
1162         case DW_OP_breg29:
1163         case DW_OP_breg30:
1164         case DW_OP_breg31:
1165           printf ("DW_OP_breg%d (%s): %s",
1166                   op - DW_OP_breg0,
1167                   regname (op - DW_OP_breg0, 1),
1168                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1169           data += bytes_read;
1170           break;
1171
1172         case DW_OP_regx:
1173           uvalue = read_uleb128 (data, &bytes_read, end);
1174           data += bytes_read;
1175           printf ("DW_OP_regx: %s (%s)",
1176                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1177           break;
1178         case DW_OP_fbreg:
1179           need_frame_base = 1;
1180           printf ("DW_OP_fbreg: %s",
1181                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1182           data += bytes_read;
1183           break;
1184         case DW_OP_bregx:
1185           uvalue = read_uleb128 (data, &bytes_read, end);
1186           data += bytes_read;
1187           printf ("DW_OP_bregx: %s (%s) %s",
1188                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1189                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1190           data += bytes_read;
1191           break;
1192         case DW_OP_piece:
1193           printf ("DW_OP_piece: %s",
1194                   dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1195           data += bytes_read;
1196           break;
1197         case DW_OP_deref_size:
1198           SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1199           printf ("DW_OP_deref_size: %ld", (long) uvalue);
1200           break;
1201         case DW_OP_xderef_size:
1202           SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1203           printf ("DW_OP_xderef_size: %ld", (long) uvalue);
1204           break;
1205         case DW_OP_nop:
1206           printf ("DW_OP_nop");
1207           break;
1208
1209           /* DWARF 3 extensions.  */
1210         case DW_OP_push_object_address:
1211           printf ("DW_OP_push_object_address");
1212           break;
1213         case DW_OP_call2:
1214           /* XXX: Strictly speaking for 64-bit DWARF3 files
1215              this ought to be an 8-byte wide computation.  */
1216           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1217           printf ("DW_OP_call2: <0x%s>",
1218                   dwarf_vmatoa ("x", svalue + cu_offset));
1219           break;
1220         case DW_OP_call4:
1221           /* XXX: Strictly speaking for 64-bit DWARF3 files
1222              this ought to be an 8-byte wide computation.  */
1223           SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1224           printf ("DW_OP_call4: <0x%s>",
1225                   dwarf_vmatoa ("x", svalue + cu_offset));
1226           break;
1227         case DW_OP_call_ref:
1228           /* XXX: Strictly speaking for 64-bit DWARF3 files
1229              this ought to be an 8-byte wide computation.  */
1230           if (dwarf_version == -1)
1231             {
1232               printf (_("(DW_OP_call_ref in frame info)"));
1233               /* No way to tell where the next op is, so just bail.  */
1234               return need_frame_base;
1235             }
1236           if (dwarf_version == 2)
1237             {
1238               SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1239             }
1240           else
1241             {
1242               SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1243             }
1244           printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue));
1245           break;
1246         case DW_OP_form_tls_address:
1247           printf ("DW_OP_form_tls_address");
1248           break;
1249         case DW_OP_call_frame_cfa:
1250           printf ("DW_OP_call_frame_cfa");
1251           break;
1252         case DW_OP_bit_piece:
1253           printf ("DW_OP_bit_piece: ");
1254           printf (_("size: %s "),
1255                   dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1256           data += bytes_read;
1257           printf (_("offset: %s "),
1258                   dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1259           data += bytes_read;
1260           break;
1261
1262           /* DWARF 4 extensions.  */
1263         case DW_OP_stack_value:
1264           printf ("DW_OP_stack_value");
1265           break;
1266
1267         case DW_OP_implicit_value:
1268           printf ("DW_OP_implicit_value");
1269           uvalue = read_uleb128 (data, &bytes_read, end);
1270           data += bytes_read;
1271           data = display_block (data, uvalue, end);
1272           break;
1273
1274           /* GNU extensions.  */
1275         case DW_OP_GNU_push_tls_address:
1276           printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1277           break;
1278         case DW_OP_GNU_uninit:
1279           printf ("DW_OP_GNU_uninit");
1280           /* FIXME: Is there data associated with this OP ?  */
1281           break;
1282         case DW_OP_GNU_encoded_addr:
1283           {
1284             int encoding = 0;
1285             dwarf_vma addr;
1286
1287             if (data < end)
1288               encoding = *data++;
1289             addr = get_encoded_value (&data, encoding, section, end);
1290
1291             printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1292             print_dwarf_vma (addr, pointer_size);
1293           }
1294           break;
1295         case DW_OP_GNU_implicit_pointer:
1296           /* XXX: Strictly speaking for 64-bit DWARF3 files
1297              this ought to be an 8-byte wide computation.  */
1298           if (dwarf_version == -1)
1299             {
1300               printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1301               /* No way to tell where the next op is, so just bail.  */
1302               return need_frame_base;
1303             }
1304           if (dwarf_version == 2)
1305             {
1306               SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1307             }
1308           else
1309             {
1310               SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1311             }
1312           printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1313                   dwarf_vmatoa ("x", uvalue),
1314                   dwarf_vmatoa ("d", read_sleb128 (data,
1315                                                    &bytes_read, end)));
1316           data += bytes_read;
1317           break;
1318         case DW_OP_GNU_entry_value:
1319           uvalue = read_uleb128 (data, &bytes_read, end);
1320           data += bytes_read;
1321           /* PR 17531: file: 0cc9cd00.  */
1322           if (uvalue > (dwarf_vma) (end - data))
1323             uvalue = end - data;
1324           printf ("DW_OP_GNU_entry_value: (");
1325           if (decode_location_expression (data, pointer_size, offset_size,
1326                                           dwarf_version, uvalue,
1327                                           cu_offset, section))
1328             need_frame_base = 1;
1329           putchar (')');
1330           data += uvalue;
1331           if (data > end)
1332             data = end;
1333           break;
1334         case DW_OP_GNU_const_type:
1335           uvalue = read_uleb128 (data, &bytes_read, end);
1336           data += bytes_read;
1337           printf ("DW_OP_GNU_const_type: <0x%s> ",
1338                   dwarf_vmatoa ("x", cu_offset + uvalue));
1339           SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1340           data = display_block (data, uvalue, end);
1341           break;
1342         case DW_OP_GNU_regval_type:
1343           uvalue = read_uleb128 (data, &bytes_read, end);
1344           data += bytes_read;
1345           printf ("DW_OP_GNU_regval_type: %s (%s)",
1346                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1347           uvalue = read_uleb128 (data, &bytes_read, end);
1348           data += bytes_read;
1349           printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1350           break;
1351         case DW_OP_GNU_deref_type:
1352           SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1353           printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue);
1354           uvalue = read_uleb128 (data, &bytes_read, end);
1355           data += bytes_read;
1356           printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1357           break;
1358         case DW_OP_GNU_convert:
1359           uvalue = read_uleb128 (data, &bytes_read, end);
1360           data += bytes_read;
1361           printf ("DW_OP_GNU_convert <0x%s>",
1362                   dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1363           break;
1364         case DW_OP_GNU_reinterpret:
1365           uvalue = read_uleb128 (data, &bytes_read, end);
1366           data += bytes_read;
1367           printf ("DW_OP_GNU_reinterpret <0x%s>",
1368                   dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1369           break;
1370         case DW_OP_GNU_parameter_ref:
1371           SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1372           printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1373                   dwarf_vmatoa ("x", cu_offset + uvalue));
1374           break;
1375         case DW_OP_GNU_addr_index:
1376           uvalue = read_uleb128 (data, &bytes_read, end);
1377           data += bytes_read;
1378           printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1379           break;
1380         case DW_OP_GNU_const_index:
1381           uvalue = read_uleb128 (data, &bytes_read, end);
1382           data += bytes_read;
1383           printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1384           break;
1385
1386           /* HP extensions.  */
1387         case DW_OP_HP_is_value:
1388           printf ("DW_OP_HP_is_value");
1389           /* FIXME: Is there data associated with this OP ?  */
1390           break;
1391         case DW_OP_HP_fltconst4:
1392           printf ("DW_OP_HP_fltconst4");
1393           /* FIXME: Is there data associated with this OP ?  */
1394           break;
1395         case DW_OP_HP_fltconst8:
1396           printf ("DW_OP_HP_fltconst8");
1397           /* FIXME: Is there data associated with this OP ?  */
1398           break;
1399         case DW_OP_HP_mod_range:
1400           printf ("DW_OP_HP_mod_range");
1401           /* FIXME: Is there data associated with this OP ?  */
1402           break;
1403         case DW_OP_HP_unmod_range:
1404           printf ("DW_OP_HP_unmod_range");
1405           /* FIXME: Is there data associated with this OP ?  */
1406           break;
1407         case DW_OP_HP_tls:
1408           printf ("DW_OP_HP_tls");
1409           /* FIXME: Is there data associated with this OP ?  */
1410           break;
1411
1412           /* PGI (STMicroelectronics) extensions.  */
1413         case DW_OP_PGI_omp_thread_num:
1414           /* Pushes the thread number for the current thread as it would be
1415              returned by the standard OpenMP library function:
1416              omp_get_thread_num().  The "current thread" is the thread for
1417              which the expression is being evaluated.  */
1418           printf ("DW_OP_PGI_omp_thread_num");
1419           break;
1420
1421         default:
1422           if (op >= DW_OP_lo_user
1423               && op <= DW_OP_hi_user)
1424             printf (_("(User defined location op)"));
1425           else
1426             printf (_("(Unknown location op)"));
1427           /* No way to tell where the next op is, so just bail.  */
1428           return need_frame_base;
1429         }
1430
1431       /* Separate the ops.  */
1432       if (data < end)
1433         printf ("; ");
1434     }
1435
1436   return need_frame_base;
1437 }
1438
1439 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1440    This is used for DWARF package files.  */
1441
1442 static struct cu_tu_set *
1443 find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types)
1444 {
1445   struct cu_tu_set *p;
1446   unsigned int nsets;
1447   unsigned int dw_sect;
1448
1449   if (do_types)
1450     {
1451       p = tu_sets;
1452       nsets = tu_count;
1453       dw_sect = DW_SECT_TYPES;
1454     }
1455   else
1456     {
1457       p = cu_sets;
1458       nsets = cu_count;
1459       dw_sect = DW_SECT_INFO;
1460     }
1461   while (nsets > 0)
1462     {
1463       if (p->section_offsets [dw_sect] == cu_offset)
1464         return p;
1465       p++;
1466       nsets--;
1467     }
1468   return NULL;
1469 }
1470
1471 /* Add INC to HIGH_BITS:LOW_BITS.  */
1472 static void
1473 add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
1474 {
1475   dwarf_vma tmp = * low_bits;
1476
1477   tmp += inc;
1478
1479   /* FIXME: There is probably a better way of handling this:
1480
1481      We need to cope with dwarf_vma being a 32-bit or 64-bit
1482      type.  Plus regardless of its size LOW_BITS is meant to
1483      only hold 32-bits, so if there is overflow or wrap around
1484      we must propagate into HIGH_BITS.  */
1485   if (tmp < * low_bits)
1486     {
1487       ++ * high_bits;
1488     }
1489   else if (sizeof (tmp) > 8
1490            && (tmp >> 31) > 1)
1491     {
1492       ++ * high_bits;
1493       tmp &= 0xFFFFFFFF;
1494     }
1495
1496   * low_bits = tmp;
1497 }
1498
1499 static unsigned char *
1500 read_and_display_attr_value (unsigned long attribute,
1501                              unsigned long form,
1502                              unsigned char * data,
1503                              unsigned char * end,
1504                              dwarf_vma cu_offset,
1505                              dwarf_vma pointer_size,
1506                              dwarf_vma offset_size,
1507                              int dwarf_version,
1508                              debug_info * debug_info_p,
1509                              int do_loc,
1510                              struct dwarf_section * section,
1511                              struct cu_tu_set * this_set)
1512 {
1513   dwarf_vma uvalue = 0;
1514   unsigned char *block_start = NULL;
1515   unsigned char * orig_data = data;
1516   unsigned int bytes_read;
1517
1518   if (data > end || (data == end && form != DW_FORM_flag_present))
1519     {
1520       warn (_("Corrupt attribute\n"));
1521       return data;
1522     }
1523
1524   switch (form)
1525     {
1526     default:
1527       break;
1528
1529     case DW_FORM_ref_addr:
1530       if (dwarf_version == 2)
1531         SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1532       else if (dwarf_version == 3 || dwarf_version == 4)
1533         SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1534       else
1535         error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1536
1537       break;
1538
1539     case DW_FORM_addr:
1540       SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1541       break;
1542
1543     case DW_FORM_strp:
1544     case DW_FORM_sec_offset:
1545     case DW_FORM_GNU_ref_alt:
1546     case DW_FORM_GNU_strp_alt:
1547       SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1548       break;
1549
1550     case DW_FORM_flag_present:
1551       uvalue = 1;
1552       break;
1553
1554     case DW_FORM_ref1:
1555     case DW_FORM_flag:
1556     case DW_FORM_data1:
1557       SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1558       break;
1559
1560     case DW_FORM_ref2:
1561     case DW_FORM_data2:
1562       SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
1563       break;
1564
1565     case DW_FORM_ref4:
1566     case DW_FORM_data4:
1567       SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1568       break;
1569
1570     case DW_FORM_sdata:
1571       uvalue = read_sleb128 (data, & bytes_read, end);
1572       data += bytes_read;
1573       break;
1574
1575     case DW_FORM_GNU_str_index:
1576       uvalue = read_uleb128 (data, & bytes_read, end);
1577       data += bytes_read;
1578       break;
1579
1580     case DW_FORM_ref_udata:
1581     case DW_FORM_udata:
1582       uvalue = read_uleb128 (data, & bytes_read, end);
1583       data += bytes_read;
1584       break;
1585
1586     case DW_FORM_indirect:
1587       form = read_uleb128 (data, & bytes_read, end);
1588       data += bytes_read;
1589       if (!do_loc)
1590         printf (" %s", get_FORM_name (form));
1591       return read_and_display_attr_value (attribute, form, data, end,
1592                                           cu_offset, pointer_size,
1593                                           offset_size, dwarf_version,
1594                                           debug_info_p, do_loc,
1595                                           section, this_set);
1596     case DW_FORM_GNU_addr_index:
1597       uvalue = read_uleb128 (data, & bytes_read, end);
1598       data += bytes_read;
1599       break;
1600     }
1601
1602   switch (form)
1603     {
1604     case DW_FORM_ref_addr:
1605       if (!do_loc)
1606         printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1607       break;
1608
1609     case DW_FORM_GNU_ref_alt:
1610       if (!do_loc)
1611         printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue));
1612       break;
1613
1614     case DW_FORM_ref1:
1615     case DW_FORM_ref2:
1616     case DW_FORM_ref4:
1617     case DW_FORM_ref_udata:
1618       if (!do_loc)
1619         printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1620       break;
1621
1622     case DW_FORM_data4:
1623     case DW_FORM_addr:
1624     case DW_FORM_sec_offset:
1625       if (!do_loc)
1626         printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1627       break;
1628
1629     case DW_FORM_flag_present:
1630     case DW_FORM_flag:
1631     case DW_FORM_data1:
1632     case DW_FORM_data2:
1633     case DW_FORM_sdata:
1634     case DW_FORM_udata:
1635       if (!do_loc)
1636         printf (" %s", dwarf_vmatoa ("d", uvalue));
1637       break;
1638
1639     case DW_FORM_ref8:
1640     case DW_FORM_data8:
1641       if (!do_loc)
1642         {
1643           dwarf_vma high_bits;
1644           dwarf_vma utmp;
1645           char buf[64];
1646
1647           SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1648           utmp = uvalue;
1649           if (form == DW_FORM_ref8)
1650             add64 (& high_bits, & utmp, cu_offset);
1651           printf (" 0x%s",
1652                   dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf)));
1653         }
1654
1655       if ((do_loc || do_debug_loc || do_debug_ranges)
1656           && num_debug_info_entries == 0)
1657         {
1658           if (sizeof (uvalue) == 8)
1659             SAFE_BYTE_GET (uvalue, data, 8, end);
1660           else
1661             error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1662         }
1663
1664       data += 8;
1665       break;
1666
1667     case DW_FORM_string:
1668       if (!do_loc)
1669         printf (" %.*s", (int) (end - data), data);
1670       data += strnlen ((char *) data, end - data) + 1;
1671       break;
1672
1673     case DW_FORM_block:
1674     case DW_FORM_exprloc:
1675       uvalue = read_uleb128 (data, & bytes_read, end);
1676       block_start = data + bytes_read;
1677       if (block_start >= end)
1678         {
1679           warn (_("Block ends prematurely\n"));
1680           uvalue = 0;
1681           block_start = end;
1682         }
1683       /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1684          gcc 4.8.3 running on an x86_64 host in 32-bit mode.  So we pre-compute
1685          block_start + uvalue here.  */
1686       data = block_start + uvalue;
1687       /* PR 17512: file: 008-103549-0.001:0.1.  */
1688       if (block_start + uvalue > end || data < block_start)
1689         {
1690           warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1691           uvalue = end - block_start;
1692         }
1693       if (do_loc)
1694         data = block_start + uvalue;
1695       else
1696         data = display_block (block_start, uvalue, end);
1697       break;
1698
1699     case DW_FORM_block1:
1700       SAFE_BYTE_GET (uvalue, data, 1, end);
1701       block_start = data + 1;
1702       if (block_start >= end)
1703         {
1704           warn (_("Block ends prematurely\n"));
1705           uvalue = 0;
1706           block_start = end;
1707         }
1708       data = block_start + uvalue;
1709       if (block_start + uvalue > end || data < block_start)
1710         {
1711           warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1712           uvalue = end - block_start;
1713         }
1714       if (do_loc)
1715         data = block_start + uvalue;
1716       else
1717         data = display_block (block_start, uvalue, end);
1718       break;
1719
1720     case DW_FORM_block2:
1721       SAFE_BYTE_GET (uvalue, data, 2, end);
1722       block_start = data + 2;
1723       if (block_start >= end)
1724         {
1725           warn (_("Block ends prematurely\n"));
1726           uvalue = 0;
1727           block_start = end;
1728         }
1729       data = block_start + uvalue;
1730       if (block_start + uvalue > end || data < block_start)
1731         {
1732           warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1733           uvalue = end - block_start;
1734         }
1735       if (do_loc)
1736         data = block_start + uvalue;
1737       else
1738         data = display_block (block_start, uvalue, end);
1739       break;
1740
1741     case DW_FORM_block4:
1742       SAFE_BYTE_GET (uvalue, data, 4, end);
1743       block_start = data + 4;
1744       /* PR 17512: file: 3371-3907-0.004.  */
1745       if (block_start >= end)
1746         {
1747           warn (_("Block ends prematurely\n"));
1748           uvalue = 0;
1749           block_start = end;
1750         }
1751       data = block_start + uvalue;
1752       if (block_start + uvalue > end
1753           /* PR 17531: file: 5b5f0592.  */
1754           || data < block_start)
1755         {
1756           warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1757           uvalue = end - block_start;
1758         }
1759       if (do_loc)
1760         data = block_start + uvalue;
1761       else
1762         data = display_block (block_start, uvalue, end);
1763       break;
1764
1765     case DW_FORM_strp:
1766       if (!do_loc)
1767         printf (_(" (indirect string, offset: 0x%s): %s"),
1768                 dwarf_vmatoa ("x", uvalue),
1769                 fetch_indirect_string (uvalue));
1770       break;
1771
1772     case DW_FORM_GNU_str_index:
1773       if (!do_loc)
1774         {
1775           const char *suffix = strrchr (section->name, '.');
1776           int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
1777
1778           printf (_(" (indexed string: 0x%s): %s"),
1779                   dwarf_vmatoa ("x", uvalue),
1780                   fetch_indexed_string (uvalue, this_set, offset_size, dwo));
1781         }
1782       break;
1783
1784     case DW_FORM_GNU_strp_alt:
1785       if (!do_loc)
1786         printf (_(" (alt indirect string, offset: 0x%s)"),
1787                 dwarf_vmatoa ("x", uvalue));
1788       break;
1789
1790     case DW_FORM_indirect:
1791       /* Handled above.  */
1792       break;
1793
1794     case DW_FORM_ref_sig8:
1795       if (!do_loc)
1796         {
1797           dwarf_vma high_bits;
1798           char buf[64];
1799
1800           SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1801           printf (" signature: 0x%s",
1802                   dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
1803         }
1804       data += 8;
1805       break;
1806
1807     case DW_FORM_GNU_addr_index:
1808       if (!do_loc)
1809         printf (_(" (addr_index: 0x%s): %s"),
1810                 dwarf_vmatoa ("x", uvalue),
1811                 fetch_indexed_value (uvalue * pointer_size, pointer_size));
1812       break;
1813
1814     default:
1815       warn (_("Unrecognized form: %lu\n"), form);
1816       break;
1817     }
1818
1819   if ((do_loc || do_debug_loc || do_debug_ranges)
1820       && num_debug_info_entries == 0
1821       && debug_info_p != NULL)
1822     {
1823       switch (attribute)
1824         {
1825         case DW_AT_frame_base:
1826           have_frame_base = 1;
1827           /* Fall through.  */
1828         case DW_AT_location:
1829         case DW_AT_string_length:
1830         case DW_AT_return_addr:
1831         case DW_AT_data_member_location:
1832         case DW_AT_vtable_elem_location:
1833         case DW_AT_segment:
1834         case DW_AT_static_link:
1835         case DW_AT_use_location:
1836         case DW_AT_GNU_call_site_value:
1837         case DW_AT_GNU_call_site_data_value:
1838         case DW_AT_GNU_call_site_target:
1839         case DW_AT_GNU_call_site_target_clobbered:
1840           if ((dwarf_version < 4
1841                && (form == DW_FORM_data4 || form == DW_FORM_data8))
1842               || form == DW_FORM_sec_offset)
1843             {
1844               /* Process location list.  */
1845               unsigned int lmax = debug_info_p->max_loc_offsets;
1846               unsigned int num = debug_info_p->num_loc_offsets;
1847
1848               if (lmax == 0 || num >= lmax)
1849                 {
1850                   lmax += 1024;
1851                   debug_info_p->loc_offsets = (dwarf_vma *)
1852                     xcrealloc (debug_info_p->loc_offsets,
1853                                lmax, sizeof (*debug_info_p->loc_offsets));
1854                   debug_info_p->have_frame_base = (int *)
1855                     xcrealloc (debug_info_p->have_frame_base,
1856                                lmax, sizeof (*debug_info_p->have_frame_base));
1857                   debug_info_p->max_loc_offsets = lmax;
1858                 }
1859               if (this_set != NULL)
1860                 uvalue += this_set->section_offsets [DW_SECT_LOC];
1861               debug_info_p->loc_offsets [num] = uvalue;
1862               debug_info_p->have_frame_base [num] = have_frame_base;
1863               debug_info_p->num_loc_offsets++;
1864             }
1865           break;
1866
1867         case DW_AT_low_pc:
1868           if (need_base_address)
1869             debug_info_p->base_address = uvalue;
1870           break;
1871
1872         case DW_AT_GNU_addr_base:
1873           debug_info_p->addr_base = uvalue;
1874           break;
1875
1876         case DW_AT_GNU_ranges_base:
1877           debug_info_p->ranges_base = uvalue;
1878           break;
1879
1880         case DW_AT_ranges:
1881           if ((dwarf_version < 4
1882                && (form == DW_FORM_data4 || form == DW_FORM_data8))
1883               || form == DW_FORM_sec_offset)
1884             {
1885               /* Process range list.  */
1886               unsigned int lmax = debug_info_p->max_range_lists;
1887               unsigned int num = debug_info_p->num_range_lists;
1888
1889               if (lmax == 0 || num >= lmax)
1890                 {
1891                   lmax += 1024;
1892                   debug_info_p->range_lists = (dwarf_vma *)
1893                     xcrealloc (debug_info_p->range_lists,
1894                                lmax, sizeof (*debug_info_p->range_lists));
1895                   debug_info_p->max_range_lists = lmax;
1896                 }
1897               debug_info_p->range_lists [num] = uvalue;
1898               debug_info_p->num_range_lists++;
1899             }
1900           break;
1901
1902         default:
1903           break;
1904         }
1905     }
1906
1907   if (do_loc || attribute == 0)
1908     return data;
1909
1910   /* For some attributes we can display further information.  */
1911   switch (attribute)
1912     {
1913     case DW_AT_inline:
1914       printf ("\t");
1915       switch (uvalue)
1916         {
1917         case DW_INL_not_inlined:
1918           printf (_("(not inlined)"));
1919           break;
1920         case DW_INL_inlined:
1921           printf (_("(inlined)"));
1922           break;
1923         case DW_INL_declared_not_inlined:
1924           printf (_("(declared as inline but ignored)"));
1925           break;
1926         case DW_INL_declared_inlined:
1927           printf (_("(declared as inline and inlined)"));
1928           break;
1929         default:
1930           printf (_("  (Unknown inline attribute value: %s)"),
1931                   dwarf_vmatoa ("x", uvalue));
1932           break;
1933         }
1934       break;
1935
1936     case DW_AT_language:
1937       printf ("\t");
1938       switch (uvalue)
1939         {
1940           /* Ordered by the numeric value of these constants.  */
1941         case DW_LANG_C89:               printf ("(ANSI C)"); break;
1942         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1943         case DW_LANG_Ada83:             printf ("(Ada)"); break;
1944         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1945         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1946         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1947         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1948         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1949         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1950         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1951           /* DWARF 2.1 values.  */
1952         case DW_LANG_Java:              printf ("(Java)"); break;
1953         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1954         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1955         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1956           /* DWARF 3 values.  */
1957         case DW_LANG_PLI:               printf ("(PLI)"); break;
1958         case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1959         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1960         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1961         case DW_LANG_D:                 printf ("(D)"); break;
1962           /* DWARF 4 values.  */
1963         case DW_LANG_Python:            printf ("(Python)"); break;
1964           /* DWARF 5 values.  */
1965         case DW_LANG_Go:                printf ("(Go)"); break;
1966         case DW_LANG_C_plus_plus_11:    printf ("(C++11)"); break;
1967         case DW_LANG_C11:               printf ("(C11)"); break;
1968         case DW_LANG_C_plus_plus_14:    printf ("(C++14)"); break;
1969         case DW_LANG_Fortran03:         printf ("(Fortran 03)"); break;
1970         case DW_LANG_Fortran08:         printf ("(Fortran 08)"); break;
1971           /* MIPS extension.  */
1972         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1973           /* UPC extension.  */
1974         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1975         default:
1976           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1977             printf (_("(implementation defined: %s)"),
1978                     dwarf_vmatoa ("x", uvalue));
1979           else
1980             printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
1981           break;
1982         }
1983       break;
1984
1985     case DW_AT_encoding:
1986       printf ("\t");
1987       switch (uvalue)
1988         {
1989         case DW_ATE_void:               printf ("(void)"); break;
1990         case DW_ATE_address:            printf ("(machine address)"); break;
1991         case DW_ATE_boolean:            printf ("(boolean)"); break;
1992         case DW_ATE_complex_float:      printf ("(complex float)"); break;
1993         case DW_ATE_float:              printf ("(float)"); break;
1994         case DW_ATE_signed:             printf ("(signed)"); break;
1995         case DW_ATE_signed_char:        printf ("(signed char)"); break;
1996         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1997         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1998           /* DWARF 2.1 values:  */
1999         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
2000         case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
2001           /* DWARF 3 values:  */
2002         case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
2003         case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
2004         case DW_ATE_edited:             printf ("(edited)"); break;
2005         case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
2006         case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
2007           /* HP extensions:  */
2008         case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
2009         case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
2010         case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
2011         case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
2012         case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
2013         case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
2014         case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
2015           /* DWARF 4 values:  */
2016         case DW_ATE_UTF:                printf ("(unicode string)"); break;
2017
2018         default:
2019           if (uvalue >= DW_ATE_lo_user
2020               && uvalue <= DW_ATE_hi_user)
2021             printf (_("(user defined type)"));
2022           else
2023             printf (_("(unknown type)"));
2024           break;
2025         }
2026       break;
2027
2028     case DW_AT_accessibility:
2029       printf ("\t");
2030       switch (uvalue)
2031         {
2032         case DW_ACCESS_public:          printf ("(public)"); break;
2033         case DW_ACCESS_protected:       printf ("(protected)"); break;
2034         case DW_ACCESS_private:         printf ("(private)"); break;
2035         default:
2036           printf (_("(unknown accessibility)"));
2037           break;
2038         }
2039       break;
2040
2041     case DW_AT_visibility:
2042       printf ("\t");
2043       switch (uvalue)
2044         {
2045         case DW_VIS_local:              printf ("(local)"); break;
2046         case DW_VIS_exported:           printf ("(exported)"); break;
2047         case DW_VIS_qualified:          printf ("(qualified)"); break;
2048         default:                        printf (_("(unknown visibility)")); break;
2049         }
2050       break;
2051
2052     case DW_AT_virtuality:
2053       printf ("\t");
2054       switch (uvalue)
2055         {
2056         case DW_VIRTUALITY_none:        printf ("(none)"); break;
2057         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
2058         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
2059         default:                        printf (_("(unknown virtuality)")); break;
2060         }
2061       break;
2062
2063     case DW_AT_identifier_case:
2064       printf ("\t");
2065       switch (uvalue)
2066         {
2067         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
2068         case DW_ID_up_case:             printf ("(up_case)"); break;
2069         case DW_ID_down_case:           printf ("(down_case)"); break;
2070         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
2071         default:                        printf (_("(unknown case)")); break;
2072         }
2073       break;
2074
2075     case DW_AT_calling_convention:
2076       printf ("\t");
2077       switch (uvalue)
2078         {
2079         case DW_CC_normal:      printf ("(normal)"); break;
2080         case DW_CC_program:     printf ("(program)"); break;
2081         case DW_CC_nocall:      printf ("(nocall)"); break;
2082         default:
2083           if (uvalue >= DW_CC_lo_user
2084               && uvalue <= DW_CC_hi_user)
2085             printf (_("(user defined)"));
2086           else
2087             printf (_("(unknown convention)"));
2088         }
2089       break;
2090
2091     case DW_AT_ordering:
2092       printf ("\t");
2093       switch (uvalue)
2094         {
2095         case -1: printf (_("(undefined)")); break;
2096         case 0:  printf ("(row major)"); break;
2097         case 1:  printf ("(column major)"); break;
2098         }
2099       break;
2100
2101     case DW_AT_frame_base:
2102       have_frame_base = 1;
2103       /* Fall through.  */
2104     case DW_AT_location:
2105     case DW_AT_string_length:
2106     case DW_AT_return_addr:
2107     case DW_AT_data_member_location:
2108     case DW_AT_vtable_elem_location:
2109     case DW_AT_segment:
2110     case DW_AT_static_link:
2111     case DW_AT_use_location:
2112     case DW_AT_GNU_call_site_value:
2113     case DW_AT_GNU_call_site_data_value:
2114     case DW_AT_GNU_call_site_target:
2115     case DW_AT_GNU_call_site_target_clobbered:
2116       if ((dwarf_version < 4
2117            && (form == DW_FORM_data4 || form == DW_FORM_data8))
2118           || form == DW_FORM_sec_offset)
2119         printf (_(" (location list)"));
2120       /* Fall through.  */
2121     case DW_AT_allocated:
2122     case DW_AT_associated:
2123     case DW_AT_data_location:
2124     case DW_AT_stride:
2125     case DW_AT_upper_bound:
2126     case DW_AT_lower_bound:
2127       if (block_start)
2128         {
2129           int need_frame_base;
2130
2131           printf ("\t(");
2132           need_frame_base = decode_location_expression (block_start,
2133                                                         pointer_size,
2134                                                         offset_size,
2135                                                         dwarf_version,
2136                                                         uvalue,
2137                                                         cu_offset, section);
2138           printf (")");
2139           if (need_frame_base && !have_frame_base)
2140             printf (_(" [without DW_AT_frame_base]"));
2141         }
2142       break;
2143
2144     case DW_AT_import:
2145       {
2146         if (form == DW_FORM_ref_sig8
2147             || form == DW_FORM_GNU_ref_alt)
2148           break;
2149
2150         if (form == DW_FORM_ref1
2151             || form == DW_FORM_ref2
2152             || form == DW_FORM_ref4
2153             || form == DW_FORM_ref_udata)
2154           uvalue += cu_offset;
2155
2156         if (uvalue >= section->size)
2157           warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2158                 dwarf_vmatoa ("x", uvalue),
2159                 (unsigned long) (orig_data - section->start));
2160         else
2161           {
2162             unsigned long abbrev_number;
2163             abbrev_entry * entry;
2164
2165             abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
2166
2167             printf (_("\t[Abbrev Number: %ld"), abbrev_number);
2168             /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2169                use different abbrev table, and we don't track .debug_info chunks
2170                yet.  */
2171             if (form != DW_FORM_ref_addr)
2172               {
2173                 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2174                   if (entry->entry == abbrev_number)
2175                     break;
2176                 if (entry != NULL)
2177                   printf (" (%s)", get_TAG_name (entry->tag));
2178               }
2179             printf ("]");
2180           }
2181       }
2182       break;
2183
2184     default:
2185       break;
2186     }
2187
2188   return data;
2189 }
2190
2191 static const char *
2192 get_AT_name (unsigned long attribute)
2193 {
2194   const char *name;
2195
2196   if (attribute == 0)
2197     return "DW_AT value: 0";
2198
2199   /* One value is shared by the MIPS and HP extensions:  */
2200   if (attribute == DW_AT_MIPS_fde)
2201     return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2202
2203   name = get_DW_AT_name (attribute);
2204
2205   if (name == NULL)
2206     {
2207       static char buffer[100];
2208
2209       snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2210                 attribute);
2211       return buffer;
2212     }
2213
2214   return name;
2215 }
2216
2217 static unsigned char *
2218 read_and_display_attr (unsigned long attribute,
2219                        unsigned long form,
2220                        unsigned char * data,
2221                        unsigned char * end,
2222                        dwarf_vma cu_offset,
2223                        dwarf_vma pointer_size,
2224                        dwarf_vma offset_size,
2225                        int dwarf_version,
2226                        debug_info * debug_info_p,
2227                        int do_loc,
2228                        struct dwarf_section * section,
2229                        struct cu_tu_set * this_set)
2230 {
2231   if (!do_loc)
2232     printf ("   %-18s:", get_AT_name (attribute));
2233   data = read_and_display_attr_value (attribute, form, data, end,
2234                                       cu_offset, pointer_size, offset_size,
2235                                       dwarf_version, debug_info_p,
2236                                       do_loc, section, this_set);
2237   if (!do_loc)
2238     printf ("\n");
2239   return data;
2240 }
2241
2242 /* Process the contents of a .debug_info section.  If do_loc is non-zero
2243    then we are scanning for location lists and we do not want to display
2244    anything to the user.  If do_types is non-zero, we are processing
2245    a .debug_types section instead of a .debug_info section.  */
2246
2247 static int
2248 process_debug_info (struct dwarf_section *section,
2249                     void *file,
2250                     enum dwarf_section_display_enum abbrev_sec,
2251                     int do_loc,
2252                     int do_types)
2253 {
2254   unsigned char *start = section->start;
2255   unsigned char *end = start + section->size;
2256   unsigned char *section_begin;
2257   unsigned int unit;
2258   unsigned int num_units = 0;
2259
2260   if ((do_loc || do_debug_loc || do_debug_ranges)
2261       && num_debug_info_entries == 0
2262       && ! do_types)
2263     {
2264       dwarf_vma length;
2265
2266       /* First scan the section to get the number of comp units.  */
2267       for (section_begin = start, num_units = 0; section_begin < end;
2268            num_units ++)
2269         {
2270           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
2271              will be the length.  For a 64-bit DWARF section, it'll be
2272              the escape code 0xffffffff followed by an 8 byte length.  */
2273           SAFE_BYTE_GET (length, section_begin, 4, end);
2274
2275           if (length == 0xffffffff)
2276             {
2277               SAFE_BYTE_GET (length, section_begin + 4, 8, end);
2278               section_begin += length + 12;
2279             }
2280           else if (length >= 0xfffffff0 && length < 0xffffffff)
2281             {
2282               warn (_("Reserved length value (0x%s) found in section %s\n"),
2283                     dwarf_vmatoa ("x", length), section->name);
2284               return 0;
2285             }
2286           else
2287             section_begin += length + 4;
2288
2289           /* Negative values are illegal, they may even cause infinite
2290              looping.  This can happen if we can't accurately apply
2291              relocations to an object file, or if the file is corrupt.  */
2292           if ((signed long) length <= 0 || section_begin < start)
2293             {
2294               warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2295                     dwarf_vmatoa ("x", length), section->name);
2296               return 0;
2297             }
2298         }
2299
2300       if (num_units == 0)
2301         {
2302           error (_("No comp units in %s section ?\n"), section->name);
2303           return 0;
2304         }
2305
2306       /* Then allocate an array to hold the information.  */
2307       debug_information = (debug_info *) cmalloc (num_units,
2308                                                   sizeof (* debug_information));
2309       if (debug_information == NULL)
2310         {
2311           error (_("Not enough memory for a debug info array of %u entries\n"),
2312                  num_units);
2313           alloc_num_debug_info_entries = num_debug_info_entries = 0;
2314           return 0;
2315         }
2316       /* PR 17531: file: 92ca3797.
2317          We cannot rely upon the debug_information array being initialised
2318          before it is used.  A corrupt file could easily contain references
2319          to a unit for which information has not been made available.  So
2320          we ensure that the array is zeroed here.  */
2321       memset (debug_information, 0, num_units * sizeof (*debug_information));
2322
2323       alloc_num_debug_info_entries = num_units;
2324     }
2325
2326   if (!do_loc)
2327     {
2328       if (dwarf_start_die == 0)
2329         printf (_("Contents of the %s section:\n\n"), section->name);
2330
2331       load_debug_section (str, file);
2332       load_debug_section (str_dwo, file);
2333       load_debug_section (str_index, file);
2334       load_debug_section (str_index_dwo, file);
2335       load_debug_section (debug_addr, file);
2336     }
2337
2338   load_debug_section (abbrev_sec, file);
2339   if (debug_displays [abbrev_sec].section.start == NULL)
2340     {
2341       warn (_("Unable to locate %s section!\n"),
2342             debug_displays [abbrev_sec].section.name);
2343       return 0;
2344     }
2345
2346   for (section_begin = start, unit = 0; start < end; unit++)
2347     {
2348       DWARF2_Internal_CompUnit compunit;
2349       unsigned char *hdrptr;
2350       unsigned char *tags;
2351       int level, last_level, saved_level;
2352       dwarf_vma cu_offset;
2353       unsigned int offset_size;
2354       int initial_length_size;
2355       dwarf_vma signature_high = 0;
2356       dwarf_vma signature_low = 0;
2357       dwarf_vma type_offset = 0;
2358       struct cu_tu_set *this_set;
2359       dwarf_vma abbrev_base;
2360       size_t abbrev_size;
2361
2362       hdrptr = start;
2363
2364       SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
2365
2366       if (compunit.cu_length == 0xffffffff)
2367         {
2368           SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
2369           offset_size = 8;
2370           initial_length_size = 12;
2371         }
2372       else
2373         {
2374           offset_size = 4;
2375           initial_length_size = 4;
2376         }
2377
2378       SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
2379
2380       cu_offset = start - section_begin;
2381
2382       this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2383
2384       SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
2385
2386       if (this_set == NULL)
2387         {
2388           abbrev_base = 0;
2389           abbrev_size = debug_displays [abbrev_sec].section.size;
2390         }
2391       else
2392         {
2393           abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2394           abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2395         }
2396
2397       SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2398       /* PR 17512: file: 001-108546-0.001:0.1.  */
2399       if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2400         {
2401           warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2402                 compunit.cu_pointer_size, offset_size);
2403           compunit.cu_pointer_size = offset_size;
2404         }
2405
2406       if (do_types)
2407         {
2408           SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
2409           hdrptr += 8;
2410           SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2411         }
2412
2413       if ((do_loc || do_debug_loc || do_debug_ranges)
2414           && num_debug_info_entries == 0
2415           && ! do_types)
2416         {
2417           debug_information [unit].cu_offset = cu_offset;
2418           debug_information [unit].pointer_size
2419             = compunit.cu_pointer_size;
2420           debug_information [unit].offset_size = offset_size;
2421           debug_information [unit].dwarf_version = compunit.cu_version;
2422           debug_information [unit].base_address = 0;
2423           debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2424           debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
2425           debug_information [unit].loc_offsets = NULL;
2426           debug_information [unit].have_frame_base = NULL;
2427           debug_information [unit].max_loc_offsets = 0;
2428           debug_information [unit].num_loc_offsets = 0;
2429           debug_information [unit].range_lists = NULL;
2430           debug_information [unit].max_range_lists= 0;
2431           debug_information [unit].num_range_lists = 0;
2432         }
2433
2434       if (!do_loc && dwarf_start_die == 0)
2435         {
2436           printf (_("  Compilation Unit @ offset 0x%s:\n"),
2437                   dwarf_vmatoa ("x", cu_offset));
2438           printf (_("   Length:        0x%s (%s)\n"),
2439                   dwarf_vmatoa ("x", compunit.cu_length),
2440                   offset_size == 8 ? "64-bit" : "32-bit");
2441           printf (_("   Version:       %d\n"), compunit.cu_version);
2442           printf (_("   Abbrev Offset: 0x%s\n"),
2443                   dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
2444           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
2445           if (do_types)
2446             {
2447               char buf[64];
2448
2449               printf (_("   Signature:     0x%s\n"),
2450                       dwarf_vmatoa64 (signature_high, signature_low,
2451                                       buf, sizeof (buf)));
2452               printf (_("   Type Offset:   0x%s\n"),
2453                       dwarf_vmatoa ("x", type_offset));
2454             }
2455           if (this_set != NULL)
2456             {
2457               dwarf_vma *offsets = this_set->section_offsets;
2458               size_t *sizes = this_set->section_sizes;
2459
2460               printf (_("   Section contributions:\n"));
2461               printf (_("    .debug_abbrev.dwo:       0x%s  0x%s\n"),
2462                       dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2463                       dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2464               printf (_("    .debug_line.dwo:         0x%s  0x%s\n"),
2465                       dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2466                       dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2467               printf (_("    .debug_loc.dwo:          0x%s  0x%s\n"),
2468                       dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2469                       dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2470               printf (_("    .debug_str_offsets.dwo:  0x%s  0x%s\n"),
2471                       dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2472                       dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2473             }
2474         }
2475
2476       if (cu_offset + compunit.cu_length + initial_length_size
2477           > section->size)
2478         {
2479           warn (_("Debug info is corrupted, length of CU at %s"
2480                   " extends beyond end of section (length = %s)\n"),
2481                 dwarf_vmatoa ("x", cu_offset),
2482                 dwarf_vmatoa ("x", compunit.cu_length));
2483           num_units = unit;
2484           break;
2485         }
2486       tags = hdrptr;
2487       start += compunit.cu_length + initial_length_size;
2488
2489       if (start > end)
2490         {
2491           warn (_("Debug info is corrupt.  CU at %s extends beyond end of section"),
2492                 dwarf_vmatoa ("x", cu_offset));
2493           start = end;
2494         }
2495
2496       if (compunit.cu_version != 2
2497           && compunit.cu_version != 3
2498           && compunit.cu_version != 4)
2499         {
2500           warn (_("CU at offset %s contains corrupt or "
2501                   "unsupported version number: %d.\n"),
2502                 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2503           continue;
2504         }
2505
2506       free_abbrevs ();
2507
2508       /* Process the abbrevs used by this compilation unit.  */
2509       if (compunit.cu_abbrev_offset >= abbrev_size)
2510         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2511               (unsigned long) compunit.cu_abbrev_offset,
2512               (unsigned long) abbrev_size);
2513       /* PR 17531: file:4bcd9ce9.  */
2514       else if ((abbrev_base + abbrev_size)
2515                > debug_displays [abbrev_sec].section.size)
2516         warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2517               (unsigned long) abbrev_base + abbrev_size,
2518               (unsigned long) debug_displays [abbrev_sec].section.size);
2519       else
2520         process_abbrev_section
2521           (((unsigned char *) debug_displays [abbrev_sec].section.start
2522             + abbrev_base + compunit.cu_abbrev_offset),
2523            ((unsigned char *) debug_displays [abbrev_sec].section.start
2524             + abbrev_base + abbrev_size));
2525
2526       level = 0;
2527       last_level = level;
2528       saved_level = -1;
2529       while (tags < start)
2530         {
2531           unsigned int bytes_read;
2532           unsigned long abbrev_number;
2533           unsigned long die_offset;
2534           abbrev_entry *entry;
2535           abbrev_attr *attr;
2536           int do_printing = 1;
2537
2538           die_offset = tags - section_begin;
2539
2540           abbrev_number = read_uleb128 (tags, & bytes_read, start);
2541           tags += bytes_read;
2542
2543           /* A null DIE marks the end of a list of siblings or it may also be
2544              a section padding.  */
2545           if (abbrev_number == 0)
2546             {
2547               /* Check if it can be a section padding for the last CU.  */
2548               if (level == 0 && start == end)
2549                 {
2550                   unsigned char *chk;
2551
2552                   for (chk = tags; chk < start; chk++)
2553                     if (*chk != 0)
2554                       break;
2555                   if (chk == start)
2556                     break;
2557                 }
2558
2559               if (!do_loc && die_offset >= dwarf_start_die
2560                   && (dwarf_cutoff_level == -1
2561                       || level < dwarf_cutoff_level))
2562                 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2563                         level, die_offset);
2564
2565               --level;
2566               if (level < 0)
2567                 {
2568                   static unsigned num_bogus_warns = 0;
2569
2570                   if (num_bogus_warns < 3)
2571                     {
2572                       warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2573                             die_offset, section->name);
2574                       num_bogus_warns ++;
2575                       if (num_bogus_warns == 3)
2576                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2577                     }
2578                 }
2579               if (dwarf_start_die != 0 && level < saved_level)
2580                 return 1;
2581               continue;
2582             }
2583
2584           if (!do_loc)
2585             {
2586               if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2587                 do_printing = 0;
2588               else
2589                 {
2590                   if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2591                     saved_level = level;
2592                   do_printing = (dwarf_cutoff_level == -1
2593                                  || level < dwarf_cutoff_level);
2594                   if (do_printing)
2595                     printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2596                             level, die_offset, abbrev_number);
2597                   else if (dwarf_cutoff_level == -1
2598                            || last_level < dwarf_cutoff_level)
2599                     printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2600                   last_level = level;
2601                 }
2602             }
2603
2604           /* Scan through the abbreviation list until we reach the
2605              correct entry.  */
2606           for (entry = first_abbrev;
2607                entry && entry->entry != abbrev_number;
2608                entry = entry->next)
2609             continue;
2610
2611           if (entry == NULL)
2612             {
2613               if (!do_loc && do_printing)
2614                 {
2615                   printf ("\n");
2616                   fflush (stdout);
2617                 }
2618               warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2619                     die_offset, abbrev_number);
2620               return 0;
2621             }
2622
2623           if (!do_loc && do_printing)
2624             printf (" (%s)\n", get_TAG_name (entry->tag));
2625
2626           switch (entry->tag)
2627             {
2628             default:
2629               need_base_address = 0;
2630               break;
2631             case DW_TAG_compile_unit:
2632               need_base_address = 1;
2633               break;
2634             case DW_TAG_entry_point:
2635             case DW_TAG_subprogram:
2636               need_base_address = 0;
2637               /* Assuming that there is no DW_AT_frame_base.  */
2638               have_frame_base = 0;
2639               break;
2640             }
2641
2642           for (attr = entry->first_attr;
2643                attr && attr->attribute;
2644                attr = attr->next)
2645             {
2646               debug_info *arg;
2647
2648               if (! do_loc && do_printing)
2649                 /* Show the offset from where the tag was extracted.  */
2650                 printf ("    <%lx>", (unsigned long)(tags - section_begin));
2651
2652               if (debug_information && unit < alloc_num_debug_info_entries)
2653                 arg = debug_information + unit;
2654               else
2655                 arg = NULL;
2656
2657               tags = read_and_display_attr (attr->attribute,
2658                                             attr->form,
2659                                             tags,
2660                                             end,
2661                                             cu_offset,
2662                                             compunit.cu_pointer_size,
2663                                             offset_size,
2664                                             compunit.cu_version,
2665                                             arg,
2666                                             do_loc || ! do_printing,
2667                                             section,
2668                                             this_set);
2669             }
2670
2671           if (entry->children)
2672             ++level;
2673         }
2674     }
2675
2676   /* Set num_debug_info_entries here so that it can be used to check if
2677      we need to process .debug_loc and .debug_ranges sections.  */
2678   if ((do_loc || do_debug_loc || do_debug_ranges)
2679       && num_debug_info_entries == 0
2680       && ! do_types)
2681     {
2682       if (num_units > alloc_num_debug_info_entries)
2683         num_debug_info_entries = alloc_num_debug_info_entries;
2684       else
2685         num_debug_info_entries = num_units;
2686     }
2687
2688   if (!do_loc)
2689     printf ("\n");
2690
2691   return 1;
2692 }
2693
2694 /* Locate and scan the .debug_info section in the file and record the pointer
2695    sizes and offsets for the compilation units in it.  Usually an executable
2696    will have just one pointer size, but this is not guaranteed, and so we try
2697    not to make any assumptions.  Returns zero upon failure, or the number of
2698    compilation units upon success.  */
2699
2700 static unsigned int
2701 load_debug_info (void * file)
2702 {
2703   /* Reset the last pointer size so that we can issue correct error
2704      messages if we are displaying the contents of more than one section.  */
2705   last_pointer_size = 0;
2706   warned_about_missing_comp_units = FALSE;
2707
2708   /* If we have already tried and failed to load the .debug_info
2709      section then do not bother to repeat the task.  */
2710   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2711     return 0;
2712
2713   /* If we already have the information there is nothing else to do.  */
2714   if (num_debug_info_entries > 0)
2715     return num_debug_info_entries;
2716
2717   /* If this is a DWARF package file, load the CU and TU indexes.  */
2718   load_cu_tu_indexes (file);
2719
2720   if (load_debug_section (info, file)
2721       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2722     return num_debug_info_entries;
2723
2724   if (load_debug_section (info_dwo, file)
2725       && process_debug_info (&debug_displays [info_dwo].section, file,
2726                              abbrev_dwo, 1, 0))
2727     return num_debug_info_entries;
2728
2729   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2730   return 0;
2731 }
2732
2733 /* Read a DWARF .debug_line section header starting at DATA.
2734    Upon success returns an updated DATA pointer and the LINFO
2735    structure and the END_OF_SEQUENCE pointer will be filled in.
2736    Otherwise returns NULL.  */
2737
2738 static unsigned char *
2739 read_debug_line_header (struct dwarf_section * section,
2740                         unsigned char * data,
2741                         unsigned char * end,
2742                         DWARF2_Internal_LineInfo * linfo,
2743                         unsigned char ** end_of_sequence)
2744 {
2745   unsigned char *hdrptr;
2746   unsigned int offset_size;
2747   unsigned int initial_length_size;
2748
2749   /* Extract information from the Line Number Program Header.
2750      (section 6.2.4 in the Dwarf3 doc).  */
2751   hdrptr = data;
2752
2753   /* Get and check the length of the block.  */
2754   SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2755
2756   if (linfo->li_length == 0xffffffff)
2757     {
2758       /* This section is 64-bit DWARF 3.  */
2759       SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2760       offset_size = 8;
2761       initial_length_size = 12;
2762     }
2763   else
2764     {
2765       offset_size = 4;
2766       initial_length_size = 4;
2767     }
2768
2769   if (linfo->li_length + initial_length_size > section->size)
2770     {
2771       /* If the length field has a relocation against it, then we should
2772          not complain if it is inaccurate (and probably negative).  This
2773          happens in object files when the .debug_line section is actually
2774          comprised of several different .debug_line.* sections, (some of
2775          which may be removed by linker garbage collection), and a relocation
2776          is used to compute the correct length once that is done.  */
2777       if (reloc_at (section, (hdrptr - section->start) - offset_size))
2778         {
2779           linfo->li_length = (end - data) - initial_length_size;
2780         }
2781       else
2782         {
2783           warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
2784                 (long) linfo->li_length);
2785           return NULL;
2786         }
2787     }
2788
2789   /* Get and check the version number.  */
2790   SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2791
2792   if (linfo->li_version != 2
2793       && linfo->li_version != 3
2794       && linfo->li_version != 4)
2795     {
2796       warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2797       return NULL;
2798     }
2799
2800   SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2801   SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2802
2803   if (linfo->li_version >= 4)
2804     {
2805       SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2806
2807       if (linfo->li_max_ops_per_insn == 0)
2808         {
2809           warn (_("Invalid maximum operations per insn.\n"));
2810           return NULL;
2811         }
2812     }
2813   else
2814     linfo->li_max_ops_per_insn = 1;
2815
2816   SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2817   SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2818   SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2819   SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2820
2821   * end_of_sequence = data + linfo->li_length + initial_length_size;
2822   /* PR 17512: file:002-117414-0.004.  */
2823   if (* end_of_sequence > end)
2824     {
2825       warn (_("Line length %s extends beyond end of section\n"),
2826             dwarf_vmatoa ("u", linfo->li_length));
2827       * end_of_sequence = end;
2828       return NULL;
2829     }
2830
2831   return hdrptr;
2832 }
2833
2834 static int
2835 display_debug_lines_raw (struct dwarf_section *section,
2836                          unsigned char *data,
2837                          unsigned char *end)
2838 {
2839   unsigned char *start = section->start;
2840
2841   printf (_("Raw dump of debug contents of section %s:\n\n"),
2842           section->name);
2843
2844   while (data < end)
2845     {
2846       static DWARF2_Internal_LineInfo saved_linfo;
2847       DWARF2_Internal_LineInfo linfo;
2848       unsigned char *standard_opcodes;
2849       unsigned char *end_of_sequence;
2850       unsigned int last_dir_entry = 0;
2851       int i;
2852
2853       if (const_strneq (section->name, ".debug_line.")
2854           /* Note: the following does not apply to .debug_line.dwo sections.
2855              These are full debug_line sections.  */
2856           && strcmp (section->name, ".debug_line.dwo") != 0)
2857         {
2858           /* Sections named .debug_line.<foo> are fragments of a .debug_line
2859              section containing just the Line Number Statements.  They are
2860              created by the assembler and intended to be used alongside gcc's
2861              -ffunction-sections command line option.  When the linker's
2862              garbage collection decides to discard a .text.<foo> section it
2863              can then also discard the line number information in .debug_line.<foo>.
2864
2865              Since the section is a fragment it does not have the details
2866              needed to fill out a LineInfo structure, so instead we use the
2867              details from the last full debug_line section that we processed.  */
2868           end_of_sequence = end;
2869           standard_opcodes = NULL;
2870           linfo = saved_linfo;
2871           /* PR 17531: file: 0522b371.  */
2872           if (linfo.li_line_range == 0)
2873             {
2874               warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2875               return 0;
2876             }
2877           reset_state_machine (linfo.li_default_is_stmt);
2878         }
2879       else
2880         {
2881           unsigned char * hdrptr;
2882
2883           if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2884                                                 & end_of_sequence)) == NULL)
2885             return 0;
2886
2887           printf (_("  Offset:                      0x%lx\n"), (long)(data - start));
2888           printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
2889           printf (_("  DWARF Version:               %d\n"), linfo.li_version);
2890           printf (_("  Prologue Length:             %d\n"), (int) linfo.li_prologue_length);
2891           printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
2892           if (linfo.li_version >= 4)
2893             printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2894           printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
2895           printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
2896           printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
2897           printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
2898
2899           /* PR 17512: file: 1665-6428-0.004.  */
2900           if (linfo.li_line_range == 0)
2901             {
2902               warn (_("Line range of 0 is invalid, using 1 instead\n"));
2903               linfo.li_line_range = 1;
2904             }
2905
2906           reset_state_machine (linfo.li_default_is_stmt);
2907
2908           /* Display the contents of the Opcodes table.  */
2909           standard_opcodes = hdrptr;
2910
2911           /* PR 17512: file: 002-417945-0.004.  */
2912           if (standard_opcodes + linfo.li_opcode_base >= end)
2913             {
2914               warn (_("Line Base extends beyond end of section\n"));
2915               return 0;
2916             }
2917
2918           printf (_("\n Opcodes:\n"));
2919
2920           for (i = 1; i < linfo.li_opcode_base; i++)
2921             printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2922
2923           /* Display the contents of the Directory table.  */
2924           data = standard_opcodes + linfo.li_opcode_base - 1;
2925
2926           if (*data == 0)
2927             printf (_("\n The Directory Table is empty.\n"));
2928           else
2929             {
2930               printf (_("\n The Directory Table (offset 0x%lx):\n"),
2931                       (long)(data - start));
2932
2933               while (data < end && *data != 0)
2934                 {
2935                   printf ("  %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
2936
2937                   data += strnlen ((char *) data, end - data) + 1;
2938                 }
2939
2940               /* PR 17512: file: 002-132094-0.004.  */
2941               if (data >= end - 1)
2942                 break;
2943             }
2944
2945           /* Skip the NUL at the end of the table.  */
2946           data++;
2947
2948           /* Display the contents of the File Name table.  */
2949           if (*data == 0)
2950             printf (_("\n The File Name Table is empty.\n"));
2951           else
2952             {
2953               printf (_("\n The File Name Table (offset 0x%lx):\n"),
2954                       (long)(data - start));
2955               printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2956
2957               while (data < end && *data != 0)
2958                 {
2959                   unsigned char *name;
2960                   unsigned int bytes_read;
2961
2962                   printf ("  %d\t", ++state_machine_regs.last_file_entry);
2963                   name = data;
2964                   data += strnlen ((char *) data, end - data) + 1;
2965
2966                   printf ("%s\t",
2967                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2968                   data += bytes_read;
2969                   printf ("%s\t",
2970                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2971                   data += bytes_read;
2972                   printf ("%s\t",
2973                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2974                   data += bytes_read;
2975                   printf ("%.*s\n", (int)(end - name), name);
2976
2977                   if (data == end)
2978                     {
2979                       warn (_("Corrupt file name table entry\n"));
2980                       break;
2981                     }
2982                 }
2983             }
2984
2985           /* Skip the NUL at the end of the table.  */
2986           data++;
2987           putchar ('\n');
2988           saved_linfo = linfo;
2989         }
2990
2991       /* Now display the statements.  */
2992       if (data >= end_of_sequence)
2993         printf (_(" No Line Number Statements.\n"));
2994       else
2995         {
2996           printf (_(" Line Number Statements:\n"));
2997
2998           while (data < end_of_sequence)
2999             {
3000               unsigned char op_code;
3001               dwarf_signed_vma adv;
3002               dwarf_vma uladv;
3003               unsigned int bytes_read;
3004
3005               printf ("  [0x%08lx]", (long)(data - start));
3006
3007               op_code = *data++;
3008
3009               if (op_code >= linfo.li_opcode_base)
3010                 {
3011                   op_code -= linfo.li_opcode_base;
3012                   uladv = (op_code / linfo.li_line_range);
3013                   if (linfo.li_max_ops_per_insn == 1)
3014                     {
3015                       uladv *= linfo.li_min_insn_length;
3016                       state_machine_regs.address += uladv;
3017                       printf (_("  Special opcode %d: "
3018                                 "advance Address by %s to 0x%s"),
3019                               op_code, dwarf_vmatoa ("u", uladv),
3020                               dwarf_vmatoa ("x", state_machine_regs.address));
3021                     }
3022                   else
3023                     {
3024                       state_machine_regs.address
3025                         += ((state_machine_regs.op_index + uladv)
3026                             / linfo.li_max_ops_per_insn)
3027                         * linfo.li_min_insn_length;
3028                       state_machine_regs.op_index
3029                         = (state_machine_regs.op_index + uladv)
3030                         % linfo.li_max_ops_per_insn;
3031                       printf (_("  Special opcode %d: "
3032                                 "advance Address by %s to 0x%s[%d]"),
3033                               op_code, dwarf_vmatoa ("u", uladv),
3034                               dwarf_vmatoa ("x", state_machine_regs.address),
3035                               state_machine_regs.op_index);
3036                     }
3037                   adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3038                   state_machine_regs.line += adv;
3039                   printf (_(" and Line by %s to %d\n"),
3040                           dwarf_vmatoa ("d", adv), state_machine_regs.line);
3041                 }
3042               else switch (op_code)
3043                      {
3044                      case DW_LNS_extended_op:
3045                        data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3046                        break;
3047
3048                      case DW_LNS_copy:
3049                        printf (_("  Copy\n"));
3050                        break;
3051
3052                      case DW_LNS_advance_pc:
3053                        uladv = read_uleb128 (data, & bytes_read, end);
3054                        data += bytes_read;
3055                        if (linfo.li_max_ops_per_insn == 1)
3056                          {
3057                            uladv *= linfo.li_min_insn_length;
3058                            state_machine_regs.address += uladv;
3059                            printf (_("  Advance PC by %s to 0x%s\n"),
3060                                    dwarf_vmatoa ("u", uladv),
3061                                    dwarf_vmatoa ("x", state_machine_regs.address));
3062                          }
3063                        else
3064                          {
3065                            state_machine_regs.address
3066                              += ((state_machine_regs.op_index + uladv)
3067                                  / linfo.li_max_ops_per_insn)
3068                              * linfo.li_min_insn_length;
3069                            state_machine_regs.op_index
3070                              = (state_machine_regs.op_index + uladv)
3071                              % linfo.li_max_ops_per_insn;
3072                            printf (_("  Advance PC by %s to 0x%s[%d]\n"),
3073                                    dwarf_vmatoa ("u", uladv),
3074                                    dwarf_vmatoa ("x", state_machine_regs.address),
3075                                    state_machine_regs.op_index);
3076                          }
3077                        break;
3078
3079                      case DW_LNS_advance_line:
3080                        adv = read_sleb128 (data, & bytes_read, end);
3081                        data += bytes_read;
3082                        state_machine_regs.line += adv;
3083                        printf (_("  Advance Line by %s to %d\n"),
3084                                dwarf_vmatoa ("d", adv),
3085                                state_machine_regs.line);
3086                        break;
3087
3088                      case DW_LNS_set_file:
3089                        adv = read_uleb128 (data, & bytes_read, end);
3090                        data += bytes_read;
3091                        printf (_("  Set File Name to entry %s in the File Name Table\n"),
3092                                dwarf_vmatoa ("d", adv));
3093                        state_machine_regs.file = adv;
3094                        break;
3095
3096                      case DW_LNS_set_column:
3097                        uladv = read_uleb128 (data, & bytes_read, end);
3098                        data += bytes_read;
3099                        printf (_("  Set column to %s\n"),
3100                                dwarf_vmatoa ("u", uladv));
3101                        state_machine_regs.column = uladv;
3102                        break;
3103
3104                      case DW_LNS_negate_stmt:
3105                        adv = state_machine_regs.is_stmt;
3106                        adv = ! adv;
3107                        printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3108                        state_machine_regs.is_stmt = adv;
3109                        break;
3110
3111                      case DW_LNS_set_basic_block:
3112                        printf (_("  Set basic block\n"));
3113                        state_machine_regs.basic_block = 1;
3114                        break;
3115
3116                      case DW_LNS_const_add_pc:
3117                        uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3118                        if (linfo.li_max_ops_per_insn)
3119                          {
3120                            uladv *= linfo.li_min_insn_length;
3121                            state_machine_regs.address += uladv;
3122                            printf (_("  Advance PC by constant %s to 0x%s\n"),
3123                                    dwarf_vmatoa ("u", uladv),
3124                                    dwarf_vmatoa ("x", state_machine_regs.address));
3125                          }
3126                        else
3127                          {
3128                            state_machine_regs.address
3129                              += ((state_machine_regs.op_index + uladv)
3130                                  / linfo.li_max_ops_per_insn)
3131                              * linfo.li_min_insn_length;
3132                            state_machine_regs.op_index
3133                              = (state_machine_regs.op_index + uladv)
3134                              % linfo.li_max_ops_per_insn;
3135                            printf (_("  Advance PC by constant %s to 0x%s[%d]\n"),
3136                                    dwarf_vmatoa ("u", uladv),
3137                                    dwarf_vmatoa ("x", state_machine_regs.address),
3138                                    state_machine_regs.op_index);
3139                          }
3140                        break;
3141
3142                      case DW_LNS_fixed_advance_pc:
3143                        SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3144                        state_machine_regs.address += uladv;
3145                        state_machine_regs.op_index = 0;
3146                        printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
3147                                dwarf_vmatoa ("u", uladv),
3148                                dwarf_vmatoa ("x", state_machine_regs.address));
3149                        break;
3150
3151                      case DW_LNS_set_prologue_end:
3152                        printf (_("  Set prologue_end to true\n"));
3153                        break;
3154
3155                      case DW_LNS_set_epilogue_begin:
3156                        printf (_("  Set epilogue_begin to true\n"));
3157                        break;
3158
3159                      case DW_LNS_set_isa:
3160                        uladv = read_uleb128 (data, & bytes_read, end);
3161                        data += bytes_read;
3162                        printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3163                        break;
3164
3165                      default:
3166                        printf (_("  Unknown opcode %d with operands: "), op_code);
3167
3168                        if (standard_opcodes != NULL)
3169                          for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3170                            {
3171                              printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3172                                                                                 &bytes_read, end)),
3173                                      i == 1 ? "" : ", ");
3174                              data += bytes_read;
3175                            }
3176                        putchar ('\n');
3177                        break;
3178                      }
3179             }
3180           putchar ('\n');
3181         }
3182     }
3183
3184   return 1;
3185 }
3186
3187 typedef struct
3188 {
3189   unsigned char *name;
3190   unsigned int directory_index;
3191   unsigned int modification_date;
3192   unsigned int length;
3193 } File_Entry;
3194
3195 /* Output a decoded representation of the .debug_line section.  */
3196
3197 static int
3198 display_debug_lines_decoded (struct dwarf_section *section,
3199                              unsigned char *data,
3200                              unsigned char *end)
3201 {
3202   static DWARF2_Internal_LineInfo saved_linfo;
3203
3204   printf (_("Decoded dump of debug contents of section %s:\n\n"),
3205           section->name);
3206
3207   while (data < end)
3208     {
3209       /* This loop amounts to one iteration per compilation unit.  */
3210       DWARF2_Internal_LineInfo linfo;
3211       unsigned char *standard_opcodes;
3212       unsigned char *end_of_sequence;
3213       int i;
3214       File_Entry *file_table = NULL;
3215       unsigned int n_files = 0;
3216       unsigned char **directory_table = NULL;
3217       unsigned int n_directories = 0;
3218
3219       if (const_strneq (section->name, ".debug_line.")
3220           /* Note: the following does not apply to .debug_line.dwo sections.
3221              These are full debug_line sections.  */
3222           && strcmp (section->name, ".debug_line.dwo") != 0)
3223         {
3224           /* See comment in display_debug_lines_raw().  */
3225           end_of_sequence = end;
3226           standard_opcodes = NULL;
3227           linfo = saved_linfo;
3228           /* PR 17531: file: 0522b371.  */
3229           if (linfo.li_line_range == 0)
3230             {
3231               warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3232               return 0;
3233             }
3234           reset_state_machine (linfo.li_default_is_stmt);
3235         }
3236       else
3237         {
3238           unsigned char *hdrptr;
3239
3240           if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3241                                                 & end_of_sequence)) == NULL)
3242               return 0;
3243
3244           /* PR 17531: file: 0522b371.  */
3245           if (linfo.li_line_range == 0)
3246             {
3247               warn (_("Line range of 0 is invalid, using 1 instead\n"));
3248               linfo.li_line_range = 1;
3249             }
3250           reset_state_machine (linfo.li_default_is_stmt);
3251
3252           /* Save a pointer to the contents of the Opcodes table.  */
3253           standard_opcodes = hdrptr;
3254
3255           /* Traverse the Directory table just to count entries.  */
3256           data = standard_opcodes + linfo.li_opcode_base - 1;
3257           /* PR 20440 */
3258           if (data >= end)
3259             {
3260               warn (_("opcode base of %d extends beyond end of section\n"),
3261                     linfo.li_opcode_base);
3262               return 0;
3263             }
3264
3265           if (*data != 0)
3266             {
3267               unsigned char *ptr_directory_table = data;
3268
3269               while (data < end && *data != 0)
3270                 {
3271                   data += strnlen ((char *) data, end - data) + 1;
3272                   n_directories++;
3273                 }
3274
3275               /* PR 20440 */
3276               if (data >= end)
3277                 {
3278                   warn (_("directory table ends unexpectedly\n"));
3279                   n_directories = 0;
3280                   break;
3281                 }
3282
3283               /* Go through the directory table again to save the directories.  */
3284               directory_table = (unsigned char **)
3285                 xmalloc (n_directories * sizeof (unsigned char *));
3286
3287               i = 0;
3288               while (*ptr_directory_table != 0)
3289                 {
3290                   directory_table[i] = ptr_directory_table;
3291                   ptr_directory_table += strnlen ((char *) ptr_directory_table,
3292                                                   ptr_directory_table - end) + 1;
3293                   i++;
3294                 }
3295             }
3296           /* Skip the NUL at the end of the table.  */
3297           data++;
3298
3299           /* Traverse the File Name table just to count the entries.  */
3300           if (data < end && *data != 0)
3301             {
3302               unsigned char *ptr_file_name_table = data;
3303
3304               while (data < end && *data != 0)
3305                 {
3306                   unsigned int bytes_read;
3307
3308                   /* Skip Name, directory index, last modification time and length
3309                      of file.  */
3310                   data += strnlen ((char *) data, end - data) + 1;
3311                   read_uleb128 (data, & bytes_read, end);
3312                   data += bytes_read;
3313                   read_uleb128 (data, & bytes_read, end);
3314                   data += bytes_read;
3315                   read_uleb128 (data, & bytes_read, end);
3316                   data += bytes_read;
3317
3318                   n_files++;
3319                 }
3320
3321               if (data >= end)
3322                 {
3323                   warn (_("file table ends unexpectedly\n"));
3324                   n_files = 0;
3325                   break;
3326                 }
3327
3328               /* Go through the file table again to save the strings.  */
3329               file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3330
3331               i = 0;
3332               while (*ptr_file_name_table != 0)
3333                 {
3334                   unsigned int bytes_read;
3335
3336                   file_table[i].name = ptr_file_name_table;
3337                   ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3338                                                   end - ptr_file_name_table) + 1;
3339
3340                   /* We are not interested in directory, time or size.  */
3341                   file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3342                                                                 & bytes_read, end);
3343                   ptr_file_name_table += bytes_read;
3344                   file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3345                                                                   & bytes_read, end);
3346                   ptr_file_name_table += bytes_read;
3347                   file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3348                   ptr_file_name_table += bytes_read;
3349                   i++;
3350                 }
3351               i = 0;
3352
3353               /* Print the Compilation Unit's name and a header.  */
3354               if (directory_table == NULL)
3355                 {
3356                   printf (_("CU: %s:\n"), file_table[0].name);
3357                   printf (_("File name                            Line number    Starting address\n"));
3358                 }
3359               else
3360                 {
3361                   unsigned int ix = file_table[0].directory_index;
3362                   const char *directory;
3363
3364                   if (ix == 0)
3365                     directory = ".";
3366                   /* PR 20439 */
3367                   else if (n_directories == 0)
3368                     directory = _("<unknown>");
3369                   else if (ix > n_directories)
3370                     {
3371                       warn (_("directory index %u > number of directories %u\n"), ix, n_directories);
3372                       directory = _("<corrupt>");
3373                     }
3374                   else
3375                     directory = (char *) directory_table[ix - 1];
3376
3377                   if (do_wide || strlen (directory) < 76)
3378                     printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3379                   else
3380                     printf ("%s:\n", file_table[0].name);
3381
3382                   printf (_("File name                            Line number    Starting address\n"));
3383                 }
3384             }
3385
3386           /* Skip the NUL at the end of the table.  */
3387           data++;
3388
3389           saved_linfo = linfo;
3390         }
3391
3392       /* This loop iterates through the Dwarf Line Number Program.  */
3393       while (data < end_of_sequence)
3394         {
3395           unsigned char op_code;
3396           int adv;
3397           unsigned long int uladv;
3398           unsigned int bytes_read;
3399           int is_special_opcode = 0;
3400
3401           op_code = *data++;
3402
3403           if (op_code >= linfo.li_opcode_base)
3404             {
3405               op_code -= linfo.li_opcode_base;
3406               uladv = (op_code / linfo.li_line_range);
3407               if (linfo.li_max_ops_per_insn == 1)
3408                 {
3409                   uladv *= linfo.li_min_insn_length;
3410                   state_machine_regs.address += uladv;
3411                 }
3412               else
3413                 {
3414                   state_machine_regs.address
3415                     += ((state_machine_regs.op_index + uladv)
3416                         / linfo.li_max_ops_per_insn)
3417                     * linfo.li_min_insn_length;
3418                   state_machine_regs.op_index
3419                     = (state_machine_regs.op_index + uladv)
3420                     % linfo.li_max_ops_per_insn;
3421                 }
3422
3423               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3424               state_machine_regs.line += adv;
3425               is_special_opcode = 1;
3426             }
3427           else switch (op_code)
3428                  {
3429                  case DW_LNS_extended_op:
3430                    {
3431                      unsigned int ext_op_code_len;
3432                      unsigned char ext_op_code;
3433                      unsigned char *op_code_data = data;
3434
3435                      ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3436                                                      end_of_sequence);
3437                      op_code_data += bytes_read;
3438
3439                      if (ext_op_code_len == 0)
3440                        {
3441                          warn (_("Badly formed extended line op encountered!\n"));
3442                          break;
3443                        }
3444                      ext_op_code_len += bytes_read;
3445                      ext_op_code = *op_code_data++;
3446
3447                      switch (ext_op_code)
3448                        {
3449                        case DW_LNE_end_sequence:
3450                          reset_state_machine (linfo.li_default_is_stmt);
3451                          break;
3452                        case DW_LNE_set_address:
3453                          SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3454                                                 op_code_data,
3455                                                 ext_op_code_len - bytes_read - 1,
3456                                                 end);
3457                          state_machine_regs.op_index = 0;
3458                          break;
3459                        case DW_LNE_define_file:
3460                          {
3461                            file_table = (File_Entry *) xrealloc
3462                              (file_table, (n_files + 1) * sizeof (File_Entry));
3463
3464                            ++state_machine_regs.last_file_entry;
3465                            /* Source file name.  */
3466                            file_table[n_files].name = op_code_data;
3467                            op_code_data += strlen ((char *) op_code_data) + 1;
3468                            /* Directory index.  */
3469                            file_table[n_files].directory_index =
3470                              read_uleb128 (op_code_data, & bytes_read,
3471                                            end_of_sequence);
3472                            op_code_data += bytes_read;
3473                            /* Last modification time.  */
3474                            file_table[n_files].modification_date =
3475                              read_uleb128 (op_code_data, & bytes_read,
3476                                            end_of_sequence);
3477                            op_code_data += bytes_read;
3478                            /* File length.  */
3479                            file_table[n_files].length =
3480                              read_uleb128 (op_code_data, & bytes_read,
3481                                            end_of_sequence);
3482
3483                            n_files++;
3484                            break;
3485                          }
3486                        case DW_LNE_set_discriminator:
3487                        case DW_LNE_HP_set_sequence:
3488                          /* Simply ignored.  */
3489                          break;
3490
3491                        default:
3492                          printf (_("UNKNOWN (%u): length %d\n"),
3493                                  ext_op_code, ext_op_code_len - bytes_read);
3494                          break;
3495                        }
3496                      data += ext_op_code_len;
3497                      break;
3498                    }
3499                  case DW_LNS_copy:
3500                    break;
3501
3502                  case DW_LNS_advance_pc:
3503                    uladv = read_uleb128 (data, & bytes_read, end);
3504                    data += bytes_read;
3505                    if (linfo.li_max_ops_per_insn == 1)
3506                      {
3507                        uladv *= linfo.li_min_insn_length;
3508                        state_machine_regs.address += uladv;
3509                      }
3510                    else
3511                      {
3512                        state_machine_regs.address
3513                          += ((state_machine_regs.op_index + uladv)
3514                              / linfo.li_max_ops_per_insn)
3515                          * linfo.li_min_insn_length;
3516                        state_machine_regs.op_index
3517                          = (state_machine_regs.op_index + uladv)
3518                          % linfo.li_max_ops_per_insn;
3519                      }
3520                    break;
3521
3522                  case DW_LNS_advance_line:
3523                    adv = read_sleb128 (data, & bytes_read, end);
3524                    data += bytes_read;
3525                    state_machine_regs.line += adv;
3526                    break;
3527
3528                  case DW_LNS_set_file:
3529                    adv = read_uleb128 (data, & bytes_read, end);
3530                    data += bytes_read;
3531                    state_machine_regs.file = adv;
3532
3533                    {
3534                      unsigned file = state_machine_regs.file - 1;
3535                      unsigned dir;
3536
3537                      if (file_table == NULL || n_files == 0)
3538                        printf (_("\n [Use file table entry %d]\n"), file);
3539                      /* PR 20439 */
3540                      else if (file >= n_files)
3541                        {
3542                          warn (_("file index %u > number of files %u\n"), file + 1, n_files);
3543                          printf (_("\n <over large file table index %u>"), file);
3544                        }
3545                      else if ((dir = file_table[file].directory_index) == 0)
3546                        /* If directory index is 0, that means current directory.  */
3547                        printf ("\n./%s:[++]\n", file_table[file].name);
3548                      else if (directory_table == NULL || n_directories == 0)
3549                        printf (_("\n [Use file %s in directory table entry %d]\n"),
3550                                file_table[file].name, dir);
3551                      /* PR 20439 */
3552                      else if (dir > n_directories)
3553                        {
3554                          warn (_("directory index %u > number of directories %u\n"), dir, n_directories);
3555                          printf (_("\n <over large directory table entry %u>\n"), dir);
3556                        }
3557                      else
3558                        printf ("\n%s/%s:\n",
3559                                /* The directory index starts counting at 1.  */
3560                                directory_table[dir - 1], file_table[file].name);
3561                    }
3562                    break;
3563
3564                  case DW_LNS_set_column:
3565                    uladv = read_uleb128 (data, & bytes_read, end);
3566                    data += bytes_read;
3567                    state_machine_regs.column = uladv;
3568                    break;
3569
3570                  case DW_LNS_negate_stmt:
3571                    adv = state_machine_regs.is_stmt;
3572                    adv = ! adv;
3573                    state_machine_regs.is_stmt = adv;
3574                    break;
3575
3576                  case DW_LNS_set_basic_block:
3577                    state_machine_regs.basic_block = 1;
3578                    break;
3579
3580                  case DW_LNS_const_add_pc:
3581                    uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3582                    if (linfo.li_max_ops_per_insn == 1)
3583                      {
3584                        uladv *= linfo.li_min_insn_length;
3585                        state_machine_regs.address += uladv;
3586                      }
3587                    else
3588                      {
3589                        state_machine_regs.address
3590                          += ((state_machine_regs.op_index + uladv)
3591                              / linfo.li_max_ops_per_insn)
3592                          * linfo.li_min_insn_length;
3593                        state_machine_regs.op_index
3594                          = (state_machine_regs.op_index + uladv)
3595                          % linfo.li_max_ops_per_insn;
3596                      }
3597                    break;
3598
3599                  case DW_LNS_fixed_advance_pc:
3600                    SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3601                    state_machine_regs.address += uladv;
3602                    state_machine_regs.op_index = 0;
3603                    break;
3604
3605                  case DW_LNS_set_prologue_end:
3606                    break;
3607
3608                  case DW_LNS_set_epilogue_begin:
3609                    break;
3610
3611                  case DW_LNS_set_isa:
3612                    uladv = read_uleb128 (data, & bytes_read, end);
3613                    data += bytes_read;
3614                    printf (_("  Set ISA to %lu\n"), uladv);
3615                    break;
3616
3617                  default:
3618                    printf (_("  Unknown opcode %d with operands: "), op_code);
3619
3620                    if (standard_opcodes != NULL)
3621                      for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3622                        {
3623                          printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3624                                                                             &bytes_read, end)),
3625                                  i == 1 ? "" : ", ");
3626                          data += bytes_read;
3627                        }
3628                    putchar ('\n');
3629                    break;
3630                  }
3631
3632           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3633              to the DWARF address/line matrix.  */
3634           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3635               || (op_code == DW_LNS_copy))
3636             {
3637               const unsigned int MAX_FILENAME_LENGTH = 35;
3638               char *fileName;
3639               char *newFileName = NULL;
3640               size_t fileNameLength;
3641
3642               if (file_table)
3643                 {
3644                   unsigned indx = state_machine_regs.file - 1;
3645                   /* PR 20439  */
3646                   if (indx >= n_files)
3647                     {
3648                       warn (_("corrupt file index %u encountered\n"), indx);
3649                       fileName = _("<corrupt>");
3650                     }
3651                   else
3652                     fileName = (char *) file_table[indx].name;
3653                 }
3654               else
3655                 fileName = _("<unknown>");
3656
3657               fileNameLength = strlen (fileName);
3658
3659               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3660                 {
3661                   newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3662                   /* Truncate file name */
3663                   strncpy (newFileName,
3664                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
3665                            MAX_FILENAME_LENGTH + 1);
3666                 }
3667               else
3668                 {
3669                   newFileName = (char *) xmalloc (fileNameLength + 1);
3670                   strncpy (newFileName, fileName, fileNameLength + 1);
3671                 }
3672
3673               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3674                 {
3675                   if (linfo.li_max_ops_per_insn == 1)
3676                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
3677                             newFileName, state_machine_regs.line,
3678                             state_machine_regs.address);
3679                   else
3680                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3681                             newFileName, state_machine_regs.line,
3682                             state_machine_regs.address,
3683                             state_machine_regs.op_index);
3684                 }
3685               else
3686                 {
3687                   if (linfo.li_max_ops_per_insn == 1)
3688                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
3689                             newFileName, state_machine_regs.line,
3690                             state_machine_regs.address);
3691                   else
3692                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3693                             newFileName, state_machine_regs.line,
3694                             state_machine_regs.address,
3695                             state_machine_regs.op_index);
3696                 }
3697
3698               if (op_code == DW_LNE_end_sequence)
3699                 printf ("\n");
3700
3701               free (newFileName);
3702             }
3703         }
3704
3705       if (file_table)
3706         {
3707           free (file_table);
3708           file_table = NULL;
3709           n_files = 0;
3710         }
3711
3712       if (directory_table)
3713         {
3714           free (directory_table);
3715           directory_table = NULL;
3716           n_directories = 0;
3717         }
3718
3719       putchar ('\n');
3720     }
3721
3722   return 1;
3723 }
3724
3725 static int
3726 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3727 {
3728   unsigned char *data = section->start;
3729   unsigned char *end = data + section->size;
3730   int retValRaw = 1;
3731   int retValDecoded = 1;
3732
3733   if (do_debug_lines == 0)
3734     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3735
3736   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3737     retValRaw = display_debug_lines_raw (section, data, end);
3738
3739   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3740     retValDecoded = display_debug_lines_decoded (section, data, end);
3741
3742   if (!retValRaw || !retValDecoded)
3743     return 0;
3744
3745   return 1;
3746 }
3747
3748 static debug_info *
3749 find_debug_info_for_offset (unsigned long offset)
3750 {
3751   unsigned int i;
3752
3753   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3754     return NULL;
3755
3756   for (i = 0; i < num_debug_info_entries; i++)
3757     if (debug_information[i].cu_offset == offset)
3758       return debug_information + i;
3759
3760   return NULL;
3761 }
3762
3763 static const char *
3764 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3765 {
3766   /* See gdb/gdb-index.h.  */
3767   static const char * const kinds[] =
3768   {
3769     N_ ("no info"),
3770     N_ ("type"),
3771     N_ ("variable"),
3772     N_ ("function"),
3773     N_ ("other"),
3774     N_ ("unused5"),
3775     N_ ("unused6"),
3776     N_ ("unused7")
3777   };
3778
3779   return _ (kinds[kind]);
3780 }
3781
3782 static int
3783 display_debug_pubnames_worker (struct dwarf_section *section,
3784                                void *file ATTRIBUTE_UNUSED,
3785                                int is_gnu)
3786 {
3787   DWARF2_Internal_PubNames names;
3788   unsigned char *start = section->start;
3789   unsigned char *end = start + section->size;
3790
3791   /* It does not matter if this load fails,
3792      we test for that later on.  */
3793   load_debug_info (file);
3794
3795   printf (_("Contents of the %s section:\n\n"), section->name);
3796
3797   while (start < end)
3798     {
3799       unsigned char *data;
3800       unsigned char *adr;
3801       dwarf_vma offset;
3802       unsigned int offset_size, initial_length_size;
3803
3804       data = start;
3805
3806       SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
3807       if (names.pn_length == 0xffffffff)
3808         {
3809           SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
3810           offset_size = 8;
3811           initial_length_size = 12;
3812         }
3813       else
3814         {
3815           offset_size = 4;
3816           initial_length_size = 4;
3817         }
3818
3819       SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3820       SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
3821
3822       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3823           && num_debug_info_entries > 0
3824           && find_debug_info_for_offset (names.pn_offset) == NULL)
3825         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3826               (unsigned long) names.pn_offset, section->name);
3827
3828       SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
3829
3830       adr = start + names.pn_length + initial_length_size;
3831       /* PR 17531: file: 7615b6b2.  */
3832       if ((dwarf_signed_vma) names.pn_length < 0
3833           /* PR 17531: file: a5dbeaa7. */
3834           || adr < start)
3835         {
3836           warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
3837           start = end;
3838         }
3839       else
3840         start = adr;
3841
3842       printf (_("  Length:                              %ld\n"),
3843               (long) names.pn_length);
3844       printf (_("  Version:                             %d\n"),
3845               names.pn_version);
3846       printf (_("  Offset into .debug_info section:     0x%lx\n"),
3847               (unsigned long) names.pn_offset);
3848       printf (_("  Size of area in .debug_info section: %ld\n"),
3849               (long) names.pn_size);
3850
3851       if (names.pn_version != 2 && names.pn_version != 3)
3852         {
3853           static int warned = 0;
3854
3855           if (! warned)
3856             {
3857               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3858               warned = 1;
3859             }
3860
3861           continue;
3862         }
3863
3864       if (is_gnu)
3865         printf (_("\n    Offset  Kind          Name\n"));
3866       else
3867         printf (_("\n    Offset\tName\n"));
3868
3869       do
3870         {
3871           bfd_size_type maxprint;
3872
3873           SAFE_BYTE_GET (offset, data, offset_size, end);
3874
3875           if (offset != 0)
3876             {
3877               data += offset_size;
3878               if (data >= end)
3879                 break;
3880               maxprint = (end - data) - 1;
3881
3882               if (is_gnu)
3883                 {
3884                   unsigned int kind_data;
3885                   gdb_index_symbol_kind kind;
3886                   const char *kind_name;
3887                   int is_static;
3888
3889                   SAFE_BYTE_GET (kind_data, data, 1, end);
3890                   data++;
3891                   maxprint --;
3892                   /* GCC computes the kind as the upper byte in the CU index
3893                      word, and then right shifts it by the CU index size.
3894                      Left shift KIND to where the gdb-index.h accessor macros
3895                      can use it.  */
3896                   kind_data <<= GDB_INDEX_CU_BITSIZE;
3897                   kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3898                   kind_name = get_gdb_index_symbol_kind_name (kind);
3899                   is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
3900                   printf ("    %-6lx  %s,%-10s  %.*s\n",
3901                           (unsigned long) offset, is_static ? _("s") : _("g"),
3902                           kind_name, (int) maxprint, data);
3903                 }
3904               else
3905                 printf ("    %-6lx\t%.*s\n",
3906                         (unsigned long) offset, (int) maxprint, data);
3907
3908               data += strnlen ((char *) data, maxprint) + 1;
3909               if (data >= end)
3910                 break;
3911             }
3912         }
3913       while (offset != 0);
3914     }
3915
3916   printf ("\n");
3917   return 1;
3918 }
3919
3920 static int
3921 display_debug_pubnames (struct dwarf_section *section, void *file)
3922 {
3923   return display_debug_pubnames_worker (section, file, 0);
3924 }
3925
3926 static int
3927 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3928 {
3929   return display_debug_pubnames_worker (section, file, 1);
3930 }
3931
3932 static int
3933 display_debug_macinfo (struct dwarf_section *section,
3934                        void *file ATTRIBUTE_UNUSED)
3935 {
3936   unsigned char *start = section->start;
3937   unsigned char *end = start + section->size;
3938   unsigned char *curr = start;
3939   unsigned int bytes_read;
3940   enum dwarf_macinfo_record_type op;
3941
3942   printf (_("Contents of the %s section:\n\n"), section->name);
3943
3944   while (curr < end)
3945     {
3946       unsigned int lineno;
3947       const unsigned char *string;
3948
3949       op = (enum dwarf_macinfo_record_type) *curr;
3950       curr++;
3951
3952       switch (op)
3953         {
3954         case DW_MACINFO_start_file:
3955           {
3956             unsigned int filenum;
3957
3958             lineno = read_uleb128 (curr, & bytes_read, end);
3959             curr += bytes_read;
3960             filenum = read_uleb128 (curr, & bytes_read, end);
3961             curr += bytes_read;
3962
3963             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3964                     lineno, filenum);
3965           }
3966           break;
3967
3968         case DW_MACINFO_end_file:
3969           printf (_(" DW_MACINFO_end_file\n"));
3970           break;
3971
3972         case DW_MACINFO_define:
3973           lineno = read_uleb128 (curr, & bytes_read, end);
3974           curr += bytes_read;
3975           string = curr;
3976           curr += strnlen ((char *) string, end - string) + 1;
3977           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3978                   lineno, string);
3979           break;
3980
3981         case DW_MACINFO_undef:
3982           lineno = read_uleb128 (curr, & bytes_read, end);
3983           curr += bytes_read;
3984           string = curr;
3985           curr += strnlen ((char *) string, end - string) + 1;
3986           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3987                   lineno, string);
3988           break;
3989
3990         case DW_MACINFO_vendor_ext:
3991           {
3992             unsigned int constant;
3993
3994             constant = read_uleb128 (curr, & bytes_read, end);
3995             curr += bytes_read;
3996             string = curr;
3997             curr += strnlen ((char *) string, end - string) + 1;
3998             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3999                     constant, string);
4000           }
4001           break;
4002         }
4003     }
4004
4005   return 1;
4006 }
4007
4008 /* Given LINE_OFFSET into the .debug_line section, attempt to return
4009    filename and dirname corresponding to file name table entry with index
4010    FILEIDX.  Return NULL on failure.  */
4011
4012 static unsigned char *
4013 get_line_filename_and_dirname (dwarf_vma line_offset,
4014                                dwarf_vma fileidx,
4015                                unsigned char **dir_name)
4016 {
4017   struct dwarf_section *section = &debug_displays [line].section;
4018   unsigned char *hdrptr, *dirtable, *file_name;
4019   unsigned int offset_size, initial_length_size;
4020   unsigned int version, opcode_base, bytes_read;
4021   dwarf_vma length, diridx;
4022   const unsigned char * end;
4023
4024   *dir_name = NULL;
4025   if (section->start == NULL
4026       || line_offset >= section->size
4027       || fileidx == 0)
4028     return NULL;
4029
4030   hdrptr = section->start + line_offset;
4031   end = section->start + section->size;
4032
4033   SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
4034   if (length == 0xffffffff)
4035     {
4036       /* This section is 64-bit DWARF 3.  */
4037       SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
4038       offset_size = 8;
4039       initial_length_size = 12;
4040     }
4041   else
4042     {
4043       offset_size = 4;
4044       initial_length_size = 4;
4045     }
4046   if (length + initial_length_size > section->size)
4047     return NULL;
4048
4049   SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
4050   if (version != 2 && version != 3 && version != 4)
4051     return NULL;
4052   hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length.  */
4053   if (version >= 4)
4054     hdrptr++;               /* Skip max_ops_per_insn.  */
4055   hdrptr += 3;              /* Skip default_is_stmt, line_base, line_range.  */
4056
4057   SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
4058   if (opcode_base == 0)
4059     return NULL;
4060
4061   hdrptr += opcode_base - 1;
4062   dirtable = hdrptr;
4063   /* Skip over dirname table.  */
4064   while (*hdrptr != '\0')
4065     hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4066   hdrptr++;                 /* Skip the NUL at the end of the table.  */
4067   /* Now skip over preceding filename table entries.  */
4068   for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
4069     {
4070       hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4071       read_uleb128 (hdrptr, &bytes_read, end);
4072       hdrptr += bytes_read;
4073       read_uleb128 (hdrptr, &bytes_read, end);
4074       hdrptr += bytes_read;
4075       read_uleb128 (hdrptr, &bytes_read, end);
4076       hdrptr += bytes_read;
4077     }
4078   if (hdrptr == end || *hdrptr == '\0')
4079     return NULL;
4080   file_name = hdrptr;
4081   hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4082   diridx = read_uleb128 (hdrptr, &bytes_read, end);
4083   if (diridx == 0)
4084     return file_name;
4085   for (; *dirtable != '\0' && diridx > 1; diridx--)
4086     dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4087   if (*dirtable == '\0')
4088     return NULL;
4089   *dir_name = dirtable;
4090   return file_name;
4091 }
4092
4093 static int
4094 display_debug_macro (struct dwarf_section *section,
4095                      void *file)
4096 {
4097   unsigned char *start = section->start;
4098   unsigned char *end = start + section->size;
4099   unsigned char *curr = start;
4100   unsigned char *extended_op_buf[256];
4101   unsigned int bytes_read;
4102
4103   load_debug_section (str, file);
4104   load_debug_section (line, file);
4105
4106   printf (_("Contents of the %s section:\n\n"), section->name);
4107
4108   while (curr < end)
4109     {
4110       unsigned int lineno, version, flags;
4111       unsigned int offset_size = 4;
4112       const unsigned char *string;
4113       dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4114       unsigned char **extended_ops = NULL;
4115
4116       SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4117       if (version != 4)
4118         {
4119           error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4120                  section->name);
4121           return 0;
4122         }
4123
4124       SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4125       if (flags & 1)
4126         offset_size = 8;
4127       printf (_("  Offset:                      0x%lx\n"),
4128               (unsigned long) sec_offset);
4129       printf (_("  Version:                     %d\n"), version);
4130       printf (_("  Offset size:                 %d\n"), offset_size);
4131       if (flags & 2)
4132         {
4133           SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4134           printf (_("  Offset into .debug_line:     0x%lx\n"),
4135                   (unsigned long) line_offset);
4136         }
4137       if (flags & 4)
4138         {
4139           unsigned int i, count, op;
4140           dwarf_vma nargs, n;
4141
4142           SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4143
4144           memset (extended_op_buf, 0, sizeof (extended_op_buf));
4145           extended_ops = extended_op_buf;
4146           if (count)
4147             {
4148               printf (_("  Extension opcode arguments:\n"));
4149               for (i = 0; i < count; i++)
4150                 {
4151                   SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4152                   extended_ops[op] = curr;
4153                   nargs = read_uleb128 (curr, &bytes_read, end);
4154                   curr += bytes_read;
4155                   if (nargs == 0)
4156                     printf (_("    DW_MACRO_GNU_%02x has no arguments\n"), op);
4157                   else
4158                     {
4159                       printf (_("    DW_MACRO_GNU_%02x arguments: "), op);
4160                       for (n = 0; n < nargs; n++)
4161                         {
4162                           unsigned int form;
4163
4164                           SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4165                           printf ("%s%s", get_FORM_name (form),
4166                                   n == nargs - 1 ? "\n" : ", ");
4167                           switch (form)
4168                             {
4169                             case DW_FORM_data1:
4170                             case DW_FORM_data2:
4171                             case DW_FORM_data4:
4172                             case DW_FORM_data8:
4173                             case DW_FORM_sdata:
4174                             case DW_FORM_udata:
4175                             case DW_FORM_block:
4176                             case DW_FORM_block1:
4177                             case DW_FORM_block2:
4178                             case DW_FORM_block4:
4179                             case DW_FORM_flag:
4180                             case DW_FORM_string:
4181                             case DW_FORM_strp:
4182                             case DW_FORM_sec_offset:
4183                               break;
4184                             default:
4185                               error (_("Invalid extension opcode form %s\n"),
4186                                      get_FORM_name (form));
4187                               return 0;
4188                             }
4189                         }
4190                     }
4191                 }
4192             }
4193         }
4194       printf ("\n");
4195
4196       while (1)
4197         {
4198           unsigned int op;
4199
4200           if (curr >= end)
4201             {
4202               error (_(".debug_macro section not zero terminated\n"));
4203               return 0;
4204             }
4205
4206           SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4207           if (op == 0)
4208             break;
4209
4210           switch (op)
4211             {
4212             case DW_MACRO_GNU_start_file:
4213               {
4214                 unsigned int filenum;
4215                 unsigned char *file_name = NULL, *dir_name = NULL;
4216
4217                 lineno = read_uleb128 (curr, &bytes_read, end);
4218                 curr += bytes_read;
4219                 filenum = read_uleb128 (curr, &bytes_read, end);
4220                 curr += bytes_read;
4221
4222                 if ((flags & 2) == 0)
4223                   error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4224                 else
4225                   file_name
4226                     = get_line_filename_and_dirname (line_offset, filenum,
4227                                                      &dir_name);
4228                 if (file_name == NULL)
4229                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4230                           lineno, filenum);
4231                 else
4232                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4233                           lineno, filenum,
4234                           dir_name != NULL ? (const char *) dir_name : "",
4235                           dir_name != NULL ? "/" : "", file_name);
4236               }
4237               break;
4238
4239             case DW_MACRO_GNU_end_file:
4240               printf (_(" DW_MACRO_GNU_end_file\n"));
4241               break;
4242
4243             case DW_MACRO_GNU_define:
4244               lineno = read_uleb128 (curr, &bytes_read, end);
4245               curr += bytes_read;
4246               string = curr;
4247               curr += strnlen ((char *) string, end - string) + 1;
4248               printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4249                       lineno, string);
4250               break;
4251
4252             case DW_MACRO_GNU_undef:
4253               lineno = read_uleb128 (curr, &bytes_read, end);
4254               curr += bytes_read;
4255               string = curr;
4256               curr += strnlen ((char *) string, end - string) + 1;
4257               printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4258                       lineno, string);
4259               break;
4260
4261             case DW_MACRO_GNU_define_indirect:
4262               lineno = read_uleb128 (curr, &bytes_read, end);
4263               curr += bytes_read;
4264               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4265               string = fetch_indirect_string (offset);
4266               printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4267                       lineno, string);
4268               break;
4269
4270             case DW_MACRO_GNU_undef_indirect:
4271               lineno = read_uleb128 (curr, &bytes_read, end);
4272               curr += bytes_read;
4273               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4274               string = fetch_indirect_string (offset);
4275               printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4276                       lineno, string);
4277               break;
4278
4279             case DW_MACRO_GNU_transparent_include:
4280               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4281               printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4282                       (unsigned long) offset);
4283               break;
4284
4285             case DW_MACRO_GNU_define_indirect_alt:
4286               lineno = read_uleb128 (curr, &bytes_read, end);
4287               curr += bytes_read;
4288               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4289               printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4290                       lineno, (unsigned long) offset);
4291               break;
4292
4293             case DW_MACRO_GNU_undef_indirect_alt:
4294               lineno = read_uleb128 (curr, &bytes_read, end);
4295               curr += bytes_read;
4296               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4297               printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4298                       lineno, (unsigned long) offset);
4299               break;
4300
4301             case DW_MACRO_GNU_transparent_include_alt:
4302               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4303               printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4304                       (unsigned long) offset);
4305               break;
4306
4307             default:
4308               if (extended_ops == NULL || extended_ops[op] == NULL)
4309                 {
4310                   error (_(" Unknown macro opcode %02x seen\n"), op);
4311                   return 0;
4312                 }
4313               else
4314                 {
4315                   /* Skip over unhandled opcodes.  */
4316                   dwarf_vma nargs, n;
4317                   unsigned char *desc = extended_ops[op];
4318                   nargs = read_uleb128 (desc, &bytes_read, end);
4319                   desc += bytes_read;
4320                   if (nargs == 0)
4321                     {
4322                       printf (_(" DW_MACRO_GNU_%02x\n"), op);
4323                       break;
4324                     }
4325                   printf (_(" DW_MACRO_GNU_%02x -"), op);
4326                   for (n = 0; n < nargs; n++)
4327                     {
4328                       int val;
4329
4330                       SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4331                       curr
4332                         = read_and_display_attr_value (0, val,
4333                                                        curr, end, 0, 0, offset_size,
4334                                                        version, NULL, 0, NULL,
4335                                                        NULL);
4336                       if (n != nargs - 1)
4337                         printf (",");
4338                     }
4339                   printf ("\n");
4340                 }
4341               break;
4342             }
4343         }
4344
4345       printf ("\n");
4346     }
4347
4348   return 1;
4349 }
4350
4351 static int
4352 display_debug_abbrev (struct dwarf_section *section,
4353                       void *file ATTRIBUTE_UNUSED)
4354 {
4355   abbrev_entry *entry;
4356   unsigned char *start = section->start;
4357   unsigned char *end = start + section->size;
4358
4359   printf (_("Contents of the %s section:\n\n"), section->name);
4360
4361   do
4362     {
4363       unsigned char *last;
4364
4365       free_abbrevs ();
4366
4367       last = start;
4368       start = process_abbrev_section (start, end);
4369
4370       if (first_abbrev == NULL)
4371         continue;
4372
4373       printf (_("  Number TAG (0x%lx)\n"), (long) (last - section->start));
4374
4375       for (entry = first_abbrev; entry; entry = entry->next)
4376         {
4377           abbrev_attr *attr;
4378
4379           printf ("   %ld      %s    [%s]\n",
4380                   entry->entry,
4381                   get_TAG_name (entry->tag),
4382                   entry->children ? _("has children") : _("no children"));
4383
4384           for (attr = entry->first_attr; attr; attr = attr->next)
4385             printf ("    %-18s %s\n",
4386                     get_AT_name (attr->attribute),
4387                     get_FORM_name (attr->form));
4388         }
4389     }
4390   while (start);
4391
4392   printf ("\n");
4393
4394   return 1;
4395 }
4396
4397 /* Return true when ADDR is the maximum address, when addresses are
4398    POINTER_SIZE bytes long.  */
4399
4400 static bfd_boolean
4401 is_max_address (dwarf_vma addr, unsigned int pointer_size)
4402 {
4403   dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1));
4404   return ((addr & mask) == mask);
4405 }
4406
4407 /* Display a location list from a normal (ie, non-dwo) .debug_loc section.  */
4408
4409 static void
4410 display_loc_list (struct dwarf_section *section,
4411                   unsigned char **start_ptr,
4412                   unsigned int debug_info_entry,
4413                   unsigned long offset,
4414                   unsigned long base_address,
4415                   int has_frame_base)
4416 {
4417   unsigned char *start = *start_ptr;
4418   unsigned char *section_end = section->start + section->size;
4419   unsigned long cu_offset;
4420   unsigned int pointer_size;
4421   unsigned int offset_size;
4422   int dwarf_version;
4423
4424   dwarf_vma begin;
4425   dwarf_vma end;
4426   unsigned short length;
4427   int need_frame_base;
4428
4429   if (debug_info_entry >= num_debug_info_entries)
4430     {
4431       warn (_("No debug information available for loc lists of entry: %u\n"),
4432             debug_info_entry);
4433       return;
4434     }
4435
4436   cu_offset = debug_information [debug_info_entry].cu_offset;
4437   pointer_size = debug_information [debug_info_entry].pointer_size;
4438   offset_size = debug_information [debug_info_entry].offset_size;
4439   dwarf_version = debug_information [debug_info_entry].dwarf_version;
4440
4441   if (pointer_size < 2 || pointer_size > 8)
4442     {
4443       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4444             pointer_size, debug_info_entry);
4445       return;
4446     }
4447
4448   while (1)
4449     {
4450       unsigned long off = offset + (start - *start_ptr);
4451
4452       if (start + 2 * pointer_size > section_end)
4453         {
4454           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4455                 offset);
4456           break;
4457         }
4458
4459       printf ("    %8.8lx ", off);
4460
4461       SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4462       SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4463
4464       if (begin == 0 && end == 0)
4465         {
4466           /* PR 18374: In a object file we can have a location list that
4467              starts with a begin and end of 0 because there are relocations
4468              that need to be applied to the addresses.  Actually applying
4469              the relocations now does not help as they will probably resolve
4470              to 0, since the object file has not been fully linked.  Real
4471              end of list markers will not have any relocations against them.  */
4472           if (! reloc_at (section, off)
4473               && ! reloc_at (section, off + pointer_size))
4474             {
4475               printf (_("<End of list>\n"));
4476               break;
4477             }
4478         }
4479
4480       /* Check base address specifiers.  */
4481       if (is_max_address (begin, pointer_size)
4482           && !is_max_address (end, pointer_size))
4483         {
4484           base_address = end;
4485           print_dwarf_vma (begin, pointer_size);
4486           print_dwarf_vma (end, pointer_size);
4487           printf (_("(base address)\n"));
4488           continue;
4489         }
4490
4491       if (start + 2 > section_end)
4492         {
4493           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4494                 offset);
4495           break;
4496         }
4497
4498       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4499
4500       if (start + length > section_end)
4501         {
4502           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4503                 offset);
4504           break;
4505         }
4506
4507       print_dwarf_vma (begin + base_address, pointer_size);
4508       print_dwarf_vma (end + base_address, pointer_size);
4509
4510       putchar ('(');
4511       need_frame_base = decode_location_expression (start,
4512                                                     pointer_size,
4513                                                     offset_size,
4514                                                     dwarf_version,
4515                                                     length,
4516                                                     cu_offset, section);
4517       putchar (')');
4518
4519       if (need_frame_base && !has_frame_base)
4520         printf (_(" [without DW_AT_frame_base]"));
4521
4522       if (begin == end)
4523         fputs (_(" (start == end)"), stdout);
4524       else if (begin > end)
4525         fputs (_(" (start > end)"), stdout);
4526
4527       putchar ('\n');
4528
4529       start += length;
4530     }
4531
4532   *start_ptr = start;
4533 }
4534
4535 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4536    right-adjusted in a field of length LEN, and followed by a space.  */
4537
4538 static void
4539 print_addr_index (unsigned int idx, unsigned int len)
4540 {
4541   static char buf[15];
4542   snprintf (buf, sizeof (buf), "[%d]", idx);
4543   printf ("%*s ", len, buf);
4544 }
4545
4546 /* Display a location list from a .dwo section. It uses address indexes rather
4547    than embedded addresses.  This code closely follows display_loc_list, but the
4548    two are sufficiently different that combining things is very ugly.  */
4549
4550 static void
4551 display_loc_list_dwo (struct dwarf_section *section,
4552                       unsigned char **start_ptr,
4553                       unsigned int debug_info_entry,
4554                       unsigned long offset,
4555                       int has_frame_base)
4556 {
4557   unsigned char *start = *start_ptr;
4558   unsigned char *section_end = section->start + section->size;
4559   unsigned long cu_offset;
4560   unsigned int pointer_size;
4561   unsigned int offset_size;
4562   int dwarf_version;
4563   int entry_type;
4564   unsigned short length;
4565   int need_frame_base;
4566   unsigned int idx;
4567   unsigned int bytes_read;
4568
4569   if (debug_info_entry >= num_debug_info_entries)
4570     {
4571       warn (_("No debug information for loc lists of entry: %u\n"),
4572             debug_info_entry);
4573       return;
4574     }
4575
4576   cu_offset = debug_information [debug_info_entry].cu_offset;
4577   pointer_size = debug_information [debug_info_entry].pointer_size;
4578   offset_size = debug_information [debug_info_entry].offset_size;
4579   dwarf_version = debug_information [debug_info_entry].dwarf_version;
4580
4581   if (pointer_size < 2 || pointer_size > 8)
4582     {
4583       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4584             pointer_size, debug_info_entry);
4585       return;
4586     }
4587
4588   while (1)
4589     {
4590       printf ("    %8.8lx ", offset + (start - *start_ptr));
4591
4592       if (start >= section_end)
4593         {
4594           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4595                 offset);
4596           break;
4597         }
4598
4599       SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4600       switch (entry_type)
4601         {
4602         case 0: /* A terminating entry.  */
4603           *start_ptr = start;
4604           printf (_("<End of list>\n"));
4605           return;
4606         case 1: /* A base-address entry.  */
4607           idx = read_uleb128 (start, &bytes_read, section_end);
4608           start += bytes_read;
4609           print_addr_index (idx, 8);
4610           printf ("         ");
4611           printf (_("(base address selection entry)\n"));
4612           continue;
4613         case 2: /* A start/end entry.  */
4614           idx = read_uleb128 (start, &bytes_read, section_end);
4615           start += bytes_read;
4616           print_addr_index (idx, 8);
4617           idx = read_uleb128 (start, &bytes_read, section_end);
4618           start += bytes_read;
4619           print_addr_index (idx, 8);
4620           break;
4621         case 3: /* A start/length entry.  */
4622           idx = read_uleb128 (start, &bytes_read, section_end);
4623           start += bytes_read;
4624           print_addr_index (idx, 8);
4625           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4626           printf ("%08x ", idx);
4627           break;
4628         case 4: /* An offset pair entry.  */
4629           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4630           printf ("%08x ", idx);
4631           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4632           printf ("%08x ", idx);
4633           break;
4634         default:
4635           warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4636           *start_ptr = start;
4637           return;
4638         }
4639
4640       if (start + 2 > section_end)
4641         {
4642           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4643                 offset);
4644           break;
4645         }
4646
4647       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4648       if (start + length > section_end)
4649         {
4650           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4651                 offset);
4652           break;
4653         }
4654
4655       putchar ('(');
4656       need_frame_base = decode_location_expression (start,
4657                                                     pointer_size,
4658                                                     offset_size,
4659                                                     dwarf_version,
4660                                                     length,
4661                                                     cu_offset, section);
4662       putchar (')');
4663
4664       if (need_frame_base && !has_frame_base)
4665         printf (_(" [without DW_AT_frame_base]"));
4666
4667       putchar ('\n');
4668
4669       start += length;
4670     }
4671
4672   *start_ptr = start;
4673 }
4674
4675 /* Sort array of indexes in ascending order of loc_offsets[idx].  */
4676
4677 static dwarf_vma *loc_offsets;
4678
4679 static int
4680 loc_offsets_compar (const void *ap, const void *bp)
4681 {
4682   dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4683   dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4684
4685   return (a > b) - (b > a);
4686 }
4687
4688 static int
4689 display_debug_loc (struct dwarf_section *section, void *file)
4690 {
4691   unsigned char *start = section->start;
4692   unsigned long bytes;
4693   unsigned char *section_begin = start;
4694   unsigned int num_loc_list = 0;
4695   unsigned long last_offset = 0;
4696   unsigned int first = 0;
4697   unsigned int i;
4698   unsigned int j;
4699   int seen_first_offset = 0;
4700   int locs_sorted = 1;
4701   unsigned char *next;
4702   unsigned int *array = NULL;
4703   const char *suffix = strrchr (section->name, '.');
4704   int is_dwo = 0;
4705
4706   if (suffix && strcmp (suffix, ".dwo") == 0)
4707     is_dwo = 1;
4708
4709   bytes = section->size;
4710
4711   if (bytes == 0)
4712     {
4713       printf (_("\nThe %s section is empty.\n"), section->name);
4714       return 0;
4715     }
4716
4717   if (load_debug_info (file) == 0)
4718     {
4719       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4720             section->name);
4721       return 0;
4722     }
4723
4724   /* Check the order of location list in .debug_info section. If
4725      offsets of location lists are in the ascending order, we can
4726      use `debug_information' directly.  */
4727   for (i = 0; i < num_debug_info_entries; i++)
4728     {
4729       unsigned int num;
4730
4731       num = debug_information [i].num_loc_offsets;
4732       if (num > num_loc_list)
4733         num_loc_list = num;
4734
4735       /* Check if we can use `debug_information' directly.  */
4736       if (locs_sorted && num != 0)
4737         {
4738           if (!seen_first_offset)
4739             {
4740               /* This is the first location list.  */
4741               last_offset = debug_information [i].loc_offsets [0];
4742               first = i;
4743               seen_first_offset = 1;
4744               j = 1;
4745             }
4746           else
4747             j = 0;
4748
4749           for (; j < num; j++)
4750             {
4751               if (last_offset >
4752                   debug_information [i].loc_offsets [j])
4753                 {
4754                   locs_sorted = 0;
4755                   break;
4756                 }
4757               last_offset = debug_information [i].loc_offsets [j];
4758             }
4759         }
4760     }
4761
4762   if (!seen_first_offset)
4763     error (_("No location lists in .debug_info section!\n"));
4764
4765   if (debug_information [first].num_loc_offsets > 0
4766       && debug_information [first].loc_offsets [0] != 0)
4767     warn (_("Location lists in %s section start at 0x%s\n"),
4768           section->name,
4769           dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4770
4771   if (!locs_sorted)
4772     array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4773   printf (_("Contents of the %s section:\n\n"), section->name);
4774   if (reloc_at (section, 0))
4775     printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
4776   printf (_("    Offset   Begin            End              Expression\n"));
4777
4778   seen_first_offset = 0;
4779   for (i = first; i < num_debug_info_entries; i++)
4780     {
4781       unsigned long offset;
4782       unsigned long base_address;
4783       unsigned int k;
4784       int has_frame_base;
4785
4786       if (!locs_sorted)
4787         {
4788           for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4789             array[k] = k;
4790           loc_offsets = debug_information [i].loc_offsets;
4791           qsort (array, debug_information [i].num_loc_offsets,
4792                  sizeof (*array), loc_offsets_compar);
4793         }
4794
4795       for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4796         {
4797           j = locs_sorted ? k : array[k];
4798           if (k
4799               && debug_information [i].loc_offsets [locs_sorted
4800                                                     ? k - 1 : array [k - 1]]
4801                  == debug_information [i].loc_offsets [j])
4802             continue;
4803           has_frame_base = debug_information [i].have_frame_base [j];
4804           offset = debug_information [i].loc_offsets [j];
4805           next = section_begin + offset;
4806           base_address = debug_information [i].base_address;
4807
4808           if (!seen_first_offset)
4809             seen_first_offset = 1;
4810           else
4811             {
4812               if (start < next)
4813                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4814                       (unsigned long) (start - section_begin),
4815                       (unsigned long) offset);
4816               else if (start > next)
4817                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4818                       (unsigned long) (start - section_begin),
4819                       (unsigned long) offset);
4820             }
4821           start = next;
4822
4823           if (offset >= bytes)
4824             {
4825               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4826                     offset);
4827               continue;
4828             }
4829
4830           if (is_dwo)
4831             display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4832           else
4833             display_loc_list (section, &start, i, offset, base_address,
4834                               has_frame_base);
4835         }
4836     }
4837
4838   if (start < section->start + section->size)
4839     warn (_("There are %ld unused bytes at the end of section %s\n"),
4840           (long) (section->start + section->size - start), section->name);
4841   putchar ('\n');
4842   free (array);
4843   return 1;
4844 }
4845
4846 static int
4847 display_debug_str (struct dwarf_section *section,
4848                    void *file ATTRIBUTE_UNUSED)
4849 {
4850   unsigned char *start = section->start;
4851   unsigned long bytes = section->size;
4852   dwarf_vma addr = section->address;
4853
4854   if (bytes == 0)
4855     {
4856       printf (_("\nThe %s section is empty.\n"), section->name);
4857       return 0;
4858     }
4859
4860   printf (_("Contents of the %s section:\n\n"), section->name);
4861
4862   while (bytes)
4863     {
4864       int j;
4865       int k;
4866       int lbytes;
4867
4868       lbytes = (bytes > 16 ? 16 : bytes);
4869
4870       printf ("  0x%8.8lx ", (unsigned long) addr);
4871
4872       for (j = 0; j < 16; j++)
4873         {
4874           if (j < lbytes)
4875             printf ("%2.2x", start[j]);
4876           else
4877             printf ("  ");
4878
4879           if ((j & 3) == 3)
4880             printf (" ");
4881         }
4882
4883       for (j = 0; j < lbytes; j++)
4884         {
4885           k = start[j];
4886           if (k >= ' ' && k < 0x80)
4887             printf ("%c", k);
4888           else
4889             printf (".");
4890         }
4891
4892       putchar ('\n');
4893
4894       start += lbytes;
4895       addr  += lbytes;
4896       bytes -= lbytes;
4897     }
4898
4899   putchar ('\n');
4900
4901   return 1;
4902 }
4903
4904 static int
4905 display_debug_info (struct dwarf_section *section, void *file)
4906 {
4907   return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4908 }
4909
4910 static int
4911 display_debug_types (struct dwarf_section *section, void *file)
4912 {
4913   return process_debug_info (section, file, section->abbrev_sec, 0, 1);
4914 }
4915
4916 static int
4917 display_trace_info (struct dwarf_section *section, void *file)
4918 {
4919   return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4920 }
4921
4922 static int
4923 display_debug_aranges (struct dwarf_section *section,
4924                        void *file ATTRIBUTE_UNUSED)
4925 {
4926   unsigned char *start = section->start;
4927   unsigned char *end = start + section->size;
4928
4929   printf (_("Contents of the %s section:\n\n"), section->name);
4930
4931   /* It does not matter if this load fails,
4932      we test for that later on.  */
4933   load_debug_info (file);
4934
4935   while (start < end)
4936     {
4937       unsigned char *hdrptr;
4938       DWARF2_Internal_ARange arange;
4939       unsigned char *addr_ranges;
4940       dwarf_vma length;
4941       dwarf_vma address;
4942       unsigned char address_size;
4943       int excess;
4944       unsigned int offset_size;
4945       unsigned int initial_length_size;
4946
4947       hdrptr = start;
4948
4949       SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
4950       if (arange.ar_length == 0xffffffff)
4951         {
4952           SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
4953           offset_size = 8;
4954           initial_length_size = 12;
4955         }
4956       else
4957         {
4958           offset_size = 4;
4959           initial_length_size = 4;
4960         }
4961
4962       SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4963       SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
4964
4965       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4966           && num_debug_info_entries > 0
4967           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4968         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4969               (unsigned long) arange.ar_info_offset, section->name);
4970
4971       SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4972       SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
4973
4974       if (arange.ar_version != 2 && arange.ar_version != 3)
4975         {
4976           /* PR 19872: A version number of 0 probably means that there is
4977              padding at the end of the .debug_aranges section.  Gold puts
4978              it there when performing an incremental link, for example.
4979              So do not generate a warning in this case.  */
4980           if (arange.ar_version)
4981             warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4982           break;
4983         }
4984
4985       printf (_("  Length:                   %ld\n"),
4986               (long) arange.ar_length);
4987       printf (_("  Version:                  %d\n"), arange.ar_version);
4988       printf (_("  Offset into .debug_info:  0x%lx\n"),
4989               (unsigned long) arange.ar_info_offset);
4990       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
4991       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
4992
4993       address_size = arange.ar_pointer_size + arange.ar_segment_size;
4994
4995       /* PR 17512: file: 001-108546-0.001:0.1.  */
4996       if (address_size == 0 || address_size > 8)
4997         {
4998           error (_("Invalid address size in %s section!\n"),
4999                  section->name);
5000           break;
5001         }
5002
5003       /* The DWARF spec does not require that the address size be a power
5004          of two, but we do.  This will have to change if we ever encounter
5005          an uneven architecture.  */
5006       if ((address_size & (address_size - 1)) != 0)
5007         {
5008           warn (_("Pointer size + Segment size is not a power of two.\n"));
5009           break;
5010         }
5011
5012       if (address_size > 4)
5013         printf (_("\n    Address            Length\n"));
5014       else
5015         printf (_("\n    Address    Length\n"));
5016
5017       addr_ranges = hdrptr;
5018
5019       /* Must pad to an alignment boundary that is twice the address size.  */
5020       excess = (hdrptr - start) % (2 * address_size);
5021       if (excess)
5022         addr_ranges += (2 * address_size) - excess;
5023
5024       hdrptr = start + arange.ar_length + initial_length_size;
5025       if (hdrptr < start || hdrptr > end)
5026         {
5027           error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
5028           break;
5029         }
5030       start = hdrptr;
5031
5032       while (addr_ranges + 2 * address_size <= start)
5033         {
5034           SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
5035           SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
5036
5037           printf ("    ");
5038           print_dwarf_vma (address, address_size);
5039           print_dwarf_vma (length, address_size);
5040           putchar ('\n');
5041         }
5042     }
5043
5044   printf ("\n");
5045
5046   return 1;
5047 }
5048
5049 /* Comparison function for qsort.  */
5050 static int
5051 comp_addr_base (const void * v0, const void * v1)
5052 {
5053   debug_info * info0 = (debug_info *) v0;
5054   debug_info * info1 = (debug_info *) v1;
5055   return info0->addr_base - info1->addr_base;
5056 }
5057
5058 /* Display the debug_addr section.  */
5059 static int
5060 display_debug_addr (struct dwarf_section *section,
5061                     void *file)
5062 {
5063   debug_info **debug_addr_info;
5064   unsigned char *entry;
5065   unsigned char *end;
5066   unsigned int i;
5067   unsigned int count;
5068
5069   if (section->size == 0)
5070     {
5071       printf (_("\nThe %s section is empty.\n"), section->name);
5072       return 0;
5073     }
5074
5075   if (load_debug_info (file) == 0)
5076     {
5077       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5078             section->name);
5079       return 0;
5080     }
5081
5082   printf (_("Contents of the %s section:\n\n"), section->name);
5083
5084   /* PR  17531: file: cf38d01b.
5085      We use xcalloc because a corrupt file may not have initialised all of the
5086      fields in the debug_info structure, which means that the sort below might
5087      try to move uninitialised data.  */
5088   debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
5089                                              sizeof (debug_info *));
5090
5091   count = 0;
5092   for (i = 0; i < num_debug_info_entries; i++)
5093     if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
5094       {
5095         /* PR 17531: file: cf38d01b.  */
5096         if (debug_information[i].addr_base >= section->size)
5097           warn (_("Corrupt address base (%lx) found in debug section %u\n"),
5098                 (unsigned long) debug_information[i].addr_base, i);
5099         else
5100           debug_addr_info [count++] = debug_information + i;
5101       }
5102
5103   /* Add a sentinel to make iteration convenient.  */
5104   debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
5105   debug_addr_info [count]->addr_base = section->size;
5106   qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
5107
5108   for (i = 0; i < count; i++)
5109     {
5110       unsigned int idx;
5111       unsigned int address_size = debug_addr_info [i]->pointer_size;
5112
5113       printf (_("  For compilation unit at offset 0x%s:\n"),
5114               dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
5115
5116       printf (_("\tIndex\tAddress\n"));
5117       entry = section->start + debug_addr_info [i]->addr_base;
5118       end = section->start + debug_addr_info [i + 1]->addr_base;
5119       idx = 0;
5120       while (entry < end)
5121         {
5122           dwarf_vma base = byte_get (entry, address_size);
5123           printf (_("\t%d:\t"), idx);
5124           print_dwarf_vma (base, address_size);
5125           printf ("\n");
5126           entry += address_size;
5127           idx++;
5128         }
5129     }
5130   printf ("\n");
5131
5132   free (debug_addr_info);
5133   return 1;
5134 }
5135
5136 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections.  */
5137 static int
5138 display_debug_str_offsets (struct dwarf_section *section,
5139                            void *file ATTRIBUTE_UNUSED)
5140 {
5141   if (section->size == 0)
5142     {
5143       printf (_("\nThe %s section is empty.\n"), section->name);
5144       return 0;
5145     }
5146   /* TODO: Dump the contents.  This is made somewhat difficult by not knowing
5147      what the offset size is for this section.  */
5148   return 1;
5149 }
5150
5151 /* Each debug_information[x].range_lists[y] gets this representation for
5152    sorting purposes.  */
5153
5154 struct range_entry
5155 {
5156   /* The debug_information[x].range_lists[y] value.  */
5157   unsigned long ranges_offset;
5158
5159   /* Original debug_information to find parameters of the data.  */
5160   debug_info *debug_info_p;
5161 };
5162
5163 /* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
5164
5165 static int
5166 range_entry_compar (const void *ap, const void *bp)
5167 {
5168   const struct range_entry *a_re = (const struct range_entry *) ap;
5169   const struct range_entry *b_re = (const struct range_entry *) bp;
5170   const unsigned long a = a_re->ranges_offset;
5171   const unsigned long b = b_re->ranges_offset;
5172
5173   return (a > b) - (b > a);
5174 }
5175
5176 static int
5177 display_debug_ranges (struct dwarf_section *section,
5178                       void *file ATTRIBUTE_UNUSED)
5179 {
5180   unsigned char *start = section->start;
5181   unsigned char *last_start = start;
5182   unsigned long bytes = section->size;
5183   unsigned char *section_begin = start;
5184   unsigned char *finish = start + bytes;
5185   unsigned int num_range_list, i;
5186   struct range_entry *range_entries, *range_entry_fill;
5187
5188   if (bytes == 0)
5189     {
5190       printf (_("\nThe %s section is empty.\n"), section->name);
5191       return 0;
5192     }
5193
5194   if (load_debug_info (file) == 0)
5195     {
5196       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5197             section->name);
5198       return 0;
5199     }
5200
5201   num_range_list = 0;
5202   for (i = 0; i < num_debug_info_entries; i++)
5203     num_range_list += debug_information [i].num_range_lists;
5204
5205   if (num_range_list == 0)
5206     {
5207       /* This can happen when the file was compiled with -gsplit-debug
5208          which removes references to range lists from the primary .o file.  */
5209       printf (_("No range lists in .debug_info section.\n"));
5210       return 1;
5211     }
5212
5213   range_entries = (struct range_entry *)
5214       xmalloc (sizeof (*range_entries) * num_range_list);
5215   range_entry_fill = range_entries;
5216
5217   for (i = 0; i < num_debug_info_entries; i++)
5218     {
5219       debug_info *debug_info_p = &debug_information[i];
5220       unsigned int j;
5221
5222       for (j = 0; j < debug_info_p->num_range_lists; j++)
5223         {
5224           range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5225           range_entry_fill->debug_info_p = debug_info_p;
5226           range_entry_fill++;
5227         }
5228     }
5229
5230   qsort (range_entries, num_range_list, sizeof (*range_entries),
5231          range_entry_compar);
5232
5233   if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5234     warn (_("Range lists in %s section start at 0x%lx\n"),
5235           section->name, range_entries[0].ranges_offset);
5236
5237   printf (_("Contents of the %s section:\n\n"), section->name);
5238   printf (_("    Offset   Begin    End\n"));
5239
5240   for (i = 0; i < num_range_list; i++)
5241     {
5242       struct range_entry *range_entry = &range_entries[i];
5243       debug_info *debug_info_p = range_entry->debug_info_p;
5244       unsigned int pointer_size;
5245       unsigned long offset;
5246       unsigned char *next;
5247       unsigned long base_address;
5248
5249       pointer_size = debug_info_p->pointer_size;
5250       offset = range_entry->ranges_offset;
5251       next = section_begin + offset;
5252       base_address = debug_info_p->base_address;
5253
5254       /* PR 17512: file: 001-101485-0.001:0.1.  */
5255       if (pointer_size < 2 || pointer_size > 8)
5256         {
5257           warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5258                 pointer_size, offset);
5259           continue;
5260         }
5261
5262       if (dwarf_check != 0 && i > 0)
5263         {
5264           if (start < next)
5265             warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5266                   (unsigned long) (start - section_begin),
5267                   (unsigned long) (next - section_begin), section->name);
5268           else if (start > next)
5269             {
5270               if (next == last_start)
5271                 continue;
5272               warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5273                     (unsigned long) (start - section_begin),
5274                     (unsigned long) (next - section_begin), section->name);
5275             }
5276         }
5277       start = next;
5278       last_start = next;
5279
5280       while (start < finish)
5281         {
5282           dwarf_vma begin;
5283           dwarf_vma end;
5284
5285           SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5286           if (start >= finish)
5287             break;
5288           SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5289
5290           printf ("    %8.8lx ", offset);
5291
5292           if (begin == 0 && end == 0)
5293             {
5294               printf (_("<End of list>\n"));
5295               break;
5296             }
5297
5298           /* Check base address specifiers.  */
5299           if (is_max_address (begin, pointer_size)
5300               && !is_max_address (end, pointer_size))
5301             {
5302               base_address = end;
5303               print_dwarf_vma (begin, pointer_size);
5304               print_dwarf_vma (end, pointer_size);
5305               printf ("(base address)\n");
5306               continue;
5307             }
5308
5309           print_dwarf_vma (begin + base_address, pointer_size);
5310           print_dwarf_vma (end + base_address, pointer_size);
5311
5312           if (begin == end)
5313             fputs (_("(start == end)"), stdout);
5314           else if (begin > end)
5315             fputs (_("(start > end)"), stdout);
5316
5317           putchar ('\n');
5318         }
5319     }
5320   putchar ('\n');
5321
5322   free (range_entries);
5323
5324   return 1;
5325 }
5326
5327 typedef struct Frame_Chunk
5328 {
5329   struct Frame_Chunk *next;
5330   unsigned char *chunk_start;
5331   unsigned int ncols;
5332   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
5333   short int *col_type;
5334   int *col_offset;
5335   char *augmentation;
5336   unsigned int code_factor;
5337   int data_factor;
5338   dwarf_vma pc_begin;
5339   dwarf_vma pc_range;
5340   int cfa_reg;
5341   dwarf_vma cfa_offset;
5342   unsigned int ra;
5343   unsigned char fde_encoding;
5344   unsigned char cfa_exp;
5345   unsigned char ptr_size;
5346   unsigned char segment_size;
5347 }
5348 Frame_Chunk;
5349
5350 static const char *const *dwarf_regnames;
5351 static unsigned int dwarf_regnames_count;
5352
5353 /* A marker for a col_type that means this column was never referenced
5354    in the frame info.  */
5355 #define DW_CFA_unreferenced (-1)
5356
5357 /* Return 0 if no more space is needed, 1 if more space is needed,
5358    -1 for invalid reg.  */
5359
5360 static int
5361 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5362 {
5363   unsigned int prev = fc->ncols;
5364
5365   if (reg < (unsigned int) fc->ncols)
5366     return 0;
5367
5368   if (dwarf_regnames_count
5369       && reg > dwarf_regnames_count)
5370     return -1;
5371
5372   fc->ncols = reg + 1;
5373   /* PR 17512: file: 10450-2643-0.004.
5374      If reg == -1 then this can happen...  */
5375   if (fc->ncols == 0)
5376     return -1;
5377
5378   /* PR 17512: file: 2844a11d.  */
5379   if (fc->ncols > 1024)
5380     {
5381       error (_("Unfeasibly large register number: %u\n"), reg);
5382       fc->ncols = 0;
5383       /* FIXME: 1024 is an arbitrary limit.  Increase it if
5384          we ever encounter a valid binary that exceeds it.  */
5385       return -1;
5386     }
5387
5388   fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5389                                           sizeof (short int));
5390   fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5391   /* PR 17512: file:002-10025-0.005.  */
5392   if (fc->col_type == NULL || fc->col_offset == NULL)
5393     {
5394       error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5395              fc->ncols);
5396       fc->ncols = 0;
5397       return -1;
5398     }
5399
5400   while (prev < fc->ncols)
5401     {
5402       fc->col_type[prev] = DW_CFA_unreferenced;
5403       fc->col_offset[prev] = 0;
5404       prev++;
5405     }
5406   return 1;
5407 }
5408
5409 static const char *const dwarf_regnames_i386[] =
5410 {
5411   "eax", "ecx", "edx", "ebx",                     /* 0 - 3  */
5412   "esp", "ebp", "esi", "edi",                     /* 4 - 7  */
5413   "eip", "eflags", NULL,                          /* 8 - 10  */
5414   "st0", "st1", "st2", "st3",                     /* 11 - 14  */
5415   "st4", "st5", "st6", "st7",                     /* 15 - 18  */
5416   NULL, NULL,                                     /* 19 - 20  */
5417   "xmm0", "xmm1", "xmm2", "xmm3",                 /* 21 - 24  */
5418   "xmm4", "xmm5", "xmm6", "xmm7",                 /* 25 - 28  */
5419   "mm0", "mm1", "mm2", "mm3",                     /* 29 - 32  */
5420   "mm4", "mm5", "mm6", "mm7",                     /* 33 - 36  */
5421   "fcw", "fsw", "mxcsr",                          /* 37 - 39  */
5422   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47  */
5423   "tr", "ldtr",                                   /* 48 - 49  */
5424   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57  */
5425   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65  */
5426   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73  */
5427   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81  */
5428   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89  */
5429   NULL, NULL, NULL,                               /* 90 - 92  */
5430   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"  /* 93 - 100  */
5431 };
5432
5433 static const char *const dwarf_regnames_iamcu[] =
5434 {
5435   "eax", "ecx", "edx", "ebx",                     /* 0 - 3  */
5436   "esp", "ebp", "esi", "edi",                     /* 4 - 7  */
5437   "eip", "eflags", NULL,                          /* 8 - 10  */
5438   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18  */
5439   NULL, NULL,                                     /* 19 - 20  */
5440   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28  */
5441   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36  */
5442   NULL, NULL, NULL,                               /* 37 - 39  */
5443   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47  */
5444   "tr", "ldtr",                                   /* 48 - 49  */
5445   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57  */
5446   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65  */
5447   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73  */
5448   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81  */
5449   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89  */
5450   NULL, NULL, NULL,                               /* 90 - 92  */
5451   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  /* 93 - 100  */
5452 };
5453
5454 void
5455 init_dwarf_regnames_i386 (void)
5456 {
5457   dwarf_regnames = dwarf_regnames_i386;
5458   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5459 }
5460
5461 void
5462 init_dwarf_regnames_iamcu (void)
5463 {
5464   dwarf_regnames = dwarf_regnames_iamcu;
5465   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu);
5466 }
5467
5468 static const char *const dwarf_regnames_x86_64[] =
5469 {
5470   "rax", "rdx", "rcx", "rbx",
5471   "rsi", "rdi", "rbp", "rsp",
5472   "r8",  "r9",  "r10", "r11",
5473   "r12", "r13", "r14", "r15",
5474   "rip",
5475   "xmm0",  "xmm1",  "xmm2",  "xmm3",
5476   "xmm4",  "xmm5",  "xmm6",  "xmm7",
5477   "xmm8",  "xmm9",  "xmm10", "xmm11",
5478   "xmm12", "xmm13", "xmm14", "xmm15",
5479   "st0", "st1", "st2", "st3",
5480   "st4", "st5", "st6", "st7",
5481   "mm0", "mm1", "mm2", "mm3",
5482   "mm4", "mm5", "mm6", "mm7",
5483   "rflags",
5484   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5485   "fs.base", "gs.base", NULL, NULL,
5486   "tr", "ldtr",
5487   "mxcsr", "fcw", "fsw",
5488   "xmm16",  "xmm17",  "xmm18",  "xmm19",
5489   "xmm20",  "xmm21",  "xmm22",  "xmm23",
5490   "xmm24",  "xmm25",  "xmm26",  "xmm27",
5491   "xmm28",  "xmm29",  "xmm30",  "xmm31",
5492   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90  */
5493   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98  */
5494   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106  */
5495   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114  */
5496   NULL, NULL, NULL,                               /* 115 - 117  */
5497   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5498 };
5499
5500 void
5501 init_dwarf_regnames_x86_64 (void)
5502 {
5503   dwarf_regnames = dwarf_regnames_x86_64;
5504   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5505 }
5506
5507 static const char *const dwarf_regnames_aarch64[] =
5508 {
5509    "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
5510    "x8",  "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5511   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5512   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5513    NULL, "elr",  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5514    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5515    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5516    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5517    "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",
5518    "v8",  "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5519   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5520   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5521 };
5522
5523 void
5524 init_dwarf_regnames_aarch64 (void)
5525 {
5526   dwarf_regnames = dwarf_regnames_aarch64;
5527   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5528 }
5529
5530 static const char *const dwarf_regnames_s390[] =
5531 {
5532   /* Avoid saying "r5 (r5)", so omit the names of r0-r15.  */
5533   NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5534   NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5535   "f0",  "f2",  "f4",  "f6",  "f1",  "f3",  "f5",  "f7",
5536   "f8",  "f10", "f12", "f14", "f9",  "f11", "f13", "f15",
5537   "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
5538   "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
5539   "a0",  "a1",  "a2",  "a3",  "a4",  "a5",  "a6",  "a7",
5540   "a8",  "a9",  "a10", "a11", "a12", "a13", "a14", "a15",
5541   "pswm", "pswa",
5542   NULL, NULL,
5543   "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
5544   "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
5545 };
5546
5547 void
5548 init_dwarf_regnames_s390 (void)
5549 {
5550   dwarf_regnames = dwarf_regnames_s390;
5551   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390);
5552 }
5553
5554 void
5555 init_dwarf_regnames (unsigned int e_machine)
5556 {
5557   switch (e_machine)
5558     {
5559     case EM_386:
5560       init_dwarf_regnames_i386 ();
5561       break;
5562
5563     case EM_IAMCU:
5564       init_dwarf_regnames_iamcu ();
5565       break;
5566
5567     case EM_X86_64:
5568     case EM_L1OM:
5569     case EM_K1OM:
5570       init_dwarf_regnames_x86_64 ();
5571       break;
5572
5573     case EM_AARCH64:
5574       init_dwarf_regnames_aarch64 ();
5575       break;
5576
5577     case EM_S390:
5578       init_dwarf_regnames_s390 ();
5579       break;
5580
5581     default:
5582       break;
5583     }
5584 }
5585
5586 static const char *
5587 regname (unsigned int regno, int row)
5588 {
5589   static char reg[64];
5590   if (dwarf_regnames
5591       && regno < dwarf_regnames_count
5592       && dwarf_regnames [regno] != NULL)
5593     {
5594       if (row)
5595         return dwarf_regnames [regno];
5596       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5597                 dwarf_regnames [regno]);
5598     }
5599   else
5600     snprintf (reg, sizeof (reg), "r%d", regno);
5601   return reg;
5602 }
5603
5604 static void
5605 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
5606 {
5607   unsigned int r;
5608   char tmp[100];
5609
5610   if (*max_regs != fc->ncols)
5611     *max_regs = fc->ncols;
5612
5613   if (*need_col_headers)
5614     {
5615       static const char *sloc = "   LOC";
5616
5617       *need_col_headers = 0;
5618
5619       printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
5620
5621       for (r = 0; r < *max_regs; r++)
5622         if (fc->col_type[r] != DW_CFA_unreferenced)
5623           {
5624             if (r == fc->ra)
5625               printf ("ra    ");
5626             else
5627               printf ("%-5s ", regname (r, 1));
5628           }
5629
5630       printf ("\n");
5631     }
5632
5633   print_dwarf_vma (fc->pc_begin, eh_addr_size);
5634   if (fc->cfa_exp)
5635     strcpy (tmp, "exp");
5636   else
5637     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
5638   printf ("%-8s ", tmp);
5639
5640   for (r = 0; r < fc->ncols; r++)
5641     {
5642       if (fc->col_type[r] != DW_CFA_unreferenced)
5643         {
5644           switch (fc->col_type[r])
5645             {
5646             case DW_CFA_undefined:
5647               strcpy (tmp, "u");
5648               break;
5649             case DW_CFA_same_value:
5650               strcpy (tmp, "s");
5651               break;
5652             case DW_CFA_offset:
5653               sprintf (tmp, "c%+d", fc->col_offset[r]);
5654               break;
5655             case DW_CFA_val_offset:
5656               sprintf (tmp, "v%+d", fc->col_offset[r]);
5657               break;
5658             case DW_CFA_register:
5659               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5660               break;
5661             case DW_CFA_expression:
5662               strcpy (tmp, "exp");
5663               break;
5664             case DW_CFA_val_expression:
5665               strcpy (tmp, "vexp");
5666               break;
5667             default:
5668               strcpy (tmp, "n/a");
5669               break;
5670             }
5671           printf ("%-5s ", tmp);
5672         }
5673     }
5674   printf ("\n");
5675 }
5676
5677 #define GET(VAR, N)     SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5678 #define LEB()   read_uleb128 (start, & length_return, end); start += length_return
5679 #define SLEB()  read_sleb128 (start, & length_return, end); start += length_return
5680
5681 static unsigned char *
5682 read_cie (unsigned char *start, unsigned char *end,
5683           Frame_Chunk **p_cie, int *p_version,
5684           unsigned long *p_aug_len, unsigned char **p_aug)
5685 {
5686   int version;
5687   Frame_Chunk *fc;
5688   unsigned int length_return;
5689   unsigned char *augmentation_data = NULL;
5690   unsigned long augmentation_data_len = 0;
5691
5692   * p_cie = NULL;
5693   /* PR 17512: file: 001-228113-0.004.  */
5694   if (start >= end)
5695     return end;
5696
5697   fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5698   memset (fc, 0, sizeof (Frame_Chunk));
5699
5700   fc->col_type = (short int *) xmalloc (sizeof (short int));
5701   fc->col_offset = (int *) xmalloc (sizeof (int));
5702
5703   version = *start++;
5704
5705   fc->augmentation = (char *) start;
5706   /* PR 17512: file: 001-228113-0.004.
5707      Skip past augmentation name, but avoid running off the end of the data.  */
5708   while (start < end)
5709     if (* start ++ == '\0')
5710       break;
5711   if (start == end)
5712     {
5713       warn (_("No terminator for augmentation name\n"));
5714       return start;
5715     }
5716
5717   if (strcmp (fc->augmentation, "eh") == 0)
5718     start += eh_addr_size;
5719
5720   if (version >= 4)
5721     {
5722       GET (fc->ptr_size, 1);
5723       if (fc->ptr_size < 1 || fc->ptr_size > 8)
5724         {
5725           warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
5726           return end;
5727         }
5728
5729       GET (fc->segment_size, 1);
5730       /* PR 17512: file: e99d2804.  */
5731       if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
5732         {
5733           warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
5734           return end;
5735         }
5736
5737       eh_addr_size = fc->ptr_size;
5738     }
5739   else
5740     {
5741       fc->ptr_size = eh_addr_size;
5742       fc->segment_size = 0;
5743     }
5744   fc->code_factor = LEB ();
5745   fc->data_factor = SLEB ();
5746   if (version == 1)
5747     {
5748       GET (fc->ra, 1);
5749     }
5750   else
5751     {
5752       fc->ra = LEB ();
5753     }
5754
5755   if (fc->augmentation[0] == 'z')
5756     {
5757       augmentation_data_len = LEB ();
5758       augmentation_data = start;
5759       start += augmentation_data_len;
5760       /* PR 17512: file: 11042-2589-0.004.  */
5761       if (start > end)
5762         {
5763           warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
5764           return end;
5765         }
5766     }
5767
5768   if (augmentation_data_len)
5769     {
5770       unsigned char *p;
5771       unsigned char *q;
5772       unsigned char *qend;
5773
5774       p = (unsigned char *) fc->augmentation + 1;
5775       q = augmentation_data;
5776       qend = q + augmentation_data_len;
5777
5778       /* PR 17531: file: 015adfaa.  */
5779       if (qend < q)
5780         {
5781           warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5782           augmentation_data_len = 0;
5783         }
5784
5785       while (p < end && q < augmentation_data + augmentation_data_len)
5786         {
5787           if (*p == 'L')
5788             q++;
5789           else if (*p == 'P')
5790             q += 1 + size_of_encoded_value (*q);
5791           else if (*p == 'R')
5792             fc->fde_encoding = *q++;
5793           else if (*p == 'S')
5794             ;
5795           else
5796             break;
5797           p++;
5798         }
5799       /* Note - it is OK if this loop terminates with q < qend.
5800          Padding may have been inserted to align the end of the CIE.  */
5801     }
5802
5803   *p_cie = fc;
5804   if (p_version)
5805     *p_version = version;
5806   if (p_aug_len)
5807     {
5808       *p_aug_len = augmentation_data_len;
5809       *p_aug = augmentation_data;
5810     }
5811   return start;
5812 }
5813
5814 static int
5815 display_debug_frames (struct dwarf_section *section,
5816                       void *file ATTRIBUTE_UNUSED)
5817 {
5818   unsigned char *start = section->start;
5819   unsigned char *end = start + section->size;
5820   unsigned char *section_start = start;
5821   Frame_Chunk *chunks = 0, *forward_refs = 0;
5822   Frame_Chunk *remembered_state = 0;
5823   Frame_Chunk *rs;
5824   int is_eh = strcmp (section->name, ".eh_frame") == 0;
5825   unsigned int length_return;
5826   unsigned int max_regs = 0;
5827   const char *bad_reg = _("bad register: ");
5828   unsigned int saved_eh_addr_size = eh_addr_size;
5829
5830   printf (_("Contents of the %s section:\n"), section->name);
5831
5832   while (start < end)
5833     {
5834       unsigned char *saved_start;
5835       unsigned char *block_end;
5836       dwarf_vma length;
5837       dwarf_vma cie_id;
5838       Frame_Chunk *fc;
5839       Frame_Chunk *cie;
5840       int need_col_headers = 1;
5841       unsigned char *augmentation_data = NULL;
5842       unsigned long augmentation_data_len = 0;
5843       unsigned int encoded_ptr_size = saved_eh_addr_size;
5844       unsigned int offset_size;
5845       unsigned int initial_length_size;
5846       bfd_boolean all_nops;
5847
5848       saved_start = start;
5849
5850       SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5851
5852       if (length == 0)
5853         {
5854           printf ("\n%08lx ZERO terminator\n\n",
5855                     (unsigned long)(saved_start - section_start));
5856           /* Skip any zero terminators that directly follow.
5857              A corrupt section size could have loaded a whole
5858              slew of zero filled memory bytes.  eg
5859              PR 17512: file: 070-19381-0.004.  */
5860           while (start < end && * start == 0)
5861             ++ start;
5862           continue;
5863         }
5864
5865       if (length == 0xffffffff)
5866         {
5867           SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5868           offset_size = 8;
5869           initial_length_size = 12;
5870         }
5871       else
5872         {
5873           offset_size = 4;
5874           initial_length_size = 4;
5875         }
5876
5877       block_end = saved_start + length + initial_length_size;
5878       if (block_end > end || block_end < start)
5879         {
5880           warn ("Invalid length 0x%s in FDE at %#08lx\n",
5881                 dwarf_vmatoa_1 (NULL, length, offset_size),
5882                 (unsigned long) (saved_start - section_start));
5883           block_end = end;
5884         }
5885
5886       SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5887
5888       if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5889                                    || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5890         {
5891           int version;
5892           unsigned int mreg;
5893
5894           start = read_cie (start, end, &cie, &version,
5895                             &augmentation_data_len, &augmentation_data);
5896           /* PR 17512: file: 027-135133-0.005.  */
5897           if (cie == NULL)
5898             break;
5899
5900           fc = cie;
5901           fc->next = chunks;
5902           chunks = fc;
5903           fc->chunk_start = saved_start;
5904           mreg = max_regs > 0 ? max_regs - 1 : 0;
5905           if (mreg < fc->ra)
5906             mreg = fc->ra;
5907           if (frame_need_space (fc, mreg) < 0)
5908             break;
5909           if (fc->fde_encoding)
5910             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5911
5912           printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5913           print_dwarf_vma (length, fc->ptr_size);
5914           print_dwarf_vma (cie_id, offset_size);
5915
5916           if (do_debug_frames_interp)
5917             {
5918               printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5919                       fc->code_factor, fc->data_factor, fc->ra);
5920             }
5921           else
5922             {
5923               printf ("CIE\n");
5924               printf ("  Version:               %d\n", version);
5925               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
5926               if (version >= 4)
5927                 {
5928                   printf ("  Pointer Size:          %u\n", fc->ptr_size);
5929                   printf ("  Segment Size:          %u\n", fc->segment_size);
5930                 }
5931               printf ("  Code alignment factor: %u\n", fc->code_factor);
5932               printf ("  Data alignment factor: %d\n", fc->data_factor);
5933               printf ("  Return address column: %d\n", fc->ra);
5934
5935               if (augmentation_data_len)
5936                 {
5937                   unsigned long i;
5938
5939                   printf ("  Augmentation data:    ");
5940                   for (i = 0; i < augmentation_data_len; ++i)
5941                     /* FIXME: If do_wide is FALSE, then we should
5942                        add carriage returns at 80 columns...  */
5943                     printf (" %02x", augmentation_data[i]);
5944                   putchar ('\n');
5945                 }
5946               putchar ('\n');
5947             }
5948         }
5949       else
5950         {
5951           unsigned char *look_for;
5952           static Frame_Chunk fde_fc;
5953           unsigned long segment_selector;
5954
5955           if (is_eh)
5956             {
5957               dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5958               look_for = start - 4 - ((cie_id ^ sign) - sign);
5959             }
5960           else
5961             look_for = section_start + cie_id;
5962
5963           if (look_for <= saved_start)
5964             {
5965               for (cie = chunks; cie ; cie = cie->next)
5966                 if (cie->chunk_start == look_for)
5967                   break;
5968             }
5969           else
5970             {
5971               for (cie = forward_refs; cie ; cie = cie->next)
5972                 if (cie->chunk_start == look_for)
5973                   break;
5974               if (!cie)
5975                 {
5976                   unsigned int off_size;
5977                   unsigned char *cie_scan;
5978
5979                   cie_scan = look_for;
5980                   off_size = 4;
5981                   SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5982                   if (length == 0xffffffff)
5983                     {
5984                       SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5985                       off_size = 8;
5986                     }
5987                   if (length != 0)
5988                     {
5989                       dwarf_vma c_id;
5990
5991                       SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5992                       if (is_eh
5993                           ? c_id == 0
5994                           : ((off_size == 4 && c_id == DW_CIE_ID)
5995                              || (off_size == 8 && c_id == DW64_CIE_ID)))
5996                         {
5997                           int version;
5998                           unsigned int mreg;
5999
6000                           read_cie (cie_scan, end, &cie, &version,
6001                                     &augmentation_data_len, &augmentation_data);
6002                           /* PR 17512: file: 3450-2098-0.004.  */
6003                           if (cie == NULL)
6004                             {
6005                               warn (_("Failed to read CIE information\n"));
6006                               break;
6007                             }
6008                           cie->next = forward_refs;
6009                           forward_refs = cie;
6010                           cie->chunk_start = look_for;
6011                           mreg = max_regs > 0 ? max_regs - 1 : 0;
6012                           if (mreg < cie->ra)
6013                             mreg = cie->ra;
6014                           if (frame_need_space (cie, mreg) < 0)
6015                             {
6016                               warn (_("Invalid max register\n"));
6017                               break;
6018                             }
6019                           if (cie->fde_encoding)
6020                             encoded_ptr_size
6021                               = size_of_encoded_value (cie->fde_encoding);
6022                         }
6023                     }
6024                 }
6025             }
6026
6027           fc = &fde_fc;
6028           memset (fc, 0, sizeof (Frame_Chunk));
6029
6030           if (!cie)
6031             {
6032               warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
6033                     dwarf_vmatoa_1 (NULL, cie_id, offset_size),
6034                     (unsigned long) (saved_start - section_start));
6035               fc->ncols = 0;
6036               fc->col_type = (short int *) xmalloc (sizeof (short int));
6037               fc->col_offset = (int *) xmalloc (sizeof (int));
6038               if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
6039                 {
6040                   warn (_("Invalid max register\n"));
6041                   break;
6042                 }
6043               cie = fc;
6044               fc->augmentation = "";
6045               fc->fde_encoding = 0;
6046               fc->ptr_size = eh_addr_size;
6047               fc->segment_size = 0;
6048             }
6049           else
6050             {
6051               fc->ncols = cie->ncols;
6052               fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
6053               fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
6054               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
6055               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
6056               fc->augmentation = cie->augmentation;
6057               fc->ptr_size = cie->ptr_size;
6058               eh_addr_size = cie->ptr_size;
6059               fc->segment_size = cie->segment_size;
6060               fc->code_factor = cie->code_factor;
6061               fc->data_factor = cie->data_factor;
6062               fc->cfa_reg = cie->cfa_reg;
6063               fc->cfa_offset = cie->cfa_offset;
6064               fc->ra = cie->ra;
6065               if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
6066                 {
6067                   warn (_("Invalid max register\n"));
6068                   break;
6069                 }
6070               fc->fde_encoding = cie->fde_encoding;
6071             }
6072
6073           if (fc->fde_encoding)
6074             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
6075
6076           segment_selector = 0;
6077           if (fc->segment_size)
6078             {
6079               if (fc->segment_size > sizeof (segment_selector))
6080                 {
6081                   /* PR 17512: file: 9e196b3e.  */
6082                   warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
6083                   fc->segment_size = 4;
6084                 }
6085               SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
6086             }
6087
6088           fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
6089
6090           /* FIXME: It appears that sometimes the final pc_range value is
6091              encoded in less than encoded_ptr_size bytes.  See the x86_64
6092              run of the "objcopy on compressed debug sections" test for an
6093              example of this.  */
6094           SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
6095
6096           if (cie->augmentation[0] == 'z')
6097             {
6098               augmentation_data_len = LEB ();
6099               augmentation_data = start;
6100               start += augmentation_data_len;
6101               /* PR 17512: file: 722-8446-0.004.  */
6102               if (start >= end || ((signed long) augmentation_data_len) < 0)
6103                 {
6104                   warn (_("Corrupt augmentation data length: %lx\n"),
6105                         augmentation_data_len);
6106                   start = end;
6107                   augmentation_data = NULL;
6108                   augmentation_data_len = 0;
6109                 }
6110             }
6111
6112           printf ("\n%08lx %s %s FDE cie=%08lx pc=",
6113                   (unsigned long)(saved_start - section_start),
6114                   dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
6115                   dwarf_vmatoa_1 (NULL, cie_id, offset_size),
6116                   (unsigned long)(cie->chunk_start - section_start));
6117
6118           if (fc->segment_size)
6119             printf ("%04lx:", segment_selector);
6120
6121           printf ("%s..%s\n",
6122                   dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
6123                   dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
6124
6125           if (! do_debug_frames_interp && augmentation_data_len)
6126             {
6127               unsigned long i;
6128
6129               printf ("  Augmentation data:    ");
6130               for (i = 0; i < augmentation_data_len; ++i)
6131                 printf (" %02x", augmentation_data[i]);
6132               putchar ('\n');
6133               putchar ('\n');
6134             }
6135         }
6136
6137       /* At this point, fc is the current chunk, cie (if any) is set, and
6138          we're about to interpret instructions for the chunk.  */
6139       /* ??? At present we need to do this always, since this sizes the
6140          fc->col_type and fc->col_offset arrays, which we write into always.
6141          We should probably split the interpreted and non-interpreted bits
6142          into two different routines, since there's so much that doesn't
6143          really overlap between them.  */
6144       if (1 || do_debug_frames_interp)
6145         {
6146           /* Start by making a pass over the chunk, allocating storage
6147              and taking note of what registers are used.  */
6148           unsigned char *tmp = start;
6149
6150           while (start < block_end)
6151             {
6152               unsigned int reg, op, opa;
6153               unsigned long temp;
6154               unsigned char * new_start;
6155
6156               op = *start++;
6157               opa = op & 0x3f;
6158               if (op & 0xc0)
6159                 op &= 0xc0;
6160
6161               /* Warning: if you add any more cases to this switch, be
6162                  sure to add them to the corresponding switch below.  */
6163               switch (op)
6164                 {
6165                 case DW_CFA_advance_loc:
6166                   break;
6167                 case DW_CFA_offset:
6168                   LEB ();
6169                   if (frame_need_space (fc, opa) >= 0)
6170                     fc->col_type[opa] = DW_CFA_undefined;
6171                   break;
6172                 case DW_CFA_restore:
6173                   if (frame_need_space (fc, opa) >= 0)
6174                     fc->col_type[opa] = DW_CFA_undefined;
6175                   break;
6176                 case DW_CFA_set_loc:
6177                   start += encoded_ptr_size;
6178                   break;
6179                 case DW_CFA_advance_loc1:
6180                   start += 1;
6181                   break;
6182                 case DW_CFA_advance_loc2:
6183                   start += 2;
6184                   break;
6185                 case DW_CFA_advance_loc4:
6186                   start += 4;
6187                   break;
6188                 case DW_CFA_offset_extended:
6189                 case DW_CFA_val_offset:
6190                   reg = LEB (); LEB ();
6191                   if (frame_need_space (fc, reg) >= 0)
6192                     fc->col_type[reg] = DW_CFA_undefined;
6193                   break;
6194                 case DW_CFA_restore_extended:
6195                   reg = LEB ();
6196                   if (frame_need_space (fc, reg) >= 0)
6197                     fc->col_type[reg] = DW_CFA_undefined;
6198                   break;
6199                 case DW_CFA_undefined:
6200                   reg = LEB ();
6201                   if (frame_need_space (fc, reg) >= 0)
6202                     fc->col_type[reg] = DW_CFA_undefined;
6203                   break;
6204                 case DW_CFA_same_value:
6205                   reg = LEB ();
6206                   if (frame_need_space (fc, reg) >= 0)
6207                     fc->col_type[reg] = DW_CFA_undefined;
6208                   break;
6209                 case DW_CFA_register:
6210                   reg = LEB (); LEB ();
6211                   if (frame_need_space (fc, reg) >= 0)
6212                     fc->col_type[reg] = DW_CFA_undefined;
6213                   break;
6214                 case DW_CFA_def_cfa:
6215                   LEB (); LEB ();
6216                   break;
6217                 case DW_CFA_def_cfa_register:
6218                   LEB ();
6219                   break;
6220                 case DW_CFA_def_cfa_offset:
6221                   LEB ();
6222                   break;
6223                 case DW_CFA_def_cfa_expression:
6224                   temp = LEB ();
6225                   new_start = start + temp;
6226                   if (new_start < start)
6227                     {
6228                       warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6229                       start = block_end;
6230                     }
6231                   else
6232                     start = new_start;
6233                   break;
6234                 case DW_CFA_expression:
6235                 case DW_CFA_val_expression:
6236                   reg = LEB ();
6237                   temp = LEB ();
6238                   new_start = start + temp;
6239                   if (new_start < start)
6240                     {
6241                       /* PR 17512: file:306-192417-0.005.  */
6242                       warn (_("Corrupt CFA expression value: %lu\n"), temp);
6243                       start = block_end;
6244                     }
6245                   else
6246                     start = new_start;
6247                   if (frame_need_space (fc, reg) >= 0)
6248                     fc->col_type[reg] = DW_CFA_undefined;
6249                   break;
6250                 case DW_CFA_offset_extended_sf:
6251                 case DW_CFA_val_offset_sf:
6252                   reg = LEB (); SLEB ();
6253                   if (frame_need_space (fc, reg) >= 0)
6254                     fc->col_type[reg] = DW_CFA_undefined;
6255                   break;
6256                 case DW_CFA_def_cfa_sf:
6257                   LEB (); SLEB ();
6258                   break;
6259                 case DW_CFA_def_cfa_offset_sf:
6260                   SLEB ();
6261                   break;
6262                 case DW_CFA_MIPS_advance_loc8:
6263                   start += 8;
6264                   break;
6265                 case DW_CFA_GNU_args_size:
6266                   LEB ();
6267                   break;
6268                 case DW_CFA_GNU_negative_offset_extended:
6269                   reg = LEB (); LEB ();
6270                   if (frame_need_space (fc, reg) >= 0)
6271                     fc->col_type[reg] = DW_CFA_undefined;
6272                   break;
6273                 default:
6274                   break;
6275                 }
6276             }
6277           start = tmp;
6278         }
6279
6280       all_nops = TRUE;
6281
6282       /* Now we know what registers are used, make a second pass over
6283          the chunk, this time actually printing out the info.  */
6284
6285       while (start < block_end)
6286         {
6287           unsigned char * tmp;
6288           unsigned op, opa;
6289           unsigned long ul, reg, roffs;
6290           dwarf_vma l;
6291           dwarf_vma ofs;
6292           dwarf_vma vma;
6293           const char *reg_prefix = "";
6294
6295           op = *start++;
6296           opa = op & 0x3f;
6297           if (op & 0xc0)
6298             op &= 0xc0;
6299
6300           /* Make a note if something other than DW_CFA_nop happens.  */
6301           if (op != DW_CFA_nop)
6302             all_nops = FALSE;
6303
6304           /* Warning: if you add any more cases to this switch, be
6305              sure to add them to the corresponding switch above.  */
6306           switch (op)
6307             {
6308             case DW_CFA_advance_loc:
6309               if (do_debug_frames_interp)
6310                 frame_display_row (fc, &need_col_headers, &max_regs);
6311               else
6312                 printf ("  DW_CFA_advance_loc: %d to %s\n",
6313                         opa * fc->code_factor,
6314                         dwarf_vmatoa_1 (NULL,
6315                                         fc->pc_begin + opa * fc->code_factor,
6316                                         fc->ptr_size));
6317               fc->pc_begin += opa * fc->code_factor;
6318               break;
6319
6320             case DW_CFA_offset:
6321               roffs = LEB ();
6322               if (opa >= (unsigned int) fc->ncols)
6323                 reg_prefix = bad_reg;
6324               if (! do_debug_frames_interp || *reg_prefix != '\0')
6325                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
6326                         reg_prefix, regname (opa, 0),
6327                         roffs * fc->data_factor);
6328               if (*reg_prefix == '\0')
6329                 {
6330                   fc->col_type[opa] = DW_CFA_offset;
6331                   fc->col_offset[opa] = roffs * fc->data_factor;
6332                 }
6333               break;
6334
6335             case DW_CFA_restore:
6336               if (opa >= (unsigned int) fc->ncols)
6337                 reg_prefix = bad_reg;
6338               if (! do_debug_frames_interp || *reg_prefix != '\0')
6339                 printf ("  DW_CFA_restore: %s%s\n",
6340                         reg_prefix, regname (opa, 0));
6341               if (*reg_prefix != '\0')
6342                 break;
6343
6344               if (opa >= (unsigned int) cie->ncols
6345                   || (do_debug_frames_interp
6346                       && cie->col_type[opa] == DW_CFA_unreferenced))
6347                 {
6348                   fc->col_type[opa] = DW_CFA_undefined;
6349                   fc->col_offset[opa] = 0;
6350                 }
6351               else
6352                 {
6353                   fc->col_type[opa] = cie->col_type[opa];
6354                   fc->col_offset[opa] = cie->col_offset[opa];
6355                 }
6356               break;
6357
6358             case DW_CFA_set_loc:
6359               vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
6360               if (do_debug_frames_interp)
6361                 frame_display_row (fc, &need_col_headers, &max_regs);
6362               else
6363                 printf ("  DW_CFA_set_loc: %s\n",
6364                         dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6365               fc->pc_begin = vma;
6366               break;
6367
6368             case DW_CFA_advance_loc1:
6369               SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6370               if (do_debug_frames_interp)
6371                 frame_display_row (fc, &need_col_headers, &max_regs);
6372               else
6373                 printf ("  DW_CFA_advance_loc1: %ld to %s\n",
6374                         (unsigned long) (ofs * fc->code_factor),
6375                         dwarf_vmatoa_1 (NULL,
6376                                         fc->pc_begin + ofs * fc->code_factor,
6377                                         fc->ptr_size));
6378               fc->pc_begin += ofs * fc->code_factor;
6379               break;
6380
6381             case DW_CFA_advance_loc2:
6382               SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
6383               if (do_debug_frames_interp)
6384                 frame_display_row (fc, &need_col_headers, &max_regs);
6385               else
6386                 printf ("  DW_CFA_advance_loc2: %ld to %s\n",
6387                         (unsigned long) (ofs * fc->code_factor),
6388                         dwarf_vmatoa_1 (NULL,
6389                                         fc->pc_begin + ofs * fc->code_factor,
6390                                         fc->ptr_size));
6391               fc->pc_begin += ofs * fc->code_factor;
6392               break;
6393
6394             case DW_CFA_advance_loc4:
6395               SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
6396               if (do_debug_frames_interp)
6397                 frame_display_row (fc, &need_col_headers, &max_regs);
6398               else
6399                 printf ("  DW_CFA_advance_loc4: %ld to %s\n",
6400                         (unsigned long) (ofs * fc->code_factor),
6401                         dwarf_vmatoa_1 (NULL,
6402                                         fc->pc_begin + ofs * fc->code_factor,
6403                                         fc->ptr_size));
6404               fc->pc_begin += ofs * fc->code_factor;
6405               break;
6406
6407             case DW_CFA_offset_extended:
6408               reg = LEB ();
6409               roffs = LEB ();
6410               if (reg >= (unsigned int) fc->ncols)
6411                 reg_prefix = bad_reg;
6412               if (! do_debug_frames_interp || *reg_prefix != '\0')
6413                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6414                         reg_prefix, regname (reg, 0),
6415                         roffs * fc->data_factor);
6416               if (*reg_prefix == '\0')
6417                 {
6418                   fc->col_type[reg] = DW_CFA_offset;
6419                   fc->col_offset[reg] = roffs * fc->data_factor;
6420                 }
6421               break;
6422
6423             case DW_CFA_val_offset:
6424               reg = LEB ();
6425               roffs = LEB ();
6426               if (reg >= (unsigned int) fc->ncols)
6427                 reg_prefix = bad_reg;
6428               if (! do_debug_frames_interp || *reg_prefix != '\0')
6429                 printf ("  DW_CFA_val_offset: %s%s is cfa%+ld\n",
6430                         reg_prefix, regname (reg, 0),
6431                         roffs * fc->data_factor);
6432               if (*reg_prefix == '\0')
6433                 {
6434                   fc->col_type[reg] = DW_CFA_val_offset;
6435                   fc->col_offset[reg] = roffs * fc->data_factor;
6436                 }
6437               break;
6438
6439             case DW_CFA_restore_extended:
6440               reg = LEB ();
6441               if (reg >= (unsigned int) fc->ncols)
6442                 reg_prefix = bad_reg;
6443               if (! do_debug_frames_interp || *reg_prefix != '\0')
6444                 printf ("  DW_CFA_restore_extended: %s%s\n",
6445                         reg_prefix, regname (reg, 0));
6446               if (*reg_prefix != '\0')
6447                 break;
6448
6449               if (reg >= (unsigned int) cie->ncols)
6450                 {
6451                   fc->col_type[reg] = DW_CFA_undefined;
6452                   fc->col_offset[reg] = 0;
6453                 }
6454               else
6455                 {
6456                   fc->col_type[reg] = cie->col_type[reg];
6457                   fc->col_offset[reg] = cie->col_offset[reg];
6458                 }
6459               break;
6460
6461             case DW_CFA_undefined:
6462               reg = LEB ();
6463               if (reg >= (unsigned int) fc->ncols)
6464                 reg_prefix = bad_reg;
6465               if (! do_debug_frames_interp || *reg_prefix != '\0')
6466                 printf ("  DW_CFA_undefined: %s%s\n",
6467                         reg_prefix, regname (reg, 0));
6468               if (*reg_prefix == '\0')
6469                 {
6470                   fc->col_type[reg] = DW_CFA_undefined;
6471                   fc->col_offset[reg] = 0;
6472                 }
6473               break;
6474
6475             case DW_CFA_same_value:
6476               reg = LEB ();
6477               if (reg >= (unsigned int) fc->ncols)
6478                 reg_prefix = bad_reg;
6479               if (! do_debug_frames_interp || *reg_prefix != '\0')
6480                 printf ("  DW_CFA_same_value: %s%s\n",
6481                         reg_prefix, regname (reg, 0));
6482               if (*reg_prefix == '\0')
6483                 {
6484                   fc->col_type[reg] = DW_CFA_same_value;
6485                   fc->col_offset[reg] = 0;
6486                 }
6487               break;
6488
6489             case DW_CFA_register:
6490               reg = LEB ();
6491               roffs = LEB ();
6492               if (reg >= (unsigned int) fc->ncols)
6493                 reg_prefix = bad_reg;
6494               if (! do_debug_frames_interp || *reg_prefix != '\0')
6495                 {
6496                   printf ("  DW_CFA_register: %s%s in ",
6497                           reg_prefix, regname (reg, 0));
6498                   puts (regname (roffs, 0));
6499                 }
6500               if (*reg_prefix == '\0')
6501                 {
6502                   fc->col_type[reg] = DW_CFA_register;
6503                   fc->col_offset[reg] = roffs;
6504                 }
6505               break;
6506
6507             case DW_CFA_remember_state:
6508               if (! do_debug_frames_interp)
6509                 printf ("  DW_CFA_remember_state\n");
6510               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6511               rs->cfa_offset = fc->cfa_offset;
6512               rs->cfa_reg = fc->cfa_reg;
6513               rs->ra = fc->ra;
6514               rs->cfa_exp = fc->cfa_exp;
6515               rs->ncols = fc->ncols;
6516               rs->col_type = (short int *) xcmalloc (rs->ncols,
6517                                                      sizeof (* rs->col_type));
6518               rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6519               memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6520               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6521               rs->next = remembered_state;
6522               remembered_state = rs;
6523               break;
6524
6525             case DW_CFA_restore_state:
6526               if (! do_debug_frames_interp)
6527                 printf ("  DW_CFA_restore_state\n");
6528               rs = remembered_state;
6529               if (rs)
6530                 {
6531                   remembered_state = rs->next;
6532                   fc->cfa_offset = rs->cfa_offset;
6533                   fc->cfa_reg = rs->cfa_reg;
6534                   fc->ra = rs->ra;
6535                   fc->cfa_exp = rs->cfa_exp;
6536                   if (frame_need_space (fc, rs->ncols - 1) < 0)
6537                     {
6538                       warn (_("Invalid column number in saved frame state\n"));
6539                       fc->ncols = 0;
6540                       break;
6541                     }
6542                   memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6543                   memcpy (fc->col_offset, rs->col_offset,
6544                           rs->ncols * sizeof (* rs->col_offset));
6545                   free (rs->col_type);
6546                   free (rs->col_offset);
6547                   free (rs);
6548                 }
6549               else if (do_debug_frames_interp)
6550                 printf ("Mismatched DW_CFA_restore_state\n");
6551               break;
6552
6553             case DW_CFA_def_cfa:
6554               fc->cfa_reg = LEB ();
6555               fc->cfa_offset = LEB ();
6556               fc->cfa_exp = 0;
6557               if (! do_debug_frames_interp)
6558                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
6559                         regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
6560               break;
6561
6562             case DW_CFA_def_cfa_register:
6563               fc->cfa_reg = LEB ();
6564               fc->cfa_exp = 0;
6565               if (! do_debug_frames_interp)
6566                 printf ("  DW_CFA_def_cfa_register: %s\n",
6567                         regname (fc->cfa_reg, 0));
6568               break;
6569
6570             case DW_CFA_def_cfa_offset:
6571               fc->cfa_offset = LEB ();
6572               if (! do_debug_frames_interp)
6573                 printf ("  DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
6574               break;
6575
6576             case DW_CFA_nop:
6577               if (! do_debug_frames_interp)
6578                 printf ("  DW_CFA_nop\n");
6579               break;
6580
6581             case DW_CFA_def_cfa_expression:
6582               ul = LEB ();
6583               if (start >= block_end || ul > (unsigned long) (block_end - start))
6584                 {
6585                   printf (_("  DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6586                   break;
6587                 }
6588               if (! do_debug_frames_interp)
6589                 {
6590                   printf ("  DW_CFA_def_cfa_expression (");
6591                   decode_location_expression (start, eh_addr_size, 0, -1,
6592                                               ul, 0, section);
6593                   printf (")\n");
6594                 }
6595               fc->cfa_exp = 1;
6596               start += ul;
6597               break;
6598
6599             case DW_CFA_expression:
6600               reg = LEB ();
6601               ul = LEB ();
6602               if (reg >= (unsigned int) fc->ncols)
6603                 reg_prefix = bad_reg;
6604               /* PR 17512: file: 069-133014-0.006.  */
6605               /* PR 17512: file: 98c02eb4.  */
6606               tmp = start + ul;
6607               if (start >= block_end || tmp > block_end || tmp < start)
6608                 {
6609                   printf (_("  DW_CFA_expression: <corrupt len %lu>\n"), ul);
6610                   break;
6611                 }
6612               if (! do_debug_frames_interp || *reg_prefix != '\0')
6613                 {
6614                   printf ("  DW_CFA_expression: %s%s (",
6615                           reg_prefix, regname (reg, 0));
6616                   decode_location_expression (start, eh_addr_size, 0, -1,
6617                                               ul, 0, section);
6618                   printf (")\n");
6619                 }
6620               if (*reg_prefix == '\0')
6621                 fc->col_type[reg] = DW_CFA_expression;
6622               start = tmp;
6623               break;
6624
6625             case DW_CFA_val_expression:
6626               reg = LEB ();
6627               ul = LEB ();
6628               if (reg >= (unsigned int) fc->ncols)
6629                 reg_prefix = bad_reg;
6630               tmp = start + ul;
6631               if (start >= block_end || tmp > block_end || tmp < start)
6632                 {
6633                   printf ("  DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6634                   break;
6635                 }
6636               if (! do_debug_frames_interp || *reg_prefix != '\0')
6637                 {
6638                   printf ("  DW_CFA_val_expression: %s%s (",
6639                           reg_prefix, regname (reg, 0));
6640                   decode_location_expression (start, eh_addr_size, 0, -1,
6641                                               ul, 0, section);
6642                   printf (")\n");
6643                 }
6644               if (*reg_prefix == '\0')
6645                 fc->col_type[reg] = DW_CFA_val_expression;
6646               start = tmp;
6647               break;
6648
6649             case DW_CFA_offset_extended_sf:
6650               reg = LEB ();
6651               l = SLEB ();
6652               if (frame_need_space (fc, reg) < 0)
6653                 reg_prefix = bad_reg;
6654               if (! do_debug_frames_interp || *reg_prefix != '\0')
6655                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6656                         reg_prefix, regname (reg, 0),
6657                         (long)(l * fc->data_factor));
6658               if (*reg_prefix == '\0')
6659                 {
6660                   fc->col_type[reg] = DW_CFA_offset;
6661                   fc->col_offset[reg] = l * fc->data_factor;
6662                 }
6663               break;
6664
6665             case DW_CFA_val_offset_sf:
6666               reg = LEB ();
6667               l = SLEB ();
6668               if (frame_need_space (fc, reg) < 0)
6669                 reg_prefix = bad_reg;
6670               if (! do_debug_frames_interp || *reg_prefix != '\0')
6671                 printf ("  DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
6672                         reg_prefix, regname (reg, 0),
6673                         (long)(l * fc->data_factor));
6674               if (*reg_prefix == '\0')
6675                 {
6676                   fc->col_type[reg] = DW_CFA_val_offset;
6677                   fc->col_offset[reg] = l * fc->data_factor;
6678                 }
6679               break;
6680
6681             case DW_CFA_def_cfa_sf:
6682               fc->cfa_reg = LEB ();
6683               fc->cfa_offset = SLEB ();
6684               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6685               fc->cfa_exp = 0;
6686               if (! do_debug_frames_interp)
6687                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
6688                         regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
6689               break;
6690
6691             case DW_CFA_def_cfa_offset_sf:
6692               fc->cfa_offset = SLEB ();
6693               fc->cfa_offset *= fc->data_factor;
6694               if (! do_debug_frames_interp)
6695                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
6696               break;
6697
6698             case DW_CFA_MIPS_advance_loc8:
6699               SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
6700               if (do_debug_frames_interp)
6701                 frame_display_row (fc, &need_col_headers, &max_regs);
6702               else
6703                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6704                         (unsigned long) (ofs * fc->code_factor),
6705                         dwarf_vmatoa_1 (NULL,
6706                                         fc->pc_begin + ofs * fc->code_factor,
6707                                         fc->ptr_size));
6708               fc->pc_begin += ofs * fc->code_factor;
6709               break;
6710
6711             case DW_CFA_GNU_window_save:
6712               if (! do_debug_frames_interp)
6713                 printf ("  DW_CFA_GNU_window_save\n");
6714               break;
6715
6716             case DW_CFA_GNU_args_size:
6717               ul = LEB ();
6718               if (! do_debug_frames_interp)
6719                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
6720               break;
6721
6722             case DW_CFA_GNU_negative_offset_extended:
6723               reg = LEB ();
6724               l = - LEB ();
6725               if (frame_need_space (fc, reg) < 0)
6726                 reg_prefix = bad_reg;
6727               if (! do_debug_frames_interp || *reg_prefix != '\0')
6728                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6729                         reg_prefix, regname (reg, 0),
6730                         (long)(l * fc->data_factor));
6731               if (*reg_prefix == '\0')
6732                 {
6733                   fc->col_type[reg] = DW_CFA_offset;
6734                   fc->col_offset[reg] = l * fc->data_factor;
6735                 }
6736               break;
6737
6738             default:
6739               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6740                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6741               else
6742                 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6743               start = block_end;
6744             }
6745         }
6746
6747       /* Interpret the CFA - as long as it is not completely full of NOPs.  */
6748       if (do_debug_frames_interp && ! all_nops)
6749         frame_display_row (fc, &need_col_headers, &max_regs);
6750
6751       start = block_end;
6752       eh_addr_size = saved_eh_addr_size;
6753     }
6754
6755   printf ("\n");
6756
6757   return 1;
6758 }
6759
6760 #undef GET
6761 #undef LEB
6762 #undef SLEB
6763
6764 static int
6765 display_gdb_index (struct dwarf_section *section,
6766                    void *file ATTRIBUTE_UNUSED)
6767 {
6768   unsigned char *start = section->start;
6769   uint32_t version;
6770   uint32_t cu_list_offset, tu_list_offset;
6771   uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6772   unsigned int cu_list_elements, tu_list_elements;
6773   unsigned int address_table_size, symbol_table_slots;
6774   unsigned char *cu_list, *tu_list;
6775   unsigned char *address_table, *symbol_table, *constant_pool;
6776   unsigned int i;
6777
6778   /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
6779
6780   printf (_("Contents of the %s section:\n"), section->name);
6781
6782   if (section->size < 6 * sizeof (uint32_t))
6783     {
6784       warn (_("Truncated header in the %s section.\n"), section->name);
6785       return 0;
6786     }
6787
6788   version = byte_get_little_endian (start, 4);
6789   printf (_("Version %ld\n"), (long) version);
6790
6791   /* Prior versions are obsolete, and future versions may not be
6792      backwards compatible.  */
6793   if (version < 3 || version > 8)
6794     {
6795       warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6796       return 0;
6797     }
6798   if (version < 4)
6799     warn (_("The address table data in version 3 may be wrong.\n"));
6800   if (version < 5)
6801     warn (_("Version 4 does not support case insensitive lookups.\n"));
6802   if (version < 6)
6803     warn (_("Version 5 does not include inlined functions.\n"));
6804   if (version < 7)
6805       warn (_("Version 6 does not include symbol attributes.\n"));
6806   /* Version 7 indices generated by Gold have bad type unit references,
6807      PR binutils/15021.  But we don't know if the index was generated by
6808      Gold or not, so to avoid worrying users with gdb-generated indices
6809      we say nothing for version 7 here.  */
6810
6811   cu_list_offset = byte_get_little_endian (start + 4, 4);
6812   tu_list_offset = byte_get_little_endian (start + 8, 4);
6813   address_table_offset = byte_get_little_endian (start + 12, 4);
6814   symbol_table_offset = byte_get_little_endian (start + 16, 4);
6815   constant_pool_offset = byte_get_little_endian (start + 20, 4);
6816
6817   if (cu_list_offset > section->size
6818       || tu_list_offset > section->size
6819       || address_table_offset > section->size
6820       || symbol_table_offset > section->size
6821       || constant_pool_offset > section->size)
6822     {
6823       warn (_("Corrupt header in the %s section.\n"), section->name);
6824       return 0;
6825     }
6826
6827   /* PR 17531: file: 418d0a8a.  */
6828   if (tu_list_offset < cu_list_offset)
6829     {
6830       warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6831             tu_list_offset, cu_list_offset);
6832       return 0;
6833     }
6834
6835   cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6836
6837   if (address_table_offset < tu_list_offset)
6838     {
6839       warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6840             address_table_offset, tu_list_offset);
6841       return 0;
6842     }
6843
6844   tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6845
6846   /* PR 17531: file: 18a47d3d.  */
6847   if (symbol_table_offset < address_table_offset)
6848     {
6849       warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6850             symbol_table_offset, address_table_offset);
6851       return 0;
6852     }
6853
6854   address_table_size = symbol_table_offset - address_table_offset;
6855
6856   if (constant_pool_offset < symbol_table_offset)
6857     {
6858       warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6859             constant_pool_offset, symbol_table_offset);
6860       return 0;
6861     }
6862
6863   symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6864
6865   cu_list = start + cu_list_offset;
6866   tu_list = start + tu_list_offset;
6867   address_table = start + address_table_offset;
6868   symbol_table = start + symbol_table_offset;
6869   constant_pool = start + constant_pool_offset;
6870
6871   if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6872     {
6873       warn (_("Address table extends beyond end of section.\n"));
6874       return 0;
6875     }
6876
6877   printf (_("\nCU table:\n"));
6878   for (i = 0; i < cu_list_elements; i += 2)
6879     {
6880       uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6881       uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6882
6883       printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6884               (unsigned long) cu_offset,
6885               (unsigned long) (cu_offset + cu_length - 1));
6886     }
6887
6888   printf (_("\nTU table:\n"));
6889   for (i = 0; i < tu_list_elements; i += 3)
6890     {
6891       uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6892       uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6893       uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6894
6895       printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6896               (unsigned long) tu_offset,
6897               (unsigned long) type_offset);
6898       print_dwarf_vma (signature, 8);
6899       printf ("\n");
6900     }
6901
6902   printf (_("\nAddress table:\n"));
6903   for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6904        i += 2 * 8 + 4)
6905     {
6906       uint64_t low = byte_get_little_endian (address_table + i, 8);
6907       uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6908       uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6909
6910       print_dwarf_vma (low, 8);
6911       print_dwarf_vma (high, 8);
6912       printf (_("%lu\n"), (unsigned long) cu_index);
6913     }
6914
6915   printf (_("\nSymbol table:\n"));
6916   for (i = 0; i < symbol_table_slots; ++i)
6917     {
6918       uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6919       uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6920       uint32_t num_cus, cu;
6921
6922       if (name_offset != 0
6923           || cu_vector_offset != 0)
6924         {
6925           unsigned int j;
6926           unsigned char * adr;
6927
6928           adr = constant_pool + name_offset;
6929           /* PR 17531: file: 5b7b07ad.  */
6930           if (adr < constant_pool || adr >= section->start + section->size)
6931             {
6932               printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6933               warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6934                     name_offset, i);
6935             }
6936           else
6937             printf ("[%3u] %.*s:", i,
6938                     (int) (section->size - (constant_pool_offset + name_offset)),
6939                     constant_pool + name_offset);
6940
6941           adr = constant_pool + cu_vector_offset;
6942           if (adr < constant_pool || adr >= section->start + section->size - 3)
6943             {
6944               printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6945               warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6946                     cu_vector_offset, i);
6947               continue;
6948             }
6949
6950           num_cus = byte_get_little_endian (adr, 4);
6951
6952           adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
6953           if (num_cus * 4 < num_cus
6954               || adr >= section->start + section->size
6955               || adr < constant_pool)
6956             {
6957               printf ("<invalid number of CUs: %d>\n", num_cus);
6958               warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6959                     num_cus, i);
6960               continue;
6961             }
6962
6963           if (num_cus > 1)
6964             printf ("\n");
6965
6966           for (j = 0; j < num_cus; ++j)
6967             {
6968               int is_static;
6969               gdb_index_symbol_kind kind;
6970
6971               cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6972               is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6973               kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6974               cu = GDB_INDEX_CU_VALUE (cu);
6975               /* Convert to TU number if it's for a type unit.  */
6976               if (cu >= cu_list_elements / 2)
6977                 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6978                         (unsigned long) (cu - cu_list_elements / 2));
6979               else
6980                 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6981
6982               printf (" [%s, %s]",
6983                       is_static ? _("static") : _("global"),
6984                       get_gdb_index_symbol_kind_name (kind));
6985               if (num_cus > 1)
6986                 printf ("\n");
6987             }
6988           if (num_cus <= 1)
6989             printf ("\n");
6990         }
6991     }
6992
6993   return 1;
6994 }
6995
6996 /* Pre-allocate enough space for the CU/TU sets needed.  */
6997
6998 static void
6999 prealloc_cu_tu_list (unsigned int nshndx)
7000 {
7001   if (shndx_pool == NULL)
7002     {
7003       shndx_pool_size = nshndx;
7004       shndx_pool_used = 0;
7005       shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
7006                                               sizeof (unsigned int));
7007     }
7008   else
7009     {
7010       shndx_pool_size = shndx_pool_used + nshndx;
7011       shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
7012                                                sizeof (unsigned int));
7013     }
7014 }
7015
7016 static void
7017 add_shndx_to_cu_tu_entry (unsigned int shndx)
7018 {
7019   if (shndx_pool_used >= shndx_pool_size)
7020     {
7021       error (_("Internal error: out of space in the shndx pool.\n"));
7022       return;
7023     }
7024   shndx_pool [shndx_pool_used++] = shndx;
7025 }
7026
7027 static void
7028 end_cu_tu_entry (void)
7029 {
7030   if (shndx_pool_used >= shndx_pool_size)
7031     {
7032       error (_("Internal error: out of space in the shndx pool.\n"));
7033       return;
7034     }
7035   shndx_pool [shndx_pool_used++] = 0;
7036 }
7037
7038 /* Return the short name of a DWARF section given by a DW_SECT enumerator.  */
7039
7040 static const char *
7041 get_DW_SECT_short_name (unsigned int dw_sect)
7042 {
7043   static char buf[16];
7044
7045   switch (dw_sect)
7046     {
7047       case DW_SECT_INFO:
7048         return "info";
7049       case DW_SECT_TYPES:
7050         return "types";
7051       case DW_SECT_ABBREV:
7052         return "abbrev";
7053       case DW_SECT_LINE:
7054         return "line";
7055       case DW_SECT_LOC:
7056         return "loc";
7057       case DW_SECT_STR_OFFSETS:
7058         return "str_off";
7059       case DW_SECT_MACINFO:
7060         return "macinfo";
7061       case DW_SECT_MACRO:
7062         return "macro";
7063       default:
7064         break;
7065     }
7066
7067   snprintf (buf, sizeof (buf), "%d", dw_sect);
7068   return buf;
7069 }
7070
7071 /* Process a CU or TU index.  If DO_DISPLAY is true, print the contents.
7072    These sections are extensions for Fission.
7073    See http://gcc.gnu.org/wiki/DebugFissionDWP.  */
7074
7075 static int
7076 process_cu_tu_index (struct dwarf_section *section, int do_display)
7077 {
7078   unsigned char *phdr = section->start;
7079   unsigned char *limit = phdr + section->size;
7080   unsigned char *phash;
7081   unsigned char *pindex;
7082   unsigned char *ppool;
7083   unsigned int version;
7084   unsigned int ncols = 0;
7085   unsigned int nused;
7086   unsigned int nslots;
7087   unsigned int i;
7088   unsigned int j;
7089   dwarf_vma signature_high;
7090   dwarf_vma signature_low;
7091   char buf[64];
7092
7093   /* PR 17512: file: 002-168123-0.004.  */
7094   if (phdr == NULL)
7095     {
7096       warn (_("Section %s is empty\n"), section->name);
7097       return 0;
7098     }
7099   /* PR 17512: file: 002-376-0.004.  */
7100   if (section->size < 24)
7101     {
7102       warn (_("Section %s is too small to contain a CU/TU header\n"),
7103             section->name);
7104       return 0;
7105     }
7106
7107   SAFE_BYTE_GET (version, phdr, 4, limit);
7108   if (version >= 2)
7109     SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
7110   SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
7111   SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
7112
7113   phash = phdr + 16;
7114   pindex = phash + nslots * 8;
7115   ppool = pindex + nslots * 4;
7116
7117   /* PR 17531: file: 45d69832.  */
7118   if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
7119     {
7120       warn (_("Section %s is too small for %d slots\n"),
7121             section->name, nslots);
7122       return 0;
7123     }
7124
7125   if (do_display)
7126     {
7127       printf (_("Contents of the %s section:\n\n"), section->name);
7128       printf (_("  Version:                 %d\n"), version);
7129       if (version >= 2)
7130         printf (_("  Number of columns:       %d\n"), ncols);
7131       printf (_("  Number of used entries:  %d\n"), nused);
7132       printf (_("  Number of slots:         %d\n\n"), nslots);
7133     }
7134
7135   if (ppool > limit || ppool < phdr)
7136     {
7137       warn (_("Section %s too small for %d hash table entries\n"),
7138             section->name, nslots);
7139       return 0;
7140     }
7141
7142   if (version == 1)
7143     {
7144       if (!do_display)
7145         prealloc_cu_tu_list ((limit - ppool) / 4);
7146       for (i = 0; i < nslots; i++)
7147         {
7148           unsigned char *shndx_list;
7149           unsigned int shndx;
7150
7151           SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
7152           if (signature_high != 0 || signature_low != 0)
7153             {
7154               SAFE_BYTE_GET (j, pindex, 4, limit);
7155               shndx_list = ppool + j * 4;
7156               /* PR 17531: file: 705e010d.  */
7157               if (shndx_list < ppool)
7158                 {
7159                   warn (_("Section index pool located before start of section\n"));
7160                   return 0;
7161                 }
7162
7163               if (do_display)
7164                 printf (_("  [%3d] Signature:  0x%s  Sections: "),
7165                         i, dwarf_vmatoa64 (signature_high, signature_low,
7166                                            buf, sizeof (buf)));
7167               for (;;)
7168                 {
7169                   if (shndx_list >= limit)
7170                     {
7171                       warn (_("Section %s too small for shndx pool\n"),
7172                             section->name);
7173                       return 0;
7174                     }
7175                   SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
7176                   if (shndx == 0)
7177                     break;
7178                   if (do_display)
7179                     printf (" %d", shndx);
7180                   else
7181                     add_shndx_to_cu_tu_entry (shndx);
7182                   shndx_list += 4;
7183                 }
7184               if (do_display)
7185                 printf ("\n");
7186               else
7187                 end_cu_tu_entry ();
7188             }
7189           phash += 8;
7190           pindex += 4;
7191         }
7192     }
7193   else if (version == 2)
7194     {
7195       unsigned int val;
7196       unsigned int dw_sect;
7197       unsigned char *ph = phash;
7198       unsigned char *pi = pindex;
7199       unsigned char *poffsets = ppool + ncols * 4;
7200       unsigned char *psizes = poffsets + nused * ncols * 4;
7201       unsigned char *pend = psizes + nused * ncols * 4;
7202       bfd_boolean is_tu_index;
7203       struct cu_tu_set *this_set = NULL;
7204       unsigned int row;
7205       unsigned char *prow;
7206
7207       is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
7208
7209       /* PR 17531: file: 0dd159bf.
7210          Check for wraparound with an overlarge ncols value.  */
7211       if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
7212         {
7213           warn (_("Overlarge number of columns: %x\n"), ncols);
7214           return 0;
7215         }
7216
7217       if (pend > limit)
7218         {
7219           warn (_("Section %s too small for offset and size tables\n"),
7220                 section->name);
7221           return 0;
7222         }
7223
7224       if (do_display)
7225         {
7226           printf (_("  Offset table\n"));
7227           printf ("  slot  %-16s  ",
7228                  is_tu_index ? _("signature") : _("dwo_id"));
7229         }
7230       else
7231         {
7232           if (is_tu_index)
7233             {
7234               tu_count = nused;
7235               tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7236               this_set = tu_sets;
7237             }
7238           else
7239             {
7240               cu_count = nused;
7241               cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7242               this_set = cu_sets;
7243             }
7244         }
7245
7246       if (do_display)
7247         {
7248           for (j = 0; j < ncols; j++)
7249             {
7250               SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7251               printf (" %8s", get_DW_SECT_short_name (dw_sect));
7252             }
7253           printf ("\n");
7254         }
7255
7256       for (i = 0; i < nslots; i++)
7257         {
7258           SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7259
7260           SAFE_BYTE_GET (row, pi, 4, limit);
7261           if (row != 0)
7262             {
7263               /* PR 17531: file: a05f6ab3.  */
7264               if (row > nused)
7265                 {
7266                   warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7267                         row, nused);
7268                   return 0;
7269                 }
7270
7271               if (!do_display)
7272                 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
7273
7274               prow = poffsets + (row - 1) * ncols * 4;
7275               /* PR 17531: file: b8ce60a8.  */
7276               if (prow < poffsets || prow > limit)
7277                 {
7278                   warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
7279                         row, ncols);
7280                   return 0;
7281                 }
7282
7283               if (do_display)
7284                 printf (_("  [%3d] 0x%s"),
7285                         i, dwarf_vmatoa64 (signature_high, signature_low,
7286                                            buf, sizeof (buf)));
7287               for (j = 0; j < ncols; j++)
7288                 {
7289                   SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7290                   if (do_display)
7291                     printf (" %8d", val);
7292                   else
7293                     {
7294                       SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7295
7296                       /* PR 17531: file: 10796eb3.  */
7297                       if (dw_sect >= DW_SECT_MAX)
7298                         warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7299                       else
7300                         this_set [row - 1].section_offsets [dw_sect] = val;
7301                     }
7302                 }
7303
7304               if (do_display)
7305                 printf ("\n");
7306             }
7307           ph += 8;
7308           pi += 4;
7309         }
7310
7311       ph = phash;
7312       pi = pindex;
7313       if (do_display)
7314         {
7315           printf ("\n");
7316           printf (_("  Size table\n"));
7317           printf ("  slot  %-16s  ",
7318                  is_tu_index ? _("signature") : _("dwo_id"));
7319         }
7320
7321       for (j = 0; j < ncols; j++)
7322         {
7323           SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
7324           if (do_display)
7325             printf (" %8s", get_DW_SECT_short_name (val));
7326         }
7327
7328       if (do_display)
7329         printf ("\n");
7330
7331       for (i = 0; i < nslots; i++)
7332         {
7333           SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7334
7335           SAFE_BYTE_GET (row, pi, 4, limit);
7336           if (row != 0)
7337             {
7338               prow = psizes + (row - 1) * ncols * 4;
7339
7340               if (do_display)
7341                 printf (_("  [%3d] 0x%s"),
7342                         i, dwarf_vmatoa64 (signature_high, signature_low,
7343                                            buf, sizeof (buf)));
7344
7345               for (j = 0; j < ncols; j++)
7346                 {
7347                   SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7348                   if (do_display)
7349                     printf (" %8d", val);
7350                   else
7351                     {
7352                       SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7353                       if (dw_sect >= DW_SECT_MAX)
7354                         warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7355                       else
7356                       this_set [row - 1].section_sizes [dw_sect] = val;
7357                     }
7358                 }
7359
7360               if (do_display)
7361                 printf ("\n");
7362             }
7363
7364           ph += 8;
7365           pi += 4;
7366         }
7367     }
7368   else if (do_display)
7369     printf (_("  Unsupported version (%d)\n"), version);
7370
7371   if (do_display)
7372       printf ("\n");
7373
7374   return 1;
7375 }
7376
7377 /* Load the CU and TU indexes if present.  This will build a list of
7378    section sets that we can use to associate a .debug_info.dwo section
7379    with its associated .debug_abbrev.dwo section in a .dwp file.  */
7380
7381 static void
7382 load_cu_tu_indexes (void *file)
7383 {
7384   /* If we have already loaded (or tried to load) the CU and TU indexes
7385      then do not bother to repeat the task.  */
7386   if (cu_tu_indexes_read)
7387     return;
7388
7389   if (load_debug_section (dwp_cu_index, file))
7390     process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7391
7392   if (load_debug_section (dwp_tu_index, file))
7393     process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7394
7395   cu_tu_indexes_read = 1;
7396 }
7397
7398 /* Find the set of sections that includes section SHNDX.  */
7399
7400 unsigned int *
7401 find_cu_tu_set (void *file, unsigned int shndx)
7402 {
7403   unsigned int i;
7404
7405   load_cu_tu_indexes (file);
7406
7407   /* Find SHNDX in the shndx pool.  */
7408   for (i = 0; i < shndx_pool_used; i++)
7409     if (shndx_pool [i] == shndx)
7410       break;
7411
7412   if (i >= shndx_pool_used)
7413     return NULL;
7414
7415   /* Now backup to find the first entry in the set.  */
7416   while (i > 0 && shndx_pool [i - 1] != 0)
7417     i--;
7418
7419   return shndx_pool + i;
7420 }
7421
7422 /* Display a .debug_cu_index or .debug_tu_index section.  */
7423
7424 static int
7425 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7426 {
7427   return process_cu_tu_index (section, 1);
7428 }
7429
7430 static int
7431 display_debug_not_supported (struct dwarf_section *section,
7432                              void *file ATTRIBUTE_UNUSED)
7433 {
7434   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7435             section->name);
7436
7437   return 1;
7438 }
7439
7440 /* Like malloc, but takes two parameters like calloc.
7441    Verifies that the first parameter is not too large.
7442    Note: does *not* initialise the allocated memory to zero.  */
7443 void *
7444 cmalloc (size_t nmemb, size_t size)
7445 {
7446   /* Check for overflow.  */
7447   if (nmemb >= ~(size_t) 0 / size)
7448     return NULL;
7449
7450   return xmalloc (nmemb * size);
7451 }
7452
7453 /* Like xmalloc, but takes two parameters like calloc.
7454    Verifies that the first parameter is not too large.
7455    Note: does *not* initialise the allocated memory to zero.  */
7456 void *
7457 xcmalloc (size_t nmemb, size_t size)
7458 {
7459   /* Check for overflow.  */
7460   if (nmemb >= ~(size_t) 0 / size)
7461     {
7462       fprintf (stderr,
7463                _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7464                (long) nmemb);
7465       xexit (1);
7466     }
7467
7468   return xmalloc (nmemb * size);
7469 }
7470
7471 /* Like xrealloc, but takes three parameters.
7472    Verifies that the second parameter is not too large.
7473    Note: does *not* initialise any new memory to zero.  */
7474 void *
7475 xcrealloc (void *ptr, size_t nmemb, size_t size)
7476 {
7477   /* Check for overflow.  */
7478   if (nmemb >= ~(size_t) 0 / size)
7479     {
7480       fprintf (stderr,
7481                _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7482                (long) nmemb);
7483       xexit (1);
7484     }
7485
7486   return xrealloc (ptr, nmemb * size);
7487 }
7488
7489 /* Like xcalloc, but verifies that the first parameter is not too large.  */
7490 void *
7491 xcalloc2 (size_t nmemb, size_t size)
7492 {
7493   /* Check for overflow.  */
7494   if (nmemb >= ~(size_t) 0 / size)
7495     {
7496       fprintf (stderr,
7497                _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7498                (long) nmemb);
7499       xexit (1);
7500     }
7501
7502   return xcalloc (nmemb, size);
7503 }
7504
7505 void
7506 free_debug_memory (void)
7507 {
7508   unsigned int i;
7509
7510   free_abbrevs ();
7511
7512   for (i = 0; i < max; i++)
7513     free_debug_section ((enum dwarf_section_display_enum) i);
7514
7515   if (debug_information != NULL)
7516     {
7517       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7518         {
7519           for (i = 0; i < num_debug_info_entries; i++)
7520             {
7521               if (!debug_information [i].max_loc_offsets)
7522                 {
7523                   free (debug_information [i].loc_offsets);
7524                   free (debug_information [i].have_frame_base);
7525                 }
7526               if (!debug_information [i].max_range_lists)
7527                 free (debug_information [i].range_lists);
7528             }
7529         }
7530       free (debug_information);
7531       debug_information = NULL;
7532       alloc_num_debug_info_entries = num_debug_info_entries = 0;
7533     }
7534 }
7535
7536 void
7537 dwarf_select_sections_by_names (const char *names)
7538 {
7539   typedef struct
7540   {
7541     const char * option;
7542     int *        variable;
7543     int          val;
7544   }
7545   debug_dump_long_opts;
7546
7547   static const debug_dump_long_opts opts_table [] =
7548     {
7549       /* Please keep this table alpha- sorted.  */
7550       { "Ranges", & do_debug_ranges, 1 },
7551       { "abbrev", & do_debug_abbrevs, 1 },
7552       { "addr", & do_debug_addr, 1 },
7553       { "aranges", & do_debug_aranges, 1 },
7554       { "cu_index", & do_debug_cu_index, 1 },
7555       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7556       { "frames", & do_debug_frames, 1 },
7557       { "frames-interp", & do_debug_frames_interp, 1 },
7558       /* The special .gdb_index section.  */
7559       { "gdb_index", & do_gdb_index, 1 },
7560       { "info", & do_debug_info, 1 },
7561       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
7562       { "loc",  & do_debug_loc, 1 },
7563       { "macro", & do_debug_macinfo, 1 },
7564       { "pubnames", & do_debug_pubnames, 1 },
7565       { "pubtypes", & do_debug_pubtypes, 1 },
7566       /* This entry is for compatibility
7567          with earlier versions of readelf.  */
7568       { "ranges", & do_debug_aranges, 1 },
7569       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7570       { "str", & do_debug_str, 1 },
7571       /* These trace_* sections are used by Itanium VMS.  */
7572       { "trace_abbrev", & do_trace_abbrevs, 1 },
7573       { "trace_aranges", & do_trace_aranges, 1 },
7574       { "trace_info", & do_trace_info, 1 },
7575       { NULL, NULL, 0 }
7576     };
7577
7578   const char *p;
7579
7580   p = names;
7581   while (*p)
7582     {
7583       const debug_dump_long_opts * entry;
7584
7585       for (entry = opts_table; entry->option; entry++)
7586         {
7587           size_t len = strlen (entry->option);
7588
7589           if (strncmp (p, entry->option, len) == 0
7590               && (p[len] == ',' || p[len] == '\0'))
7591             {
7592               * entry->variable |= entry->val;
7593
7594               /* The --debug-dump=frames-interp option also
7595                  enables the --debug-dump=frames option.  */
7596               if (do_debug_frames_interp)
7597                 do_debug_frames = 1;
7598
7599               p += len;
7600               break;
7601             }
7602         }
7603
7604       if (entry->option == NULL)
7605         {
7606           warn (_("Unrecognized debug option '%s'\n"), p);
7607           p = strchr (p, ',');
7608           if (p == NULL)
7609             break;
7610         }
7611
7612       if (*p == ',')
7613         p++;
7614     }
7615 }
7616
7617 void
7618 dwarf_select_sections_by_letters (const char *letters)
7619 {
7620   unsigned int lindex = 0;
7621
7622   while (letters[lindex])
7623     switch (letters[lindex++])
7624       {
7625       case 'i':
7626         do_debug_info = 1;
7627         break;
7628
7629       case 'a':
7630         do_debug_abbrevs = 1;
7631         break;
7632
7633       case 'l':
7634         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7635         break;
7636
7637       case 'L':
7638         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7639         break;
7640
7641       case 'p':
7642         do_debug_pubnames = 1;
7643         break;
7644
7645       case 't':
7646         do_debug_pubtypes = 1;
7647         break;
7648
7649       case 'r':
7650         do_debug_aranges = 1;
7651         break;
7652
7653       case 'R':
7654         do_debug_ranges = 1;
7655         break;
7656
7657       case 'F':
7658         do_debug_frames_interp = 1;
7659         /* Fall through.  */
7660       case 'f':
7661         do_debug_frames = 1;
7662         break;
7663
7664       case 'm':
7665         do_debug_macinfo = 1;
7666         break;
7667
7668       case 's':
7669         do_debug_str = 1;
7670         break;
7671
7672       case 'o':
7673         do_debug_loc = 1;
7674         break;
7675
7676       default:
7677         warn (_("Unrecognized debug option '%s'\n"), letters);
7678         break;
7679       }
7680 }
7681
7682 void
7683 dwarf_select_sections_all (void)
7684 {
7685   do_debug_info = 1;
7686   do_debug_abbrevs = 1;
7687   do_debug_lines = FLAG_DEBUG_LINES_RAW;
7688   do_debug_pubnames = 1;
7689   do_debug_pubtypes = 1;
7690   do_debug_aranges = 1;
7691   do_debug_ranges = 1;
7692   do_debug_frames = 1;
7693   do_debug_macinfo = 1;
7694   do_debug_str = 1;
7695   do_debug_loc = 1;
7696   do_gdb_index = 1;
7697   do_trace_info = 1;
7698   do_trace_abbrevs = 1;
7699   do_trace_aranges = 1;
7700   do_debug_addr = 1;
7701   do_debug_cu_index = 1;
7702 }
7703
7704 struct dwarf_section_display debug_displays[] =
7705 {
7706   { { ".debug_abbrev",      ".zdebug_abbrev",   NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7707     display_debug_abbrev,   &do_debug_abbrevs,  FALSE },
7708   { { ".debug_aranges",     ".zdebug_aranges",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7709     display_debug_aranges,  &do_debug_aranges,  TRUE },
7710   { { ".debug_frame",       ".zdebug_frame",    NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7711     display_debug_frames,   &do_debug_frames,   TRUE },
7712   { { ".debug_info",        ".zdebug_info",     NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
7713     display_debug_info,     &do_debug_info,     TRUE },
7714   { { ".debug_line",        ".zdebug_line",     NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7715     display_debug_lines,    &do_debug_lines,    TRUE },
7716   { { ".debug_pubnames",    ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7717     display_debug_pubnames, &do_debug_pubnames, FALSE },
7718   { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7719     display_debug_gnu_pubnames, &do_debug_pubnames, FALSE },
7720   { { ".eh_frame",          "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7721     display_debug_frames,   &do_debug_frames,   TRUE },
7722   { { ".debug_macinfo",     ".zdebug_macinfo",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7723     display_debug_macinfo,  &do_debug_macinfo,  FALSE },
7724   { { ".debug_macro",       ".zdebug_macro",    NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7725     display_debug_macro,    &do_debug_macinfo,  TRUE },
7726   { { ".debug_str",         ".zdebug_str",      NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7727     display_debug_str,      &do_debug_str,      FALSE },
7728   { { ".debug_loc",         ".zdebug_loc",      NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7729     display_debug_loc,      &do_debug_loc,      TRUE },
7730   { { ".debug_pubtypes",    ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7731     display_debug_pubnames, &do_debug_pubtypes, FALSE },
7732   { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7733     display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE },
7734   { { ".debug_ranges",      ".zdebug_ranges",   NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7735     display_debug_ranges,   &do_debug_ranges,   TRUE },
7736   { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7737     display_debug_not_supported, NULL,          FALSE },
7738   { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7739     display_debug_not_supported, NULL,          FALSE },
7740   { { ".debug_types",       ".zdebug_types",    NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
7741     display_debug_types,    &do_debug_info,     TRUE },
7742   { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7743     display_debug_not_supported, NULL,          FALSE },
7744   { { ".gdb_index",         "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7745     display_gdb_index,      &do_gdb_index,      FALSE },
7746   { { ".trace_info",        "",                 NULL, NULL, 0, 0, trace_abbrev, NULL, 0, NULL },
7747     display_trace_info,     &do_trace_info,     TRUE },
7748   { { ".trace_abbrev",      "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7749     display_debug_abbrev,   &do_trace_abbrevs,  FALSE },
7750   { { ".trace_aranges",     "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7751     display_debug_aranges,  &do_trace_aranges,  FALSE },
7752   { { ".debug_info.dwo",    ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
7753     display_debug_info,     &do_debug_info,     TRUE },
7754   { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7755     display_debug_abbrev,   &do_debug_abbrevs,  FALSE },
7756   { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
7757     display_debug_types,    &do_debug_info,     TRUE },
7758   { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7759     display_debug_lines,    &do_debug_lines,    TRUE },
7760   { { ".debug_loc.dwo",     ".zdebug_loc.dwo",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7761     display_debug_loc,      &do_debug_loc,      TRUE },
7762   { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7763     display_debug_macro,    &do_debug_macinfo,  TRUE },
7764   { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7765     display_debug_macinfo,  &do_debug_macinfo,  FALSE },
7766   { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7767     display_debug_str,      &do_debug_str,      TRUE },
7768   { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7769     display_debug_str_offsets, NULL,            FALSE },
7770   { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7771     display_debug_str_offsets, NULL,            FALSE },
7772   { { ".debug_addr",        ".zdebug_addr",     NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7773     display_debug_addr,     &do_debug_addr,     TRUE },
7774   { { ".debug_cu_index",    "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7775     display_cu_index,       &do_debug_cu_index, FALSE },
7776   { { ".debug_tu_index",    "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7777     display_cu_index,       &do_debug_cu_index, FALSE },
7778 };