binutils/dwarf.c

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