binutils/dwarf.c

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