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       /* PR 17531: file:4bcd9ce9.  */
2470       else if (abbrev_base >= abbrev_size)
2471         warn (_("Debug info is corrupted, abbrev base (%lx) is larger than abbrev section size (%lx)\n"),
2472               (unsigned long) abbrev_base,
2473               (unsigned long) abbrev_size);
2474       else
2475         process_abbrev_section
2476           (((unsigned char *) debug_displays [abbrev_sec].section.start
2477             + abbrev_base + compunit.cu_abbrev_offset),
2478            ((unsigned char *) debug_displays [abbrev_sec].section.start
2479             + abbrev_base + abbrev_size));
2480
2481       level = 0;
2482       last_level = level;
2483       saved_level = -1;
2484       while (tags < start)
2485         {
2486           unsigned int bytes_read;
2487           unsigned long abbrev_number;
2488           unsigned long die_offset;
2489           abbrev_entry *entry;
2490           abbrev_attr *attr;
2491           int do_printing = 1;
2492
2493           die_offset = tags - section_begin;
2494
2495           abbrev_number = read_uleb128 (tags, & bytes_read, start);
2496           tags += bytes_read;
2497
2498           /* A null DIE marks the end of a list of siblings or it may also be
2499              a section padding.  */
2500           if (abbrev_number == 0)
2501             {
2502               /* Check if it can be a section padding for the last CU.  */
2503               if (level == 0 && start == end)
2504                 {
2505                   unsigned char *chk;
2506
2507                   for (chk = tags; chk < start; chk++)
2508                     if (*chk != 0)
2509                       break;
2510                   if (chk == start)
2511                     break;
2512                 }
2513
2514               if (!do_loc && die_offset >= dwarf_start_die
2515                   && (dwarf_cutoff_level == -1
2516                       || level < dwarf_cutoff_level))
2517                 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2518                         level, die_offset);
2519
2520               --level;
2521               if (level < 0)
2522                 {
2523                   static unsigned num_bogus_warns = 0;
2524
2525                   if (num_bogus_warns < 3)
2526                     {
2527                       warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2528                             die_offset, section->name);
2529                       num_bogus_warns ++;
2530                       if (num_bogus_warns == 3)
2531                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2532                     }
2533                 }
2534               if (dwarf_start_die != 0 && level < saved_level)
2535                 return 1;
2536               continue;
2537             }
2538
2539           if (!do_loc)
2540             {
2541               if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2542                 do_printing = 0;
2543               else
2544                 {
2545                   if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2546                     saved_level = level;
2547                   do_printing = (dwarf_cutoff_level == -1
2548                                  || level < dwarf_cutoff_level);
2549                   if (do_printing)
2550                     printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2551                             level, die_offset, abbrev_number);
2552                   else if (dwarf_cutoff_level == -1
2553                            || last_level < dwarf_cutoff_level)
2554                     printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2555                   last_level = level;
2556                 }
2557             }
2558
2559           /* Scan through the abbreviation list until we reach the
2560              correct entry.  */
2561           for (entry = first_abbrev;
2562                entry && entry->entry != abbrev_number;
2563                entry = entry->next)
2564             continue;
2565
2566           if (entry == NULL)
2567             {
2568               if (!do_loc && do_printing)
2569                 {
2570                   printf ("\n");
2571                   fflush (stdout);
2572                 }
2573               warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2574                     die_offset, abbrev_number);
2575               return 0;
2576             }
2577
2578           if (!do_loc && do_printing)
2579             printf (" (%s)\n", get_TAG_name (entry->tag));
2580
2581           switch (entry->tag)
2582             {
2583             default:
2584               need_base_address = 0;
2585               break;
2586             case DW_TAG_compile_unit:
2587               need_base_address = 1;
2588               break;
2589             case DW_TAG_entry_point:
2590             case DW_TAG_subprogram:
2591               need_base_address = 0;
2592               /* Assuming that there is no DW_AT_frame_base.  */
2593               have_frame_base = 0;
2594               break;
2595             }
2596
2597           for (attr = entry->first_attr;
2598                attr && attr->attribute;
2599                attr = attr->next)
2600             {
2601               debug_info *arg;
2602
2603               if (! do_loc && do_printing)
2604                 /* Show the offset from where the tag was extracted.  */
2605                 printf ("    <%lx>", (unsigned long)(tags - section_begin));
2606
2607               if (debug_information && unit < alloc_num_debug_info_entries)
2608                 arg = debug_information + unit;
2609               else
2610                 arg = NULL;
2611
2612               tags = read_and_display_attr (attr->attribute,
2613                                             attr->form,
2614                                             tags,
2615                                             end,
2616                                             cu_offset,
2617                                             compunit.cu_pointer_size,
2618                                             offset_size,
2619                                             compunit.cu_version,
2620                                             arg,
2621                                             do_loc || ! do_printing,
2622                                             section,
2623                                             this_set);
2624             }
2625
2626           if (entry->children)
2627             ++level;
2628         }
2629     }
2630
2631   /* Set num_debug_info_entries here so that it can be used to check if
2632      we need to process .debug_loc and .debug_ranges sections.  */
2633   if ((do_loc || do_debug_loc || do_debug_ranges)
2634       && num_debug_info_entries == 0
2635       && ! do_types)
2636     {
2637       if (num_units > alloc_num_debug_info_entries)
2638         num_debug_info_entries = alloc_num_debug_info_entries;
2639       else
2640         num_debug_info_entries = num_units;
2641     }
2642
2643   if (!do_loc)
2644     printf ("\n");
2645
2646   return 1;
2647 }
2648
2649 /* Locate and scan the .debug_info section in the file and record the pointer
2650    sizes and offsets for the compilation units in it.  Usually an executable
2651    will have just one pointer size, but this is not guaranteed, and so we try
2652    not to make any assumptions.  Returns zero upon failure, or the number of
2653    compilation units upon success.  */
2654
2655 static unsigned int
2656 load_debug_info (void * file)
2657 {
2658   /* Reset the last pointer size so that we can issue correct error
2659      messages if we are displaying the contents of more than one section.  */
2660   last_pointer_size = 0;
2661   warned_about_missing_comp_units = FALSE;
2662
2663   /* If we have already tried and failed to load the .debug_info
2664      section then do not bother to repeat the task.  */
2665   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2666     return 0;
2667
2668   /* If we already have the information there is nothing else to do.  */
2669   if (num_debug_info_entries > 0)
2670     return num_debug_info_entries;
2671
2672   /* If this is a DWARF package file, load the CU and TU indexes.  */
2673   load_cu_tu_indexes (file);
2674
2675   if (load_debug_section (info, file)
2676       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2677     return num_debug_info_entries;
2678
2679   if (load_debug_section (info_dwo, file)
2680       && process_debug_info (&debug_displays [info_dwo].section, file,
2681                              abbrev_dwo, 1, 0))
2682     return num_debug_info_entries;
2683
2684   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2685   return 0;
2686 }
2687
2688 /* Read a DWARF .debug_line section header starting at DATA.
2689    Upon success returns an updated DATA pointer and the LINFO
2690    structure and the END_OF_SEQUENCE pointer will be filled in.
2691    Otherwise returns NULL.  */
2692
2693 static unsigned char *
2694 read_debug_line_header (struct dwarf_section * section,
2695                         unsigned char * data,
2696                         unsigned char * end,
2697                         DWARF2_Internal_LineInfo * linfo,
2698                         unsigned char ** end_of_sequence)
2699 {
2700   unsigned char *hdrptr;
2701   unsigned int offset_size;
2702   unsigned int initial_length_size;
2703
2704   /* Extract information from the Line Number Program Header.
2705      (section 6.2.4 in the Dwarf3 doc).  */
2706   hdrptr = data;
2707
2708   /* Get and check the length of the block.  */
2709   SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2710
2711   if (linfo->li_length == 0xffffffff)
2712     {
2713       /* This section is 64-bit DWARF 3.  */
2714       SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2715       offset_size = 8;
2716       initial_length_size = 12;
2717     }
2718   else
2719     {
2720       offset_size = 4;
2721       initial_length_size = 4;
2722     }
2723
2724   if (linfo->li_length + initial_length_size > section->size)
2725     {
2726       /* If the length is just a bias against the initial_length_size then
2727          this means that the field has a relocation against it which has not
2728          been applied.  (Ie we are dealing with an object file, not a linked
2729          binary).  Do not complain but instead assume that the rest of the
2730          section applies to this particular header.  */
2731       if (linfo->li_length == - initial_length_size)
2732         {
2733           linfo->li_length = section->size - initial_length_size;
2734         }
2735       else
2736         {
2737           warn (_("The line info appears to be corrupt - the section is too small\n"));
2738           return NULL;
2739         }
2740     }
2741
2742   /* Get and check the version number.  */
2743   SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2744
2745   if (linfo->li_version != 2
2746       && linfo->li_version != 3
2747       && linfo->li_version != 4)
2748     {
2749       warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2750       return NULL;
2751     }
2752
2753   SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2754   SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2755
2756   if (linfo->li_version >= 4)
2757     {
2758       SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2759
2760       if (linfo->li_max_ops_per_insn == 0)
2761         {
2762           warn (_("Invalid maximum operations per insn.\n"));
2763           return NULL;
2764         }
2765     }
2766   else
2767     linfo->li_max_ops_per_insn = 1;
2768
2769   SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2770   SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2771   SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2772   SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2773
2774   * end_of_sequence = data + linfo->li_length + initial_length_size;
2775   /* PR 17512: file:002-117414-0.004.  */
2776   if (* end_of_sequence > end)
2777     {
2778       warn (_("Line length %s extends beyond end of section\n"),
2779             dwarf_vmatoa ("u", linfo->li_length));
2780       * end_of_sequence = end;
2781       return NULL;
2782     }
2783
2784   return hdrptr;
2785 }
2786
2787 static int
2788 display_debug_lines_raw (struct dwarf_section *section,
2789                          unsigned char *data,
2790                          unsigned char *end)
2791 {
2792   unsigned char *start = section->start;
2793
2794   printf (_("Raw dump of debug contents of section %s:\n\n"),
2795           section->name);
2796
2797   while (data < end)
2798     {
2799       static DWARF2_Internal_LineInfo saved_linfo;
2800       DWARF2_Internal_LineInfo linfo;
2801       unsigned char *standard_opcodes;
2802       unsigned char *end_of_sequence;
2803       unsigned int last_dir_entry = 0;
2804       int i;
2805
2806       if (const_strneq (section->name, ".debug_line.")
2807           /* Note: the following does not apply to .debug_line.dwo sections.
2808              These are full debug_line sections.  */
2809           && strcmp (section->name, ".debug_line.dwo") != 0)
2810         {
2811           /* Sections named .debug_line.<foo> are fragments of a .debug_line
2812              section containing just the Line Number Statements.  They are
2813              created by the assembler and intended to be used alongside gcc's
2814              -ffunction-sections command line option.  When the linker's
2815              garbage collection decides to discard a .text.<foo> section it
2816              can then also discard the line number information in .debug_line.<foo>.
2817
2818              Since the section is a fragment it does not have the details
2819              needed to fill out a LineInfo structure, so instead we use the
2820              details from the last full debug_line section that we processed.  */
2821           end_of_sequence = end;
2822           standard_opcodes = NULL;
2823           linfo = saved_linfo;
2824           /* PR 17531: file: 0522b371.  */
2825           if (linfo.li_line_range == 0)
2826             {
2827               warn (_("Partial .debug_line. section encountered without a prior full .debug_line section"));
2828               return 0;
2829             }
2830           reset_state_machine (linfo.li_default_is_stmt);
2831         }
2832       else
2833         {
2834           unsigned char * hdrptr;
2835
2836           if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2837                                                 & end_of_sequence)) == NULL)
2838             return 0;
2839
2840           printf (_("  Offset:                      0x%lx\n"), (long)(data - start));
2841           printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
2842           printf (_("  DWARF Version:               %d\n"), linfo.li_version);
2843           printf (_("  Prologue Length:             %d\n"), linfo.li_prologue_length);
2844           printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
2845           if (linfo.li_version >= 4)
2846             printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2847           printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
2848           printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
2849           printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
2850           printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
2851
2852           /* PR 17512: file: 1665-6428-0.004.  */
2853           if (linfo.li_line_range == 0)
2854             {
2855               warn (_("Line range of 0 is invalid, using 1 instead\n"));
2856               linfo.li_line_range = 1;
2857             }
2858
2859           reset_state_machine (linfo.li_default_is_stmt);
2860
2861           /* Display the contents of the Opcodes table.  */
2862           standard_opcodes = hdrptr;
2863
2864           /* PR 17512: file: 002-417945-0.004.  */
2865           if (standard_opcodes + linfo.li_opcode_base >= end)
2866             {
2867               warn (_("Line Base extends beyond end of section\n"));
2868               return 0;
2869             }
2870
2871           printf (_("\n Opcodes:\n"));
2872
2873           for (i = 1; i < linfo.li_opcode_base; i++)
2874             printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2875
2876           /* Display the contents of the Directory table.  */
2877           data = standard_opcodes + linfo.li_opcode_base - 1;
2878
2879           if (*data == 0)
2880             printf (_("\n The Directory Table is empty.\n"));
2881           else
2882             {
2883               printf (_("\n The Directory Table (offset 0x%lx):\n"),
2884                       (long)(data - start));
2885
2886               while (data < end && *data != 0)
2887                 {
2888                   printf ("  %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
2889
2890                   data += strnlen ((char *) data, end - data) + 1;
2891                 }
2892
2893               /* PR 17512: file: 002-132094-0.004.  */
2894               if (data >= end - 1)
2895                 break;
2896             }
2897
2898           /* Skip the NUL at the end of the table.  */
2899           data++;
2900
2901           /* Display the contents of the File Name table.  */
2902           if (*data == 0)
2903             printf (_("\n The File Name Table is empty.\n"));
2904           else
2905             {
2906               printf (_("\n The File Name Table (offset 0x%lx):\n"),
2907                       (long)(data - start));
2908               printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2909
2910               while (data < end && *data != 0)
2911                 {
2912                   unsigned char *name;
2913                   unsigned int bytes_read;
2914
2915                   printf ("  %d\t", ++state_machine_regs.last_file_entry);
2916                   name = data;
2917                   data += strnlen ((char *) data, end - data) + 1;
2918
2919                   printf ("%s\t",
2920                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2921                   data += bytes_read;
2922                   printf ("%s\t",
2923                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2924                   data += bytes_read;
2925                   printf ("%s\t",
2926                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2927                   data += bytes_read;
2928                   printf ("%.*s\n", (int)(end - name), name);
2929
2930                   if (data == end)
2931                     {
2932                       warn (_("Corrupt file name table entry\n"));
2933                       break;
2934                     }
2935                 }
2936             }
2937
2938           /* Skip the NUL at the end of the table.  */
2939           data++;
2940           putchar ('\n');
2941           saved_linfo = linfo;
2942         }
2943
2944       /* Now display the statements.  */
2945       if (data >= end_of_sequence)
2946         printf (_(" No Line Number Statements.\n"));
2947       else
2948         {
2949           printf (_(" Line Number Statements:\n"));
2950
2951           while (data < end_of_sequence)
2952             {
2953               unsigned char op_code;
2954               dwarf_signed_vma adv;
2955               dwarf_vma uladv;
2956               unsigned int bytes_read;
2957
2958               printf ("  [0x%08lx]", (long)(data - start));
2959
2960               op_code = *data++;
2961
2962               if (op_code >= linfo.li_opcode_base)
2963                 {
2964                   op_code -= linfo.li_opcode_base;
2965                   uladv = (op_code / linfo.li_line_range);
2966                   if (linfo.li_max_ops_per_insn == 1)
2967                     {
2968                       uladv *= linfo.li_min_insn_length;
2969                       state_machine_regs.address += uladv;
2970                       printf (_("  Special opcode %d: "
2971                                 "advance Address by %s to 0x%s"),
2972                               op_code, dwarf_vmatoa ("u", uladv),
2973                               dwarf_vmatoa ("x", state_machine_regs.address));
2974                     }
2975                   else
2976                     {
2977                       state_machine_regs.address
2978                         += ((state_machine_regs.op_index + uladv)
2979                             / linfo.li_max_ops_per_insn)
2980                         * linfo.li_min_insn_length;
2981                       state_machine_regs.op_index
2982                         = (state_machine_regs.op_index + uladv)
2983                         % linfo.li_max_ops_per_insn;
2984                       printf (_("  Special opcode %d: "
2985                                 "advance Address by %s to 0x%s[%d]"),
2986                               op_code, dwarf_vmatoa ("u", uladv),
2987                               dwarf_vmatoa ("x", state_machine_regs.address),
2988                               state_machine_regs.op_index);
2989                     }
2990                   adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2991                   state_machine_regs.line += adv;
2992                   printf (_(" and Line by %s to %d\n"),
2993                           dwarf_vmatoa ("d", adv), state_machine_regs.line);
2994                 }
2995               else switch (op_code)
2996                      {
2997                      case DW_LNS_extended_op:
2998                        data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
2999                        break;
3000
3001                      case DW_LNS_copy:
3002                        printf (_("  Copy\n"));
3003                        break;
3004
3005                      case DW_LNS_advance_pc:
3006                        uladv = read_uleb128 (data, & bytes_read, end);
3007                        data += bytes_read;
3008                        if (linfo.li_max_ops_per_insn == 1)
3009                          {
3010                            uladv *= linfo.li_min_insn_length;
3011                            state_machine_regs.address += uladv;
3012                            printf (_("  Advance PC by %s to 0x%s\n"),
3013                                    dwarf_vmatoa ("u", uladv),
3014                                    dwarf_vmatoa ("x", state_machine_regs.address));
3015                          }
3016                        else
3017                          {
3018                            state_machine_regs.address
3019                              += ((state_machine_regs.op_index + uladv)
3020                                  / linfo.li_max_ops_per_insn)
3021                              * linfo.li_min_insn_length;
3022                            state_machine_regs.op_index
3023                              = (state_machine_regs.op_index + uladv)
3024                              % linfo.li_max_ops_per_insn;
3025                            printf (_("  Advance PC by %s to 0x%s[%d]\n"),
3026                                    dwarf_vmatoa ("u", uladv),
3027                                    dwarf_vmatoa ("x", state_machine_regs.address),
3028                                    state_machine_regs.op_index);
3029                          }
3030                        break;
3031
3032                      case DW_LNS_advance_line:
3033                        adv = read_sleb128 (data, & bytes_read, end);
3034                        data += bytes_read;
3035                        state_machine_regs.line += adv;
3036                        printf (_("  Advance Line by %s to %d\n"),
3037                                dwarf_vmatoa ("d", adv),
3038                                state_machine_regs.line);
3039                        break;
3040
3041                      case DW_LNS_set_file:
3042                        adv = read_uleb128 (data, & bytes_read, end);
3043                        data += bytes_read;
3044                        printf (_("  Set File Name to entry %s in the File Name Table\n"),
3045                                dwarf_vmatoa ("d", adv));
3046                        state_machine_regs.file = adv;
3047                        break;
3048
3049                      case DW_LNS_set_column:
3050                        uladv = read_uleb128 (data, & bytes_read, end);
3051                        data += bytes_read;
3052                        printf (_("  Set column to %s\n"),
3053                                dwarf_vmatoa ("u", uladv));
3054                        state_machine_regs.column = uladv;
3055                        break;
3056
3057                      case DW_LNS_negate_stmt:
3058                        adv = state_machine_regs.is_stmt;
3059                        adv = ! adv;
3060                        printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3061                        state_machine_regs.is_stmt = adv;
3062                        break;
3063
3064                      case DW_LNS_set_basic_block:
3065                        printf (_("  Set basic block\n"));
3066                        state_machine_regs.basic_block = 1;
3067                        break;
3068
3069                      case DW_LNS_const_add_pc:
3070                        uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3071                        if (linfo.li_max_ops_per_insn)
3072                          {
3073                            uladv *= linfo.li_min_insn_length;
3074                            state_machine_regs.address += uladv;
3075                            printf (_("  Advance PC by constant %s to 0x%s\n"),
3076                                    dwarf_vmatoa ("u", uladv),
3077                                    dwarf_vmatoa ("x", state_machine_regs.address));
3078                          }
3079                        else
3080                          {
3081                            state_machine_regs.address
3082                              += ((state_machine_regs.op_index + uladv)
3083                                  / linfo.li_max_ops_per_insn)
3084                              * linfo.li_min_insn_length;
3085                            state_machine_regs.op_index
3086                              = (state_machine_regs.op_index + uladv)
3087                              % linfo.li_max_ops_per_insn;
3088                            printf (_("  Advance PC by constant %s to 0x%s[%d]\n"),
3089                                    dwarf_vmatoa ("u", uladv),
3090                                    dwarf_vmatoa ("x", state_machine_regs.address),
3091                                    state_machine_regs.op_index);
3092                          }
3093                        break;
3094
3095                      case DW_LNS_fixed_advance_pc:
3096                        SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3097                        state_machine_regs.address += uladv;
3098                        state_machine_regs.op_index = 0;
3099                        printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
3100                                dwarf_vmatoa ("u", uladv),
3101                                dwarf_vmatoa ("x", state_machine_regs.address));
3102                        break;
3103
3104                      case DW_LNS_set_prologue_end:
3105                        printf (_("  Set prologue_end to true\n"));
3106                        break;
3107
3108                      case DW_LNS_set_epilogue_begin:
3109                        printf (_("  Set epilogue_begin to true\n"));
3110                        break;
3111
3112                      case DW_LNS_set_isa:
3113                        uladv = read_uleb128 (data, & bytes_read, end);
3114                        data += bytes_read;
3115                        printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3116                        break;
3117
3118                      default:
3119                        printf (_("  Unknown opcode %d with operands: "), op_code);
3120
3121                        if (standard_opcodes != NULL)
3122                          for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3123                            {
3124                              printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3125                                                                                 &bytes_read, end)),
3126                                      i == 1 ? "" : ", ");
3127                              data += bytes_read;
3128                            }
3129                        putchar ('\n');
3130                        break;
3131                      }
3132             }
3133           putchar ('\n');
3134         }
3135     }
3136
3137   return 1;
3138 }
3139
3140 typedef struct
3141 {
3142   unsigned char *name;
3143   unsigned int directory_index;
3144   unsigned int modification_date;
3145   unsigned int length;
3146 } File_Entry;
3147
3148 /* Output a decoded representation of the .debug_line section.  */
3149
3150 static int
3151 display_debug_lines_decoded (struct dwarf_section *section,
3152                              unsigned char *data,
3153                              unsigned char *end)
3154 {
3155   static DWARF2_Internal_LineInfo saved_linfo;
3156
3157   printf (_("Decoded dump of debug contents of section %s:\n\n"),
3158           section->name);
3159
3160   while (data < end)
3161     {
3162       /* This loop amounts to one iteration per compilation unit.  */
3163       DWARF2_Internal_LineInfo linfo;
3164       unsigned char *standard_opcodes;
3165       unsigned char *end_of_sequence;
3166       int i;
3167       File_Entry *file_table = NULL;
3168       unsigned int n_files = 0;
3169       unsigned char **directory_table = NULL;
3170       unsigned int n_directories = 0;
3171
3172       if (const_strneq (section->name, ".debug_line.")
3173           /* Note: the following does not apply to .debug_line.dwo sections.
3174              These are full debug_line sections.  */
3175           && strcmp (section->name, ".debug_line.dwo") != 0)
3176         {
3177           /* See comment in display_debug_lines_raw().  */
3178           end_of_sequence = end;
3179           standard_opcodes = NULL;
3180           linfo = saved_linfo;
3181           /* PR 17531: file: 0522b371.  */
3182           if (linfo.li_line_range == 0)
3183             {
3184               warn (_("Partial .debug_line. section encountered without a prior full .debug_line section"));
3185               return 0;
3186             }
3187           reset_state_machine (linfo.li_default_is_stmt);
3188         }
3189       else
3190         {
3191           unsigned char *hdrptr;
3192
3193           if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3194                                                 & end_of_sequence)) == NULL)
3195               return 0;
3196
3197           /* PR 17531: file: 0522b371.  */
3198           if (linfo.li_line_range == 0)
3199             {
3200               warn (_("Line range of 0 is invalid, using 1 instead\n"));
3201               linfo.li_line_range = 1;
3202             }
3203           reset_state_machine (linfo.li_default_is_stmt);
3204
3205           /* Save a pointer to the contents of the Opcodes table.  */
3206           standard_opcodes = hdrptr;
3207
3208           /* Traverse the Directory table just to count entries.  */
3209           data = standard_opcodes + linfo.li_opcode_base - 1;
3210           if (*data != 0)
3211             {
3212               unsigned char *ptr_directory_table = data;
3213
3214               while (*data != 0)
3215                 {
3216                   data += strnlen ((char *) data, end - data) + 1;
3217                   n_directories++;
3218                 }
3219
3220               /* Go through the directory table again to save the directories.  */
3221               directory_table = (unsigned char **)
3222                 xmalloc (n_directories * sizeof (unsigned char *));
3223
3224               i = 0;
3225               while (*ptr_directory_table != 0)
3226                 {
3227                   directory_table[i] = ptr_directory_table;
3228                   ptr_directory_table += strnlen ((char *) ptr_directory_table,
3229                                                   ptr_directory_table - end) + 1;
3230                   i++;
3231                 }
3232             }
3233           /* Skip the NUL at the end of the table.  */
3234           data++;
3235
3236           /* Traverse the File Name table just to count the entries.  */
3237           if (*data != 0)
3238             {
3239               unsigned char *ptr_file_name_table = data;
3240
3241               while (*data != 0)
3242                 {
3243                   unsigned int bytes_read;
3244
3245                   /* Skip Name, directory index, last modification time and length
3246                      of file.  */
3247                   data += strnlen ((char *) data, end - data) + 1;
3248                   read_uleb128 (data, & bytes_read, end);
3249                   data += bytes_read;
3250                   read_uleb128 (data, & bytes_read, end);
3251                   data += bytes_read;
3252                   read_uleb128 (data, & bytes_read, end);
3253                   data += bytes_read;
3254
3255                   n_files++;
3256                 }
3257
3258               /* Go through the file table again to save the strings.  */
3259               file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3260
3261               i = 0;
3262               while (*ptr_file_name_table != 0)
3263                 {
3264                   unsigned int bytes_read;
3265
3266                   file_table[i].name = ptr_file_name_table;
3267                   ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3268                                                   end - ptr_file_name_table) + 1;
3269
3270                   /* We are not interested in directory, time or size.  */
3271                   file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3272                                                                 & bytes_read, end);
3273                   ptr_file_name_table += bytes_read;
3274                   file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3275                                                                   & bytes_read, end);
3276                   ptr_file_name_table += bytes_read;
3277                   file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3278                   ptr_file_name_table += bytes_read;
3279                   i++;
3280                 }
3281               i = 0;
3282
3283               /* Print the Compilation Unit's name and a header.  */
3284               if (directory_table == NULL)
3285                 {
3286                   printf (_("CU: %s:\n"), file_table[0].name);
3287                   printf (_("File name                            Line number    Starting address\n"));
3288                 }
3289               else
3290                 {
3291                   unsigned int ix = file_table[0].directory_index;
3292                   const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
3293
3294                   if (do_wide || strlen (directory) < 76)
3295                     printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3296                   else
3297                     printf ("%s:\n", file_table[0].name);
3298
3299                   printf (_("File name                            Line number    Starting address\n"));
3300                 }
3301             }
3302
3303           /* Skip the NUL at the end of the table.  */
3304           data++;
3305
3306           saved_linfo = linfo;
3307         }
3308
3309       /* This loop iterates through the Dwarf Line Number Program.  */
3310       while (data < end_of_sequence)
3311         {
3312           unsigned char op_code;
3313           int adv;
3314           unsigned long int uladv;
3315           unsigned int bytes_read;
3316           int is_special_opcode = 0;
3317
3318           op_code = *data++;
3319
3320           if (op_code >= linfo.li_opcode_base)
3321             {
3322               op_code -= linfo.li_opcode_base;
3323               uladv = (op_code / linfo.li_line_range);
3324               if (linfo.li_max_ops_per_insn == 1)
3325                 {
3326                   uladv *= linfo.li_min_insn_length;
3327                   state_machine_regs.address += uladv;
3328                 }
3329               else
3330                 {
3331                   state_machine_regs.address
3332                     += ((state_machine_regs.op_index + uladv)
3333                         / linfo.li_max_ops_per_insn)
3334                     * linfo.li_min_insn_length;
3335                   state_machine_regs.op_index
3336                     = (state_machine_regs.op_index + uladv)
3337                     % linfo.li_max_ops_per_insn;
3338                 }
3339
3340               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3341               state_machine_regs.line += adv;
3342               is_special_opcode = 1;
3343             }
3344           else switch (op_code)
3345                  {
3346                  case DW_LNS_extended_op:
3347                    {
3348                      unsigned int ext_op_code_len;
3349                      unsigned char ext_op_code;
3350                      unsigned char *op_code_data = data;
3351
3352                      ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3353                                                      end_of_sequence);
3354                      op_code_data += bytes_read;
3355
3356                      if (ext_op_code_len == 0)
3357                        {
3358                          warn (_("Badly formed extended line op encountered!\n"));
3359                          break;
3360                        }
3361                      ext_op_code_len += bytes_read;
3362                      ext_op_code = *op_code_data++;
3363
3364                      switch (ext_op_code)
3365                        {
3366                        case DW_LNE_end_sequence:
3367                          reset_state_machine (linfo.li_default_is_stmt);
3368                          break;
3369                        case DW_LNE_set_address:
3370                          SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3371                                                 op_code_data,
3372                                                 ext_op_code_len - bytes_read - 1,
3373                                                 end);
3374                          state_machine_regs.op_index = 0;
3375                          break;
3376                        case DW_LNE_define_file:
3377                          {
3378                            file_table = (File_Entry *) xrealloc
3379                              (file_table, (n_files + 1) * sizeof (File_Entry));
3380
3381                            ++state_machine_regs.last_file_entry;
3382                            /* Source file name.  */
3383                            file_table[n_files].name = op_code_data;
3384                            op_code_data += strlen ((char *) op_code_data) + 1;
3385                            /* Directory index.  */
3386                            file_table[n_files].directory_index =
3387                              read_uleb128 (op_code_data, & bytes_read,
3388                                            end_of_sequence);
3389                            op_code_data += bytes_read;
3390                            /* Last modification time.  */
3391                            file_table[n_files].modification_date =
3392                              read_uleb128 (op_code_data, & bytes_read,
3393                                            end_of_sequence);
3394                            op_code_data += bytes_read;
3395                            /* File length.  */
3396                            file_table[n_files].length =
3397                              read_uleb128 (op_code_data, & bytes_read,
3398                                            end_of_sequence);
3399
3400                            n_files++;
3401                            break;
3402                          }
3403                        case DW_LNE_set_discriminator:
3404                        case DW_LNE_HP_set_sequence:
3405                          /* Simply ignored.  */
3406                          break;
3407
3408                        default:
3409                          printf (_("UNKNOWN (%u): length %d\n"),
3410                                  ext_op_code, ext_op_code_len - bytes_read);
3411                          break;
3412                        }
3413                      data += ext_op_code_len;
3414                      break;
3415                    }
3416                  case DW_LNS_copy:
3417                    break;
3418
3419                  case DW_LNS_advance_pc:
3420                    uladv = read_uleb128 (data, & bytes_read, end);
3421                    data += bytes_read;
3422                    if (linfo.li_max_ops_per_insn == 1)
3423                      {
3424                        uladv *= linfo.li_min_insn_length;
3425                        state_machine_regs.address += uladv;
3426                      }
3427                    else
3428                      {
3429                        state_machine_regs.address
3430                          += ((state_machine_regs.op_index + uladv)
3431                              / linfo.li_max_ops_per_insn)
3432                          * linfo.li_min_insn_length;
3433                        state_machine_regs.op_index
3434                          = (state_machine_regs.op_index + uladv)
3435                          % linfo.li_max_ops_per_insn;
3436                      }
3437                    break;
3438
3439                  case DW_LNS_advance_line:
3440                    adv = read_sleb128 (data, & bytes_read, end);
3441                    data += bytes_read;
3442                    state_machine_regs.line += adv;
3443                    break;
3444
3445                  case DW_LNS_set_file:
3446                    adv = read_uleb128 (data, & bytes_read, end);
3447                    data += bytes_read;
3448                    state_machine_regs.file = adv;
3449
3450                    if (file_table == NULL)
3451                      printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3452                    else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3453                      /* If directory index is 0, that means current directory.  */
3454                      printf ("\n./%s:[++]\n",
3455                              file_table[state_machine_regs.file - 1].name);
3456                    else if (directory_table == NULL)
3457                      printf (_("\n [Use directory table entry %d]\n"),
3458                              file_table[state_machine_regs.file - 1].directory_index - 1);
3459                    else
3460                      /* The directory index starts counting at 1.  */
3461                      printf ("\n%s/%s:\n",
3462                              directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3463                              file_table[state_machine_regs.file - 1].name);
3464                    break;
3465
3466                  case DW_LNS_set_column:
3467                    uladv = read_uleb128 (data, & bytes_read, end);
3468                    data += bytes_read;
3469                    state_machine_regs.column = uladv;
3470                    break;
3471
3472                  case DW_LNS_negate_stmt:
3473                    adv = state_machine_regs.is_stmt;
3474                    adv = ! adv;
3475                    state_machine_regs.is_stmt = adv;
3476                    break;
3477
3478                  case DW_LNS_set_basic_block:
3479                    state_machine_regs.basic_block = 1;
3480                    break;
3481
3482                  case DW_LNS_const_add_pc:
3483                    uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3484                    if (linfo.li_max_ops_per_insn == 1)
3485                      {
3486                        uladv *= linfo.li_min_insn_length;
3487                        state_machine_regs.address += uladv;
3488                      }
3489                    else
3490                      {
3491                        state_machine_regs.address
3492                          += ((state_machine_regs.op_index + uladv)
3493                              / linfo.li_max_ops_per_insn)
3494                          * linfo.li_min_insn_length;
3495                        state_machine_regs.op_index
3496                          = (state_machine_regs.op_index + uladv)
3497                          % linfo.li_max_ops_per_insn;
3498                      }
3499                    break;
3500
3501                  case DW_LNS_fixed_advance_pc:
3502                    SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3503                    state_machine_regs.address += uladv;
3504                    state_machine_regs.op_index = 0;
3505                    break;
3506
3507                  case DW_LNS_set_prologue_end:
3508                    break;
3509
3510                  case DW_LNS_set_epilogue_begin:
3511                    break;
3512
3513                  case DW_LNS_set_isa:
3514                    uladv = read_uleb128 (data, & bytes_read, end);
3515                    data += bytes_read;
3516                    printf (_("  Set ISA to %lu\n"), uladv);
3517                    break;
3518
3519                  default:
3520                    printf (_("  Unknown opcode %d with operands: "), op_code);
3521
3522                    if (standard_opcodes != NULL)
3523                      for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3524                        {
3525                          printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3526                                                                             &bytes_read, end)),
3527                                  i == 1 ? "" : ", ");
3528                          data += bytes_read;
3529                        }
3530                    putchar ('\n');
3531                    break;
3532                  }
3533
3534           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3535              to the DWARF address/line matrix.  */
3536           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3537               || (op_code == DW_LNS_copy))
3538             {
3539               const unsigned int MAX_FILENAME_LENGTH = 35;
3540               char *fileName;
3541               char *newFileName = NULL;
3542               size_t fileNameLength;
3543
3544               if (file_table)
3545                 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3546               else
3547                 fileName = "<unknown>";
3548
3549               fileNameLength = strlen (fileName);
3550
3551               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3552                 {
3553                   newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3554                   /* Truncate file name */
3555                   strncpy (newFileName,
3556                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
3557                            MAX_FILENAME_LENGTH + 1);
3558                 }
3559               else
3560                 {
3561                   newFileName = (char *) xmalloc (fileNameLength + 1);
3562                   strncpy (newFileName, fileName, fileNameLength + 1);
3563                 }
3564
3565               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3566                 {
3567                   if (linfo.li_max_ops_per_insn == 1)
3568                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
3569                             newFileName, state_machine_regs.line,
3570                             state_machine_regs.address);
3571                   else
3572                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3573                             newFileName, state_machine_regs.line,
3574                             state_machine_regs.address,
3575                             state_machine_regs.op_index);
3576                 }
3577               else
3578                 {
3579                   if (linfo.li_max_ops_per_insn == 1)
3580                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
3581                             newFileName, state_machine_regs.line,
3582                             state_machine_regs.address);
3583                   else
3584                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3585                             newFileName, state_machine_regs.line,
3586                             state_machine_regs.address,
3587                             state_machine_regs.op_index);
3588                 }
3589
3590               if (op_code == DW_LNE_end_sequence)
3591                 printf ("\n");
3592
3593               free (newFileName);
3594             }
3595         }
3596
3597       if (file_table)
3598         {
3599           free (file_table);
3600           file_table = NULL;
3601           n_files = 0;
3602         }
3603
3604       if (directory_table)
3605         {
3606           free (directory_table);
3607           directory_table = NULL;
3608           n_directories = 0;
3609         }
3610
3611       putchar ('\n');
3612     }
3613
3614   return 1;
3615 }
3616
3617 static int
3618 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3619 {
3620   unsigned char *data = section->start;
3621   unsigned char *end = data + section->size;
3622   int retValRaw = 1;
3623   int retValDecoded = 1;
3624
3625   if (do_debug_lines == 0)
3626     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3627
3628   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3629     retValRaw = display_debug_lines_raw (section, data, end);
3630
3631   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3632     retValDecoded = display_debug_lines_decoded (section, data, end);
3633
3634   if (!retValRaw || !retValDecoded)
3635     return 0;
3636
3637   return 1;
3638 }
3639
3640 static debug_info *
3641 find_debug_info_for_offset (unsigned long offset)
3642 {
3643   unsigned int i;
3644
3645   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3646     return NULL;
3647
3648   for (i = 0; i < num_debug_info_entries; i++)
3649     if (debug_information[i].cu_offset == offset)
3650       return debug_information + i;
3651
3652   return NULL;
3653 }
3654
3655 static const char *
3656 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3657 {
3658   /* See gdb/gdb-index.h.  */
3659   static const char * const kinds[] =
3660   {
3661     N_ ("no info"),
3662     N_ ("type"),
3663     N_ ("variable"),
3664     N_ ("function"),
3665     N_ ("other"),
3666     N_ ("unused5"),
3667     N_ ("unused6"),
3668     N_ ("unused7")
3669   };
3670
3671   return _ (kinds[kind]);
3672 }
3673
3674 static int
3675 display_debug_pubnames_worker (struct dwarf_section *section,
3676                                void *file ATTRIBUTE_UNUSED,
3677                                int is_gnu)
3678 {
3679   DWARF2_Internal_PubNames names;
3680   unsigned char *start = section->start;
3681   unsigned char *end = start + section->size;
3682
3683   /* It does not matter if this load fails,
3684      we test for that later on.  */
3685   load_debug_info (file);
3686
3687   printf (_("Contents of the %s section:\n\n"), section->name);
3688
3689   while (start < end)
3690     {
3691       unsigned char *data;
3692       unsigned long offset;
3693       unsigned int offset_size, initial_length_size;
3694
3695       data = start;
3696
3697       SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
3698       if (names.pn_length == 0xffffffff)
3699         {
3700           SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
3701           offset_size = 8;
3702           initial_length_size = 12;
3703         }
3704       else
3705         {
3706           offset_size = 4;
3707           initial_length_size = 4;
3708         }
3709
3710       SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3711       SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
3712
3713       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3714           && num_debug_info_entries > 0
3715           && find_debug_info_for_offset (names.pn_offset) == NULL)
3716         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3717               (unsigned long) names.pn_offset, section->name);
3718
3719       SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
3720
3721       /* PR 17531: file: 7615b6b2.  */
3722       if ((dwarf_signed_vma) names.pn_length < 0)
3723         {
3724           warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
3725           start = end;
3726         }
3727       else
3728         start += names.pn_length + initial_length_size;
3729
3730       printf (_("  Length:                              %ld\n"),
3731               (long) names.pn_length);
3732       printf (_("  Version:                             %d\n"),
3733               names.pn_version);
3734       printf (_("  Offset into .debug_info section:     0x%lx\n"),
3735               (unsigned long) names.pn_offset);
3736       printf (_("  Size of area in .debug_info section: %ld\n"),
3737               (long) names.pn_size);
3738
3739       if (names.pn_version != 2 && names.pn_version != 3)
3740         {
3741           static int warned = 0;
3742
3743           if (! warned)
3744             {
3745               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3746               warned = 1;
3747             }
3748
3749           continue;
3750         }
3751
3752       if (is_gnu)
3753         printf (_("\n    Offset  Kind          Name\n"));
3754       else
3755         printf (_("\n    Offset\tName\n"));
3756
3757       do
3758         {
3759           bfd_size_type maxprint;
3760
3761           SAFE_BYTE_GET (offset, data, offset_size, end);
3762
3763           if (offset != 0)
3764             {
3765               data += offset_size;
3766               if (data >= end)
3767                 break;
3768               maxprint = (end - data) - 1;
3769
3770               if (is_gnu)
3771                 {
3772                   unsigned int kind_data;
3773                   gdb_index_symbol_kind kind;
3774                   const char *kind_name;
3775                   int is_static;
3776
3777                   SAFE_BYTE_GET (kind_data, data, 1, end);
3778                   data++;
3779                   maxprint --;
3780                   /* GCC computes the kind as the upper byte in the CU index
3781                      word, and then right shifts it by the CU index size.
3782                      Left shift KIND to where the gdb-index.h accessor macros
3783                      can use it.  */
3784                   kind_data <<= GDB_INDEX_CU_BITSIZE;
3785                   kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3786                   kind_name = get_gdb_index_symbol_kind_name (kind);
3787                   is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
3788                   printf ("    %-6lx  %s,%-10s  %.*s\n",
3789                           offset, is_static ? _("s") : _("g"),
3790                           kind_name, (int) maxprint, data);
3791                 }
3792               else
3793                 printf ("    %-6lx\t%.*s\n", offset, (int) maxprint, data);
3794
3795               data += strnlen ((char *) data, maxprint) + 1;
3796               if (data >= end)
3797                 break;
3798             }
3799         }
3800       while (offset != 0);
3801     }
3802
3803   printf ("\n");
3804   return 1;
3805 }
3806
3807 static int
3808 display_debug_pubnames (struct dwarf_section *section, void *file)
3809 {
3810   return display_debug_pubnames_worker (section, file, 0);
3811 }
3812
3813 static int
3814 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3815 {
3816   return display_debug_pubnames_worker (section, file, 1);
3817 }
3818
3819 static int
3820 display_debug_macinfo (struct dwarf_section *section,
3821                        void *file ATTRIBUTE_UNUSED)
3822 {
3823   unsigned char *start = section->start;
3824   unsigned char *end = start + section->size;
3825   unsigned char *curr = start;
3826   unsigned int bytes_read;
3827   enum dwarf_macinfo_record_type op;
3828
3829   printf (_("Contents of the %s section:\n\n"), section->name);
3830
3831   while (curr < end)
3832     {
3833       unsigned int lineno;
3834       const unsigned char *string;
3835
3836       op = (enum dwarf_macinfo_record_type) *curr;
3837       curr++;
3838
3839       switch (op)
3840         {
3841         case DW_MACINFO_start_file:
3842           {
3843             unsigned int filenum;
3844
3845             lineno = read_uleb128 (curr, & bytes_read, end);
3846             curr += bytes_read;
3847             filenum = read_uleb128 (curr, & bytes_read, end);
3848             curr += bytes_read;
3849
3850             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3851                     lineno, filenum);
3852           }
3853           break;
3854
3855         case DW_MACINFO_end_file:
3856           printf (_(" DW_MACINFO_end_file\n"));
3857           break;
3858
3859         case DW_MACINFO_define:
3860           lineno = read_uleb128 (curr, & bytes_read, end);
3861           curr += bytes_read;
3862           string = curr;
3863           curr += strnlen ((char *) string, end - string) + 1;
3864           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3865                   lineno, string);
3866           break;
3867
3868         case DW_MACINFO_undef:
3869           lineno = read_uleb128 (curr, & bytes_read, end);
3870           curr += bytes_read;
3871           string = curr;
3872           curr += strnlen ((char *) string, end - string) + 1;
3873           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3874                   lineno, string);
3875           break;
3876
3877         case DW_MACINFO_vendor_ext:
3878           {
3879             unsigned int constant;
3880
3881             constant = read_uleb128 (curr, & bytes_read, end);
3882             curr += bytes_read;
3883             string = curr;
3884             curr += strnlen ((char *) string, end - string) + 1;
3885             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3886                     constant, string);
3887           }
3888           break;
3889         }
3890     }
3891
3892   return 1;
3893 }
3894
3895 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3896    filename and dirname corresponding to file name table entry with index
3897    FILEIDX.  Return NULL on failure.  */
3898
3899 static unsigned char *
3900 get_line_filename_and_dirname (dwarf_vma line_offset,
3901                                dwarf_vma fileidx,
3902                                unsigned char **dir_name)
3903 {
3904   struct dwarf_section *section = &debug_displays [line].section;
3905   unsigned char *hdrptr, *dirtable, *file_name;
3906   unsigned int offset_size, initial_length_size;
3907   unsigned int version, opcode_base, bytes_read;
3908   dwarf_vma length, diridx;
3909   const unsigned char * end;
3910
3911   *dir_name = NULL;
3912   if (section->start == NULL
3913       || line_offset >= section->size
3914       || fileidx == 0)
3915     return NULL;
3916
3917   hdrptr = section->start + line_offset;
3918   end = section->start + section->size;
3919
3920   SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
3921   if (length == 0xffffffff)
3922     {
3923       /* This section is 64-bit DWARF 3.  */
3924       SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
3925       offset_size = 8;
3926       initial_length_size = 12;
3927     }
3928   else
3929     {
3930       offset_size = 4;
3931       initial_length_size = 4;
3932     }
3933   if (length + initial_length_size > section->size)
3934     return NULL;
3935
3936   SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
3937   if (version != 2 && version != 3 && version != 4)
3938     return NULL;
3939   hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length.  */
3940   if (version >= 4)
3941     hdrptr++;               /* Skip max_ops_per_insn.  */
3942   hdrptr += 3;              /* Skip default_is_stmt, line_base, line_range.  */
3943
3944   SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
3945   if (opcode_base == 0)
3946     return NULL;
3947
3948   hdrptr += opcode_base - 1;
3949   dirtable = hdrptr;
3950   /* Skip over dirname table.  */
3951   while (*hdrptr != '\0')
3952     hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3953   hdrptr++;                 /* Skip the NUL at the end of the table.  */
3954   /* Now skip over preceding filename table entries.  */
3955   for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3956     {
3957       hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3958       read_uleb128 (hdrptr, &bytes_read, end);
3959       hdrptr += bytes_read;
3960       read_uleb128 (hdrptr, &bytes_read, end);
3961       hdrptr += bytes_read;
3962       read_uleb128 (hdrptr, &bytes_read, end);
3963       hdrptr += bytes_read;
3964     }
3965   if (hdrptr == end || *hdrptr == '\0')
3966     return NULL;
3967   file_name = hdrptr;
3968   hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3969   diridx = read_uleb128 (hdrptr, &bytes_read, end);
3970   if (diridx == 0)
3971     return file_name;
3972   for (; *dirtable != '\0' && diridx > 1; diridx--)
3973     dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
3974   if (*dirtable == '\0')
3975     return NULL;
3976   *dir_name = dirtable;
3977   return file_name;
3978 }
3979
3980 static int
3981 display_debug_macro (struct dwarf_section *section,
3982                      void *file)
3983 {
3984   unsigned char *start = section->start;
3985   unsigned char *end = start + section->size;
3986   unsigned char *curr = start;
3987   unsigned char *extended_op_buf[256];
3988   unsigned int bytes_read;
3989
3990   load_debug_section (str, file);
3991   load_debug_section (line, file);
3992
3993   printf (_("Contents of the %s section:\n\n"), section->name);
3994
3995   while (curr < end)
3996     {
3997       unsigned int lineno, version, flags;
3998       unsigned int offset_size = 4;
3999       const unsigned char *string;
4000       dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4001       unsigned char **extended_ops = NULL;
4002
4003       SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4004       if (version != 4)
4005         {
4006           error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4007                  section->name);
4008           return 0;
4009         }
4010
4011       SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4012       if (flags & 1)
4013         offset_size = 8;
4014       printf (_("  Offset:                      0x%lx\n"),
4015               (unsigned long) sec_offset);
4016       printf (_("  Version:                     %d\n"), version);
4017       printf (_("  Offset size:                 %d\n"), offset_size);
4018       if (flags & 2)
4019         {
4020           SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4021           printf (_("  Offset into .debug_line:     0x%lx\n"),
4022                   (unsigned long) line_offset);
4023         }
4024       if (flags & 4)
4025         {
4026           unsigned int i, count, op;
4027           dwarf_vma nargs, n;
4028
4029           SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4030
4031           memset (extended_op_buf, 0, sizeof (extended_op_buf));
4032           extended_ops = extended_op_buf;
4033           if (count)
4034             {
4035               printf (_("  Extension opcode arguments:\n"));
4036               for (i = 0; i < count; i++)
4037                 {
4038                   SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4039                   extended_ops[op] = curr;
4040                   nargs = read_uleb128 (curr, &bytes_read, end);
4041                   curr += bytes_read;
4042                   if (nargs == 0)
4043                     printf (_("    DW_MACRO_GNU_%02x has no arguments\n"), op);
4044                   else
4045                     {
4046                       printf (_("    DW_MACRO_GNU_%02x arguments: "), op);
4047                       for (n = 0; n < nargs; n++)
4048                         {
4049                           unsigned int form;
4050
4051                           SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4052                           printf ("%s%s", get_FORM_name (form),
4053                                   n == nargs - 1 ? "\n" : ", ");
4054                           switch (form)
4055                             {
4056                             case DW_FORM_data1:
4057                             case DW_FORM_data2:
4058                             case DW_FORM_data4:
4059                             case DW_FORM_data8:
4060                             case DW_FORM_sdata:
4061                             case DW_FORM_udata:
4062                             case DW_FORM_block:
4063                             case DW_FORM_block1:
4064                             case DW_FORM_block2:
4065                             case DW_FORM_block4:
4066                             case DW_FORM_flag:
4067                             case DW_FORM_string:
4068                             case DW_FORM_strp:
4069                             case DW_FORM_sec_offset:
4070                               break;
4071                             default:
4072                               error (_("Invalid extension opcode form %s\n"),
4073                                      get_FORM_name (form));
4074                               return 0;
4075                             }
4076                         }
4077                     }
4078                 }
4079             }
4080         }
4081       printf ("\n");
4082
4083       while (1)
4084         {
4085           unsigned int op;
4086
4087           if (curr >= end)
4088             {
4089               error (_(".debug_macro section not zero terminated\n"));
4090               return 0;
4091             }
4092
4093           SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4094           if (op == 0)
4095             break;
4096
4097           switch (op)
4098             {
4099             case DW_MACRO_GNU_start_file:
4100               {
4101                 unsigned int filenum;
4102                 unsigned char *file_name = NULL, *dir_name = NULL;
4103
4104                 lineno = read_uleb128 (curr, &bytes_read, end);
4105                 curr += bytes_read;
4106                 filenum = read_uleb128 (curr, &bytes_read, end);
4107                 curr += bytes_read;
4108
4109                 if ((flags & 2) == 0)
4110                   error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4111                 else
4112                   file_name
4113                     = get_line_filename_and_dirname (line_offset, filenum,
4114                                                      &dir_name);
4115                 if (file_name == NULL)
4116                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4117                           lineno, filenum);
4118                 else
4119                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4120                           lineno, filenum,
4121                           dir_name != NULL ? (const char *) dir_name : "",
4122                           dir_name != NULL ? "/" : "", file_name);
4123               }
4124               break;
4125
4126             case DW_MACRO_GNU_end_file:
4127               printf (_(" DW_MACRO_GNU_end_file\n"));
4128               break;
4129
4130             case DW_MACRO_GNU_define:
4131               lineno = read_uleb128 (curr, &bytes_read, end);
4132               curr += bytes_read;
4133               string = curr;
4134               curr += strnlen ((char *) string, end - string) + 1;
4135               printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4136                       lineno, string);
4137               break;
4138
4139             case DW_MACRO_GNU_undef:
4140               lineno = read_uleb128 (curr, &bytes_read, end);
4141               curr += bytes_read;
4142               string = curr;
4143               curr += strnlen ((char *) string, end - string) + 1;
4144               printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4145                       lineno, string);
4146               break;
4147
4148             case DW_MACRO_GNU_define_indirect:
4149               lineno = read_uleb128 (curr, &bytes_read, end);
4150               curr += bytes_read;
4151               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4152               string = fetch_indirect_string (offset);
4153               printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4154                       lineno, string);
4155               break;
4156
4157             case DW_MACRO_GNU_undef_indirect:
4158               lineno = read_uleb128 (curr, &bytes_read, end);
4159               curr += bytes_read;
4160               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4161               string = fetch_indirect_string (offset);
4162               printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4163                       lineno, string);
4164               break;
4165
4166             case DW_MACRO_GNU_transparent_include:
4167               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4168               printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4169                       (unsigned long) offset);
4170               break;
4171
4172             case DW_MACRO_GNU_define_indirect_alt:
4173               lineno = read_uleb128 (curr, &bytes_read, end);
4174               curr += bytes_read;
4175               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4176               printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4177                       lineno, (unsigned long) offset);
4178               break;
4179
4180             case DW_MACRO_GNU_undef_indirect_alt:
4181               lineno = read_uleb128 (curr, &bytes_read, end);
4182               curr += bytes_read;
4183               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4184               printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4185                       lineno, (unsigned long) offset);
4186               break;
4187
4188             case DW_MACRO_GNU_transparent_include_alt:
4189               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4190               printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4191                       (unsigned long) offset);
4192               break;
4193
4194             default:
4195               if (extended_ops == NULL || extended_ops[op] == NULL)
4196                 {
4197                   error (_(" Unknown macro opcode %02x seen\n"), op);
4198                   return 0;
4199                 }
4200               else
4201                 {
4202                   /* Skip over unhandled opcodes.  */
4203                   dwarf_vma nargs, n;
4204                   unsigned char *desc = extended_ops[op];
4205                   nargs = read_uleb128 (desc, &bytes_read, end);
4206                   desc += bytes_read;
4207                   if (nargs == 0)
4208                     {
4209                       printf (_(" DW_MACRO_GNU_%02x\n"), op);
4210                       break;
4211                     }
4212                   printf (_(" DW_MACRO_GNU_%02x -"), op);
4213                   for (n = 0; n < nargs; n++)
4214                     {
4215                       int val;
4216
4217                       SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4218                       curr
4219                         = read_and_display_attr_value (0, val,
4220                                                        curr, end, 0, 0, offset_size,
4221                                                        version, NULL, 0, NULL,
4222                                                        NULL);
4223                       if (n != nargs - 1)
4224                         printf (",");
4225                     }
4226                   printf ("\n");
4227                 }
4228               break;
4229             }
4230         }
4231
4232       printf ("\n");
4233     }
4234
4235   return 1;
4236 }
4237
4238 static int
4239 display_debug_abbrev (struct dwarf_section *section,
4240                       void *file ATTRIBUTE_UNUSED)
4241 {
4242   abbrev_entry *entry;
4243   unsigned char *start = section->start;
4244   unsigned char *end = start + section->size;
4245
4246   printf (_("Contents of the %s section:\n\n"), section->name);
4247
4248   do
4249     {
4250       unsigned char *last;
4251
4252       free_abbrevs ();
4253
4254       last = start;
4255       start = process_abbrev_section (start, end);
4256
4257       if (first_abbrev == NULL)
4258         continue;
4259
4260       printf (_("  Number TAG (0x%lx)\n"), (long) (last - section->start));
4261
4262       for (entry = first_abbrev; entry; entry = entry->next)
4263         {
4264           abbrev_attr *attr;
4265
4266           printf ("   %ld      %s    [%s]\n",
4267                   entry->entry,
4268                   get_TAG_name (entry->tag),
4269                   entry->children ? _("has children") : _("no children"));
4270
4271           for (attr = entry->first_attr; attr; attr = attr->next)
4272             printf ("    %-18s %s\n",
4273                     get_AT_name (attr->attribute),
4274                     get_FORM_name (attr->form));
4275         }
4276     }
4277   while (start);
4278
4279   printf ("\n");
4280
4281   return 1;
4282 }
4283
4284 /* Display a location list from a normal (ie, non-dwo) .debug_loc section.  */
4285
4286 static void
4287 display_loc_list (struct dwarf_section *section,
4288                   unsigned char **start_ptr,
4289                   unsigned int debug_info_entry,
4290                   unsigned long offset,
4291                   unsigned long base_address,
4292                   int has_frame_base)
4293 {
4294   unsigned char *start = *start_ptr;
4295   unsigned char *section_end = section->start + section->size;
4296   unsigned long cu_offset;
4297   unsigned int pointer_size;
4298   unsigned int offset_size;
4299   int dwarf_version;
4300
4301   dwarf_vma begin;
4302   dwarf_vma end;
4303   unsigned short length;
4304   int need_frame_base;
4305
4306   if (debug_info_entry >= num_debug_info_entries)
4307     {
4308       warn (_("No debug information available for loc lists of entry: %u\n"),
4309             debug_info_entry);
4310       return;
4311     }
4312
4313   cu_offset = debug_information [debug_info_entry].cu_offset;
4314   pointer_size = debug_information [debug_info_entry].pointer_size;
4315   offset_size = debug_information [debug_info_entry].offset_size;
4316   dwarf_version = debug_information [debug_info_entry].dwarf_version;
4317
4318   if (pointer_size < 2 || pointer_size > 8)
4319     {
4320       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4321             pointer_size, debug_info_entry);
4322       return;
4323     }
4324
4325   while (1)
4326     {
4327       if (start + 2 * pointer_size > section_end)
4328         {
4329           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4330                 offset);
4331           break;
4332         }
4333
4334       printf ("    %8.8lx ", offset + (start - *start_ptr));
4335
4336       /* Note: we use sign extension here in order to be sure that we can detect
4337          the -1 escape value.  Sign extension into the top 32 bits of a 32-bit
4338          address will not affect the values that we display since we always show
4339          hex values, and always the bottom 32-bits.  */
4340       SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4341       SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4342
4343       if (begin == 0 && end == 0)
4344         {
4345           printf (_("<End of list>\n"));
4346           break;
4347         }
4348
4349       /* Check base address specifiers.  */
4350       if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4351         {
4352           base_address = end;
4353           print_dwarf_vma (begin, pointer_size);
4354           print_dwarf_vma (end, pointer_size);
4355           printf (_("(base address)\n"));
4356           continue;
4357         }
4358
4359       if (start + 2 > section_end)
4360         {
4361           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4362                 offset);
4363           break;
4364         }
4365
4366       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4367
4368       if (start + length > section_end)
4369         {
4370           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4371                 offset);
4372           break;
4373         }
4374
4375       print_dwarf_vma (begin + base_address, pointer_size);
4376       print_dwarf_vma (end + base_address, pointer_size);
4377
4378       putchar ('(');
4379       need_frame_base = decode_location_expression (start,
4380                                                     pointer_size,
4381                                                     offset_size,
4382                                                     dwarf_version,
4383                                                     length,
4384                                                     cu_offset, section);
4385       putchar (')');
4386
4387       if (need_frame_base && !has_frame_base)
4388         printf (_(" [without DW_AT_frame_base]"));
4389
4390       if (begin == end)
4391         fputs (_(" (start == end)"), stdout);
4392       else if (begin > end)
4393         fputs (_(" (start > end)"), stdout);
4394
4395       putchar ('\n');
4396
4397       start += length;
4398     }
4399
4400   *start_ptr = start;
4401 }
4402
4403 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4404    right-adjusted in a field of length LEN, and followed by a space.  */
4405
4406 static void
4407 print_addr_index (unsigned int idx, unsigned int len)
4408 {
4409   static char buf[15];
4410   snprintf (buf, sizeof (buf), "[%d]", idx);
4411   printf ("%*s ", len, buf);
4412 }
4413
4414 /* Display a location list from a .dwo section. It uses address indexes rather
4415    than embedded addresses.  This code closely follows display_loc_list, but the
4416    two are sufficiently different that combining things is very ugly.  */
4417
4418 static void
4419 display_loc_list_dwo (struct dwarf_section *section,
4420                       unsigned char **start_ptr,
4421                       unsigned int debug_info_entry,
4422                       unsigned long offset,
4423                       int has_frame_base)
4424 {
4425   unsigned char *start = *start_ptr;
4426   unsigned char *section_end = section->start + section->size;
4427   unsigned long cu_offset;
4428   unsigned int pointer_size;
4429   unsigned int offset_size;
4430   int dwarf_version;
4431   int entry_type;
4432   unsigned short length;
4433   int need_frame_base;
4434   unsigned int idx;
4435   unsigned int bytes_read;
4436
4437   if (debug_info_entry >= num_debug_info_entries)
4438     {
4439       warn (_("No debug information for loc lists of entry: %u\n"),
4440             debug_info_entry);
4441       return;
4442     }
4443
4444   cu_offset = debug_information [debug_info_entry].cu_offset;
4445   pointer_size = debug_information [debug_info_entry].pointer_size;
4446   offset_size = debug_information [debug_info_entry].offset_size;
4447   dwarf_version = debug_information [debug_info_entry].dwarf_version;
4448
4449   if (pointer_size < 2 || pointer_size > 8)
4450     {
4451       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4452             pointer_size, debug_info_entry);
4453       return;
4454     }
4455
4456   while (1)
4457     {
4458       printf ("    %8.8lx ", offset + (start - *start_ptr));
4459
4460       if (start >= section_end)
4461         {
4462           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4463                 offset);
4464           break;
4465         }
4466
4467       SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4468       switch (entry_type)
4469         {
4470           case 0: /* A terminating entry.  */
4471             *start_ptr = start;
4472             printf (_("<End of list>\n"));
4473             return;
4474           case 1: /* A base-address entry.  */
4475             idx = read_uleb128 (start, &bytes_read, section_end);
4476             start += bytes_read;
4477             print_addr_index (idx, 8);
4478             printf ("         ");
4479             printf (_("(base address selection entry)\n"));
4480             continue;
4481           case 2: /* A start/end entry.  */
4482             idx = read_uleb128 (start, &bytes_read, section_end);
4483             start += bytes_read;
4484             print_addr_index (idx, 8);
4485             idx = read_uleb128 (start, &bytes_read, section_end);
4486             start += bytes_read;
4487             print_addr_index (idx, 8);
4488             break;
4489           case 3: /* A start/length entry.  */
4490             idx = read_uleb128 (start, &bytes_read, section_end);
4491             start += bytes_read;
4492             print_addr_index (idx, 8);
4493             SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4494             printf ("%08x ", idx);
4495             break;
4496           case 4: /* An offset pair entry.  */
4497             SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4498             printf ("%08x ", idx);
4499             SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4500             printf ("%08x ", idx);
4501             break;
4502           default:
4503             warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4504             *start_ptr = start;
4505             return;
4506         }
4507
4508       if (start + 2 > section_end)
4509         {
4510           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4511                 offset);
4512           break;
4513         }
4514
4515       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4516       if (start + length > section_end)
4517         {
4518           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4519                 offset);
4520           break;
4521         }
4522
4523       putchar ('(');
4524       need_frame_base = decode_location_expression (start,
4525                                                     pointer_size,
4526                                                     offset_size,
4527                                                     dwarf_version,
4528                                                     length,
4529                                                     cu_offset, section);
4530       putchar (')');
4531
4532       if (need_frame_base && !has_frame_base)
4533         printf (_(" [without DW_AT_frame_base]"));
4534
4535       putchar ('\n');
4536
4537       start += length;
4538     }
4539
4540   *start_ptr = start;
4541 }
4542
4543 /* Sort array of indexes in ascending order of loc_offsets[idx].  */
4544
4545 static dwarf_vma *loc_offsets;
4546
4547 static int
4548 loc_offsets_compar (const void *ap, const void *bp)
4549 {
4550   dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4551   dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4552
4553   return (a > b) - (b > a);
4554 }
4555
4556 static int
4557 display_debug_loc (struct dwarf_section *section, void *file)
4558 {
4559   unsigned char *start = section->start;
4560   unsigned long bytes;
4561   unsigned char *section_begin = start;
4562   unsigned int num_loc_list = 0;
4563   unsigned long last_offset = 0;
4564   unsigned int first = 0;
4565   unsigned int i;
4566   unsigned int j;
4567   unsigned int k;
4568   int seen_first_offset = 0;
4569   int locs_sorted = 1;
4570   unsigned char *next;
4571   unsigned int *array = NULL;
4572   const char *suffix = strrchr (section->name, '.');
4573   int is_dwo = 0;
4574
4575   if (suffix && strcmp (suffix, ".dwo") == 0)
4576     is_dwo = 1;
4577
4578   bytes = section->size;
4579
4580   if (bytes == 0)
4581     {
4582       printf (_("\nThe %s section is empty.\n"), section->name);
4583       return 0;
4584     }
4585
4586   if (load_debug_info (file) == 0)
4587     {
4588       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4589             section->name);
4590       return 0;
4591     }
4592
4593   /* Check the order of location list in .debug_info section. If
4594      offsets of location lists are in the ascending order, we can
4595      use `debug_information' directly.  */
4596   for (i = 0; i < num_debug_info_entries; i++)
4597     {
4598       unsigned int num;
4599
4600       num = debug_information [i].num_loc_offsets;
4601       if (num > num_loc_list)
4602         num_loc_list = num;
4603
4604       /* Check if we can use `debug_information' directly.  */
4605       if (locs_sorted && num != 0)
4606         {
4607           if (!seen_first_offset)
4608             {
4609               /* This is the first location list.  */
4610               last_offset = debug_information [i].loc_offsets [0];
4611               first = i;
4612               seen_first_offset = 1;
4613               j = 1;
4614             }
4615           else
4616             j = 0;
4617
4618           for (; j < num; j++)
4619             {
4620               if (last_offset >
4621                   debug_information [i].loc_offsets [j])
4622                 {
4623                   locs_sorted = 0;
4624                   break;
4625                 }
4626               last_offset = debug_information [i].loc_offsets [j];
4627             }
4628         }
4629     }
4630
4631   if (!seen_first_offset)
4632     error (_("No location lists in .debug_info section!\n"));
4633
4634   if (debug_information [first].num_loc_offsets > 0
4635       && debug_information [first].loc_offsets [0] != 0)
4636     warn (_("Location lists in %s section start at 0x%s\n"),
4637           section->name,
4638           dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4639
4640   if (!locs_sorted)
4641     array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4642   printf (_("Contents of the %s section:\n\n"), section->name);
4643   printf (_("    Offset   Begin    End      Expression\n"));
4644
4645   seen_first_offset = 0;
4646   for (i = first; i < num_debug_info_entries; i++)
4647     {
4648       unsigned long offset;
4649       unsigned long base_address;
4650       int has_frame_base;
4651
4652       if (!locs_sorted)
4653         {
4654           for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4655             array[k] = k;
4656           loc_offsets = debug_information [i].loc_offsets;
4657           qsort (array, debug_information [i].num_loc_offsets,
4658                  sizeof (*array), loc_offsets_compar);
4659         }
4660
4661       for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4662         {
4663           j = locs_sorted ? k : array[k];
4664           if (k
4665               && debug_information [i].loc_offsets [locs_sorted
4666                                                     ? k - 1 : array [k - 1]]
4667                  == debug_information [i].loc_offsets [j])
4668             continue;
4669           has_frame_base = debug_information [i].have_frame_base [j];
4670           offset = debug_information [i].loc_offsets [j];
4671           next = section_begin + offset;
4672           base_address = debug_information [i].base_address;
4673
4674           if (!seen_first_offset)
4675             seen_first_offset = 1;
4676           else
4677             {
4678               if (start < next)
4679                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4680                       (unsigned long) (start - section_begin),
4681                       (unsigned long) (next - section_begin));
4682               else if (start > next)
4683                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4684                       (unsigned long) (start - section_begin),
4685                       (unsigned long) (next - section_begin));
4686             }
4687           start = next;
4688
4689           if (offset >= bytes)
4690             {
4691               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4692                     offset);
4693               continue;
4694             }
4695
4696           if (is_dwo)
4697             display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4698           else
4699             display_loc_list (section, &start, i, offset, base_address,
4700                               has_frame_base);
4701         }
4702     }
4703
4704   if (start < section->start + section->size)
4705     warn (_("There are %ld unused bytes at the end of section %s\n"),
4706           (long) (section->start + section->size - start), section->name);
4707   putchar ('\n');
4708   free (array);
4709   return 1;
4710 }
4711
4712 static int
4713 display_debug_str (struct dwarf_section *section,
4714                    void *file ATTRIBUTE_UNUSED)
4715 {
4716   unsigned char *start = section->start;
4717   unsigned long bytes = section->size;
4718   dwarf_vma addr = section->address;
4719
4720   if (bytes == 0)
4721     {
4722       printf (_("\nThe %s section is empty.\n"), section->name);
4723       return 0;
4724     }
4725
4726   printf (_("Contents of the %s section:\n\n"), section->name);
4727
4728   while (bytes)
4729     {
4730       int j;
4731       int k;
4732       int lbytes;
4733
4734       lbytes = (bytes > 16 ? 16 : bytes);
4735
4736       printf ("  0x%8.8lx ", (unsigned long) addr);
4737
4738       for (j = 0; j < 16; j++)
4739         {
4740           if (j < lbytes)
4741             printf ("%2.2x", start[j]);
4742           else
4743             printf ("  ");
4744
4745           if ((j & 3) == 3)
4746             printf (" ");
4747         }
4748
4749       for (j = 0; j < lbytes; j++)
4750         {
4751           k = start[j];
4752           if (k >= ' ' && k < 0x80)
4753             printf ("%c", k);
4754           else
4755             printf (".");
4756         }
4757
4758       putchar ('\n');
4759
4760       start += lbytes;
4761       addr  += lbytes;
4762       bytes -= lbytes;
4763     }
4764
4765   putchar ('\n');
4766
4767   return 1;
4768 }
4769
4770 static int
4771 display_debug_info (struct dwarf_section *section, void *file)
4772 {
4773   return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4774 }
4775
4776 static int
4777 display_debug_types (struct dwarf_section *section, void *file)
4778 {
4779   return process_debug_info (section, file, section->abbrev_sec, 0, 1);
4780 }
4781
4782 static int
4783 display_trace_info (struct dwarf_section *section, void *file)
4784 {
4785   return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4786 }
4787
4788 static int
4789 display_debug_aranges (struct dwarf_section *section,
4790                        void *file ATTRIBUTE_UNUSED)
4791 {
4792   unsigned char *start = section->start;
4793   unsigned char *end = start + section->size;
4794
4795   printf (_("Contents of the %s section:\n\n"), section->name);
4796
4797   /* It does not matter if this load fails,
4798      we test for that later on.  */
4799   load_debug_info (file);
4800
4801   while (start < end)
4802     {
4803       unsigned char *hdrptr;
4804       DWARF2_Internal_ARange arange;
4805       unsigned char *addr_ranges;
4806       dwarf_vma length;
4807       dwarf_vma address;
4808       unsigned char address_size;
4809       int excess;
4810       unsigned int offset_size;
4811       unsigned int initial_length_size;
4812
4813       hdrptr = start;
4814
4815       SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
4816       if (arange.ar_length == 0xffffffff)
4817         {
4818           SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
4819           offset_size = 8;
4820           initial_length_size = 12;
4821         }
4822       else
4823         {
4824           offset_size = 4;
4825           initial_length_size = 4;
4826         }
4827
4828       SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4829       SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
4830
4831       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4832           && num_debug_info_entries > 0
4833           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4834         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4835               (unsigned long) arange.ar_info_offset, section->name);
4836
4837       SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4838       SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
4839
4840       if (arange.ar_version != 2 && arange.ar_version != 3)
4841         {
4842           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4843           break;
4844         }
4845
4846       printf (_("  Length:                   %ld\n"),
4847               (long) arange.ar_length);
4848       printf (_("  Version:                  %d\n"), arange.ar_version);
4849       printf (_("  Offset into .debug_info:  0x%lx\n"),
4850               (unsigned long) arange.ar_info_offset);
4851       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
4852       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
4853
4854       address_size = arange.ar_pointer_size + arange.ar_segment_size;
4855
4856       /* PR 17512: file: 001-108546-0.001:0.1.  */
4857       if (address_size == 0 || address_size > 8)
4858         {
4859           error (_("Invalid address size in %s section!\n"),
4860                  section->name);
4861           break;
4862         }
4863
4864       /* The DWARF spec does not require that the address size be a power
4865          of two, but we do.  This will have to change if we ever encounter
4866          an uneven architecture.  */
4867       if ((address_size & (address_size - 1)) != 0)
4868         {
4869           warn (_("Pointer size + Segment size is not a power of two.\n"));
4870           break;
4871         }
4872
4873       if (address_size > 4)
4874         printf (_("\n    Address            Length\n"));
4875       else
4876         printf (_("\n    Address    Length\n"));
4877
4878       addr_ranges = hdrptr;
4879
4880       /* Must pad to an alignment boundary that is twice the address size.  */
4881       excess = (hdrptr - start) % (2 * address_size);
4882       if (excess)
4883         addr_ranges += (2 * address_size) - excess;
4884
4885       start += arange.ar_length + initial_length_size;
4886
4887       while (addr_ranges + 2 * address_size <= start)
4888         {
4889           SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4890           SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
4891
4892           printf ("    ");
4893           print_dwarf_vma (address, address_size);
4894           print_dwarf_vma (length, address_size);
4895           putchar ('\n');
4896         }
4897     }
4898
4899   printf ("\n");
4900
4901   return 1;
4902 }
4903
4904 /* Comparison function for qsort.  */
4905 static int
4906 comp_addr_base (const void * v0, const void * v1)
4907 {
4908   debug_info * info0 = (debug_info *) v0;
4909   debug_info * info1 = (debug_info *) v1;
4910   return info0->addr_base - info1->addr_base;
4911 }
4912
4913 /* Display the debug_addr section.  */
4914 static int
4915 display_debug_addr (struct dwarf_section *section,
4916                     void *file)
4917 {
4918   debug_info **debug_addr_info;
4919   unsigned char *entry;
4920   unsigned char *end;
4921   unsigned int i;
4922   unsigned int count;
4923
4924   if (section->size == 0)
4925     {
4926       printf (_("\nThe %s section is empty.\n"), section->name);
4927       return 0;
4928     }
4929
4930   if (load_debug_info (file) == 0)
4931     {
4932       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4933             section->name);
4934       return 0;
4935     }
4936
4937   printf (_("Contents of the %s section:\n\n"), section->name);
4938
4939   debug_addr_info = (debug_info **) xmalloc ((num_debug_info_entries + 1)
4940                                              * sizeof (debug_info *));
4941
4942   count = 0;
4943   for (i = 0; i < num_debug_info_entries; i++)
4944     if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
4945       debug_addr_info [count++] = debug_information + i;
4946
4947   /* Add a sentinel to make iteration convenient.  */
4948   debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
4949   debug_addr_info [count]->addr_base = section->size;
4950
4951   qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
4952   for (i = 0; i < count; i++)
4953     {
4954       unsigned int idx;
4955       unsigned int address_size = debug_addr_info [i]->pointer_size;
4956
4957       printf (_("  For compilation unit at offset 0x%s:\n"),
4958               dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
4959
4960       printf (_("\tIndex\tAddress\n"));
4961       entry = section->start + debug_addr_info [i]->addr_base;
4962       end = section->start + debug_addr_info [i + 1]->addr_base;
4963       idx = 0;
4964       while (entry < end)
4965         {
4966           dwarf_vma base = byte_get (entry, address_size);
4967           printf (_("\t%d:\t"), idx);
4968           print_dwarf_vma (base, address_size);
4969           printf ("\n");
4970           entry += address_size;
4971           idx++;
4972         }
4973     }
4974   printf ("\n");
4975
4976   free (debug_addr_info);
4977   return 1;
4978 }
4979
4980 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections.  */
4981 static int
4982 display_debug_str_offsets (struct dwarf_section *section,
4983                            void *file ATTRIBUTE_UNUSED)
4984 {
4985   if (section->size == 0)
4986     {
4987       printf (_("\nThe %s section is empty.\n"), section->name);
4988       return 0;
4989     }
4990   /* TODO: Dump the contents.  This is made somewhat difficult by not knowing
4991      what the offset size is for this section.  */
4992   return 1;
4993 }
4994
4995 /* Each debug_information[x].range_lists[y] gets this representation for
4996    sorting purposes.  */
4997
4998 struct range_entry
4999 {
5000   /* The debug_information[x].range_lists[y] value.  */
5001   unsigned long ranges_offset;
5002
5003   /* Original debug_information to find parameters of the data.  */
5004   debug_info *debug_info_p;
5005 };
5006
5007 /* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
5008
5009 static int
5010 range_entry_compar (const void *ap, const void *bp)
5011 {
5012   const struct range_entry *a_re = (const struct range_entry *) ap;
5013   const struct range_entry *b_re = (const struct range_entry *) bp;
5014   const unsigned long a = a_re->ranges_offset;
5015   const unsigned long b = b_re->ranges_offset;
5016
5017   return (a > b) - (b > a);
5018 }
5019
5020 static int
5021 display_debug_ranges (struct dwarf_section *section,
5022                       void *file ATTRIBUTE_UNUSED)
5023 {
5024   unsigned char *start = section->start;
5025   unsigned char *last_start = start;
5026   unsigned long bytes = section->size;
5027   unsigned char *section_begin = start;
5028   unsigned char *finish = start + bytes;
5029   unsigned int num_range_list, i;
5030   struct range_entry *range_entries, *range_entry_fill;
5031
5032   if (bytes == 0)
5033     {
5034       printf (_("\nThe %s section is empty.\n"), section->name);
5035       return 0;
5036     }
5037
5038   if (load_debug_info (file) == 0)
5039     {
5040       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5041             section->name);
5042       return 0;
5043     }
5044
5045   num_range_list = 0;
5046   for (i = 0; i < num_debug_info_entries; i++)
5047     num_range_list += debug_information [i].num_range_lists;
5048
5049   if (num_range_list == 0)
5050     {
5051       /* This can happen when the file was compiled with -gsplit-debug
5052          which removes references to range lists from the primary .o file.  */
5053       printf (_("No range lists in .debug_info section.\n"));
5054       return 1;
5055     }
5056
5057   range_entries = (struct range_entry *)
5058       xmalloc (sizeof (*range_entries) * num_range_list);
5059   range_entry_fill = range_entries;
5060
5061   for (i = 0; i < num_debug_info_entries; i++)
5062     {
5063       debug_info *debug_info_p = &debug_information[i];
5064       unsigned int j;
5065
5066       for (j = 0; j < debug_info_p->num_range_lists; j++)
5067         {
5068           range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5069           range_entry_fill->debug_info_p = debug_info_p;
5070           range_entry_fill++;
5071         }
5072     }
5073
5074   qsort (range_entries, num_range_list, sizeof (*range_entries),
5075          range_entry_compar);
5076
5077   if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5078     warn (_("Range lists in %s section start at 0x%lx\n"),
5079           section->name, range_entries[0].ranges_offset);
5080
5081   printf (_("Contents of the %s section:\n\n"), section->name);
5082   printf (_("    Offset   Begin    End\n"));
5083
5084   for (i = 0; i < num_range_list; i++)
5085     {
5086       struct range_entry *range_entry = &range_entries[i];
5087       debug_info *debug_info_p = range_entry->debug_info_p;
5088       unsigned int pointer_size;
5089       unsigned long offset;
5090       unsigned char *next;
5091       unsigned long base_address;
5092
5093       pointer_size = debug_info_p->pointer_size;
5094       offset = range_entry->ranges_offset;
5095       next = section_begin + offset;
5096       base_address = debug_info_p->base_address;
5097
5098       /* PR 17512: file: 001-101485-0.001:0.1.  */
5099       if (pointer_size < 2 || pointer_size > 8)
5100         {
5101           warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5102                 pointer_size, offset);
5103           continue;
5104         }
5105
5106       if (dwarf_check != 0 && i > 0)
5107         {
5108           if (start < next)
5109             warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5110                   (unsigned long) (start - section_begin),
5111                   (unsigned long) (next - section_begin), section->name);
5112           else if (start > next)
5113             {
5114               if (next == last_start)
5115                 continue;
5116               warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5117                     (unsigned long) (start - section_begin),
5118                     (unsigned long) (next - section_begin), section->name);
5119             }
5120         }
5121       start = next;
5122       last_start = next;
5123
5124       while (start < finish)
5125         {
5126           dwarf_vma begin;
5127           dwarf_vma end;
5128
5129           /* Note: we use sign extension here in order to be sure that
5130              we can detect the -1 escape value.  Sign extension into the
5131              top 32 bits of a 32-bit address will not affect the values
5132              that we display since we always show hex values, and always
5133              the bottom 32-bits.  */
5134           SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5135           if (start >= finish)
5136             break;
5137           SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5138
5139           printf ("    %8.8lx ", offset);
5140
5141           if (begin == 0 && end == 0)
5142             {
5143               printf (_("<End of list>\n"));
5144               break;
5145             }
5146
5147           /* Check base address specifiers.  */
5148           if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
5149             {
5150               base_address = end;
5151               print_dwarf_vma (begin, pointer_size);
5152               print_dwarf_vma (end, pointer_size);
5153               printf ("(base address)\n");
5154               continue;
5155             }
5156
5157           print_dwarf_vma (begin + base_address, pointer_size);
5158           print_dwarf_vma (end + base_address, pointer_size);
5159
5160           if (begin == end)
5161             fputs (_("(start == end)"), stdout);
5162           else if (begin > end)
5163             fputs (_("(start > end)"), stdout);
5164
5165           putchar ('\n');
5166         }
5167     }
5168   putchar ('\n');
5169
5170   free (range_entries);
5171
5172   return 1;
5173 }
5174
5175 typedef struct Frame_Chunk
5176 {
5177   struct Frame_Chunk *next;
5178   unsigned char *chunk_start;
5179   unsigned int ncols;
5180   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
5181   short int *col_type;
5182   int *col_offset;
5183   char *augmentation;
5184   unsigned int code_factor;
5185   int data_factor;
5186   dwarf_vma pc_begin;
5187   dwarf_vma pc_range;
5188   int cfa_reg;
5189   int cfa_offset;
5190   unsigned int ra;
5191   unsigned char fde_encoding;
5192   unsigned char cfa_exp;
5193   unsigned char ptr_size;
5194   unsigned char segment_size;
5195 }
5196 Frame_Chunk;
5197
5198 static const char *const *dwarf_regnames;
5199 static unsigned int dwarf_regnames_count;
5200
5201 /* A marker for a col_type that means this column was never referenced
5202    in the frame info.  */
5203 #define DW_CFA_unreferenced (-1)
5204
5205 /* Return 0 if no more space is needed, 1 if more space is needed,
5206    -1 for invalid reg.  */
5207
5208 static int
5209 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5210 {
5211   unsigned int prev = fc->ncols;
5212
5213   if (reg < (unsigned int) fc->ncols)
5214     return 0;
5215
5216   if (dwarf_regnames_count
5217       && reg > dwarf_regnames_count)
5218     return -1;
5219
5220   fc->ncols = reg + 1;
5221   /* PR 17512: file: 10450-2643-0.004.
5222      If reg == -1 then this can happen...  */
5223   if (fc->ncols == 0)
5224     return -1;
5225
5226   /* PR 17512: file: 2844a11d.  */
5227   if (fc->ncols > 1024)
5228     {
5229       error (_("Unfeasibly large register number: %u\n"), reg);
5230       fc->ncols = 0;
5231       /* FIXME: 1024 is an arbitrary limit.  Increase it if
5232          we ever encounter a valid binary that exceeds it.  */
5233       return -1;
5234     }
5235
5236   fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5237                                           sizeof (short int));
5238   fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5239   /* PR 17512: file:002-10025-0.005.  */
5240   if (fc->col_type == NULL || fc->col_offset == NULL)
5241     {
5242       error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5243              fc->ncols);
5244       fc->ncols = 0;
5245       return -1;
5246     }
5247
5248   while (prev < fc->ncols)
5249     {
5250       fc->col_type[prev] = DW_CFA_unreferenced;
5251       fc->col_offset[prev] = 0;
5252       prev++;
5253     }
5254   return 1;
5255 }
5256
5257 static const char *const dwarf_regnames_i386[] =
5258 {
5259   "eax", "ecx", "edx", "ebx",                     /* 0 - 3  */
5260   "esp", "ebp", "esi", "edi",                     /* 4 - 7  */
5261   "eip", "eflags", NULL,                          /* 8 - 10  */
5262   "st0", "st1", "st2", "st3",                     /* 11 - 14  */
5263   "st4", "st5", "st6", "st7",                     /* 15 - 18  */
5264   NULL, NULL,                                     /* 19 - 20  */
5265   "xmm0", "xmm1", "xmm2", "xmm3",                 /* 21 - 24  */
5266   "xmm4", "xmm5", "xmm6", "xmm7",                 /* 25 - 28  */
5267   "mm0", "mm1", "mm2", "mm3",                     /* 29 - 32  */
5268   "mm4", "mm5", "mm6", "mm7",                     /* 33 - 36  */
5269   "fcw", "fsw", "mxcsr",                          /* 37 - 39  */
5270   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47  */
5271   "tr", "ldtr",                                   /* 48 - 49  */
5272   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57  */
5273   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65  */
5274   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73  */
5275   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81  */
5276   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89  */
5277   NULL, NULL, NULL,                               /* 90 - 92  */
5278   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"  /* 93 - 100  */
5279 };
5280
5281 void
5282 init_dwarf_regnames_i386 (void)
5283 {
5284   dwarf_regnames = dwarf_regnames_i386;
5285   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5286 }
5287
5288 static const char *const dwarf_regnames_x86_64[] =
5289 {
5290   "rax", "rdx", "rcx", "rbx",
5291   "rsi", "rdi", "rbp", "rsp",
5292   "r8",  "r9",  "r10", "r11",
5293   "r12", "r13", "r14", "r15",
5294   "rip",
5295   "xmm0",  "xmm1",  "xmm2",  "xmm3",
5296   "xmm4",  "xmm5",  "xmm6",  "xmm7",
5297   "xmm8",  "xmm9",  "xmm10", "xmm11",
5298   "xmm12", "xmm13", "xmm14", "xmm15",
5299   "st0", "st1", "st2", "st3",
5300   "st4", "st5", "st6", "st7",
5301   "mm0", "mm1", "mm2", "mm3",
5302   "mm4", "mm5", "mm6", "mm7",
5303   "rflags",
5304   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5305   "fs.base", "gs.base", NULL, NULL,
5306   "tr", "ldtr",
5307   "mxcsr", "fcw", "fsw",
5308   "xmm16",  "xmm17",  "xmm18",  "xmm19",
5309   "xmm20",  "xmm21",  "xmm22",  "xmm23",
5310   "xmm24",  "xmm25",  "xmm26",  "xmm27",
5311   "xmm28",  "xmm29",  "xmm30",  "xmm31",
5312   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90  */
5313   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98  */
5314   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106  */
5315   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114  */
5316   NULL, NULL, NULL,                               /* 115 - 117  */
5317   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5318 };
5319
5320 void
5321 init_dwarf_regnames_x86_64 (void)
5322 {
5323   dwarf_regnames = dwarf_regnames_x86_64;
5324   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5325 }
5326
5327 static const char *const dwarf_regnames_aarch64[] =
5328 {
5329    "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
5330    "x8",  "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5331   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5332   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5333    NULL, "elr",  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5334    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5335    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5336    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5337    "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",
5338    "v8",  "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5339   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5340   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5341 };
5342
5343 void
5344 init_dwarf_regnames_aarch64 (void)
5345 {
5346   dwarf_regnames = dwarf_regnames_aarch64;
5347   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5348 }
5349
5350 void
5351 init_dwarf_regnames (unsigned int e_machine)
5352 {
5353   switch (e_machine)
5354     {
5355     case EM_386:
5356     case EM_486:
5357       init_dwarf_regnames_i386 ();
5358       break;
5359
5360     case EM_X86_64:
5361     case EM_L1OM:
5362     case EM_K1OM:
5363       init_dwarf_regnames_x86_64 ();
5364       break;
5365
5366     case EM_AARCH64:
5367       init_dwarf_regnames_aarch64 ();
5368       break;
5369
5370     default:
5371       break;
5372     }
5373 }
5374
5375 static const char *
5376 regname (unsigned int regno, int row)
5377 {
5378   static char reg[64];
5379   if (dwarf_regnames
5380       && regno < dwarf_regnames_count
5381       && dwarf_regnames [regno] != NULL)
5382     {
5383       if (row)
5384         return dwarf_regnames [regno];
5385       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5386                 dwarf_regnames [regno]);
5387     }
5388   else
5389     snprintf (reg, sizeof (reg), "r%d", regno);
5390   return reg;
5391 }
5392
5393 static void
5394 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
5395 {
5396   unsigned int r;
5397   char tmp[100];
5398
5399   if (*max_regs < fc->ncols)
5400     *max_regs = fc->ncols;
5401
5402   if (*need_col_headers)
5403     {
5404       static const char *sloc = "   LOC";
5405
5406       *need_col_headers = 0;
5407
5408       printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
5409
5410       for (r = 0; r < *max_regs; r++)
5411         if (fc->col_type[r] != DW_CFA_unreferenced)
5412           {
5413             if (r == fc->ra)
5414               printf ("ra      ");
5415             else
5416               printf ("%-5s ", regname (r, 1));
5417           }
5418
5419       printf ("\n");
5420     }
5421
5422   print_dwarf_vma (fc->pc_begin, eh_addr_size);
5423   if (fc->cfa_exp)
5424     strcpy (tmp, "exp");
5425   else
5426     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
5427   printf ("%-8s ", tmp);
5428
5429   for (r = 0; r < fc->ncols; r++)
5430     {
5431       if (fc->col_type[r] != DW_CFA_unreferenced)
5432         {
5433           switch (fc->col_type[r])
5434             {
5435             case DW_CFA_undefined:
5436               strcpy (tmp, "u");
5437               break;
5438             case DW_CFA_same_value:
5439               strcpy (tmp, "s");
5440               break;
5441             case DW_CFA_offset:
5442               sprintf (tmp, "c%+d", fc->col_offset[r]);
5443               break;
5444             case DW_CFA_val_offset:
5445               sprintf (tmp, "v%+d", fc->col_offset[r]);
5446               break;
5447             case DW_CFA_register:
5448               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5449               break;
5450             case DW_CFA_expression:
5451               strcpy (tmp, "exp");
5452               break;
5453             case DW_CFA_val_expression:
5454               strcpy (tmp, "vexp");
5455               break;
5456             default:
5457               strcpy (tmp, "n/a");
5458               break;
5459             }
5460           printf ("%-5s ", tmp);
5461         }
5462     }
5463   printf ("\n");
5464 }
5465
5466 #define GET(VAR, N)     SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5467 #define LEB()   read_uleb128 (start, & length_return, end); start += length_return
5468 #define SLEB()  read_sleb128 (start, & length_return, end); start += length_return
5469
5470 static unsigned char *
5471 read_cie (unsigned char *start, unsigned char *end,
5472           Frame_Chunk **p_cie, int *p_version,
5473           unsigned long *p_aug_len, unsigned char **p_aug)
5474 {
5475   int version;
5476   Frame_Chunk *fc;
5477   unsigned int length_return;
5478   unsigned char *augmentation_data = NULL;
5479   unsigned long augmentation_data_len = 0;
5480
5481   * p_cie = NULL;
5482   /* PR 17512: file: 001-228113-0.004.  */
5483   if (start >= end)
5484     return end;
5485
5486   fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5487   memset (fc, 0, sizeof (Frame_Chunk));
5488
5489   fc->col_type = (short int *) xmalloc (sizeof (short int));
5490   fc->col_offset = (int *) xmalloc (sizeof (int));
5491
5492   version = *start++;
5493
5494   fc->augmentation = (char *) start;
5495   /* PR 17512: file: 001-228113-0.004.
5496      Skip past augmentation name, but avoid running off the end of the data.  */
5497   while (start < end)
5498     if (* start ++ == '\0')
5499       break;
5500   if (start == end)
5501     {
5502       warn (_("No terminator for augmentation name\n"));
5503       return start;
5504     }
5505
5506   if (strcmp (fc->augmentation, "eh") == 0)
5507     start += eh_addr_size;
5508
5509   if (version >= 4)
5510     {
5511       GET (fc->ptr_size, 1);
5512       GET (fc->segment_size, 1);
5513       eh_addr_size = fc->ptr_size;
5514     }
5515   else
5516     {
5517       fc->ptr_size = eh_addr_size;
5518       fc->segment_size = 0;
5519     }
5520   fc->code_factor = LEB ();
5521   fc->data_factor = SLEB ();
5522   if (version == 1)
5523     {
5524       GET (fc->ra, 1);
5525     }
5526   else
5527     {
5528       fc->ra = LEB ();
5529     }
5530
5531   if (fc->augmentation[0] == 'z')
5532     {
5533       augmentation_data_len = LEB ();
5534       augmentation_data = start;
5535       start += augmentation_data_len;
5536       /* PR 17512: file: 11042-2589-0.004.  */
5537       if (start > end)
5538         {
5539           warn (_("Augmentation data too long: 0x%lx"), augmentation_data_len);
5540           return end;
5541         }
5542     }
5543
5544   if (augmentation_data_len)
5545     {
5546       unsigned char *p;
5547       unsigned char *q;
5548       unsigned char *qend;
5549
5550       p = (unsigned char *) fc->augmentation + 1;
5551       q = augmentation_data;
5552       qend = q + augmentation_data_len;
5553
5554       /* PR 17531: file: 015adfaa.  */
5555       if (qend < q)
5556         {
5557           warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5558           augmentation_data_len = 0;
5559         }
5560
5561       while (p < end && q < augmentation_data + augmentation_data_len)
5562         {
5563           if (*p == 'L')
5564             q++;
5565           else if (*p == 'P')
5566             q += 1 + size_of_encoded_value (*q);
5567           else if (*p == 'R')
5568             fc->fde_encoding = *q++;
5569           else if (*p == 'S')
5570             ;
5571           else
5572             break;
5573           p++;
5574         }
5575       /* Note - it is OK if this loop terminates with q < qend.
5576          Padding may have been inserted to align the end of the CIE.  */
5577     }
5578
5579   *p_cie = fc;
5580   if (p_version)
5581     *p_version = version;
5582   if (p_aug_len)
5583     {
5584       *p_aug_len = augmentation_data_len;
5585       *p_aug = augmentation_data;
5586     }
5587   return start;
5588 }
5589
5590 static int
5591 display_debug_frames (struct dwarf_section *section,
5592                       void *file ATTRIBUTE_UNUSED)
5593 {
5594   unsigned char *start = section->start;
5595   unsigned char *end = start + section->size;
5596   unsigned char *section_start = start;
5597   Frame_Chunk *chunks = 0, *forward_refs = 0;
5598   Frame_Chunk *remembered_state = 0;
5599   Frame_Chunk *rs;
5600   int is_eh = strcmp (section->name, ".eh_frame") == 0;
5601   unsigned int length_return;
5602   unsigned int max_regs = 0;
5603   const char *bad_reg = _("bad register: ");
5604   int saved_eh_addr_size = eh_addr_size;
5605
5606   printf (_("Contents of the %s section:\n"), section->name);
5607
5608   while (start < end)
5609     {
5610       unsigned char *saved_start;
5611       unsigned char *block_end;
5612       dwarf_vma length;
5613       dwarf_vma cie_id;
5614       Frame_Chunk *fc;
5615       Frame_Chunk *cie;
5616       int need_col_headers = 1;
5617       unsigned char *augmentation_data = NULL;
5618       unsigned long augmentation_data_len = 0;
5619       unsigned int encoded_ptr_size = saved_eh_addr_size;
5620       unsigned int offset_size;
5621       unsigned int initial_length_size;
5622
5623       saved_start = start;
5624
5625       SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5626
5627       if (length == 0)
5628         {
5629           printf ("\n%08lx ZERO terminator\n\n",
5630                     (unsigned long)(saved_start - section_start));
5631           /* Skip any zero terminators that directly follow.
5632              A corrupt section size could have loaded a whole
5633              slew of zero filled memory bytes.  eg
5634              PR 17512: file: 070-19381-0.004.  */
5635           while (start < end && * start == 0)
5636             ++ start;
5637           continue;
5638         }
5639
5640       if (length == 0xffffffff)
5641         {
5642           SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5643           offset_size = 8;
5644           initial_length_size = 12;
5645         }
5646       else
5647         {
5648           offset_size = 4;
5649           initial_length_size = 4;
5650         }
5651
5652       block_end = saved_start + length + initial_length_size;
5653       if (block_end > end || block_end < start)
5654         {
5655           warn ("Invalid length 0x%s in FDE at %#08lx\n",
5656                 dwarf_vmatoa_1 (NULL, length, offset_size),
5657                 (unsigned long) (saved_start - section_start));
5658           block_end = end;
5659         }
5660
5661       SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5662
5663       if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5664                                    || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5665         {
5666           int version;
5667           unsigned int mreg;
5668
5669           start = read_cie (start, end, &cie, &version,
5670                             &augmentation_data_len, &augmentation_data);
5671           /* PR 17512: file: 027-135133-0.005.  */
5672           if (cie == NULL)
5673             break;
5674
5675           fc = cie;
5676           fc->next = chunks;
5677           chunks = fc;
5678           fc->chunk_start = saved_start;
5679           mreg = max_regs > 0 ? max_regs - 1 : 0;
5680           if (mreg < fc->ra)
5681             mreg = fc->ra;
5682           if (frame_need_space (fc, mreg) < 0)
5683             break;
5684           if (fc->fde_encoding)
5685             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5686
5687           printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5688           print_dwarf_vma (length, fc->ptr_size);
5689           print_dwarf_vma (cie_id, offset_size);
5690
5691           if (do_debug_frames_interp)
5692             {
5693               printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5694                       fc->code_factor, fc->data_factor, fc->ra);
5695             }
5696           else
5697             {
5698               printf ("CIE\n");
5699               printf ("  Version:               %d\n", version);
5700               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
5701               if (version >= 4)
5702                 {
5703                   printf ("  Pointer Size:          %u\n", fc->ptr_size);
5704                   printf ("  Segment Size:          %u\n", fc->segment_size);
5705                 }
5706               printf ("  Code alignment factor: %u\n", fc->code_factor);
5707               printf ("  Data alignment factor: %d\n", fc->data_factor);
5708               printf ("  Return address column: %d\n", fc->ra);
5709
5710               if (augmentation_data_len)
5711                 {
5712                   unsigned long i;
5713
5714                   printf ("  Augmentation data:    ");
5715                   for (i = 0; i < augmentation_data_len; ++i)
5716                     /* FIXME: If do_wide is FALSE, then we should
5717                        add carriage returns at 80 columns...  */
5718                     printf (" %02x", augmentation_data[i]);
5719                   putchar ('\n');
5720                 }
5721               putchar ('\n');
5722             }
5723         }
5724       else
5725         {
5726           unsigned char *look_for;
5727           static Frame_Chunk fde_fc;
5728           unsigned long segment_selector;
5729
5730           if (is_eh)
5731             {
5732               dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5733               look_for = start - 4 - ((cie_id ^ sign) - sign);
5734             }
5735           else
5736             look_for = section_start + cie_id;
5737
5738           if (look_for <= saved_start)
5739             {
5740               for (cie = chunks; cie ; cie = cie->next)
5741                 if (cie->chunk_start == look_for)
5742                   break;
5743             }
5744           else
5745             {
5746               for (cie = forward_refs; cie ; cie = cie->next)
5747                 if (cie->chunk_start == look_for)
5748                   break;
5749               if (!cie)
5750                 {
5751                   unsigned int off_size;
5752                   unsigned char *cie_scan;
5753
5754                   cie_scan = look_for;
5755                   off_size = 4;
5756                   SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5757                   if (length == 0xffffffff)
5758                     {
5759                       SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5760                       off_size = 8;
5761                     }
5762                   if (length != 0)
5763                     {
5764                       dwarf_vma c_id;
5765
5766                       SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5767                       if (is_eh
5768                           ? c_id == 0
5769                           : ((off_size == 4 && c_id == DW_CIE_ID)
5770                              || (off_size == 8 && c_id == DW64_CIE_ID)))
5771                         {
5772                           int version;
5773                           unsigned int mreg;
5774
5775                           read_cie (cie_scan, end, &cie, &version,
5776                                     &augmentation_data_len, &augmentation_data);
5777                           /* PR 17512: file: 3450-2098-0.004.  */
5778                           if (cie == NULL)
5779                             {
5780                               warn (_("Failed to read CIE information\n"));
5781                               break;
5782                             }
5783                           cie->next = forward_refs;
5784                           forward_refs = cie;
5785                           cie->chunk_start = look_for;
5786                           mreg = max_regs > 0 ? max_regs - 1 : 0;
5787                           if (mreg < cie->ra)
5788                             mreg = cie->ra;
5789                           if (frame_need_space (cie, mreg) < 0)
5790                             {
5791                               warn (_("Invalid max register\n"));
5792                               break;
5793                             }
5794                           if (cie->fde_encoding)
5795                             encoded_ptr_size
5796                               = size_of_encoded_value (cie->fde_encoding);
5797                         }
5798                     }
5799                 }
5800             }
5801
5802           fc = &fde_fc;
5803           memset (fc, 0, sizeof (Frame_Chunk));
5804
5805           if (!cie)
5806             {
5807               warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5808                     dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5809                     (unsigned long) (saved_start - section_start));
5810               fc->ncols = 0;
5811               fc->col_type = (short int *) xmalloc (sizeof (short int));
5812               fc->col_offset = (int *) xmalloc (sizeof (int));
5813               if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5814                 {
5815                   warn (_("Invalid max register\n"));
5816                   break;
5817                 }
5818               cie = fc;
5819               fc->augmentation = "";
5820               fc->fde_encoding = 0;
5821               fc->ptr_size = eh_addr_size;
5822               fc->segment_size = 0;
5823             }
5824           else
5825             {
5826               fc->ncols = cie->ncols;
5827               fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5828               fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
5829               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5830               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5831               fc->augmentation = cie->augmentation;
5832               fc->ptr_size = cie->ptr_size;
5833               eh_addr_size = cie->ptr_size;
5834               fc->segment_size = cie->segment_size;
5835               fc->code_factor = cie->code_factor;
5836               fc->data_factor = cie->data_factor;
5837               fc->cfa_reg = cie->cfa_reg;
5838               fc->cfa_offset = cie->cfa_offset;
5839               fc->ra = cie->ra;
5840               if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
5841                 {
5842                   warn (_("Invalid max register\n"));
5843                   break;
5844                 }
5845               fc->fde_encoding = cie->fde_encoding;
5846             }
5847
5848           if (fc->fde_encoding)
5849             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5850
5851           segment_selector = 0;
5852           if (fc->segment_size)
5853             SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5854
5855           fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
5856
5857           /* FIXME: It appears that sometimes the final pc_range value is
5858              encoded in less than encoded_ptr_size bytes.  See the x86_64
5859              run of the "objcopy on compressed debug sections" test for an
5860              example of this.  */
5861           SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
5862
5863           if (cie->augmentation[0] == 'z')
5864             {
5865               augmentation_data_len = LEB ();
5866               augmentation_data = start;
5867               start += augmentation_data_len;
5868               /* PR 17512: file: 722-8446-0.004.  */
5869               if (start >= end || ((signed long) augmentation_data_len) < 0)
5870                 {
5871                   warn (_("Corrupt augmentation data length: %lx\n"),
5872                         augmentation_data_len);
5873                   start = end;
5874                   augmentation_data = NULL;
5875                   augmentation_data_len = 0;
5876                 }
5877             }
5878
5879           printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5880                   (unsigned long)(saved_start - section_start),
5881                   dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
5882                   dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5883                   (unsigned long)(cie->chunk_start - section_start));
5884
5885           if (fc->segment_size)
5886             printf ("%04lx:", segment_selector);
5887
5888           printf ("%s..%s\n",
5889                   dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
5890                   dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
5891
5892           if (! do_debug_frames_interp && augmentation_data_len)
5893             {
5894               unsigned long i;
5895
5896               printf ("  Augmentation data:    ");
5897               for (i = 0; i < augmentation_data_len; ++i)
5898                 printf (" %02x", augmentation_data[i]);
5899               putchar ('\n');
5900               putchar ('\n');
5901             }
5902         }
5903
5904       /* At this point, fc is the current chunk, cie (if any) is set, and
5905          we're about to interpret instructions for the chunk.  */
5906       /* ??? At present we need to do this always, since this sizes the
5907          fc->col_type and fc->col_offset arrays, which we write into always.
5908          We should probably split the interpreted and non-interpreted bits
5909          into two different routines, since there's so much that doesn't
5910          really overlap between them.  */
5911       if (1 || do_debug_frames_interp)
5912         {
5913           /* Start by making a pass over the chunk, allocating storage
5914              and taking note of what registers are used.  */
5915           unsigned char *tmp = start;
5916
5917           while (start < block_end)
5918             {
5919               unsigned int reg, op, opa;
5920               unsigned long temp;
5921
5922               op = *start++;
5923               opa = op & 0x3f;
5924               if (op & 0xc0)
5925                 op &= 0xc0;
5926
5927               /* Warning: if you add any more cases to this switch, be
5928                  sure to add them to the corresponding switch below.  */
5929               switch (op)
5930                 {
5931                 case DW_CFA_advance_loc:
5932                   break;
5933                 case DW_CFA_offset:
5934                   LEB ();
5935                   if (frame_need_space (fc, opa) >= 0)
5936                     fc->col_type[opa] = DW_CFA_undefined;
5937                   break;
5938                 case DW_CFA_restore:
5939                   if (frame_need_space (fc, opa) >= 0)
5940                     fc->col_type[opa] = DW_CFA_undefined;
5941                   break;
5942                 case DW_CFA_set_loc:
5943                   start += encoded_ptr_size;
5944                   break;
5945                 case DW_CFA_advance_loc1:
5946                   start += 1;
5947                   break;
5948                 case DW_CFA_advance_loc2:
5949                   start += 2;
5950                   break;
5951                 case DW_CFA_advance_loc4:
5952                   start += 4;
5953                   break;
5954                 case DW_CFA_offset_extended:
5955                 case DW_CFA_val_offset:
5956                   reg = LEB (); LEB ();
5957                   if (frame_need_space (fc, reg) >= 0)
5958                     fc->col_type[reg] = DW_CFA_undefined;
5959                   break;
5960                 case DW_CFA_restore_extended:
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_undefined:
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_same_value:
5971                   reg = LEB ();
5972                   if (frame_need_space (fc, reg) >= 0)
5973                     fc->col_type[reg] = DW_CFA_undefined;
5974                   break;
5975                 case DW_CFA_register:
5976                   reg = LEB (); LEB ();
5977                   if (frame_need_space (fc, reg) >= 0)
5978                     fc->col_type[reg] = DW_CFA_undefined;
5979                   break;
5980                 case DW_CFA_def_cfa:
5981                   LEB (); LEB ();
5982                   break;
5983                 case DW_CFA_def_cfa_register:
5984                   LEB ();
5985                   break;
5986                 case DW_CFA_def_cfa_offset:
5987                   LEB ();
5988                   break;
5989                 case DW_CFA_def_cfa_expression:
5990                   temp = LEB ();
5991                   if (start + temp < start)
5992                     {
5993                       warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
5994                       start = block_end;
5995                     }
5996                   else
5997                     start += temp;
5998                   break;
5999                 case DW_CFA_expression:
6000                 case DW_CFA_val_expression:
6001                   reg = LEB ();
6002                   temp = LEB ();
6003                   if (start + temp < start)
6004                     {
6005                       /* PR 17512: file:306-192417-0.005.  */
6006                       warn (_("Corrupt CFA expression value: %lu\n"), temp);
6007                       start = block_end;
6008                     }
6009                   else
6010                     start += temp;
6011                   if (frame_need_space (fc, reg) >= 0)
6012                     fc->col_type[reg] = DW_CFA_undefined;
6013                   break;
6014                 case DW_CFA_offset_extended_sf:
6015                 case DW_CFA_val_offset_sf:
6016                   reg = LEB (); SLEB ();
6017                   if (frame_need_space (fc, reg) >= 0)
6018                     fc->col_type[reg] = DW_CFA_undefined;
6019                   break;
6020                 case DW_CFA_def_cfa_sf:
6021                   LEB (); SLEB ();
6022                   break;
6023                 case DW_CFA_def_cfa_offset_sf:
6024                   SLEB ();
6025                   break;
6026                 case DW_CFA_MIPS_advance_loc8:
6027                   start += 8;
6028                   break;
6029                 case DW_CFA_GNU_args_size:
6030                   LEB ();
6031                   break;
6032                 case DW_CFA_GNU_negative_offset_extended:
6033                   reg = LEB (); LEB ();
6034                   if (frame_need_space (fc, reg) >= 0)
6035                     fc->col_type[reg] = DW_CFA_undefined;
6036                   break;
6037                 default:
6038                   break;
6039                 }
6040             }
6041           start = tmp;
6042         }
6043
6044       /* Now we know what registers are used, make a second pass over
6045          the chunk, this time actually printing out the info.  */
6046
6047       while (start < block_end)
6048         {
6049           unsigned op, opa;
6050           unsigned long ul, reg, roffs;
6051           long l;
6052           dwarf_vma ofs;
6053           dwarf_vma vma;
6054           const char *reg_prefix = "";
6055
6056           op = *start++;
6057           opa = op & 0x3f;
6058           if (op & 0xc0)
6059             op &= 0xc0;
6060
6061           /* Warning: if you add any more cases to this switch, be
6062              sure to add them to the corresponding switch above.  */
6063           switch (op)
6064             {
6065             case DW_CFA_advance_loc:
6066               if (do_debug_frames_interp)
6067                 frame_display_row (fc, &need_col_headers, &max_regs);
6068               else
6069                 printf ("  DW_CFA_advance_loc: %d to %s\n",
6070                         opa * fc->code_factor,
6071                         dwarf_vmatoa_1 (NULL,
6072                                         fc->pc_begin + opa * fc->code_factor,
6073                                         fc->ptr_size));
6074               fc->pc_begin += opa * fc->code_factor;
6075               break;
6076
6077             case DW_CFA_offset:
6078               roffs = LEB ();
6079               if (opa >= (unsigned int) fc->ncols)
6080                 reg_prefix = bad_reg;
6081               if (! do_debug_frames_interp || *reg_prefix != '\0')
6082                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
6083                         reg_prefix, regname (opa, 0),
6084                         roffs * fc->data_factor);
6085               if (*reg_prefix == '\0')
6086                 {
6087                   fc->col_type[opa] = DW_CFA_offset;
6088                   fc->col_offset[opa] = roffs * fc->data_factor;
6089                 }
6090               break;
6091
6092             case DW_CFA_restore:
6093               if (opa >= (unsigned int) cie->ncols
6094                   || opa >= (unsigned int) fc->ncols)
6095                 reg_prefix = bad_reg;
6096               if (! do_debug_frames_interp || *reg_prefix != '\0')
6097                 printf ("  DW_CFA_restore: %s%s\n",
6098                         reg_prefix, regname (opa, 0));
6099               if (*reg_prefix == '\0')
6100                 {
6101                   fc->col_type[opa] = cie->col_type[opa];
6102                   fc->col_offset[opa] = cie->col_offset[opa];
6103                   if (do_debug_frames_interp
6104                       && fc->col_type[opa] == DW_CFA_unreferenced)
6105                     fc->col_type[opa] = DW_CFA_undefined;
6106                 }
6107               break;
6108
6109             case DW_CFA_set_loc:
6110               vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
6111               if (do_debug_frames_interp)
6112                 frame_display_row (fc, &need_col_headers, &max_regs);
6113               else
6114                 printf ("  DW_CFA_set_loc: %s\n",
6115                         dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6116               fc->pc_begin = vma;
6117               break;
6118
6119             case DW_CFA_advance_loc1:
6120               SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6121               if (do_debug_frames_interp)
6122                 frame_display_row (fc, &need_col_headers, &max_regs);
6123               else
6124                 printf ("  DW_CFA_advance_loc1: %ld to %s\n",
6125                         (unsigned long) (ofs * fc->code_factor),
6126                         dwarf_vmatoa_1 (NULL,
6127                                         fc->pc_begin + ofs * fc->code_factor,
6128                                         fc->ptr_size));
6129               fc->pc_begin += ofs * fc->code_factor;
6130               break;
6131
6132             case DW_CFA_advance_loc2:
6133               SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
6134               if (do_debug_frames_interp)
6135                 frame_display_row (fc, &need_col_headers, &max_regs);
6136               else
6137                 printf ("  DW_CFA_advance_loc2: %ld to %s\n",
6138                         (unsigned long) (ofs * fc->code_factor),
6139                         dwarf_vmatoa_1 (NULL,
6140                                         fc->pc_begin + ofs * fc->code_factor,
6141                                         fc->ptr_size));
6142               fc->pc_begin += ofs * fc->code_factor;
6143               break;
6144
6145             case DW_CFA_advance_loc4:
6146               SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
6147               if (do_debug_frames_interp)
6148                 frame_display_row (fc, &need_col_headers, &max_regs);
6149               else
6150                 printf ("  DW_CFA_advance_loc4: %ld to %s\n",
6151                         (unsigned long) (ofs * fc->code_factor),
6152                         dwarf_vmatoa_1 (NULL,
6153                                         fc->pc_begin + ofs * fc->code_factor,
6154                                         fc->ptr_size));
6155               fc->pc_begin += ofs * fc->code_factor;
6156               break;
6157
6158             case DW_CFA_offset_extended:
6159               reg = LEB ();
6160               roffs = LEB ();
6161               if (reg >= (unsigned int) fc->ncols)
6162                 reg_prefix = bad_reg;
6163               if (! do_debug_frames_interp || *reg_prefix != '\0')
6164                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6165                         reg_prefix, regname (reg, 0),
6166                         roffs * fc->data_factor);
6167               if (*reg_prefix == '\0')
6168                 {
6169                   fc->col_type[reg] = DW_CFA_offset;
6170                   fc->col_offset[reg] = roffs * fc->data_factor;
6171                 }
6172               break;
6173
6174             case DW_CFA_val_offset:
6175               reg = LEB ();
6176               roffs = LEB ();
6177               if (reg >= (unsigned int) fc->ncols)
6178                 reg_prefix = bad_reg;
6179               if (! do_debug_frames_interp || *reg_prefix != '\0')
6180                 printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
6181                         reg_prefix, regname (reg, 0),
6182                         roffs * fc->data_factor);
6183               if (*reg_prefix == '\0')
6184                 {
6185                   fc->col_type[reg] = DW_CFA_val_offset;
6186                   fc->col_offset[reg] = roffs * fc->data_factor;
6187                 }
6188               break;
6189
6190             case DW_CFA_restore_extended:
6191               reg = LEB ();
6192               if (reg >= (unsigned int) cie->ncols
6193                   || reg >= (unsigned int) fc->ncols)
6194                 reg_prefix = bad_reg;
6195               if (! do_debug_frames_interp || *reg_prefix != '\0')
6196                 printf ("  DW_CFA_restore_extended: %s%s\n",
6197                         reg_prefix, regname (reg, 0));
6198               if (*reg_prefix == '\0')
6199                 {
6200                   fc->col_type[reg] = cie->col_type[reg];
6201                   fc->col_offset[reg] = cie->col_offset[reg];
6202                 }
6203               break;
6204
6205             case DW_CFA_undefined:
6206               reg = LEB ();
6207               if (reg >= (unsigned int) fc->ncols)
6208                 reg_prefix = bad_reg;
6209               if (! do_debug_frames_interp || *reg_prefix != '\0')
6210                 printf ("  DW_CFA_undefined: %s%s\n",
6211                         reg_prefix, regname (reg, 0));
6212               if (*reg_prefix == '\0')
6213                 {
6214                   fc->col_type[reg] = DW_CFA_undefined;
6215                   fc->col_offset[reg] = 0;
6216                 }
6217               break;
6218
6219             case DW_CFA_same_value:
6220               reg = LEB ();
6221               if (reg >= (unsigned int) fc->ncols)
6222                 reg_prefix = bad_reg;
6223               if (! do_debug_frames_interp || *reg_prefix != '\0')
6224                 printf ("  DW_CFA_same_value: %s%s\n",
6225                         reg_prefix, regname (reg, 0));
6226               if (*reg_prefix == '\0')
6227                 {
6228                   fc->col_type[reg] = DW_CFA_same_value;
6229                   fc->col_offset[reg] = 0;
6230                 }
6231               break;
6232
6233             case DW_CFA_register:
6234               reg = LEB ();
6235               roffs = LEB ();
6236               if (reg >= (unsigned int) fc->ncols)
6237                 reg_prefix = bad_reg;
6238               if (! do_debug_frames_interp || *reg_prefix != '\0')
6239                 {
6240                   printf ("  DW_CFA_register: %s%s in ",
6241                           reg_prefix, regname (reg, 0));
6242                   puts (regname (roffs, 0));
6243                 }
6244               if (*reg_prefix == '\0')
6245                 {
6246                   fc->col_type[reg] = DW_CFA_register;
6247                   fc->col_offset[reg] = roffs;
6248                 }
6249               break;
6250
6251             case DW_CFA_remember_state:
6252               if (! do_debug_frames_interp)
6253                 printf ("  DW_CFA_remember_state\n");
6254               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6255               rs->cfa_offset = fc->cfa_offset;
6256               rs->cfa_reg = fc->cfa_reg;
6257               rs->ra = fc->ra;
6258               rs->cfa_exp = fc->cfa_exp;
6259               rs->ncols = fc->ncols;
6260               rs->col_type = (short int *) xcmalloc (rs->ncols,
6261                                                      sizeof (* rs->col_type));
6262               rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6263               memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6264               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6265               rs->next = remembered_state;
6266               remembered_state = rs;
6267               break;
6268
6269             case DW_CFA_restore_state:
6270               if (! do_debug_frames_interp)
6271                 printf ("  DW_CFA_restore_state\n");
6272               rs = remembered_state;
6273               if (rs)
6274                 {
6275                   remembered_state = rs->next;
6276                   fc->cfa_offset = rs->cfa_offset;
6277                   fc->cfa_reg = rs->cfa_reg;
6278                   fc->ra = rs->ra;
6279                   fc->cfa_exp = rs->cfa_exp;
6280                   if (frame_need_space (fc, rs->ncols - 1) < 0)
6281                     {
6282                       warn (_("Invalid column number in saved frame state"));
6283                       fc->ncols = 0;
6284                       break;
6285                     }
6286                   memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6287                   memcpy (fc->col_offset, rs->col_offset,
6288                           rs->ncols * sizeof (* rs->col_offset));
6289                   free (rs->col_type);
6290                   free (rs->col_offset);
6291                   free (rs);
6292                 }
6293               else if (do_debug_frames_interp)
6294                 printf ("Mismatched DW_CFA_restore_state\n");
6295               break;
6296
6297             case DW_CFA_def_cfa:
6298               fc->cfa_reg = LEB ();
6299               fc->cfa_offset = LEB ();
6300               fc->cfa_exp = 0;
6301               if (! do_debug_frames_interp)
6302                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
6303                         regname (fc->cfa_reg, 0), fc->cfa_offset);
6304               break;
6305
6306             case DW_CFA_def_cfa_register:
6307               fc->cfa_reg = LEB ();
6308               fc->cfa_exp = 0;
6309               if (! do_debug_frames_interp)
6310                 printf ("  DW_CFA_def_cfa_register: %s\n",
6311                         regname (fc->cfa_reg, 0));
6312               break;
6313
6314             case DW_CFA_def_cfa_offset:
6315               fc->cfa_offset = LEB ();
6316               if (! do_debug_frames_interp)
6317                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
6318               break;
6319
6320             case DW_CFA_nop:
6321               if (! do_debug_frames_interp)
6322                 printf ("  DW_CFA_nop\n");
6323               break;
6324
6325             case DW_CFA_def_cfa_expression:
6326               ul = LEB ();
6327               if (start >= block_end || start + ul > block_end || start + ul < start)
6328                 {
6329                   printf (_("  DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6330                   break;
6331                 }
6332               if (! do_debug_frames_interp)
6333                 {
6334                   printf ("  DW_CFA_def_cfa_expression (");
6335                   decode_location_expression (start, eh_addr_size, 0, -1,
6336                                               ul, 0, section);
6337                   printf (")\n");
6338                 }
6339               fc->cfa_exp = 1;
6340               start += ul;
6341               break;
6342
6343             case DW_CFA_expression:
6344               reg = LEB ();
6345               ul = LEB ();
6346               if (reg >= (unsigned int) fc->ncols)
6347                 reg_prefix = bad_reg;
6348               /* PR 17512: file: 069-133014-0.006.  */
6349               /* PR 17512: file: 98c02eb4.  */
6350               if (start >= block_end || start + ul > block_end || start + ul < start)
6351                 {
6352                   printf (_("  DW_CFA_expression: <corrupt len %lu>\n"), ul);
6353                   break;
6354                 }
6355               if (! do_debug_frames_interp || *reg_prefix != '\0')
6356                 {
6357                   printf ("  DW_CFA_expression: %s%s (",
6358                           reg_prefix, regname (reg, 0));
6359                   decode_location_expression (start, eh_addr_size, 0, -1,
6360                                               ul, 0, section);
6361                   printf (")\n");
6362                 }
6363               if (*reg_prefix == '\0')
6364                 fc->col_type[reg] = DW_CFA_expression;
6365               start += ul;
6366               break;
6367
6368             case DW_CFA_val_expression:
6369               reg = LEB ();
6370               ul = LEB ();
6371               if (reg >= (unsigned int) fc->ncols)
6372                 reg_prefix = bad_reg;
6373               if (start >= block_end || start + ul > block_end || start + ul < start)
6374                 {
6375                   printf ("  DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6376                   break;
6377                 }
6378               if (! do_debug_frames_interp || *reg_prefix != '\0')
6379                 {
6380                   printf ("  DW_CFA_val_expression: %s%s (",
6381                           reg_prefix, regname (reg, 0));
6382                   decode_location_expression (start, eh_addr_size, 0, -1,
6383                                               ul, 0, section);
6384                   printf (")\n");
6385                 }
6386               if (*reg_prefix == '\0')
6387                 fc->col_type[reg] = DW_CFA_val_expression;
6388               start += ul;
6389               break;
6390
6391             case DW_CFA_offset_extended_sf:
6392               reg = LEB ();
6393               l = SLEB ();
6394               if (frame_need_space (fc, reg) < 0)
6395                 reg_prefix = bad_reg;
6396               if (! do_debug_frames_interp || *reg_prefix != '\0')
6397                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6398                         reg_prefix, regname (reg, 0),
6399                         l * fc->data_factor);
6400               if (*reg_prefix == '\0')
6401                 {
6402                   fc->col_type[reg] = DW_CFA_offset;
6403                   fc->col_offset[reg] = l * fc->data_factor;
6404                 }
6405               break;
6406
6407             case DW_CFA_val_offset_sf:
6408               reg = LEB ();
6409               l = SLEB ();
6410               if (frame_need_space (fc, reg) < 0)
6411                 reg_prefix = bad_reg;
6412               if (! do_debug_frames_interp || *reg_prefix != '\0')
6413                 printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6414                         reg_prefix, regname (reg, 0),
6415                         l * fc->data_factor);
6416               if (*reg_prefix == '\0')
6417                 {
6418                   fc->col_type[reg] = DW_CFA_val_offset;
6419                   fc->col_offset[reg] = l * fc->data_factor;
6420                 }
6421               break;
6422
6423             case DW_CFA_def_cfa_sf:
6424               fc->cfa_reg = LEB ();
6425               fc->cfa_offset = SLEB ();
6426               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6427               fc->cfa_exp = 0;
6428               if (! do_debug_frames_interp)
6429                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
6430                         regname (fc->cfa_reg, 0), fc->cfa_offset);
6431               break;
6432
6433             case DW_CFA_def_cfa_offset_sf:
6434               fc->cfa_offset = SLEB ();
6435               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6436               if (! do_debug_frames_interp)
6437                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
6438               break;
6439
6440             case DW_CFA_MIPS_advance_loc8:
6441               SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
6442               if (do_debug_frames_interp)
6443                 frame_display_row (fc, &need_col_headers, &max_regs);
6444               else
6445                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6446                         (unsigned long) (ofs * fc->code_factor),
6447                         dwarf_vmatoa_1 (NULL,
6448                                         fc->pc_begin + ofs * fc->code_factor,
6449                                         fc->ptr_size));
6450               fc->pc_begin += ofs * fc->code_factor;
6451               break;
6452
6453             case DW_CFA_GNU_window_save:
6454               if (! do_debug_frames_interp)
6455                 printf ("  DW_CFA_GNU_window_save\n");
6456               break;
6457
6458             case DW_CFA_GNU_args_size:
6459               ul = LEB ();
6460               if (! do_debug_frames_interp)
6461                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
6462               break;
6463
6464             case DW_CFA_GNU_negative_offset_extended:
6465               reg = LEB ();
6466               l = - LEB ();
6467               if (frame_need_space (fc, reg) < 0)
6468                 reg_prefix = bad_reg;
6469               if (! do_debug_frames_interp || *reg_prefix != '\0')
6470                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6471                         reg_prefix, regname (reg, 0),
6472                         l * fc->data_factor);
6473               if (*reg_prefix == '\0')
6474                 {
6475                   fc->col_type[reg] = DW_CFA_offset;
6476                   fc->col_offset[reg] = l * fc->data_factor;
6477                 }
6478               break;
6479
6480             default:
6481               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6482                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6483               else
6484                 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6485               start = block_end;
6486             }
6487         }
6488
6489       if (do_debug_frames_interp)
6490         frame_display_row (fc, &need_col_headers, &max_regs);
6491
6492       start = block_end;
6493       eh_addr_size = saved_eh_addr_size;
6494     }
6495
6496   printf ("\n");
6497
6498   return 1;
6499 }
6500
6501 #undef GET
6502 #undef LEB
6503 #undef SLEB
6504
6505 static int
6506 display_gdb_index (struct dwarf_section *section,
6507                    void *file ATTRIBUTE_UNUSED)
6508 {
6509   unsigned char *start = section->start;
6510   uint32_t version;
6511   uint32_t cu_list_offset, tu_list_offset;
6512   uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6513   unsigned int cu_list_elements, tu_list_elements;
6514   unsigned int address_table_size, symbol_table_slots;
6515   unsigned char *cu_list, *tu_list;
6516   unsigned char *address_table, *symbol_table, *constant_pool;
6517   unsigned int i;
6518
6519   /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
6520
6521   printf (_("Contents of the %s section:\n"), section->name);
6522
6523   if (section->size < 6 * sizeof (uint32_t))
6524     {
6525       warn (_("Truncated header in the %s section.\n"), section->name);
6526       return 0;
6527     }
6528
6529   version = byte_get_little_endian (start, 4);
6530   printf (_("Version %ld\n"), (long) version);
6531
6532   /* Prior versions are obsolete, and future versions may not be
6533      backwards compatible.  */
6534   if (version < 3 || version > 8)
6535     {
6536       warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6537       return 0;
6538     }
6539   if (version < 4)
6540     warn (_("The address table data in version 3 may be wrong.\n"));
6541   if (version < 5)
6542     warn (_("Version 4 does not support case insensitive lookups.\n"));
6543   if (version < 6)
6544     warn (_("Version 5 does not include inlined functions.\n"));
6545   if (version < 7)
6546       warn (_("Version 6 does not include symbol attributes.\n"));
6547   /* Version 7 indices generated by Gold have bad type unit references,
6548      PR binutils/15021.  But we don't know if the index was generated by
6549      Gold or not, so to avoid worrying users with gdb-generated indices
6550      we say nothing for version 7 here.  */
6551
6552   cu_list_offset = byte_get_little_endian (start + 4, 4);
6553   tu_list_offset = byte_get_little_endian (start + 8, 4);
6554   address_table_offset = byte_get_little_endian (start + 12, 4);
6555   symbol_table_offset = byte_get_little_endian (start + 16, 4);
6556   constant_pool_offset = byte_get_little_endian (start + 20, 4);
6557
6558   if (cu_list_offset > section->size
6559       || tu_list_offset > section->size
6560       || address_table_offset > section->size
6561       || symbol_table_offset > section->size
6562       || constant_pool_offset > section->size)
6563     {
6564       warn (_("Corrupt header in the %s section.\n"), section->name);
6565       return 0;
6566     }
6567
6568   /* PR 17531: file: 418d0a8a.  */
6569   if (tu_list_offset < cu_list_offset)
6570     {
6571       warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6572             tu_list_offset, cu_list_offset);
6573       return 0;
6574     }
6575
6576   cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6577
6578   if (address_table_offset < tu_list_offset)
6579     {
6580       warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6581             address_table_offset, tu_list_offset);
6582       return 0;
6583     }
6584
6585   tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6586
6587   /* PR 17531: file: 18a47d3d.  */
6588   if (symbol_table_offset < address_table_offset)
6589     {
6590       warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6591             symbol_table_offset, address_table_offset);
6592       return 0;
6593     }
6594
6595   address_table_size = symbol_table_offset - address_table_offset;
6596
6597   if (constant_pool_offset < symbol_table_offset)
6598     {
6599       warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6600             constant_pool_offset, symbol_table_offset);
6601       return 0;
6602     }
6603
6604   symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6605
6606   cu_list = start + cu_list_offset;
6607   tu_list = start + tu_list_offset;
6608   address_table = start + address_table_offset;
6609   symbol_table = start + symbol_table_offset;
6610   constant_pool = start + constant_pool_offset;
6611
6612   if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6613     {
6614       warn (_("Address table extends beyond end of section. %x"), address_table_size);
6615       return 0;
6616     }
6617
6618   printf (_("\nCU table:\n"));
6619   for (i = 0; i < cu_list_elements; i += 2)
6620     {
6621       uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6622       uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6623
6624       printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6625               (unsigned long) cu_offset,
6626               (unsigned long) (cu_offset + cu_length - 1));
6627     }
6628
6629   printf (_("\nTU table:\n"));
6630   for (i = 0; i < tu_list_elements; i += 3)
6631     {
6632       uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6633       uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6634       uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6635
6636       printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6637               (unsigned long) tu_offset,
6638               (unsigned long) type_offset);
6639       print_dwarf_vma (signature, 8);
6640       printf ("\n");
6641     }
6642
6643   printf (_("\nAddress table:\n"));
6644   for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6645        i += 2 * 8 + 4)
6646     {
6647       uint64_t low = byte_get_little_endian (address_table + i, 8);
6648       uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6649       uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6650
6651       print_dwarf_vma (low, 8);
6652       print_dwarf_vma (high, 8);
6653       printf (_("%lu\n"), (unsigned long) cu_index);
6654     }
6655
6656   printf (_("\nSymbol table:\n"));
6657   for (i = 0; i < symbol_table_slots; ++i)
6658     {
6659       uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6660       uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6661       uint32_t num_cus, cu;
6662
6663       if (name_offset != 0
6664           || cu_vector_offset != 0)
6665         {
6666           unsigned int j;
6667
6668           /* PR 17531: file: 5b7b07ad.  */
6669           if (constant_pool + name_offset < constant_pool
6670               || constant_pool + name_offset >= section->start + section->size)
6671             {
6672               printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6673               warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6674                     name_offset, i);
6675             }
6676           else
6677             printf ("[%3u] %.*s:", i,
6678                     (int) (section->size - (constant_pool_offset + name_offset)),
6679                     constant_pool + name_offset);
6680
6681           if (constant_pool + cu_vector_offset < constant_pool
6682               || constant_pool + cu_vector_offset >= section->start + section->size)
6683             {
6684               printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6685               warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6686                     cu_vector_offset, i);
6687               continue;
6688             }
6689           else
6690             num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
6691
6692           if (num_cus * 4 < num_cus
6693               || constant_pool + cu_vector_offset + 4 + num_cus * 4 >=
6694               section->start + section->size)
6695             {
6696               printf ("<invalid number of CUs: %d>\n", num_cus);
6697               warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6698                     num_cus, i);
6699               continue;
6700             }
6701
6702           if (num_cus > 1)
6703             printf ("\n");
6704           for (j = 0; j < num_cus; ++j)
6705             {
6706               int is_static;
6707               gdb_index_symbol_kind kind;
6708
6709               cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6710               is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6711               kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6712               cu = GDB_INDEX_CU_VALUE (cu);
6713               /* Convert to TU number if it's for a type unit.  */
6714               if (cu >= cu_list_elements / 2)
6715                 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6716                         (unsigned long) (cu - cu_list_elements / 2));
6717               else
6718                 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6719
6720               printf (" [%s, %s]",
6721                       is_static ? _("static") : _("global"),
6722                       get_gdb_index_symbol_kind_name (kind));
6723               if (num_cus > 1)
6724                 printf ("\n");
6725             }
6726           if (num_cus <= 1)
6727             printf ("\n");
6728         }
6729     }
6730
6731   return 1;
6732 }
6733
6734 /* Pre-allocate enough space for the CU/TU sets needed.  */
6735
6736 static void
6737 prealloc_cu_tu_list (unsigned int nshndx)
6738 {
6739   if (shndx_pool == NULL)
6740     {
6741       shndx_pool_size = nshndx;
6742       shndx_pool_used = 0;
6743       shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6744                                               sizeof (unsigned int));
6745     }
6746   else
6747     {
6748       shndx_pool_size = shndx_pool_used + nshndx;
6749       shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6750                                                sizeof (unsigned int));
6751     }
6752 }
6753
6754 static void
6755 add_shndx_to_cu_tu_entry (unsigned int shndx)
6756 {
6757   if (shndx_pool_used >= shndx_pool_size)
6758     {
6759       error (_("Internal error: out of space in the shndx pool.\n"));
6760       return;
6761     }
6762   shndx_pool [shndx_pool_used++] = shndx;
6763 }
6764
6765 static void
6766 end_cu_tu_entry (void)
6767 {
6768   if (shndx_pool_used >= shndx_pool_size)
6769     {
6770       error (_("Internal error: out of space in the shndx pool.\n"));
6771       return;
6772     }
6773   shndx_pool [shndx_pool_used++] = 0;
6774 }
6775
6776 /* Return the short name of a DWARF section given by a DW_SECT enumerator.  */
6777
6778 static const char *
6779 get_DW_SECT_short_name (unsigned int dw_sect)
6780 {
6781   static char buf[16];
6782
6783   switch (dw_sect)
6784     {
6785       case DW_SECT_INFO:
6786         return "info";
6787       case DW_SECT_TYPES:
6788         return "types";
6789       case DW_SECT_ABBREV:
6790         return "abbrev";
6791       case DW_SECT_LINE:
6792         return "line";
6793       case DW_SECT_LOC:
6794         return "loc";
6795       case DW_SECT_STR_OFFSETS:
6796         return "str_off";
6797       case DW_SECT_MACINFO:
6798         return "macinfo";
6799       case DW_SECT_MACRO:
6800         return "macro";
6801       default:
6802         break;
6803     }
6804
6805   snprintf (buf, sizeof (buf), "%d", dw_sect);
6806   return buf;
6807 }
6808
6809 /* Process a CU or TU index.  If DO_DISPLAY is true, print the contents.
6810    These sections are extensions for Fission.
6811    See http://gcc.gnu.org/wiki/DebugFissionDWP.  */
6812
6813 static int
6814 process_cu_tu_index (struct dwarf_section *section, int do_display)
6815 {
6816   unsigned char *phdr = section->start;
6817   unsigned char *limit = phdr + section->size;
6818   unsigned char *phash;
6819   unsigned char *pindex;
6820   unsigned char *ppool;
6821   unsigned int version;
6822   unsigned int ncols = 0;
6823   unsigned int nused;
6824   unsigned int nslots;
6825   unsigned int i;
6826   unsigned int j;
6827   dwarf_vma signature_high;
6828   dwarf_vma signature_low;
6829   char buf[64];
6830
6831   /* PR 17512: file: 002-168123-0.004.  */
6832   if (phdr == NULL)
6833     {
6834       warn (_("Section %s is empty\n"), section->name);
6835       return 0;
6836     }
6837   /* PR 17512: file: 002-376-0.004.  */
6838   if (section->size < 24)
6839     {
6840       warn (_("Section %s is too small to contain a CU/TU header\n"),
6841             section->name);
6842       return 0;
6843     }
6844
6845   SAFE_BYTE_GET (version, phdr, 4, limit);
6846   if (version >= 2)
6847     SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
6848   SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
6849   SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
6850
6851   phash = phdr + 16;
6852   pindex = phash + nslots * 8;
6853   ppool = pindex + nslots * 4;
6854
6855   if (do_display)
6856     {
6857       printf (_("Contents of the %s section:\n\n"), section->name);
6858       printf (_("  Version:                 %d\n"), version);
6859       if (version >= 2)
6860         printf (_("  Number of columns:       %d\n"), ncols);
6861       printf (_("  Number of used entries:  %d\n"), nused);
6862       printf (_("  Number of slots:         %d\n\n"), nslots);
6863     }
6864
6865   if (ppool > limit)
6866     {
6867       warn (_("Section %s too small for %d hash table entries\n"),
6868             section->name, nslots);
6869       return 0;
6870     }
6871
6872   if (version == 1)
6873     {
6874       if (!do_display)
6875         prealloc_cu_tu_list ((limit - ppool) / 4);
6876       for (i = 0; i < nslots; i++)
6877         {
6878           unsigned char *shndx_list;
6879           unsigned int shndx;
6880
6881           SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
6882           if (signature_high != 0 || signature_low != 0)
6883             {
6884               SAFE_BYTE_GET (j, pindex, 4, limit);
6885               shndx_list = ppool + j * 4;
6886               if (do_display)
6887                 printf (_("  [%3d] Signature:  0x%s  Sections: "),
6888                         i, dwarf_vmatoa64 (signature_high, signature_low,
6889                                            buf, sizeof (buf)));
6890               for (;;)
6891                 {
6892                   if (shndx_list >= limit)
6893                     {
6894                       warn (_("Section %s too small for shndx pool\n"),
6895                             section->name);
6896                       return 0;
6897                     }
6898                   SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
6899                   if (shndx == 0)
6900                     break;
6901                   if (do_display)
6902                     printf (" %d", shndx);
6903                   else
6904                     add_shndx_to_cu_tu_entry (shndx);
6905                   shndx_list += 4;
6906                 }
6907               if (do_display)
6908                 printf ("\n");
6909               else
6910                 end_cu_tu_entry ();
6911             }
6912           phash += 8;
6913           pindex += 4;
6914         }
6915     }
6916   else if (version == 2)
6917     {
6918       unsigned int val;
6919       unsigned int dw_sect;
6920       unsigned char *ph = phash;
6921       unsigned char *pi = pindex;
6922       unsigned char *poffsets = ppool + ncols * 4;
6923       unsigned char *psizes = poffsets + nused * ncols * 4;
6924       unsigned char *pend = psizes + nused * ncols * 4;
6925       bfd_boolean is_tu_index;
6926       struct cu_tu_set *this_set = NULL;
6927       unsigned int row;
6928       unsigned char *prow;
6929
6930       is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
6931
6932       if (pend > limit)
6933         {
6934           warn (_("Section %s too small for offset and size tables\n"),
6935                 section->name);
6936           return 0;
6937         }
6938
6939       if (do_display)
6940         {
6941           printf (_("  Offset table\n"));
6942           printf ("  slot  %-16s  ",
6943                  is_tu_index ? _("signature") : _("dwo_id"));
6944         }
6945       else
6946         {
6947           if (is_tu_index)
6948             {
6949               tu_count = nused;
6950               tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
6951               this_set = tu_sets;
6952             }
6953           else
6954             {
6955               cu_count = nused;
6956               cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
6957               this_set = cu_sets;
6958             }
6959         }
6960
6961       if (do_display)
6962         {
6963           for (j = 0; j < ncols; j++)
6964             {
6965               SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
6966               printf (" %8s", get_DW_SECT_short_name (dw_sect));
6967             }
6968           printf ("\n");
6969         }
6970
6971       for (i = 0; i < nslots; i++)
6972         {
6973           SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
6974
6975           SAFE_BYTE_GET (row, pi, 4, limit);
6976           if (row != 0)
6977             {
6978               /* PR 17531: file: a05f6ab3.  */
6979               if (row > nused)
6980                 {
6981                   warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
6982                         row, nused);
6983                   return 0;
6984                 }
6985
6986               if (!do_display)
6987                 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
6988
6989               prow = poffsets + (row - 1) * ncols * 4;
6990
6991               if (do_display)
6992                 printf (_("  [%3d] 0x%s"),
6993                         i, dwarf_vmatoa64 (signature_high, signature_low,
6994                                            buf, sizeof (buf)));
6995               for (j = 0; j < ncols; j++)
6996                 {
6997                   SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
6998                   if (do_display)
6999                     printf (" %8d", val);
7000                   else
7001                     {
7002                       SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7003
7004                       /* PR 17531: file: 10796eb3.  */
7005                       if (dw_sect >= DW_SECT_MAX)
7006                         warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7007                       else
7008                         this_set [row - 1].section_offsets [dw_sect] = val;
7009                     }
7010                 }
7011
7012               if (do_display)
7013                 printf ("\n");
7014             }
7015           ph += 8;
7016           pi += 4;
7017         }
7018
7019       ph = phash;
7020       pi = pindex;
7021       if (do_display)
7022         {
7023           printf ("\n");
7024           printf (_("  Size table\n"));
7025           printf ("  slot  %-16s  ",
7026                  is_tu_index ? _("signature") : _("dwo_id"));
7027         }
7028
7029       for (j = 0; j < ncols; j++)
7030         {
7031           SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
7032           if (do_display)
7033             printf (" %8s", get_DW_SECT_short_name (val));
7034         }
7035
7036       if (do_display)
7037         printf ("\n");
7038
7039       for (i = 0; i < nslots; i++)
7040         {
7041           SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7042
7043           SAFE_BYTE_GET (row, pi, 4, limit);
7044           if (row != 0)
7045             {
7046               prow = psizes + (row - 1) * ncols * 4;
7047
7048               if (do_display)
7049                 printf (_("  [%3d] 0x%s"),
7050                         i, dwarf_vmatoa64 (signature_high, signature_low,
7051                                            buf, sizeof (buf)));
7052
7053               for (j = 0; j < ncols; j++)
7054                 {
7055                   SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7056                   if (do_display)
7057                     printf (" %8d", val);
7058                   else
7059                     {
7060                       SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7061                       if (dw_sect >= DW_SECT_MAX)
7062                         warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7063                       else
7064                       this_set [row - 1].section_sizes [dw_sect] = val;
7065                     }
7066                 }
7067
7068               if (do_display)
7069                 printf ("\n");
7070             }
7071
7072           ph += 8;
7073           pi += 4;
7074         }
7075     }
7076   else if (do_display)
7077     printf (_("  Unsupported version (%d)\n"), version);
7078
7079   if (do_display)
7080       printf ("\n");
7081
7082   return 1;
7083 }
7084
7085 /* Load the CU and TU indexes if present.  This will build a list of
7086    section sets that we can use to associate a .debug_info.dwo section
7087    with its associated .debug_abbrev.dwo section in a .dwp file.  */
7088
7089 static void
7090 load_cu_tu_indexes (void *file)
7091 {
7092   /* If we have already loaded (or tried to load) the CU and TU indexes
7093      then do not bother to repeat the task.  */
7094   if (cu_tu_indexes_read)
7095     return;
7096
7097   if (load_debug_section (dwp_cu_index, file))
7098     process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7099
7100   if (load_debug_section (dwp_tu_index, file))
7101     process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7102
7103   cu_tu_indexes_read = 1;
7104 }
7105
7106 /* Find the set of sections that includes section SHNDX.  */
7107
7108 unsigned int *
7109 find_cu_tu_set (void *file, unsigned int shndx)
7110 {
7111   unsigned int i;
7112
7113   load_cu_tu_indexes (file);
7114
7115   /* Find SHNDX in the shndx pool.  */
7116   for (i = 0; i < shndx_pool_used; i++)
7117     if (shndx_pool [i] == shndx)
7118       break;
7119
7120   if (i >= shndx_pool_used)
7121     return NULL;
7122
7123   /* Now backup to find the first entry in the set.  */
7124   while (i > 0 && shndx_pool [i - 1] != 0)
7125     i--;
7126
7127   return shndx_pool + i;
7128 }
7129
7130 /* Display a .debug_cu_index or .debug_tu_index section.  */
7131
7132 static int
7133 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7134 {
7135   return process_cu_tu_index (section, 1);
7136 }
7137
7138 static int
7139 display_debug_not_supported (struct dwarf_section *section,
7140                              void *file ATTRIBUTE_UNUSED)
7141 {
7142   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7143             section->name);
7144
7145   return 1;
7146 }
7147
7148 /* Like malloc, but takes two parameters.
7149    Note: does *not* initialise the allocated memory to zero.  */
7150 void *
7151 cmalloc (size_t nmemb, size_t size)
7152 {
7153   /* Check for overflow.  */
7154   if (nmemb >= ~(size_t) 0 / size)
7155     return NULL;
7156
7157   return xmalloc (nmemb * size);
7158 }
7159
7160 /* Like xcalloc, but verifies that the first paramer is not too large.  */
7161 void *
7162 xcalloc2 (size_t nmemb, size_t size)
7163 {
7164   /* Check for overflow.  */
7165   if (nmemb >= ~(size_t) 0 / size)
7166     return NULL;
7167
7168   return xcalloc (nmemb, size);
7169 }
7170
7171 /* Like xmalloc, but takes two parameters.
7172    Note: does *not* initialise the allocated memory to zero.  */
7173 void *
7174 xcmalloc (size_t nmemb, size_t size)
7175 {
7176   /* Check for overflow.  */
7177   if (nmemb >= ~(size_t) 0 / size)
7178     return NULL;
7179
7180   return xmalloc (nmemb * size);
7181 }
7182
7183 /* Like xrealloc, but takes three parameters.
7184    Note: does *not* initialise any new memory to zero.  */
7185 void *
7186 xcrealloc (void *ptr, size_t nmemb, size_t size)
7187 {
7188   /* Check for overflow.  */
7189   if (nmemb >= ~(size_t) 0 / size)
7190     return NULL;
7191
7192   return xrealloc (ptr, nmemb * size);
7193 }
7194
7195 void
7196 free_debug_memory (void)
7197 {
7198   unsigned int i;
7199
7200   free_abbrevs ();
7201
7202   for (i = 0; i < max; i++)
7203     free_debug_section ((enum dwarf_section_display_enum) i);
7204
7205   if (debug_information != NULL)
7206     {
7207       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7208         {
7209           for (i = 0; i < num_debug_info_entries; i++)
7210             {
7211               if (!debug_information [i].max_loc_offsets)
7212                 {
7213                   free (debug_information [i].loc_offsets);
7214                   free (debug_information [i].have_frame_base);
7215                 }
7216               if (!debug_information [i].max_range_lists)
7217                 free (debug_information [i].range_lists);
7218             }
7219         }
7220       free (debug_information);
7221       debug_information = NULL;
7222       alloc_num_debug_info_entries = num_debug_info_entries = 0;
7223     }
7224 }
7225
7226 void
7227 dwarf_select_sections_by_names (const char *names)
7228 {
7229   typedef struct
7230   {
7231     const char * option;
7232     int *        variable;
7233     int          val;
7234   }
7235   debug_dump_long_opts;
7236
7237   static const debug_dump_long_opts opts_table [] =
7238     {
7239       /* Please keep this table alpha- sorted.  */
7240       { "Ranges", & do_debug_ranges, 1 },
7241       { "abbrev", & do_debug_abbrevs, 1 },
7242       { "addr", & do_debug_addr, 1 },
7243       { "aranges", & do_debug_aranges, 1 },
7244       { "cu_index", & do_debug_cu_index, 1 },
7245       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7246       { "frames", & do_debug_frames, 1 },
7247       { "frames-interp", & do_debug_frames_interp, 1 },
7248       /* The special .gdb_index section.  */
7249       { "gdb_index", & do_gdb_index, 1 },
7250       { "info", & do_debug_info, 1 },
7251       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
7252       { "loc",  & do_debug_loc, 1 },
7253       { "macro", & do_debug_macinfo, 1 },
7254       { "pubnames", & do_debug_pubnames, 1 },
7255       { "pubtypes", & do_debug_pubtypes, 1 },
7256       /* This entry is for compatability
7257          with earlier versions of readelf.  */
7258       { "ranges", & do_debug_aranges, 1 },
7259       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7260       { "str", & do_debug_str, 1 },
7261       /* These trace_* sections are used by Itanium VMS.  */
7262       { "trace_abbrev", & do_trace_abbrevs, 1 },
7263       { "trace_aranges", & do_trace_aranges, 1 },
7264       { "trace_info", & do_trace_info, 1 },
7265       { NULL, NULL, 0 }
7266     };
7267
7268   const char *p;
7269
7270   p = names;
7271   while (*p)
7272     {
7273       const debug_dump_long_opts * entry;
7274
7275       for (entry = opts_table; entry->option; entry++)
7276         {
7277           size_t len = strlen (entry->option);
7278
7279           if (strncmp (p, entry->option, len) == 0
7280               && (p[len] == ',' || p[len] == '\0'))
7281             {
7282               * entry->variable |= entry->val;
7283
7284               /* The --debug-dump=frames-interp option also
7285                  enables the --debug-dump=frames option.  */
7286               if (do_debug_frames_interp)
7287                 do_debug_frames = 1;
7288
7289               p += len;
7290               break;
7291             }
7292         }
7293
7294       if (entry->option == NULL)
7295         {
7296           warn (_("Unrecognized debug option '%s'\n"), p);
7297           p = strchr (p, ',');
7298           if (p == NULL)
7299             break;
7300         }
7301
7302       if (*p == ',')
7303         p++;
7304     }
7305 }
7306
7307 void
7308 dwarf_select_sections_by_letters (const char *letters)
7309 {
7310   unsigned int lindex = 0;
7311
7312   while (letters[lindex])
7313     switch (letters[lindex++])
7314       {
7315       case 'i':
7316         do_debug_info = 1;
7317         break;
7318
7319       case 'a':
7320         do_debug_abbrevs = 1;
7321         break;
7322
7323       case 'l':
7324         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7325         break;
7326
7327       case 'L':
7328         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7329         break;
7330
7331       case 'p':
7332         do_debug_pubnames = 1;
7333         break;
7334
7335       case 't':
7336         do_debug_pubtypes = 1;
7337         break;
7338
7339       case 'r':
7340         do_debug_aranges = 1;
7341         break;
7342
7343       case 'R':
7344         do_debug_ranges = 1;
7345         break;
7346
7347       case 'F':
7348         do_debug_frames_interp = 1;
7349       case 'f':
7350         do_debug_frames = 1;
7351         break;
7352
7353       case 'm':
7354         do_debug_macinfo = 1;
7355         break;
7356
7357       case 's':
7358         do_debug_str = 1;
7359         break;
7360
7361       case 'o':
7362         do_debug_loc = 1;
7363         break;
7364
7365       default:
7366         warn (_("Unrecognized debug option '%s'\n"), optarg);
7367         break;
7368       }
7369 }
7370
7371 void
7372 dwarf_select_sections_all (void)
7373 {
7374   do_debug_info = 1;
7375   do_debug_abbrevs = 1;
7376   do_debug_lines = FLAG_DEBUG_LINES_RAW;
7377   do_debug_pubnames = 1;
7378   do_debug_pubtypes = 1;
7379   do_debug_aranges = 1;
7380   do_debug_ranges = 1;
7381   do_debug_frames = 1;
7382   do_debug_macinfo = 1;
7383   do_debug_str = 1;
7384   do_debug_loc = 1;
7385   do_gdb_index = 1;
7386   do_trace_info = 1;
7387   do_trace_abbrevs = 1;
7388   do_trace_aranges = 1;
7389   do_debug_addr = 1;
7390   do_debug_cu_index = 1;
7391 }
7392
7393 struct dwarf_section_display debug_displays[] =
7394 {
7395   { { ".debug_abbrev",      ".zdebug_abbrev",   NULL, NULL, 0, 0, 0, NULL },
7396     display_debug_abbrev,   &do_debug_abbrevs,  0 },
7397   { { ".debug_aranges",     ".zdebug_aranges",  NULL, NULL, 0, 0, 0, NULL },
7398     display_debug_aranges,  &do_debug_aranges,  1 },
7399   { { ".debug_frame",       ".zdebug_frame",    NULL, NULL, 0, 0, 0, NULL },
7400     display_debug_frames,   &do_debug_frames,   1 },
7401   { { ".debug_info",        ".zdebug_info",     NULL, NULL, 0, 0, abbrev, NULL },
7402     display_debug_info,     &do_debug_info,     1 },
7403   { { ".debug_line",        ".zdebug_line",     NULL, NULL, 0, 0, 0, NULL },
7404     display_debug_lines,    &do_debug_lines,    1 },
7405   { { ".debug_pubnames",    ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL },
7406     display_debug_pubnames, &do_debug_pubnames, 0 },
7407   { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
7408     display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
7409   { { ".eh_frame",          "",                 NULL, NULL, 0, 0, 0, NULL },
7410     display_debug_frames,   &do_debug_frames,   1 },
7411   { { ".debug_macinfo",     ".zdebug_macinfo",  NULL, NULL, 0, 0, 0, NULL },
7412     display_debug_macinfo,  &do_debug_macinfo,  0 },
7413   { { ".debug_macro",       ".zdebug_macro",    NULL, NULL, 0, 0, 0, NULL },
7414     display_debug_macro,    &do_debug_macinfo,  1 },
7415   { { ".debug_str",         ".zdebug_str",      NULL, NULL, 0, 0, 0, NULL },
7416     display_debug_str,      &do_debug_str,      0 },
7417   { { ".debug_loc",         ".zdebug_loc",      NULL, NULL, 0, 0, 0, NULL },
7418     display_debug_loc,      &do_debug_loc,      1 },
7419   { { ".debug_pubtypes",    ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7420     display_debug_pubnames, &do_debug_pubtypes, 0 },
7421   { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7422     display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
7423   { { ".debug_ranges",      ".zdebug_ranges",   NULL, NULL, 0, 0, 0, NULL },
7424     display_debug_ranges,   &do_debug_ranges,   1 },
7425   { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
7426     display_debug_not_supported, NULL,          0 },
7427   { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
7428     display_debug_not_supported, NULL,          0 },
7429   { { ".debug_types",       ".zdebug_types",    NULL, NULL, 0, 0, abbrev, NULL },
7430     display_debug_types,    &do_debug_info,     1 },
7431   { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
7432     display_debug_not_supported, NULL,          0 },
7433   { { ".gdb_index",         "",                 NULL, NULL, 0, 0, 0, NULL },
7434     display_gdb_index,      &do_gdb_index,      0 },
7435   { { ".trace_info",        "",                 NULL, NULL, 0, 0, trace_abbrev, NULL },
7436     display_trace_info,     &do_trace_info,     1 },
7437   { { ".trace_abbrev",      "",                 NULL, NULL, 0, 0, 0, NULL },
7438     display_debug_abbrev,   &do_trace_abbrevs,  0 },
7439   { { ".trace_aranges",     "",                 NULL, NULL, 0, 0, 0, NULL },
7440     display_debug_aranges,  &do_trace_aranges,  0 },
7441   { { ".debug_info.dwo",    ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7442     display_debug_info,     &do_debug_info,     1 },
7443   { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
7444     display_debug_abbrev,   &do_debug_abbrevs,  0 },
7445   { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7446     display_debug_types,    &do_debug_info,     1 },
7447   { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
7448     display_debug_lines,    &do_debug_lines,    1 },
7449   { { ".debug_loc.dwo",     ".zdebug_loc.dwo",  NULL, NULL, 0, 0, 0, NULL },
7450     display_debug_loc,      &do_debug_loc,      1 },
7451   { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
7452     display_debug_macro,    &do_debug_macinfo,  1 },
7453   { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
7454     display_debug_macinfo,  &do_debug_macinfo,  0 },
7455   { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0, NULL },
7456     display_debug_str,      &do_debug_str,      1 },
7457   { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
7458     display_debug_str_offsets, NULL,            0 },
7459   { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
7460     display_debug_str_offsets, NULL,            0 },
7461   { { ".debug_addr",        ".zdebug_addr",     NULL, NULL, 0, 0, 0, NULL },
7462     display_debug_addr,     &do_debug_addr,     1 },
7463   { { ".debug_cu_index",    "",                 NULL, NULL, 0, 0, 0, NULL },
7464     display_cu_index,       &do_debug_cu_index, 0 },
7465   { { ".debug_tu_index",    "",                 NULL, NULL, 0, 0, 0, NULL },
7466     display_cu_index,       &do_debug_cu_index, 0 },
7467 };