binutils/dwarf.c

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