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       unsigned 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       else if (compunit.cu_length + initial_length_size < initial_length_size)
2743         {
2744           warn (_("Debug info is corrupted, length of CU at %s is negative (%s)\n"),
2745                 dwarf_vmatoa ("x", cu_offset),
2746                 dwarf_vmatoa ("x", compunit.cu_length));
2747           num_units = unit;
2748           break;
2749         }
2750
2751       tags = hdrptr;
2752       start += compunit.cu_length + initial_length_size;
2753
2754       if (start > end)
2755         {
2756           warn (_("Debug info is corrupt.  CU at %s extends beyond end of section"),
2757                 dwarf_vmatoa ("x", cu_offset));
2758           start = end;
2759         }
2760
2761       if (compunit.cu_version < 2 || compunit.cu_version > 5)
2762         {
2763           warn (_("CU at offset %s contains corrupt or "
2764                   "unsupported version number: %d.\n"),
2765                 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2766           continue;
2767         }
2768
2769       if (compunit.cu_unit_type != DW_UT_compile
2770           && compunit.cu_unit_type != DW_UT_type)
2771         {
2772           warn (_("CU at offset %s contains corrupt or "
2773                   "unsupported unit type: %d.\n"),
2774                 dwarf_vmatoa ("x", cu_offset), compunit.cu_unit_type);
2775           continue;
2776         }
2777
2778       free_abbrevs ();
2779
2780       /* Process the abbrevs used by this compilation unit.  */
2781       if (compunit.cu_abbrev_offset >= abbrev_size)
2782         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2783               (unsigned long) compunit.cu_abbrev_offset,
2784               (unsigned long) abbrev_size);
2785       /* PR 17531: file:4bcd9ce9.  */
2786       else if ((abbrev_base + abbrev_size)
2787                > debug_displays [abbrev_sec].section.size)
2788         warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2789               (unsigned long) abbrev_base + abbrev_size,
2790               (unsigned long) debug_displays [abbrev_sec].section.size);
2791       else
2792         process_abbrev_section
2793           (((unsigned char *) debug_displays [abbrev_sec].section.start
2794             + abbrev_base + compunit.cu_abbrev_offset),
2795            ((unsigned char *) debug_displays [abbrev_sec].section.start
2796             + abbrev_base + abbrev_size));
2797
2798       level = 0;
2799       last_level = level;
2800       saved_level = -1;
2801       while (tags < start)
2802         {
2803           unsigned int bytes_read;
2804           unsigned long abbrev_number;
2805           unsigned long die_offset;
2806           abbrev_entry *entry;
2807           abbrev_attr *attr;
2808           int do_printing = 1;
2809
2810           die_offset = tags - section_begin;
2811
2812           abbrev_number = read_uleb128 (tags, & bytes_read, start);
2813           tags += bytes_read;
2814
2815           /* A null DIE marks the end of a list of siblings or it may also be
2816              a section padding.  */
2817           if (abbrev_number == 0)
2818             {
2819               /* Check if it can be a section padding for the last CU.  */
2820               if (level == 0 && start == end)
2821                 {
2822                   unsigned char *chk;
2823
2824                   for (chk = tags; chk < start; chk++)
2825                     if (*chk != 0)
2826                       break;
2827                   if (chk == start)
2828                     break;
2829                 }
2830
2831               if (!do_loc && die_offset >= dwarf_start_die
2832                   && (dwarf_cutoff_level == -1
2833                       || level < dwarf_cutoff_level))
2834                 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2835                         level, die_offset);
2836
2837               --level;
2838               if (level < 0)
2839                 {
2840                   static unsigned num_bogus_warns = 0;
2841
2842                   if (num_bogus_warns < 3)
2843                     {
2844                       warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2845                             die_offset, section->name);
2846                       num_bogus_warns ++;
2847                       if (num_bogus_warns == 3)
2848                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2849                     }
2850                 }
2851               if (dwarf_start_die != 0 && level < saved_level)
2852                 return 1;
2853               continue;
2854             }
2855
2856           if (!do_loc)
2857             {
2858               if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2859                 do_printing = 0;
2860               else
2861                 {
2862                   if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2863                     saved_level = level;
2864                   do_printing = (dwarf_cutoff_level == -1
2865                                  || level < dwarf_cutoff_level);
2866                   if (do_printing)
2867                     printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2868                             level, die_offset, abbrev_number);
2869                   else if (dwarf_cutoff_level == -1
2870                            || last_level < dwarf_cutoff_level)
2871                     printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2872                   last_level = level;
2873                 }
2874             }
2875
2876           /* Scan through the abbreviation list until we reach the
2877              correct entry.  */
2878           for (entry = first_abbrev;
2879                entry && entry->entry != abbrev_number;
2880                entry = entry->next)
2881             continue;
2882
2883           if (entry == NULL)
2884             {
2885               if (!do_loc && do_printing)
2886                 {
2887                   printf ("\n");
2888                   fflush (stdout);
2889                 }
2890               warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2891                     die_offset, abbrev_number);
2892               return 0;
2893             }
2894
2895           if (!do_loc && do_printing)
2896             printf (" (%s)\n", get_TAG_name (entry->tag));
2897
2898           switch (entry->tag)
2899             {
2900             default:
2901               need_base_address = 0;
2902               break;
2903             case DW_TAG_compile_unit:
2904               need_base_address = 1;
2905               break;
2906             case DW_TAG_entry_point:
2907             case DW_TAG_subprogram:
2908               need_base_address = 0;
2909               /* Assuming that there is no DW_AT_frame_base.  */
2910               have_frame_base = 0;
2911               break;
2912             }
2913
2914           debug_info *debug_info_p =
2915             (debug_information && unit < alloc_num_debug_info_entries)
2916             ? debug_information + unit : NULL;
2917
2918           assert (!debug_info_p
2919                   || (debug_info_p->num_loc_offsets
2920                       == debug_info_p->num_loc_views));
2921
2922           for (attr = entry->first_attr;
2923                attr && attr->attribute;
2924                attr = attr->next)
2925             {
2926               if (! do_loc && do_printing)
2927                 /* Show the offset from where the tag was extracted.  */
2928                 printf ("    <%lx>", (unsigned long)(tags - section_begin));
2929
2930               tags = read_and_display_attr (attr->attribute,
2931                                             attr->form,
2932                                             attr->implicit_const,
2933                                             tags,
2934                                             end,
2935                                             cu_offset,
2936                                             compunit.cu_pointer_size,
2937                                             offset_size,
2938                                             compunit.cu_version,
2939                                             debug_info_p,
2940                                             do_loc || ! do_printing,
2941                                             section,
2942                                             this_set);
2943             }
2944
2945           /* If a locview attribute appears before a location one,
2946              make sure we don't associate it with an earlier
2947              loclist. */
2948           if (debug_info_p)
2949             switch (debug_info_p->num_loc_offsets - debug_info_p->num_loc_views)
2950               {
2951               case 1:
2952                 debug_info_p->loc_views [debug_info_p->num_loc_views] = vm1;
2953                 debug_info_p->num_loc_views++;
2954                 assert (debug_info_p->num_loc_views
2955                         == debug_info_p->num_loc_offsets);
2956                 break;
2957
2958               case 0:
2959                 break;
2960
2961               case -1:
2962                 warn(_("DIE has locviews without loclist\n"));
2963                 debug_info_p->num_loc_views--;
2964                 break;
2965
2966               default:
2967                 assert (0);
2968             }
2969
2970           if (entry->children)
2971             ++level;
2972         }
2973     }
2974
2975   /* Set num_debug_info_entries here so that it can be used to check if
2976      we need to process .debug_loc and .debug_ranges sections.  */
2977   if ((do_loc || do_debug_loc || do_debug_ranges)
2978       && num_debug_info_entries == 0
2979       && ! do_types)
2980     {
2981       if (num_units > alloc_num_debug_info_entries)
2982         num_debug_info_entries = alloc_num_debug_info_entries;
2983       else
2984         num_debug_info_entries = num_units;
2985     }
2986
2987   if (!do_loc)
2988     printf ("\n");
2989
2990   return 1;
2991 }
2992
2993 /* Locate and scan the .debug_info section in the file and record the pointer
2994    sizes and offsets for the compilation units in it.  Usually an executable
2995    will have just one pointer size, but this is not guaranteed, and so we try
2996    not to make any assumptions.  Returns zero upon failure, or the number of
2997    compilation units upon success.  */
2998
2999 static unsigned int
3000 load_debug_info (void * file)
3001 {
3002   /* If we have already tried and failed to load the .debug_info
3003      section then do not bother to repeat the task.  */
3004   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3005     return 0;
3006
3007   /* If we already have the information there is nothing else to do.  */
3008   if (num_debug_info_entries > 0)
3009     return num_debug_info_entries;
3010
3011   /* If this is a DWARF package file, load the CU and TU indexes.  */
3012   (void) load_cu_tu_indexes (file);
3013
3014   if (load_debug_section (info, file)
3015       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
3016     return num_debug_info_entries;
3017
3018   if (load_debug_section (info_dwo, file)
3019       && process_debug_info (&debug_displays [info_dwo].section, file,
3020                              abbrev_dwo, 1, 0))
3021     return num_debug_info_entries;
3022
3023   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
3024   return 0;
3025 }
3026
3027 /* Read a DWARF .debug_line section header starting at DATA.
3028    Upon success returns an updated DATA pointer and the LINFO
3029    structure and the END_OF_SEQUENCE pointer will be filled in.
3030    Otherwise returns NULL.  */
3031
3032 static unsigned char *
3033 read_debug_line_header (struct dwarf_section * section,
3034                         unsigned char * data,
3035                         unsigned char * end,
3036                         DWARF2_Internal_LineInfo * linfo,
3037                         unsigned char ** end_of_sequence)
3038 {
3039   unsigned char *hdrptr;
3040   unsigned int initial_length_size;
3041   unsigned char address_size, segment_selector_size;
3042
3043   /* Extract information from the Line Number Program Header.
3044      (section 6.2.4 in the Dwarf3 doc).  */
3045   hdrptr = data;
3046
3047   /* Get and check the length of the block.  */
3048   SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
3049
3050   if (linfo->li_length == 0xffffffff)
3051     {
3052       /* This section is 64-bit DWARF 3.  */
3053       SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
3054       linfo->li_offset_size = 8;
3055       initial_length_size = 12;
3056     }
3057   else
3058     {
3059       linfo->li_offset_size = 4;
3060       initial_length_size = 4;
3061     }
3062
3063   if (linfo->li_length + initial_length_size > section->size)
3064     {
3065       /* If the length field has a relocation against it, then we should
3066          not complain if it is inaccurate (and probably negative).  This
3067          happens in object files when the .debug_line section is actually
3068          comprised of several different .debug_line.* sections, (some of
3069          which may be removed by linker garbage collection), and a relocation
3070          is used to compute the correct length once that is done.  */
3071       if (reloc_at (section, (hdrptr - section->start) - linfo->li_offset_size))
3072         {
3073           linfo->li_length = (end - data) - initial_length_size;
3074         }
3075       else
3076         {
3077           warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3078                 (long) linfo->li_length);
3079           return NULL;
3080         }
3081     }
3082
3083   /* Get and check the version number.  */
3084   SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
3085
3086   if (linfo->li_version != 2
3087       && linfo->li_version != 3
3088       && linfo->li_version != 4
3089       && linfo->li_version != 5)
3090     {
3091       warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3092               "is currently supported.\n"));
3093       return NULL;
3094     }
3095
3096   if (linfo->li_version >= 5)
3097     {
3098       SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
3099
3100       SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
3101       if (segment_selector_size != 0)
3102         {
3103           warn (_("The %s section contains "
3104                   "unsupported segment selector size: %d.\n"),
3105                 section->name, segment_selector_size);
3106           return 0;
3107         }
3108     }
3109
3110   SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr,
3111                          linfo->li_offset_size, end);
3112   SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
3113
3114   if (linfo->li_version >= 4)
3115     {
3116       SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
3117
3118       if (linfo->li_max_ops_per_insn == 0)
3119         {
3120           warn (_("Invalid maximum operations per insn.\n"));
3121           return NULL;
3122         }
3123     }
3124   else
3125     linfo->li_max_ops_per_insn = 1;
3126
3127   SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
3128   SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
3129   SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
3130   SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
3131
3132   * end_of_sequence = data + linfo->li_length + initial_length_size;
3133   /* PR 17512: file:002-117414-0.004.  */
3134   if (* end_of_sequence > end)
3135     {
3136       warn (_("Line length %s extends beyond end of section\n"),
3137             dwarf_vmatoa ("u", linfo->li_length));
3138       * end_of_sequence = end;
3139       return NULL;
3140     }
3141
3142   return hdrptr;
3143 }
3144
3145 static unsigned char *
3146 display_formatted_table (unsigned char *data,
3147                          unsigned char *start, unsigned char *end,
3148                          const DWARF2_Internal_LineInfo *linfo,
3149                          struct dwarf_section *section, const char *what)
3150 {
3151   unsigned char *format_start, format_count, *format, formati;
3152   dwarf_vma data_count, datai;
3153   unsigned int bytes_read, namepass, last_entry = 0;
3154
3155   SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3156   format_start = data;
3157   for (formati = 0; formati < format_count; formati++)
3158     {
3159       read_uleb128 (data, & bytes_read, end);
3160       data += bytes_read;
3161       read_uleb128 (data, & bytes_read, end);
3162       data += bytes_read;
3163       if (data == end)
3164         {
3165           warn (_("Corrupt %s format table entry\n"), what);
3166           return data;
3167         }
3168     }
3169
3170   data_count = read_uleb128 (data, & bytes_read, end);
3171   data += bytes_read;
3172   if (data == end)
3173     {
3174       warn (_("Corrupt %s list\n"), what);
3175       return data;
3176     }
3177
3178   if (data_count == 0)
3179     {
3180       printf (_("\n The %s Table is empty.\n"), what);
3181       return data;
3182     }
3183
3184   printf (_("\n The %s Table (offset 0x%lx):\n"), what,
3185           (long)(data - start));
3186
3187   printf (_("  Entry"));
3188   /* Delay displaying name as the last entry for better screen layout.  */
3189   for (namepass = 0; namepass < 2; namepass++)
3190     {
3191       format = format_start;
3192       for (formati = 0; formati < format_count; formati++)
3193         {
3194           dwarf_vma content_type;
3195
3196           content_type = read_uleb128 (format, & bytes_read, end);
3197           format += bytes_read;
3198           if ((content_type == DW_LNCT_path) == (namepass == 1))
3199             switch (content_type)
3200               {
3201               case DW_LNCT_path:
3202                 printf (_("\tName"));
3203                 break;
3204               case DW_LNCT_directory_index:
3205                 printf (_("\tDir"));
3206                 break;
3207               case DW_LNCT_timestamp:
3208                 printf (_("\tTime"));
3209                 break;
3210               case DW_LNCT_size:
3211                 printf (_("\tSize"));
3212                 break;
3213               case DW_LNCT_MD5:
3214                 printf (_("\tMD5"));
3215                 break;
3216               default:
3217                 printf (_("\t(Unknown format content type %s)"),
3218                         dwarf_vmatoa ("u", content_type));
3219               }
3220           read_uleb128 (format, & bytes_read, end);
3221           format += bytes_read;
3222         }
3223     }
3224   putchar ('\n');
3225
3226   for (datai = 0; datai < data_count; datai++)
3227     {
3228       unsigned char *datapass = data;
3229
3230       printf ("  %d", last_entry++);
3231       /* Delay displaying name as the last entry for better screen layout.  */
3232       for (namepass = 0; namepass < 2; namepass++)
3233         {
3234           format = format_start;
3235           data = datapass;
3236           for (formati = 0; formati < format_count; formati++)
3237             {
3238               dwarf_vma content_type, form;
3239
3240               content_type = read_uleb128 (format, & bytes_read, end);
3241               format += bytes_read;
3242               form = read_uleb128 (format, & bytes_read, end);
3243               format += bytes_read;
3244               data = read_and_display_attr_value (0, form, 0, data, end, 0, 0,
3245                                                   linfo->li_offset_size,
3246                                                   linfo->li_version, NULL,
3247                             ((content_type == DW_LNCT_path) != (namepass == 1)),
3248                                                   section, NULL, '\t');
3249             }
3250         }
3251       if (data == end)
3252         {
3253           warn (_("Corrupt %s entries list\n"), what);
3254           return data;
3255         }
3256       putchar ('\n');
3257     }
3258   return data;
3259 }
3260
3261 static int
3262 display_debug_lines_raw (struct dwarf_section *section,
3263                          unsigned char *data,
3264                          unsigned char *end, void *file)
3265 {
3266   unsigned char *start = section->start;
3267   int verbose_view = 0;
3268
3269   printf (_("Raw dump of debug contents of section %s:\n\n"),
3270           section->name);
3271
3272   while (data < end)
3273     {
3274       static DWARF2_Internal_LineInfo saved_linfo;
3275       DWARF2_Internal_LineInfo linfo;
3276       unsigned char *standard_opcodes;
3277       unsigned char *end_of_sequence;
3278       int i;
3279
3280       if (const_strneq (section->name, ".debug_line.")
3281           /* Note: the following does not apply to .debug_line.dwo sections.
3282              These are full debug_line sections.  */
3283           && strcmp (section->name, ".debug_line.dwo") != 0)
3284         {
3285           /* Sections named .debug_line.<foo> are fragments of a .debug_line
3286              section containing just the Line Number Statements.  They are
3287              created by the assembler and intended to be used alongside gcc's
3288              -ffunction-sections command line option.  When the linker's
3289              garbage collection decides to discard a .text.<foo> section it
3290              can then also discard the line number information in .debug_line.<foo>.
3291
3292              Since the section is a fragment it does not have the details
3293              needed to fill out a LineInfo structure, so instead we use the
3294              details from the last full debug_line section that we processed.  */
3295           end_of_sequence = end;
3296           standard_opcodes = NULL;
3297           linfo = saved_linfo;
3298           /* PR 17531: file: 0522b371.  */
3299           if (linfo.li_line_range == 0)
3300             {
3301               warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3302               return 0;
3303             }
3304           reset_state_machine (linfo.li_default_is_stmt);
3305         }
3306       else
3307         {
3308           unsigned char * hdrptr;
3309
3310           if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3311                                                 & end_of_sequence)) == NULL)
3312             return 0;
3313
3314           printf (_("  Offset:                      0x%lx\n"), (long)(data - start));
3315           printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
3316           printf (_("  DWARF Version:               %d\n"), linfo.li_version);
3317           printf (_("  Prologue Length:             %d\n"), (int) linfo.li_prologue_length);
3318           printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
3319           if (linfo.li_version >= 4)
3320             printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
3321           printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
3322           printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
3323           printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
3324           printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
3325
3326           /* PR 17512: file: 1665-6428-0.004.  */
3327           if (linfo.li_line_range == 0)
3328             {
3329               warn (_("Line range of 0 is invalid, using 1 instead\n"));
3330               linfo.li_line_range = 1;
3331             }
3332
3333           reset_state_machine (linfo.li_default_is_stmt);
3334
3335           /* Display the contents of the Opcodes table.  */
3336           standard_opcodes = hdrptr;
3337
3338           /* PR 17512: file: 002-417945-0.004.  */
3339           if (standard_opcodes + linfo.li_opcode_base >= end)
3340             {
3341               warn (_("Line Base extends beyond end of section\n"));
3342               return 0;
3343             }
3344
3345           printf (_("\n Opcodes:\n"));
3346
3347           for (i = 1; i < linfo.li_opcode_base; i++)
3348             printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
3349
3350           /* Display the contents of the Directory table.  */
3351           data = standard_opcodes + linfo.li_opcode_base - 1;
3352
3353           if (linfo.li_version >= 5)
3354             {
3355               load_debug_section (line_str, file);
3356
3357               data = display_formatted_table (data, start, end, &linfo, section,
3358                                               _("Directory"));
3359               data = display_formatted_table (data, start, end, &linfo, section,
3360                                               _("File name"));
3361             }
3362           else
3363             {
3364               if (*data == 0)
3365                 printf (_("\n The Directory Table is empty.\n"));
3366               else
3367                 {
3368                   unsigned int last_dir_entry = 0;
3369
3370                   printf (_("\n The Directory Table (offset 0x%lx):\n"),
3371                           (long)(data - start));
3372
3373                   while (data < end && *data != 0)
3374                     {
3375                       printf ("  %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
3376
3377                       data += strnlen ((char *) data, end - data) + 1;
3378                     }
3379
3380                   /* PR 17512: file: 002-132094-0.004.  */
3381                   if (data >= end - 1)
3382                     break;
3383                 }
3384
3385               /* Skip the NUL at the end of the table.  */
3386               data++;
3387
3388               /* Display the contents of the File Name table.  */
3389               if (*data == 0)
3390                 printf (_("\n The File Name Table is empty.\n"));
3391               else
3392                 {
3393                   printf (_("\n The File Name Table (offset 0x%lx):\n"),
3394                           (long)(data - start));
3395                   printf (_("  Entry\tDir\tTime\tSize\tName\n"));
3396
3397                   while (data < end && *data != 0)
3398                     {
3399                       unsigned char *name;
3400                       unsigned int bytes_read;
3401
3402                       printf ("  %d\t", ++state_machine_regs.last_file_entry);
3403                       name = data;
3404                       data += strnlen ((char *) data, end - data) + 1;
3405
3406                       printf ("%s\t",
3407                               dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3408                       data += bytes_read;
3409                       printf ("%s\t",
3410                               dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3411                       data += bytes_read;
3412                       printf ("%s\t",
3413                               dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3414                       data += bytes_read;
3415                       printf ("%.*s\n", (int)(end - name), name);
3416
3417                       if (data == end)
3418                         {
3419                           warn (_("Corrupt file name table entry\n"));
3420                           break;
3421                         }
3422                     }
3423                 }
3424
3425               /* Skip the NUL at the end of the table.  */
3426               data++;
3427             }
3428
3429           putchar ('\n');
3430           saved_linfo = linfo;
3431         }
3432
3433       /* Now display the statements.  */
3434       if (data >= end_of_sequence)
3435         printf (_(" No Line Number Statements.\n"));
3436       else
3437         {
3438           printf (_(" Line Number Statements:\n"));
3439
3440           while (data < end_of_sequence)
3441             {
3442               unsigned char op_code;
3443               dwarf_signed_vma adv;
3444               dwarf_vma uladv;
3445               unsigned int bytes_read;
3446
3447               printf ("  [0x%08lx]", (long)(data - start));
3448
3449               op_code = *data++;
3450
3451               if (op_code >= linfo.li_opcode_base)
3452                 {
3453                   op_code -= linfo.li_opcode_base;
3454                   uladv = (op_code / linfo.li_line_range);
3455                   if (linfo.li_max_ops_per_insn == 1)
3456                     {
3457                       uladv *= linfo.li_min_insn_length;
3458                       state_machine_regs.address += uladv;
3459                       if (uladv)
3460                         state_machine_regs.view = 0;
3461                       printf (_("  Special opcode %d: "
3462                                 "advance Address by %s to 0x%s%s"),
3463                               op_code, dwarf_vmatoa ("u", uladv),
3464                               dwarf_vmatoa ("x", state_machine_regs.address),
3465                               verbose_view && uladv
3466                               ? _(" (reset view)") : "");
3467                     }
3468                   else
3469                     {
3470                       unsigned addrdelta
3471                         = ((state_machine_regs.op_index + uladv)
3472                             / linfo.li_max_ops_per_insn)
3473                         * linfo.li_min_insn_length;
3474
3475                       state_machine_regs.address += addrdelta;
3476                       state_machine_regs.op_index
3477                         = (state_machine_regs.op_index + uladv)
3478                         % linfo.li_max_ops_per_insn;
3479                       if (addrdelta)
3480                         state_machine_regs.view = 0;
3481                       printf (_("  Special opcode %d: "
3482                                 "advance Address by %s to 0x%s[%d]%s"),
3483                               op_code, dwarf_vmatoa ("u", uladv),
3484                               dwarf_vmatoa ("x", state_machine_regs.address),
3485                               state_machine_regs.op_index,
3486                               verbose_view && addrdelta
3487                               ? _(" (reset view)") : "");
3488                     }
3489                   adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3490                   state_machine_regs.line += adv;
3491                   printf (_(" and Line by %s to %d"),
3492                           dwarf_vmatoa ("d", adv), state_machine_regs.line);
3493                   if (verbose_view || state_machine_regs.view)
3494                     printf (_(" (view %u)\n"), state_machine_regs.view);
3495                   else
3496                     putchar ('\n');
3497                   state_machine_regs.view++;
3498                 }
3499               else switch (op_code)
3500                      {
3501                      case DW_LNS_extended_op:
3502                        data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3503                        break;
3504
3505                      case DW_LNS_copy:
3506                        printf (_("  Copy"));
3507                        if (verbose_view || state_machine_regs.view)
3508                          printf (_(" (view %u)\n"), state_machine_regs.view);
3509                        else
3510                          putchar ('\n');
3511                        state_machine_regs.view++;
3512                        break;
3513
3514                      case DW_LNS_advance_pc:
3515                        uladv = read_uleb128 (data, & bytes_read, end);
3516                        data += bytes_read;
3517                        if (linfo.li_max_ops_per_insn == 1)
3518                          {
3519                            uladv *= linfo.li_min_insn_length;
3520                            state_machine_regs.address += uladv;
3521                            if (uladv)
3522                              state_machine_regs.view = 0;
3523                            printf (_("  Advance PC by %s to 0x%s%s\n"),
3524                                    dwarf_vmatoa ("u", uladv),
3525                                    dwarf_vmatoa ("x", state_machine_regs.address),
3526                                    verbose_view && uladv
3527                                    ? _(" (reset view)") : "");
3528                          }
3529                        else
3530                          {
3531                            unsigned addrdelta
3532                              = ((state_machine_regs.op_index + uladv)
3533                                 / linfo.li_max_ops_per_insn)
3534                              * linfo.li_min_insn_length;
3535                            state_machine_regs.address
3536                              += addrdelta;
3537                            state_machine_regs.op_index
3538                              = (state_machine_regs.op_index + uladv)
3539                              % linfo.li_max_ops_per_insn;
3540                            if (addrdelta)
3541                              state_machine_regs.view = 0;
3542                            printf (_("  Advance PC by %s to 0x%s[%d]%s\n"),
3543                                    dwarf_vmatoa ("u", uladv),
3544                                    dwarf_vmatoa ("x", state_machine_regs.address),
3545                                    state_machine_regs.op_index,
3546                                    verbose_view && addrdelta
3547                                    ? _(" (reset view)") : "");
3548                          }
3549                        break;
3550
3551                      case DW_LNS_advance_line:
3552                        adv = read_sleb128 (data, & bytes_read, end);
3553                        data += bytes_read;
3554                        state_machine_regs.line += adv;
3555                        printf (_("  Advance Line by %s to %d\n"),
3556                                dwarf_vmatoa ("d", adv),
3557                                state_machine_regs.line);
3558                        break;
3559
3560                      case DW_LNS_set_file:
3561                        adv = read_uleb128 (data, & bytes_read, end);
3562                        data += bytes_read;
3563                        printf (_("  Set File Name to entry %s in the File Name Table\n"),
3564                                dwarf_vmatoa ("d", adv));
3565                        state_machine_regs.file = adv;
3566                        break;
3567
3568                      case DW_LNS_set_column:
3569                        uladv = read_uleb128 (data, & bytes_read, end);
3570                        data += bytes_read;
3571                        printf (_("  Set column to %s\n"),
3572                                dwarf_vmatoa ("u", uladv));
3573                        state_machine_regs.column = uladv;
3574                        break;
3575
3576                      case DW_LNS_negate_stmt:
3577                        adv = state_machine_regs.is_stmt;
3578                        adv = ! adv;
3579                        printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3580                        state_machine_regs.is_stmt = adv;
3581                        break;
3582
3583                      case DW_LNS_set_basic_block:
3584                        printf (_("  Set basic block\n"));
3585                        state_machine_regs.basic_block = 1;
3586                        break;
3587
3588                      case DW_LNS_const_add_pc:
3589                        uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3590                        if (linfo.li_max_ops_per_insn)
3591                          {
3592                            uladv *= linfo.li_min_insn_length;
3593                            state_machine_regs.address += uladv;
3594                            if (uladv)
3595                              state_machine_regs.view = 0;
3596                            printf (_("  Advance PC by constant %s to 0x%s%s\n"),
3597                                    dwarf_vmatoa ("u", uladv),
3598                                    dwarf_vmatoa ("x", state_machine_regs.address),
3599                                    verbose_view && uladv
3600                                    ? _(" (reset view)") : "");
3601                          }
3602                        else
3603                          {
3604                            unsigned addrdelta
3605                              = ((state_machine_regs.op_index + uladv)
3606                                 / linfo.li_max_ops_per_insn)
3607                              * linfo.li_min_insn_length;
3608                            state_machine_regs.address
3609                              += addrdelta;
3610                            state_machine_regs.op_index
3611                              = (state_machine_regs.op_index + uladv)
3612                              % linfo.li_max_ops_per_insn;
3613                            if (addrdelta)
3614                              state_machine_regs.view = 0;
3615                            printf (_("  Advance PC by constant %s to 0x%s[%d]%s\n"),
3616                                    dwarf_vmatoa ("u", uladv),
3617                                    dwarf_vmatoa ("x", state_machine_regs.address),
3618                                    state_machine_regs.op_index,
3619                                    verbose_view && addrdelta
3620                                    ? _(" (reset view)") : "");
3621                          }
3622                        break;
3623
3624                      case DW_LNS_fixed_advance_pc:
3625                        SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3626                        state_machine_regs.address += uladv;
3627                        state_machine_regs.op_index = 0;
3628                        printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
3629                                dwarf_vmatoa ("u", uladv),
3630                                dwarf_vmatoa ("x", state_machine_regs.address));
3631                        /* Do NOT reset view.  */
3632                        break;
3633
3634                      case DW_LNS_set_prologue_end:
3635                        printf (_("  Set prologue_end to true\n"));
3636                        break;
3637
3638                      case DW_LNS_set_epilogue_begin:
3639                        printf (_("  Set epilogue_begin to true\n"));
3640                        break;
3641
3642                      case DW_LNS_set_isa:
3643                        uladv = read_uleb128 (data, & bytes_read, end);
3644                        data += bytes_read;
3645                        printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3646                        break;
3647
3648                      default:
3649                        printf (_("  Unknown opcode %d with operands: "), op_code);
3650
3651                        if (standard_opcodes != NULL)
3652                          for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3653                            {
3654                              printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3655                                                                                 &bytes_read, end)),
3656                                      i == 1 ? "" : ", ");
3657                              data += bytes_read;
3658                            }
3659                        putchar ('\n');
3660                        break;
3661                      }
3662             }
3663           putchar ('\n');
3664         }
3665     }
3666
3667   return 1;
3668 }
3669
3670 typedef struct
3671 {
3672   unsigned char *name;
3673   unsigned int directory_index;
3674   unsigned int modification_date;
3675   unsigned int length;
3676 } File_Entry;
3677
3678 /* Output a decoded representation of the .debug_line section.  */
3679
3680 static int
3681 display_debug_lines_decoded (struct dwarf_section *section,
3682                              unsigned char *data,
3683                              unsigned char *end, void *fileptr)
3684 {
3685   static DWARF2_Internal_LineInfo saved_linfo;
3686
3687   printf (_("Decoded dump of debug contents of section %s:\n\n"),
3688           section->name);
3689
3690   while (data < end)
3691     {
3692       /* This loop amounts to one iteration per compilation unit.  */
3693       DWARF2_Internal_LineInfo linfo;
3694       unsigned char *standard_opcodes;
3695       unsigned char *end_of_sequence;
3696       int i;
3697       File_Entry *file_table = NULL;
3698       unsigned int n_files = 0;
3699       unsigned char **directory_table = NULL;
3700       dwarf_vma n_directories = 0;
3701
3702       if (const_strneq (section->name, ".debug_line.")
3703           /* Note: the following does not apply to .debug_line.dwo sections.
3704              These are full debug_line sections.  */
3705           && strcmp (section->name, ".debug_line.dwo") != 0)
3706         {
3707           /* See comment in display_debug_lines_raw().  */
3708           end_of_sequence = end;
3709           standard_opcodes = NULL;
3710           linfo = saved_linfo;
3711           /* PR 17531: file: 0522b371.  */
3712           if (linfo.li_line_range == 0)
3713             {
3714               warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3715               return 0;
3716             }
3717           reset_state_machine (linfo.li_default_is_stmt);
3718         }
3719       else
3720         {
3721           unsigned char *hdrptr;
3722
3723           if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3724                                                 & end_of_sequence)) == NULL)
3725               return 0;
3726
3727           /* PR 17531: file: 0522b371.  */
3728           if (linfo.li_line_range == 0)
3729             {
3730               warn (_("Line range of 0 is invalid, using 1 instead\n"));
3731               linfo.li_line_range = 1;
3732             }
3733           reset_state_machine (linfo.li_default_is_stmt);
3734
3735           /* Save a pointer to the contents of the Opcodes table.  */
3736           standard_opcodes = hdrptr;
3737
3738           /* Traverse the Directory table just to count entries.  */
3739           data = standard_opcodes + linfo.li_opcode_base - 1;
3740           /* PR 20440 */
3741           if (data >= end)
3742             {
3743               warn (_("opcode base of %d extends beyond end of section\n"),
3744                     linfo.li_opcode_base);
3745               return 0;
3746             }
3747
3748           if (linfo.li_version >= 5)
3749             {
3750               unsigned char *format_start, format_count, *format;
3751               dwarf_vma formati, entryi;
3752               unsigned int bytes_read;
3753
3754               load_debug_section (line_str, fileptr);
3755
3756               /* Skip directories format.  */
3757               SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3758               format_start = data;
3759               for (formati = 0; formati < format_count; formati++)
3760                 {
3761                   read_uleb128 (data, & bytes_read, end);
3762                   data += bytes_read;
3763                   read_uleb128 (data, & bytes_read, end);
3764                   data += bytes_read;
3765                 }
3766
3767               n_directories = read_uleb128 (data, & bytes_read, end);
3768               data += bytes_read;
3769               if (data == end)
3770                 {
3771                   warn (_("Corrupt directories list\n"));
3772                   break;
3773                 }
3774
3775               directory_table = (unsigned char **)
3776                 xmalloc (n_directories * sizeof (unsigned char *));
3777
3778               for (entryi = 0; entryi < n_directories; entryi++)
3779                 {
3780                   unsigned char **pathp = &directory_table[entryi];
3781
3782                   format = format_start;
3783                   for (formati = 0; formati < format_count; formati++)
3784                     {
3785                       dwarf_vma content_type, form;
3786                       dwarf_vma uvalue;
3787
3788                       content_type = read_uleb128 (format, & bytes_read, end);
3789                       format += bytes_read;
3790                       form = read_uleb128 (format, & bytes_read, end);
3791                       format += bytes_read;
3792                       if (data == end)
3793                         {
3794                           warn (_("Corrupt directories list\n"));
3795                           break;
3796                         }
3797                       switch (content_type)
3798                         {
3799                         case DW_LNCT_path:
3800                           switch (form)
3801                             {
3802                             case DW_FORM_string:
3803                               *pathp = data;
3804                               break;
3805                             case DW_FORM_line_strp:
3806                               SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size,
3807                                              end);
3808                               /* Remove const by the cast.  */
3809                               *pathp = (unsigned char *)
3810                                        fetch_indirect_line_string (uvalue);
3811                               break;
3812                             }
3813                           break;
3814                         }
3815                       data = read_and_display_attr_value (0, form, 0, data, end,
3816                                                           0, 0,
3817                                                           linfo.li_offset_size,
3818                                                           linfo.li_version,
3819                                                           NULL, 1, section,
3820                                                           NULL, '\t');
3821                     }
3822                   if (data == end)
3823                     {
3824                       warn (_("Corrupt directories list\n"));
3825                       break;
3826                     }
3827                 }
3828
3829               /* Skip files format.  */
3830               SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3831               format_start = data;
3832               for (formati = 0; formati < format_count; formati++)
3833                 {
3834                   read_uleb128 (data, & bytes_read, end);
3835                   data += bytes_read;
3836                   read_uleb128 (data, & bytes_read, end);
3837                   data += bytes_read;
3838                 }
3839
3840               n_files = read_uleb128 (data, & bytes_read, end);
3841               data += bytes_read;
3842               if (data == end)
3843                 {
3844                   warn (_("Corrupt file name list\n"));
3845                   break;
3846                 }
3847
3848               file_table = (File_Entry *) xcalloc (1, n_files
3849                                                       * sizeof (File_Entry));
3850
3851               for (entryi = 0; entryi < n_files; entryi++)
3852                 {
3853                   File_Entry *file = &file_table[entryi];
3854
3855                   format = format_start;
3856                   for (formati = 0; formati < format_count; formati++)
3857                     {
3858                       dwarf_vma content_type, form;
3859                       dwarf_vma uvalue;
3860
3861                       content_type = read_uleb128 (format, & bytes_read, end);
3862                       format += bytes_read;
3863                       form = read_uleb128 (format, & bytes_read, end);
3864                       format += bytes_read;
3865                       if (data == end)
3866                         {
3867                           warn (_("Corrupt file name list\n"));
3868                           break;
3869                         }
3870                       switch (content_type)
3871                         {
3872                         case DW_LNCT_path:
3873                           switch (form)
3874                             {
3875                             case DW_FORM_string:
3876                               file->name = data;
3877                               break;
3878                             case DW_FORM_line_strp:
3879                               SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size,
3880                                              end);
3881                               /* Remove const by the cast.  */
3882                               file->name = (unsigned char *)
3883                                            fetch_indirect_line_string (uvalue);
3884                               break;
3885                             }
3886                           break;
3887                         case DW_LNCT_directory_index:
3888                           switch (form)
3889                             {
3890                             case DW_FORM_data1:
3891                               SAFE_BYTE_GET (file->directory_index, data, 1,
3892                                              end);
3893                               break;
3894                             case DW_FORM_data2:
3895                               SAFE_BYTE_GET (file->directory_index, data, 2,
3896                                              end);
3897                               break;
3898                             case DW_FORM_udata:
3899                               file->directory_index = read_uleb128 (data, NULL,
3900                                                                     end);
3901                               break;
3902                             }
3903                           break;
3904                         }
3905                       data = read_and_display_attr_value (0, form, 0, data, end,
3906                                                           0, 0,
3907                                                           linfo.li_offset_size,
3908                                                           linfo.li_version,
3909                                                           NULL, 1, section,
3910                                                           NULL, '\t');
3911                     }
3912                   if (data == end)
3913                     {
3914                       warn (_("Corrupt file name list\n"));
3915                       break;
3916                     }
3917                 }
3918             }
3919           else
3920             {
3921               if (*data != 0)
3922                 {
3923                   unsigned char *ptr_directory_table = data;
3924
3925                   while (data < end && *data != 0)
3926                     {
3927                       data += strnlen ((char *) data, end - data) + 1;
3928                       n_directories++;
3929                     }
3930
3931                   /* PR 20440 */
3932                   if (data >= end)
3933                     {
3934                       warn (_("directory table ends unexpectedly\n"));
3935                       n_directories = 0;
3936                       break;
3937                     }
3938
3939                   /* Go through the directory table again to save the directories.  */
3940                   directory_table = (unsigned char **)
3941                     xmalloc (n_directories * sizeof (unsigned char *));
3942
3943                   i = 0;
3944                   while (*ptr_directory_table != 0)
3945                     {
3946                       directory_table[i] = ptr_directory_table;
3947                       ptr_directory_table += strnlen ((char *) ptr_directory_table,
3948                                                       ptr_directory_table - end) + 1;
3949                       i++;
3950                     }
3951                 }
3952               /* Skip the NUL at the end of the table.  */
3953               data++;
3954
3955               /* Traverse the File Name table just to count the entries.  */
3956               if (data < end && *data != 0)
3957                 {
3958                   unsigned char *ptr_file_name_table = data;
3959
3960                   while (data < end && *data != 0)
3961                     {
3962                       unsigned int bytes_read;
3963
3964                       /* Skip Name, directory index, last modification time and length
3965                          of file.  */
3966                       data += strnlen ((char *) data, end - data) + 1;
3967                       read_uleb128 (data, & bytes_read, end);
3968                       data += bytes_read;
3969                       read_uleb128 (data, & bytes_read, end);
3970                       data += bytes_read;
3971                       read_uleb128 (data, & bytes_read, end);
3972                       data += bytes_read;
3973
3974                       n_files++;
3975                     }
3976
3977                   if (data >= end)
3978                     {
3979                       warn (_("file table ends unexpectedly\n"));
3980                       n_files = 0;
3981                       break;
3982                     }
3983
3984                   /* Go through the file table again to save the strings.  */
3985                   file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3986
3987                   i = 0;
3988                   while (*ptr_file_name_table != 0)
3989                     {
3990                       unsigned int bytes_read;
3991
3992                       file_table[i].name = ptr_file_name_table;
3993                       ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3994                                                       end - ptr_file_name_table) + 1;
3995
3996                       /* We are not interested in directory, time or size.  */
3997                       file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3998                                                                     & bytes_read, end);
3999                       ptr_file_name_table += bytes_read;
4000                       file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
4001                                                                       & bytes_read, end);
4002                       ptr_file_name_table += bytes_read;
4003                       file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
4004                       ptr_file_name_table += bytes_read;
4005                       i++;
4006                     }
4007                   i = 0;
4008                 }
4009
4010               /* Skip the NUL at the end of the table.  */
4011               data++;
4012             }
4013
4014           /* Print the Compilation Unit's name and a header.  */
4015           if (file_table == NULL)
4016             ;
4017           else if (directory_table == NULL)
4018             printf (_("CU: %s:\n"), file_table[0].name);
4019           else
4020             {
4021               unsigned int ix = file_table[0].directory_index;
4022               const char *directory;
4023
4024               if (ix == 0)
4025                 directory = ".";
4026               /* PR 20439 */
4027               else if (n_directories == 0)
4028                 directory = _("<unknown>");
4029               else if (ix > n_directories)
4030                 {
4031                   warn (_("directory index %u > number of directories %s\n"),
4032                         ix, dwarf_vmatoa ("u", n_directories));
4033                   directory = _("<corrupt>");
4034                 }
4035               else
4036                 directory = (char *) directory_table[ix - 1];
4037
4038               if (do_wide || strlen (directory) < 76)
4039                 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
4040               else
4041                 printf ("%s:\n", file_table[0].name);
4042             }
4043
4044           printf (_("File name                            Line number    Starting address    View\n"));
4045           saved_linfo = linfo;
4046         }
4047
4048       /* This loop iterates through the Dwarf Line Number Program.  */
4049       while (data < end_of_sequence)
4050         {
4051           unsigned char op_code;
4052           int xop;
4053           int adv;
4054           unsigned long int uladv;
4055           unsigned int bytes_read;
4056           int is_special_opcode = 0;
4057
4058           op_code = *data++;
4059           xop = op_code;
4060
4061           if (op_code >= linfo.li_opcode_base)
4062             {
4063               op_code -= linfo.li_opcode_base;
4064               uladv = (op_code / linfo.li_line_range);
4065               if (linfo.li_max_ops_per_insn == 1)
4066                 {
4067                   uladv *= linfo.li_min_insn_length;
4068                   state_machine_regs.address += uladv;
4069                   if (uladv)
4070                     state_machine_regs.view = 0;
4071                 }
4072               else
4073                 {
4074                   unsigned addrdelta
4075                     = ((state_machine_regs.op_index + uladv)
4076                        / linfo.li_max_ops_per_insn)
4077                     * linfo.li_min_insn_length;
4078                   state_machine_regs.address
4079                     += addrdelta;
4080                   state_machine_regs.op_index
4081                     = (state_machine_regs.op_index + uladv)
4082                     % linfo.li_max_ops_per_insn;
4083                   if (addrdelta)
4084                     state_machine_regs.view = 0;
4085                 }
4086
4087               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
4088               state_machine_regs.line += adv;
4089               is_special_opcode = 1;
4090               /* Increment view after printing this row.  */
4091             }
4092           else switch (op_code)
4093                  {
4094                  case DW_LNS_extended_op:
4095                    {
4096                      unsigned int ext_op_code_len;
4097                      unsigned char ext_op_code;
4098                      unsigned char *op_code_data = data;
4099
4100                      ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
4101                                                      end_of_sequence);
4102                      op_code_data += bytes_read;
4103
4104                      if (ext_op_code_len == 0)
4105                        {
4106                          warn (_("Badly formed extended line op encountered!\n"));
4107                          break;
4108                        }
4109                      ext_op_code_len += bytes_read;
4110                      ext_op_code = *op_code_data++;
4111                      xop = ext_op_code;
4112                      xop = -xop;
4113
4114                      switch (ext_op_code)
4115                        {
4116                        case DW_LNE_end_sequence:
4117                          /* Reset stuff after printing this row.  */
4118                          break;
4119                        case DW_LNE_set_address:
4120                          SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
4121                                                 op_code_data,
4122                                                 ext_op_code_len - bytes_read - 1,
4123                                                 end);
4124                          state_machine_regs.op_index = 0;
4125                          state_machine_regs.view = 0;
4126                          break;
4127                        case DW_LNE_define_file:
4128                          {
4129                            file_table = (File_Entry *) xrealloc
4130                              (file_table, (n_files + 1) * sizeof (File_Entry));
4131
4132                            ++state_machine_regs.last_file_entry;
4133                            /* Source file name.  */
4134                            file_table[n_files].name = op_code_data;
4135                            op_code_data += strlen ((char *) op_code_data) + 1;
4136                            /* Directory index.  */
4137                            file_table[n_files].directory_index =
4138                              read_uleb128 (op_code_data, & bytes_read,
4139                                            end_of_sequence);
4140                            op_code_data += bytes_read;
4141                            /* Last modification time.  */
4142                            file_table[n_files].modification_date =
4143                              read_uleb128 (op_code_data, & bytes_read,
4144                                            end_of_sequence);
4145                            op_code_data += bytes_read;
4146                            /* File length.  */
4147                            file_table[n_files].length =
4148                              read_uleb128 (op_code_data, & bytes_read,
4149                                            end_of_sequence);
4150
4151                            n_files++;
4152                            break;
4153                          }
4154                        case DW_LNE_set_discriminator:
4155                        case DW_LNE_HP_set_sequence:
4156                          /* Simply ignored.  */
4157                          break;
4158
4159                        default:
4160                          printf (_("UNKNOWN (%u): length %d\n"),
4161                                  ext_op_code, ext_op_code_len - bytes_read);
4162                          break;
4163                        }
4164                      data += ext_op_code_len;
4165                      break;
4166                    }
4167                  case DW_LNS_copy:
4168                    /* Increment view after printing this row.  */
4169                    break;
4170
4171                  case DW_LNS_advance_pc:
4172                    uladv = read_uleb128 (data, & bytes_read, end);
4173                    data += bytes_read;
4174                    if (linfo.li_max_ops_per_insn == 1)
4175                      {
4176                        uladv *= linfo.li_min_insn_length;
4177                        state_machine_regs.address += uladv;
4178                        if (uladv)
4179                          state_machine_regs.view = 0;
4180                      }
4181                    else
4182                      {
4183                        unsigned addrdelta
4184                          = ((state_machine_regs.op_index + uladv)
4185                             / linfo.li_max_ops_per_insn)
4186                          * linfo.li_min_insn_length;
4187                        state_machine_regs.address
4188                          += addrdelta;
4189                        state_machine_regs.op_index
4190                          = (state_machine_regs.op_index + uladv)
4191                          % linfo.li_max_ops_per_insn;
4192                        if (addrdelta)
4193                          state_machine_regs.view = 0;
4194                      }
4195                    break;
4196
4197                  case DW_LNS_advance_line:
4198                    adv = read_sleb128 (data, & bytes_read, end);
4199                    data += bytes_read;
4200                    state_machine_regs.line += adv;
4201                    break;
4202
4203                  case DW_LNS_set_file:
4204                    adv = read_uleb128 (data, & bytes_read, end);
4205                    data += bytes_read;
4206                    state_machine_regs.file = adv;
4207
4208                    {
4209                      unsigned file = state_machine_regs.file - 1;
4210                      unsigned dir;
4211
4212                      if (file_table == NULL || n_files == 0)
4213                        printf (_("\n [Use file table entry %d]\n"), file);
4214                      /* PR 20439 */
4215                      else if (file >= n_files)
4216                        {
4217                          warn (_("file index %u > number of files %u\n"), file + 1, n_files);
4218                          printf (_("\n <over large file table index %u>"), file);
4219                        }
4220                      else if ((dir = file_table[file].directory_index) == 0)
4221                        /* If directory index is 0, that means current directory.  */
4222                        printf ("\n./%s:[++]\n", file_table[file].name);
4223                      else if (directory_table == NULL || n_directories == 0)
4224                        printf (_("\n [Use file %s in directory table entry %d]\n"),
4225                                file_table[file].name, dir);
4226                      /* PR 20439 */
4227                      else if (dir > n_directories)
4228                        {
4229                          warn (_("directory index %u > number of directories %s\n"),
4230                                dir, dwarf_vmatoa ("u", n_directories));
4231                          printf (_("\n <over large directory table entry %u>\n"), dir);
4232                        }
4233                      else
4234                        printf ("\n%s/%s:\n",
4235                                /* The directory index starts counting at 1.  */
4236                                directory_table[dir - 1], file_table[file].name);
4237                    }
4238                    break;
4239
4240                  case DW_LNS_set_column:
4241                    uladv = read_uleb128 (data, & bytes_read, end);
4242                    data += bytes_read;
4243                    state_machine_regs.column = uladv;
4244                    break;
4245
4246                  case DW_LNS_negate_stmt:
4247                    adv = state_machine_regs.is_stmt;
4248                    adv = ! adv;
4249                    state_machine_regs.is_stmt = adv;
4250                    break;
4251
4252                  case DW_LNS_set_basic_block:
4253                    state_machine_regs.basic_block = 1;
4254                    break;
4255
4256                  case DW_LNS_const_add_pc:
4257                    uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
4258                    if (linfo.li_max_ops_per_insn == 1)
4259                      {
4260                        uladv *= linfo.li_min_insn_length;
4261                        state_machine_regs.address += uladv;
4262                        if (uladv)
4263                          state_machine_regs.view = 0;
4264                      }
4265                    else
4266                      {
4267                        unsigned addrdelta
4268                          = ((state_machine_regs.op_index + uladv)
4269                             / linfo.li_max_ops_per_insn)
4270                          * linfo.li_min_insn_length;
4271                        state_machine_regs.address
4272                          += addrdelta;
4273                        state_machine_regs.op_index
4274                          = (state_machine_regs.op_index + uladv)
4275                          % linfo.li_max_ops_per_insn;
4276                        if (addrdelta)
4277                          state_machine_regs.view = 0;
4278                      }
4279                    break;
4280
4281                  case DW_LNS_fixed_advance_pc:
4282                    SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
4283                    state_machine_regs.address += uladv;
4284                    state_machine_regs.op_index = 0;
4285                    /* Do NOT reset view.  */
4286                    break;
4287
4288                  case DW_LNS_set_prologue_end:
4289                    break;
4290
4291                  case DW_LNS_set_epilogue_begin:
4292                    break;
4293
4294                  case DW_LNS_set_isa:
4295                    uladv = read_uleb128 (data, & bytes_read, end);
4296                    data += bytes_read;
4297                    printf (_("  Set ISA to %lu\n"), uladv);
4298                    break;
4299
4300                  default:
4301                    printf (_("  Unknown opcode %d with operands: "), op_code);
4302
4303                    if (standard_opcodes != NULL)
4304                      for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
4305                        {
4306                          printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
4307                                                                             &bytes_read, end)),
4308                                  i == 1 ? "" : ", ");
4309                          data += bytes_read;
4310                        }
4311                    putchar ('\n');
4312                    break;
4313                  }
4314
4315           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4316              to the DWARF address/line matrix.  */
4317           if ((is_special_opcode) || (xop == -DW_LNE_end_sequence)
4318               || (xop == DW_LNS_copy))
4319             {
4320               const unsigned int MAX_FILENAME_LENGTH = 35;
4321               char *fileName;
4322               char *newFileName = NULL;
4323               size_t fileNameLength;
4324
4325               if (file_table)
4326                 {
4327                   unsigned indx = state_machine_regs.file - 1;
4328                   /* PR 20439  */
4329                   if (indx >= n_files)
4330                     {
4331                       warn (_("corrupt file index %u encountered\n"), indx);
4332                       fileName = _("<corrupt>");
4333                     }
4334                   else
4335                     fileName = (char *) file_table[indx].name;
4336                 }
4337               else
4338                 fileName = _("<unknown>");
4339
4340               fileNameLength = strlen (fileName);
4341
4342               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
4343                 {
4344                   newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
4345                   /* Truncate file name */
4346                   strncpy (newFileName,
4347                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
4348                            MAX_FILENAME_LENGTH + 1);
4349                 }
4350               else
4351                 {
4352                   newFileName = (char *) xmalloc (fileNameLength + 1);
4353                   strncpy (newFileName, fileName, fileNameLength + 1);
4354                 }
4355
4356               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
4357                 {
4358                   if (linfo.li_max_ops_per_insn == 1)
4359                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x",
4360                             newFileName, state_machine_regs.line,
4361                             state_machine_regs.address);
4362                   else
4363                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]",
4364                             newFileName, state_machine_regs.line,
4365                             state_machine_regs.address,
4366                             state_machine_regs.op_index);
4367                 }
4368               else
4369                 {
4370                   if (linfo.li_max_ops_per_insn == 1)
4371                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x",
4372                             newFileName, state_machine_regs.line,
4373                             state_machine_regs.address);
4374                   else
4375                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]",
4376                             newFileName, state_machine_regs.line,
4377                             state_machine_regs.address,
4378                             state_machine_regs.op_index);
4379                 }
4380
4381               if (state_machine_regs.view)
4382                 printf ("  %6u\n", state_machine_regs.view);
4383               else
4384                 putchar ('\n');
4385               state_machine_regs.view++;
4386
4387               if (xop == -DW_LNE_end_sequence)
4388                 {
4389                   reset_state_machine (linfo.li_default_is_stmt);
4390                   putchar ('\n');
4391                 }
4392
4393               free (newFileName);
4394             }
4395         }
4396
4397       if (file_table)
4398         {
4399           free (file_table);
4400           file_table = NULL;
4401           n_files = 0;
4402         }
4403
4404       if (directory_table)
4405         {
4406           free (directory_table);
4407           directory_table = NULL;
4408           n_directories = 0;
4409         }
4410
4411       putchar ('\n');
4412     }
4413
4414   return 1;
4415 }
4416
4417 static int
4418 display_debug_lines (struct dwarf_section *section, void *file)
4419 {
4420   unsigned char *data = section->start;
4421   unsigned char *end = data + section->size;
4422   int retValRaw = 1;
4423   int retValDecoded = 1;
4424
4425   if (do_debug_lines == 0)
4426     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
4427
4428   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
4429     retValRaw = display_debug_lines_raw (section, data, end, file);
4430
4431   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
4432     retValDecoded = display_debug_lines_decoded (section, data, end, file);
4433
4434   if (!retValRaw || !retValDecoded)
4435     return 0;
4436
4437   return 1;
4438 }
4439
4440 static debug_info *
4441 find_debug_info_for_offset (unsigned long offset)
4442 {
4443   unsigned int i;
4444
4445   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
4446     return NULL;
4447
4448   for (i = 0; i < num_debug_info_entries; i++)
4449     if (debug_information[i].cu_offset == offset)
4450       return debug_information + i;
4451
4452   return NULL;
4453 }
4454
4455 static const char *
4456 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
4457 {
4458   /* See gdb/gdb-index.h.  */
4459   static const char * const kinds[] =
4460   {
4461     N_ ("no info"),
4462     N_ ("type"),
4463     N_ ("variable"),
4464     N_ ("function"),
4465     N_ ("other"),
4466     N_ ("unused5"),
4467     N_ ("unused6"),
4468     N_ ("unused7")
4469   };
4470
4471   return _ (kinds[kind]);
4472 }
4473
4474 static int
4475 display_debug_pubnames_worker (struct dwarf_section *section,
4476                                void *file ATTRIBUTE_UNUSED,
4477                                int is_gnu)
4478 {
4479   DWARF2_Internal_PubNames names;
4480   unsigned char *start = section->start;
4481   unsigned char *end = start + section->size;
4482
4483   /* It does not matter if this load fails,
4484      we test for that later on.  */
4485   load_debug_info (file);
4486
4487   printf (_("Contents of the %s section:\n\n"), section->name);
4488
4489   while (start < end)
4490     {
4491       unsigned char *data;
4492       unsigned char *adr;
4493       dwarf_vma offset;
4494       unsigned int offset_size, initial_length_size;
4495
4496       data = start;
4497
4498       SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
4499       if (names.pn_length == 0xffffffff)
4500         {
4501           SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
4502           offset_size = 8;
4503           initial_length_size = 12;
4504         }
4505       else
4506         {
4507           offset_size = 4;
4508           initial_length_size = 4;
4509         }
4510
4511       SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
4512       SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
4513
4514       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4515           && num_debug_info_entries > 0
4516           && find_debug_info_for_offset (names.pn_offset) == NULL)
4517         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4518               (unsigned long) names.pn_offset, section->name);
4519
4520       SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
4521
4522       adr = start + names.pn_length + initial_length_size;
4523       /* PR 17531: file: 7615b6b2.  */
4524       if ((dwarf_signed_vma) names.pn_length < 0
4525           /* PR 17531: file: a5dbeaa7. */
4526           || adr < start)
4527         {
4528           warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
4529           start = end;
4530         }
4531       else
4532         start = adr;
4533
4534       printf (_("  Length:                              %ld\n"),
4535               (long) names.pn_length);
4536       printf (_("  Version:                             %d\n"),
4537               names.pn_version);
4538       printf (_("  Offset into .debug_info section:     0x%lx\n"),
4539               (unsigned long) names.pn_offset);
4540       printf (_("  Size of area in .debug_info section: %ld\n"),
4541               (long) names.pn_size);
4542
4543       if (names.pn_version != 2 && names.pn_version != 3)
4544         {
4545           static int warned = 0;
4546
4547           if (! warned)
4548             {
4549               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4550               warned = 1;
4551             }
4552
4553           continue;
4554         }
4555
4556       if (is_gnu)
4557         printf (_("\n    Offset  Kind          Name\n"));
4558       else
4559         printf (_("\n    Offset\tName\n"));
4560
4561       do
4562         {
4563           bfd_size_type maxprint;
4564
4565           SAFE_BYTE_GET (offset, data, offset_size, end);
4566
4567           if (offset != 0)
4568             {
4569               data += offset_size;
4570               if (data >= end)
4571                 break;
4572               maxprint = (end - data) - 1;
4573
4574               if (is_gnu)
4575                 {
4576                   unsigned int kind_data;
4577                   gdb_index_symbol_kind kind;
4578                   const char *kind_name;
4579                   int is_static;
4580
4581                   SAFE_BYTE_GET (kind_data, data, 1, end);
4582                   data++;
4583                   maxprint --;
4584                   /* GCC computes the kind as the upper byte in the CU index
4585                      word, and then right shifts it by the CU index size.
4586                      Left shift KIND to where the gdb-index.h accessor macros
4587                      can use it.  */
4588                   kind_data <<= GDB_INDEX_CU_BITSIZE;
4589                   kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
4590                   kind_name = get_gdb_index_symbol_kind_name (kind);
4591                   is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
4592                   printf ("    %-6lx  %s,%-10s  %.*s\n",
4593                           (unsigned long) offset, is_static ? _("s") : _("g"),
4594                           kind_name, (int) maxprint, data);
4595                 }
4596               else
4597                 printf ("    %-6lx\t%.*s\n",
4598                         (unsigned long) offset, (int) maxprint, data);
4599
4600               data += strnlen ((char *) data, maxprint) + 1;
4601               if (data >= end)
4602                 break;
4603             }
4604         }
4605       while (offset != 0);
4606     }
4607
4608   printf ("\n");
4609   return 1;
4610 }
4611
4612 static int
4613 display_debug_pubnames (struct dwarf_section *section, void *file)
4614 {
4615   return display_debug_pubnames_worker (section, file, 0);
4616 }
4617
4618 static int
4619 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
4620 {
4621   return display_debug_pubnames_worker (section, file, 1);
4622 }
4623
4624 static int
4625 display_debug_macinfo (struct dwarf_section *section,
4626                        void *file ATTRIBUTE_UNUSED)
4627 {
4628   unsigned char *start = section->start;
4629   unsigned char *end = start + section->size;
4630   unsigned char *curr = start;
4631   unsigned int bytes_read;
4632   enum dwarf_macinfo_record_type op;
4633
4634   printf (_("Contents of the %s section:\n\n"), section->name);
4635
4636   while (curr < end)
4637     {
4638       unsigned int lineno;
4639       const unsigned char *string;
4640
4641       op = (enum dwarf_macinfo_record_type) *curr;
4642       curr++;
4643
4644       switch (op)
4645         {
4646         case DW_MACINFO_start_file:
4647           {
4648             unsigned int filenum;
4649
4650             lineno = read_uleb128 (curr, & bytes_read, end);
4651             curr += bytes_read;
4652             filenum = read_uleb128 (curr, & bytes_read, end);
4653             curr += bytes_read;
4654
4655             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4656                     lineno, filenum);
4657           }
4658           break;
4659
4660         case DW_MACINFO_end_file:
4661           printf (_(" DW_MACINFO_end_file\n"));
4662           break;
4663
4664         case DW_MACINFO_define:
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_define - lineno : %d macro : %s\n"),
4670                   lineno, string);
4671           break;
4672
4673         case DW_MACINFO_undef:
4674           lineno = read_uleb128 (curr, & bytes_read, end);
4675           curr += bytes_read;
4676           string = curr;
4677           curr += strnlen ((char *) string, end - string) + 1;
4678           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
4679                   lineno, string);
4680           break;
4681
4682         case DW_MACINFO_vendor_ext:
4683           {
4684             unsigned int constant;
4685
4686             constant = read_uleb128 (curr, & bytes_read, end);
4687             curr += bytes_read;
4688             string = curr;
4689             curr += strnlen ((char *) string, end - string) + 1;
4690             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
4691                     constant, string);
4692           }
4693           break;
4694         }
4695     }
4696
4697   return 1;
4698 }
4699
4700 /* Given LINE_OFFSET into the .debug_line section, attempt to return
4701    filename and dirname corresponding to file name table entry with index
4702    FILEIDX.  Return NULL on failure.  */
4703
4704 static unsigned char *
4705 get_line_filename_and_dirname (dwarf_vma line_offset,
4706                                dwarf_vma fileidx,
4707                                unsigned char **dir_name)
4708 {
4709   struct dwarf_section *section = &debug_displays [line].section;
4710   unsigned char *hdrptr, *dirtable, *file_name;
4711   unsigned int offset_size, initial_length_size;
4712   unsigned int version, opcode_base, bytes_read;
4713   dwarf_vma length, diridx;
4714   const unsigned char * end;
4715
4716   *dir_name = NULL;
4717   if (section->start == NULL
4718       || line_offset >= section->size
4719       || fileidx == 0)
4720     return NULL;
4721
4722   hdrptr = section->start + line_offset;
4723   end = section->start + section->size;
4724
4725   SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
4726   if (length == 0xffffffff)
4727     {
4728       /* This section is 64-bit DWARF 3.  */
4729       SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
4730       offset_size = 8;
4731       initial_length_size = 12;
4732     }
4733   else
4734     {
4735       offset_size = 4;
4736       initial_length_size = 4;
4737     }
4738   if (length + initial_length_size > section->size)
4739     return NULL;
4740
4741   SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
4742   if (version != 2 && version != 3 && version != 4)
4743     return NULL;
4744   hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length.  */
4745   if (version >= 4)
4746     hdrptr++;               /* Skip max_ops_per_insn.  */
4747   hdrptr += 3;              /* Skip default_is_stmt, line_base, line_range.  */
4748
4749   SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
4750   if (opcode_base == 0)
4751     return NULL;
4752
4753   hdrptr += opcode_base - 1;
4754   if (hdrptr >= end)
4755     return NULL;
4756
4757   dirtable = hdrptr;
4758   /* Skip over dirname table.  */
4759   while (*hdrptr != '\0')
4760     {
4761       hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4762       if (hdrptr >= end)
4763         return NULL;
4764     }
4765   hdrptr++;                 /* Skip the NUL at the end of the table.  */
4766
4767   /* Now skip over preceding filename table entries.  */
4768   for (; hdrptr < end && *hdrptr != '\0' && fileidx > 1; fileidx--)
4769     {
4770       hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4771       read_uleb128 (hdrptr, &bytes_read, end);
4772       hdrptr += bytes_read;
4773       read_uleb128 (hdrptr, &bytes_read, end);
4774       hdrptr += bytes_read;
4775       read_uleb128 (hdrptr, &bytes_read, end);
4776       hdrptr += bytes_read;
4777     }
4778   if (hdrptr >= end || *hdrptr == '\0')
4779     return NULL;
4780
4781   file_name = hdrptr;
4782   hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4783   if (hdrptr >= end)
4784     return NULL;
4785   diridx = read_uleb128 (hdrptr, &bytes_read, end);
4786   if (diridx == 0)
4787     return file_name;
4788   for (; dirtable < end && *dirtable != '\0' && diridx > 1; diridx--)
4789     dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4790   if (dirtable >= end || *dirtable == '\0')
4791     return NULL;
4792   *dir_name = dirtable;
4793   return file_name;
4794 }
4795
4796 static int
4797 display_debug_macro (struct dwarf_section *section,
4798                      void *file)
4799 {
4800   unsigned char *start = section->start;
4801   unsigned char *end = start + section->size;
4802   unsigned char *curr = start;
4803   unsigned char *extended_op_buf[256];
4804   unsigned int bytes_read;
4805
4806   load_debug_section (str, file);
4807   load_debug_section (line, file);
4808
4809   printf (_("Contents of the %s section:\n\n"), section->name);
4810
4811   while (curr < end)
4812     {
4813       unsigned int lineno, version, flags;
4814       unsigned int offset_size = 4;
4815       const unsigned char *string;
4816       dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4817       unsigned char **extended_ops = NULL;
4818
4819       SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4820       if (version != 4 && version != 5)
4821         {
4822           error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
4823                  section->name);
4824           return 0;
4825         }
4826
4827       SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4828       if (flags & 1)
4829         offset_size = 8;
4830       printf (_("  Offset:                      0x%lx\n"),
4831               (unsigned long) sec_offset);
4832       printf (_("  Version:                     %d\n"), version);
4833       printf (_("  Offset size:                 %d\n"), offset_size);
4834       if (flags & 2)
4835         {
4836           SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4837           printf (_("  Offset into .debug_line:     0x%lx\n"),
4838                   (unsigned long) line_offset);
4839         }
4840       if (flags & 4)
4841         {
4842           unsigned int i, count, op;
4843           dwarf_vma nargs, n;
4844
4845           SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4846
4847           memset (extended_op_buf, 0, sizeof (extended_op_buf));
4848           extended_ops = extended_op_buf;
4849           if (count)
4850             {
4851               printf (_("  Extension opcode arguments:\n"));
4852               for (i = 0; i < count; i++)
4853                 {
4854                   SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4855                   extended_ops[op] = curr;
4856                   nargs = read_uleb128 (curr, &bytes_read, end);
4857                   curr += bytes_read;
4858                   if (nargs == 0)
4859                     printf (_("    DW_MACRO_%02x has no arguments\n"), op);
4860                   else
4861                     {
4862                       printf (_("    DW_MACRO_%02x arguments: "), op);
4863                       for (n = 0; n < nargs; n++)
4864                         {
4865                           unsigned int form;
4866
4867                           SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4868                           printf ("%s%s", get_FORM_name (form),
4869                                   n == nargs - 1 ? "\n" : ", ");
4870                           switch (form)
4871                             {
4872                             case DW_FORM_data1:
4873                             case DW_FORM_data2:
4874                             case DW_FORM_data4:
4875                             case DW_FORM_data8:
4876                             case DW_FORM_sdata:
4877                             case DW_FORM_udata:
4878                             case DW_FORM_block:
4879                             case DW_FORM_block1:
4880                             case DW_FORM_block2:
4881                             case DW_FORM_block4:
4882                             case DW_FORM_flag:
4883                             case DW_FORM_string:
4884                             case DW_FORM_strp:
4885                             case DW_FORM_sec_offset:
4886                               break;
4887                             default:
4888                               error (_("Invalid extension opcode form %s\n"),
4889                                      get_FORM_name (form));
4890                               return 0;
4891                             }
4892                         }
4893                     }
4894                 }
4895             }
4896         }
4897       printf ("\n");
4898
4899       while (1)
4900         {
4901           unsigned int op;
4902
4903           if (curr >= end)
4904             {
4905               error (_(".debug_macro section not zero terminated\n"));
4906               return 0;
4907             }
4908
4909           SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4910           if (op == 0)
4911             break;
4912
4913           switch (op)
4914             {
4915             case DW_MACRO_start_file:
4916               {
4917                 unsigned int filenum;
4918                 unsigned char *file_name = NULL, *dir_name = NULL;
4919
4920                 lineno = read_uleb128 (curr, &bytes_read, end);
4921                 curr += bytes_read;
4922                 filenum = read_uleb128 (curr, &bytes_read, end);
4923                 curr += bytes_read;
4924
4925                 if ((flags & 2) == 0)
4926                   error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
4927                 else
4928                   file_name
4929                     = get_line_filename_and_dirname (line_offset, filenum,
4930                                                      &dir_name);
4931                 if (file_name == NULL)
4932                   printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
4933                           lineno, filenum);
4934                 else
4935                   printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4936                           lineno, filenum,
4937                           dir_name != NULL ? (const char *) dir_name : "",
4938                           dir_name != NULL ? "/" : "", file_name);
4939               }
4940               break;
4941
4942             case DW_MACRO_end_file:
4943               printf (_(" DW_MACRO_end_file\n"));
4944               break;
4945
4946             case DW_MACRO_define:
4947               lineno = read_uleb128 (curr, &bytes_read, end);
4948               curr += bytes_read;
4949               string = curr;
4950               curr += strnlen ((char *) string, end - string) + 1;
4951               printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
4952                       lineno, string);
4953               break;
4954
4955             case DW_MACRO_undef:
4956               lineno = read_uleb128 (curr, &bytes_read, end);
4957               curr += bytes_read;
4958               string = curr;
4959               curr += strnlen ((char *) string, end - string) + 1;
4960               printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
4961                       lineno, string);
4962               break;
4963
4964             case DW_MACRO_define_strp:
4965               lineno = read_uleb128 (curr, &bytes_read, end);
4966               curr += bytes_read;
4967               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4968               string = fetch_indirect_string (offset);
4969               printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
4970                       lineno, string);
4971               break;
4972
4973             case DW_MACRO_undef_strp:
4974               lineno = read_uleb128 (curr, &bytes_read, end);
4975               curr += bytes_read;
4976               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4977               string = fetch_indirect_string (offset);
4978               printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
4979                       lineno, string);
4980               break;
4981
4982             case DW_MACRO_import:
4983               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4984               printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
4985                       (unsigned long) offset);
4986               break;
4987
4988             case DW_MACRO_define_sup:
4989               lineno = read_uleb128 (curr, &bytes_read, end);
4990               curr += bytes_read;
4991               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4992               printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
4993                       lineno, (unsigned long) offset);
4994               break;
4995
4996             case DW_MACRO_undef_sup:
4997               lineno = read_uleb128 (curr, &bytes_read, end);
4998               curr += bytes_read;
4999               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
5000               printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5001                       lineno, (unsigned long) offset);
5002               break;
5003
5004             case DW_MACRO_import_sup:
5005               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
5006               printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5007                       (unsigned long) offset);
5008               break;
5009
5010             default:
5011               if (extended_ops == NULL || extended_ops[op] == NULL)
5012                 {
5013                   error (_(" Unknown macro opcode %02x seen\n"), op);
5014                   return 0;
5015                 }
5016               else
5017                 {
5018                   /* Skip over unhandled opcodes.  */
5019                   dwarf_vma nargs, n;
5020                   unsigned char *desc = extended_ops[op];
5021                   nargs = read_uleb128 (desc, &bytes_read, end);
5022                   desc += bytes_read;
5023                   if (nargs == 0)
5024                     {
5025                       printf (_(" DW_MACRO_%02x\n"), op);
5026                       break;
5027                     }
5028                   printf (_(" DW_MACRO_%02x -"), op);
5029                   for (n = 0; n < nargs; n++)
5030                     {
5031                       int val;
5032
5033                       /* DW_FORM_implicit_const is not expected here.  */
5034                       SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
5035                       curr
5036                         = read_and_display_attr_value (0, val, 0,
5037                                                        curr, end, 0, 0, offset_size,
5038                                                        version, NULL, 0, NULL,
5039                                                        NULL, ' ');
5040                       if (n != nargs - 1)
5041                         printf (",");
5042                     }
5043                   printf ("\n");
5044                 }
5045               break;
5046             }
5047         }
5048
5049       printf ("\n");
5050     }
5051
5052   return 1;
5053 }
5054
5055 static int
5056 display_debug_abbrev (struct dwarf_section *section,
5057                       void *file ATTRIBUTE_UNUSED)
5058 {
5059   abbrev_entry *entry;
5060   unsigned char *start = section->start;
5061   unsigned char *end = start + section->size;
5062
5063   printf (_("Contents of the %s section:\n\n"), section->name);
5064
5065   do
5066     {
5067       unsigned char *last;
5068
5069       free_abbrevs ();
5070
5071       last = start;
5072       start = process_abbrev_section (start, end);
5073
5074       if (first_abbrev == NULL)
5075         continue;
5076
5077       printf (_("  Number TAG (0x%lx)\n"), (long) (last - section->start));
5078
5079       for (entry = first_abbrev; entry; entry = entry->next)
5080         {
5081           abbrev_attr *attr;
5082
5083           printf ("   %ld      %s    [%s]\n",
5084                   entry->entry,
5085                   get_TAG_name (entry->tag),
5086                   entry->children ? _("has children") : _("no children"));
5087
5088           for (attr = entry->first_attr; attr; attr = attr->next)
5089             {
5090               printf ("    %-18s %s",
5091                       get_AT_name (attr->attribute),
5092                       get_FORM_name (attr->form));
5093               if (attr->form == DW_FORM_implicit_const)
5094                 printf (": %" BFD_VMA_FMT "d", attr->implicit_const);
5095               putchar ('\n');
5096             }
5097         }
5098     }
5099   while (start);
5100
5101   printf ("\n");
5102
5103   return 1;
5104 }
5105
5106 /* Return true when ADDR is the maximum address, when addresses are
5107    POINTER_SIZE bytes long.  */
5108
5109 static bfd_boolean
5110 is_max_address (dwarf_vma addr, unsigned int pointer_size)
5111 {
5112   dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1));
5113   return ((addr & mask) == mask);
5114 }
5115
5116 /* Display a view pair list starting at *VSTART_PTR and ending at
5117    VLISTEND within SECTION.  */
5118
5119 static void
5120 display_view_pair_list (struct dwarf_section *section,
5121                         unsigned char **vstart_ptr,
5122                         unsigned int debug_info_entry,
5123                         unsigned char *vlistend)
5124 {
5125   unsigned char *vstart = *vstart_ptr;
5126   unsigned char *section_end = section->start + section->size;
5127   unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
5128
5129   if (vlistend < section_end)
5130     section_end = vlistend;
5131
5132   putchar ('\n');
5133
5134   while (vstart < section_end)
5135     {
5136       dwarf_vma off = vstart - section->start;
5137       dwarf_vma vbegin, vend;
5138
5139       unsigned int bytes_read;
5140       vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5141       vstart += bytes_read;
5142       if (vstart == section_end)
5143         {
5144           vstart -= bytes_read;
5145           break;
5146         }
5147
5148       vend = read_uleb128 (vstart, &bytes_read, section_end);
5149       vstart += bytes_read;
5150
5151       printf ("    %8.8lx ", (unsigned long) off);
5152
5153       print_dwarf_view (vbegin, pointer_size, 1);
5154       print_dwarf_view (vend, pointer_size, 1);
5155       printf (_("location view pair\n"));
5156     }
5157
5158   putchar ('\n');
5159   *vstart_ptr = vstart;
5160 }
5161
5162 /* Display a location list from a normal (ie, non-dwo) .debug_loc section.  */
5163
5164 static void
5165 display_loc_list (struct dwarf_section *section,
5166                   unsigned char **start_ptr,
5167                   unsigned int debug_info_entry,
5168                   dwarf_vma offset,
5169                   dwarf_vma base_address,
5170                   unsigned char **vstart_ptr,
5171                   int has_frame_base)
5172 {
5173   unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
5174   unsigned char *section_end = section->start + section->size;
5175   unsigned long cu_offset;
5176   unsigned int pointer_size;
5177   unsigned int offset_size;
5178   int dwarf_version;
5179
5180   dwarf_vma begin;
5181   dwarf_vma end;
5182   unsigned short length;
5183   int need_frame_base;
5184
5185   if (debug_info_entry >= num_debug_info_entries)
5186     {
5187       warn (_("No debug information available for loc lists of entry: %u\n"),
5188             debug_info_entry);
5189       return;
5190     }
5191
5192   cu_offset = debug_information [debug_info_entry].cu_offset;
5193   pointer_size = debug_information [debug_info_entry].pointer_size;
5194   offset_size = debug_information [debug_info_entry].offset_size;
5195   dwarf_version = debug_information [debug_info_entry].dwarf_version;
5196
5197   if (pointer_size < 2 || pointer_size > 8)
5198     {
5199       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5200             pointer_size, debug_info_entry);
5201       return;
5202     }
5203
5204   while (1)
5205     {
5206       dwarf_vma off = offset + (start - *start_ptr);
5207       dwarf_vma vbegin = vm1, vend = vm1;
5208
5209       if (start + 2 * pointer_size > section_end)
5210         {
5211           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5212                 (unsigned long) offset);
5213           break;
5214         }
5215
5216       printf ("    %8.8lx ", (unsigned long) off);
5217
5218       SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
5219       SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
5220
5221       if (begin == 0 && end == 0)
5222         {
5223           /* PR 18374: In a object file we can have a location list that
5224              starts with a begin and end of 0 because there are relocations
5225              that need to be applied to the addresses.  Actually applying
5226              the relocations now does not help as they will probably resolve
5227              to 0, since the object file has not been fully linked.  Real
5228              end of list markers will not have any relocations against them.  */
5229           if (! reloc_at (section, off)
5230               && ! reloc_at (section, off + pointer_size))
5231             {
5232               printf (_("<End of list>\n"));
5233               break;
5234             }
5235         }
5236
5237       /* Check base address specifiers.  */
5238       if (is_max_address (begin, pointer_size)
5239           && !is_max_address (end, pointer_size))
5240         {
5241           base_address = end;
5242           print_dwarf_vma (begin, pointer_size);
5243           print_dwarf_vma (end, pointer_size);
5244           printf (_("(base address)\n"));
5245           continue;
5246         }
5247
5248       if (vstart)
5249         {
5250           unsigned int bytes_read;
5251
5252           off = offset + (vstart - *start_ptr);
5253
5254           vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5255           vstart += bytes_read;
5256           print_dwarf_view (vbegin, pointer_size, 1);
5257
5258           vend = read_uleb128 (vstart, &bytes_read, section_end);
5259           vstart += bytes_read;
5260           print_dwarf_view (vend, pointer_size, 1);
5261
5262           printf (_("views at %8.8lx for:\n    %*s "),
5263                   (unsigned long) off, 8, "");
5264         }
5265
5266       if (start + 2 > section_end)
5267         {
5268           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5269                 (unsigned long) offset);
5270           break;
5271         }
5272
5273       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
5274
5275       if (start + length > section_end)
5276         {
5277           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5278                 (unsigned long) offset);
5279           break;
5280         }
5281
5282       print_dwarf_vma (begin + base_address, pointer_size);
5283       print_dwarf_vma (end + base_address, pointer_size);
5284
5285       putchar ('(');
5286       need_frame_base = decode_location_expression (start,
5287                                                     pointer_size,
5288                                                     offset_size,
5289                                                     dwarf_version,
5290                                                     length,
5291                                                     cu_offset, section);
5292       putchar (')');
5293
5294       if (need_frame_base && !has_frame_base)
5295         printf (_(" [without DW_AT_frame_base]"));
5296
5297       if (begin == end && vbegin == vend)
5298         fputs (_(" (start == end)"), stdout);
5299       else if (begin > end || (begin == end && vbegin > vend))
5300         fputs (_(" (start > end)"), stdout);
5301
5302       putchar ('\n');
5303
5304       start += length;
5305     }
5306
5307   *start_ptr = start;
5308   *vstart_ptr = vstart;
5309 }
5310
5311 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section.  */
5312
5313 static void
5314 display_loclists_list (struct dwarf_section *section,
5315                        unsigned char **start_ptr,
5316                        unsigned int debug_info_entry,
5317                        dwarf_vma offset,
5318                        dwarf_vma base_address,
5319                        unsigned char **vstart_ptr,
5320                        int has_frame_base)
5321 {
5322   unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
5323   unsigned char *section_end = section->start + section->size;
5324   unsigned long cu_offset;
5325   unsigned int pointer_size;
5326   unsigned int offset_size;
5327   int dwarf_version;
5328   unsigned int bytes_read;
5329
5330   /* Initialize it due to a false compiler warning.  */
5331   dwarf_vma begin = -1, vbegin = -1;
5332   dwarf_vma end = -1, vend = -1;
5333   dwarf_vma length;
5334   int need_frame_base;
5335
5336   if (debug_info_entry >= num_debug_info_entries)
5337     {
5338       warn (_("No debug information available for "
5339               "loclists lists of entry: %u\n"),
5340             debug_info_entry);
5341       return;
5342     }
5343
5344   cu_offset = debug_information [debug_info_entry].cu_offset;
5345   pointer_size = debug_information [debug_info_entry].pointer_size;
5346   offset_size = debug_information [debug_info_entry].offset_size;
5347   dwarf_version = debug_information [debug_info_entry].dwarf_version;
5348
5349   if (pointer_size < 2 || pointer_size > 8)
5350     {
5351       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5352             pointer_size, debug_info_entry);
5353       return;
5354     }
5355
5356   while (1)
5357     {
5358       dwarf_vma off = offset + (start - *start_ptr);
5359       enum dwarf_location_list_entry_type llet;
5360
5361       if (start + 1 > section_end)
5362         {
5363           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5364                 (unsigned long) offset);
5365           break;
5366         }
5367
5368       printf ("    %8.8lx ", (unsigned long) off);
5369
5370       SAFE_BYTE_GET_AND_INC (llet, start, 1, section_end);
5371
5372       if (vstart && llet == DW_LLE_offset_pair)
5373         {
5374           off = offset + (vstart - *start_ptr);
5375
5376           vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5377           vstart += bytes_read;
5378           print_dwarf_view (vbegin, pointer_size, 1);
5379
5380           vend = read_uleb128 (vstart, &bytes_read, section_end);
5381           vstart += bytes_read;
5382           print_dwarf_view (vend, pointer_size, 1);
5383
5384           printf (_("views at %8.8lx for:\n    %*s "),
5385                   (unsigned long) off, 8, "");
5386         }
5387
5388       switch (llet)
5389         {
5390         case DW_LLE_end_of_list:
5391           printf (_("<End of list>\n"));
5392           break;
5393         case DW_LLE_offset_pair:
5394           begin = read_uleb128 (start, &bytes_read, section_end);
5395           start += bytes_read;
5396           end = read_uleb128 (start, &bytes_read, section_end);
5397           start += bytes_read;
5398           break;
5399         case DW_LLE_base_address:
5400           SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size,
5401                                  section_end);
5402           print_dwarf_vma (base_address, pointer_size);
5403           printf (_("(base address)\n"));
5404           break;
5405 #ifdef DW_LLE_view_pair
5406         case DW_LLE_view_pair:
5407           if (vstart)
5408             printf (_("View pair entry in loclist with locviews attribute\n"));
5409           vbegin = read_uleb128 (start, &bytes_read, section_end);
5410           start += bytes_read;
5411           print_dwarf_view (vbegin, pointer_size, 1);
5412
5413           vend = read_uleb128 (start, &bytes_read, section_end);
5414           start += bytes_read;
5415           print_dwarf_view (vend, pointer_size, 1);
5416
5417           printf (_("views for:\n"));
5418           continue;
5419 #endif
5420         default:
5421           error (_("Invalid location list entry type %d\n"), llet);
5422           return;
5423         }
5424       if (llet == DW_LLE_end_of_list)
5425         break;
5426       if (llet != DW_LLE_offset_pair)
5427         continue;
5428
5429       if (start + 2 > section_end)
5430         {
5431           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5432                 (unsigned long) offset);
5433           break;
5434         }
5435
5436       length = read_uleb128 (start, &bytes_read, section_end);
5437       start += bytes_read;
5438
5439       print_dwarf_vma (begin + base_address, pointer_size);
5440       print_dwarf_vma (end + base_address, pointer_size);
5441
5442       putchar ('(');
5443       need_frame_base = decode_location_expression (start,
5444                                                     pointer_size,
5445                                                     offset_size,
5446                                                     dwarf_version,
5447                                                     length,
5448                                                     cu_offset, section);
5449       putchar (')');
5450
5451       if (need_frame_base && !has_frame_base)
5452         printf (_(" [without DW_AT_frame_base]"));
5453
5454       if (begin == end && vbegin == vend)
5455         fputs (_(" (start == end)"), stdout);
5456       else if (begin > end || (begin == end && vbegin > vend))
5457         fputs (_(" (start > end)"), stdout);
5458
5459       putchar ('\n');
5460
5461       start += length;
5462       vbegin = vend = -1;
5463     }
5464
5465   if (vbegin != vm1 || vend != vm1)
5466     printf (_("Trailing view pair not used in a range"));
5467
5468   *start_ptr = start;
5469   *vstart_ptr = vstart;
5470 }
5471
5472 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5473    right-adjusted in a field of length LEN, and followed by a space.  */
5474
5475 static void
5476 print_addr_index (unsigned int idx, unsigned int len)
5477 {
5478   static char buf[15];
5479   snprintf (buf, sizeof (buf), "[%d]", idx);
5480   printf ("%*s ", len, buf);
5481 }
5482
5483 /* Display a location list from a .dwo section. It uses address indexes rather
5484    than embedded addresses.  This code closely follows display_loc_list, but the
5485    two are sufficiently different that combining things is very ugly.  */
5486
5487 static void
5488 display_loc_list_dwo (struct dwarf_section *section,
5489                       unsigned char **start_ptr,
5490                       unsigned int debug_info_entry,
5491                       dwarf_vma offset,
5492                       unsigned char **vstart_ptr,
5493                       int has_frame_base)
5494 {
5495   unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
5496   unsigned char *section_end = section->start + section->size;
5497   unsigned long cu_offset;
5498   unsigned int pointer_size;
5499   unsigned int offset_size;
5500   int dwarf_version;
5501   int entry_type;
5502   unsigned short length;
5503   int need_frame_base;
5504   unsigned int idx;
5505   unsigned int bytes_read;
5506
5507   if (debug_info_entry >= num_debug_info_entries)
5508     {
5509       warn (_("No debug information for loc lists of entry: %u\n"),
5510             debug_info_entry);
5511       return;
5512     }
5513
5514   cu_offset = debug_information [debug_info_entry].cu_offset;
5515   pointer_size = debug_information [debug_info_entry].pointer_size;
5516   offset_size = debug_information [debug_info_entry].offset_size;
5517   dwarf_version = debug_information [debug_info_entry].dwarf_version;
5518
5519   if (pointer_size < 2 || pointer_size > 8)
5520     {
5521       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5522             pointer_size, debug_info_entry);
5523       return;
5524     }
5525
5526   while (1)
5527     {
5528       printf ("    %8.8lx ", (unsigned long) (offset + (start - *start_ptr)));
5529
5530       if (start >= section_end)
5531         {
5532           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5533                 (unsigned long) offset);
5534           break;
5535         }
5536
5537       SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
5538
5539       if (vstart)
5540         switch (entry_type)
5541           {
5542           default:
5543             break;
5544
5545           case 2:
5546           case 3:
5547           case 4:
5548             {
5549               dwarf_vma view;
5550               dwarf_vma off = offset + (vstart - *start_ptr);
5551
5552               view = read_uleb128 (vstart, &bytes_read, section_end);
5553               vstart += bytes_read;
5554               print_dwarf_view (view, 8, 1);
5555
5556               view = read_uleb128 (vstart, &bytes_read, section_end);
5557               vstart += bytes_read;
5558               print_dwarf_view (view, 8, 1);
5559
5560               printf (_("views at %8.8lx for:\n    %*s "),
5561                       (unsigned long) off, 8, "");
5562
5563             }
5564             break;
5565           }
5566
5567       switch (entry_type)
5568         {
5569         case 0: /* A terminating entry.  */
5570           *start_ptr = start;
5571           *vstart_ptr = vstart;
5572           printf (_("<End of list>\n"));
5573           return;
5574         case 1: /* A base-address entry.  */
5575           idx = read_uleb128 (start, &bytes_read, section_end);
5576           start += bytes_read;
5577           print_addr_index (idx, 8);
5578           printf ("%*s", 9 + (vstart ? 2 * 6 : 0), "");
5579           printf (_("(base address selection entry)\n"));
5580           continue;
5581         case 2: /* A start/end entry.  */
5582           idx = read_uleb128 (start, &bytes_read, section_end);
5583           start += bytes_read;
5584           print_addr_index (idx, 8);
5585           idx = read_uleb128 (start, &bytes_read, section_end);
5586           start += bytes_read;
5587           print_addr_index (idx, 8);
5588           break;
5589         case 3: /* A start/length entry.  */
5590           idx = read_uleb128 (start, &bytes_read, section_end);
5591           start += bytes_read;
5592           print_addr_index (idx, 8);
5593           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5594           printf ("%08x ", idx);
5595           break;
5596         case 4: /* An offset pair entry.  */
5597           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5598           printf ("%08x ", idx);
5599           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5600           printf ("%08x ", idx);
5601           break;
5602         default:
5603           warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
5604           *start_ptr = start;
5605           *vstart_ptr = vstart;
5606           return;
5607         }
5608
5609       if (start + 2 > section_end)
5610         {
5611           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5612                 (unsigned long) offset);
5613           break;
5614         }
5615
5616       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
5617       if (start + length > section_end)
5618         {
5619           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5620                 (unsigned long) offset);
5621           break;
5622         }
5623
5624       putchar ('(');
5625       need_frame_base = decode_location_expression (start,
5626                                                     pointer_size,
5627                                                     offset_size,
5628                                                     dwarf_version,
5629                                                     length,
5630                                                     cu_offset, section);
5631       putchar (')');
5632
5633       if (need_frame_base && !has_frame_base)
5634         printf (_(" [without DW_AT_frame_base]"));
5635
5636       putchar ('\n');
5637
5638       start += length;
5639     }
5640
5641   *start_ptr = start;
5642   *vstart_ptr = vstart;
5643 }
5644
5645 /* Sort array of indexes in ascending order of loc_offsets[idx] and
5646    loc_views.  */
5647
5648 static dwarf_vma *loc_offsets, *loc_views;
5649
5650 static int
5651 loc_offsets_compar (const void *ap, const void *bp)
5652 {
5653   dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
5654   dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
5655
5656   int ret = (a > b) - (b > a);
5657   if (ret)
5658     return ret;
5659
5660   a = loc_views[*(const unsigned int *) ap];
5661   b = loc_views[*(const unsigned int *) bp];
5662
5663   ret = (a > b) - (b > a);
5664
5665   return ret;
5666 }
5667
5668 static int
5669 display_debug_loc (struct dwarf_section *section, void *file)
5670 {
5671   unsigned char *start = section->start, *vstart = NULL;
5672   unsigned long bytes;
5673   unsigned char *section_begin = start;
5674   unsigned int num_loc_list = 0;
5675   unsigned long last_offset = 0;
5676   unsigned long last_view = 0;
5677   unsigned int first = 0;
5678   unsigned int i;
5679   unsigned int j;
5680   int seen_first_offset = 0;
5681   int locs_sorted = 1;
5682   unsigned char *next = start, *vnext = vstart;
5683   unsigned int *array = NULL;
5684   const char *suffix = strrchr (section->name, '.');
5685   int is_dwo = 0;
5686   int is_loclists = strstr (section->name, "debug_loclists") != NULL;
5687   dwarf_vma expected_start = 0;
5688
5689   if (suffix && strcmp (suffix, ".dwo") == 0)
5690     is_dwo = 1;
5691
5692   bytes = section->size;
5693
5694   if (bytes == 0)
5695     {
5696       printf (_("\nThe %s section is empty.\n"), section->name);
5697       return 0;
5698     }
5699
5700   if (is_loclists)
5701     {
5702       unsigned char *hdrptr = section_begin;
5703       dwarf_vma ll_length;
5704       unsigned short ll_version;
5705       unsigned char *end = section_begin + section->size;
5706       unsigned char address_size, segment_selector_size;
5707       uint32_t offset_entry_count;
5708
5709       SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 4, end);
5710       if (ll_length == 0xffffffff)
5711         SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 8, end);
5712
5713       SAFE_BYTE_GET_AND_INC (ll_version, hdrptr, 2, end);
5714       if (ll_version != 5)
5715         {
5716           warn (_("The %s section contains corrupt or "
5717                   "unsupported version number: %d.\n"),
5718                 section->name, ll_version);
5719           return 0;
5720         }
5721
5722       SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
5723
5724       SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
5725       if (segment_selector_size != 0)
5726         {
5727           warn (_("The %s section contains "
5728                   "unsupported segment selector size: %d.\n"),
5729                 section->name, segment_selector_size);
5730           return 0;
5731         }
5732
5733       SAFE_BYTE_GET_AND_INC (offset_entry_count, hdrptr, 4, end);
5734       if (offset_entry_count != 0)
5735         {
5736           warn (_("The %s section contains "
5737                   "unsupported offset entry count: %d.\n"),
5738                 section->name, offset_entry_count);
5739           return 0;
5740         }
5741
5742       expected_start = hdrptr - section_begin;
5743     }
5744
5745   if (load_debug_info (file) == 0)
5746     {
5747       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5748             section->name);
5749       return 0;
5750     }
5751
5752   /* Check the order of location list in .debug_info section. If
5753      offsets of location lists are in the ascending order, we can
5754      use `debug_information' directly.  */
5755   for (i = 0; i < num_debug_info_entries; i++)
5756     {
5757       unsigned int num;
5758
5759       num = debug_information [i].num_loc_offsets;
5760       if (num > num_loc_list)
5761         num_loc_list = num;
5762
5763       /* Check if we can use `debug_information' directly.  */
5764       if (locs_sorted && num != 0)
5765         {
5766           if (!seen_first_offset)
5767             {
5768               /* This is the first location list.  */
5769               last_offset = debug_information [i].loc_offsets [0];
5770               last_view = debug_information [i].loc_views [0];
5771               first = i;
5772               seen_first_offset = 1;
5773               j = 1;
5774             }
5775           else
5776             j = 0;
5777
5778           for (; j < num; j++)
5779             {
5780               if (last_offset >
5781                   debug_information [i].loc_offsets [j]
5782                   || (last_offset == debug_information [i].loc_offsets [j]
5783                       && last_view > debug_information [i].loc_views [j]))
5784                 {
5785                   locs_sorted = 0;
5786                   break;
5787                 }
5788               last_offset = debug_information [i].loc_offsets [j];
5789               last_view = debug_information [i].loc_views [j];
5790             }
5791         }
5792     }
5793
5794   if (!seen_first_offset)
5795     error (_("No location lists in .debug_info section!\n"));
5796
5797   if (debug_information [first].num_loc_offsets > 0
5798       && debug_information [first].loc_offsets [0] != expected_start
5799       && debug_information [first].loc_views [0] != expected_start)
5800     warn (_("Location lists in %s section start at 0x%s\n"),
5801           section->name,
5802           dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
5803
5804   if (!locs_sorted)
5805     array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
5806   printf (_("Contents of the %s section:\n\n"), section->name);
5807   if (reloc_at (section, 0))
5808     printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
5809   printf (_("    Offset   Begin            End              Expression\n"));
5810
5811   seen_first_offset = 0;
5812   for (i = first; i < num_debug_info_entries; i++)
5813     {
5814       dwarf_vma offset, voffset;
5815       dwarf_vma base_address;
5816       unsigned int k;
5817       int has_frame_base;
5818
5819       if (!locs_sorted)
5820         {
5821           for (k = 0; k < debug_information [i].num_loc_offsets; k++)
5822             array[k] = k;
5823           loc_offsets = debug_information [i].loc_offsets;
5824           loc_views = debug_information [i].loc_views;
5825           qsort (array, debug_information [i].num_loc_offsets,
5826                  sizeof (*array), loc_offsets_compar);
5827         }
5828
5829       int adjacent_view_loclists = 1;
5830       for (k = 0; k < debug_information [i].num_loc_offsets; k++)
5831         {
5832           j = locs_sorted ? k : array[k];
5833           if (k
5834               && (debug_information [i].loc_offsets [locs_sorted
5835                                                     ? k - 1 : array [k - 1]]
5836                   == debug_information [i].loc_offsets [j])
5837               && (debug_information [i].loc_views [locs_sorted
5838                                                    ? k - 1 : array [k - 1]]
5839                   == debug_information [i].loc_views [j]))
5840             continue;
5841           has_frame_base = debug_information [i].have_frame_base [j];
5842           offset = debug_information [i].loc_offsets [j];
5843           next = section_begin + offset;
5844           voffset = debug_information [i].loc_views [j];
5845           if (voffset != vm1)
5846             vnext = section_begin + voffset;
5847           else
5848             vnext = NULL;
5849           base_address = debug_information [i].base_address;
5850
5851           if (vnext && vnext < next)
5852             {
5853               vstart = vnext;
5854               display_view_pair_list (section, &vstart, i, next);
5855               if (start == vnext)
5856                 start = vstart;
5857             }
5858
5859           if (!seen_first_offset || !adjacent_view_loclists)
5860             seen_first_offset = 1;
5861           else
5862             {
5863               if (start < next)
5864                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
5865                       (unsigned long) (start - section_begin),
5866                       (unsigned long) offset);
5867               else if (start > next)
5868                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
5869                       (unsigned long) (start - section_begin),
5870                       (unsigned long) offset);
5871             }
5872           start = next;
5873           vstart = vnext;
5874
5875           if (offset >= bytes)
5876             {
5877               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
5878                     (unsigned long) offset);
5879               continue;
5880             }
5881
5882           if (vnext && voffset >= bytes)
5883             {
5884               warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
5885                     (unsigned long) voffset);
5886               continue;
5887             }
5888
5889           if (!is_loclists)
5890             {
5891               if (is_dwo)
5892                 display_loc_list_dwo (section, &start, i, offset,
5893                                       &vstart, has_frame_base);
5894               else
5895                 display_loc_list (section, &start, i, offset, base_address,
5896                                   &vstart, has_frame_base);
5897             }
5898           else
5899             {
5900               if (is_dwo)
5901                 warn (_("DWO is not yet supported.\n"));
5902               else
5903                 display_loclists_list (section, &start, i, offset, base_address,
5904                                        &vstart, has_frame_base);
5905             }
5906
5907           /* FIXME: this arrangement is quite simplistic.  Nothing
5908              requires locview lists to be adjacent to corresponding
5909              loclists, and a single loclist could be augmented by
5910              different locview lists, and vice-versa, unlikely as it
5911              is that it would make sense to do so.  Hopefully we'll
5912              have view pair support built into loclists before we ever
5913              need to address all these possibilities.  */
5914           if (adjacent_view_loclists && vnext
5915               && vnext != start && vstart != next)
5916             {
5917               adjacent_view_loclists = 0;
5918               warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
5919             }
5920
5921           if (vnext && vnext == start)
5922             display_view_pair_list (section, &start, i, vstart);
5923         }
5924     }
5925
5926   if (start < section->start + section->size)
5927     warn (_("There are %ld unused bytes at the end of section %s\n"),
5928           (long) (section->start + section->size - start), section->name);
5929   putchar ('\n');
5930   free (array);
5931   return 1;
5932 }
5933
5934 static int
5935 display_debug_str (struct dwarf_section *section,
5936                    void *file ATTRIBUTE_UNUSED)
5937 {
5938   unsigned char *start = section->start;
5939   unsigned long bytes = section->size;
5940   dwarf_vma addr = section->address;
5941
5942   if (bytes == 0)
5943     {
5944       printf (_("\nThe %s section is empty.\n"), section->name);
5945       return 0;
5946     }
5947
5948   printf (_("Contents of the %s section:\n\n"), section->name);
5949
5950   while (bytes)
5951     {
5952       int j;
5953       int k;
5954       int lbytes;
5955
5956       lbytes = (bytes > 16 ? 16 : bytes);
5957
5958       printf ("  0x%8.8lx ", (unsigned long) addr);
5959
5960       for (j = 0; j < 16; j++)
5961         {
5962           if (j < lbytes)
5963             printf ("%2.2x", start[j]);
5964           else
5965             printf ("  ");
5966
5967           if ((j & 3) == 3)
5968             printf (" ");
5969         }
5970
5971       for (j = 0; j < lbytes; j++)
5972         {
5973           k = start[j];
5974           if (k >= ' ' && k < 0x80)
5975             printf ("%c", k);
5976           else
5977             printf (".");
5978         }
5979
5980       putchar ('\n');
5981
5982       start += lbytes;
5983       addr  += lbytes;
5984       bytes -= lbytes;
5985     }
5986
5987   putchar ('\n');
5988
5989   return 1;
5990 }
5991
5992 static int
5993 display_debug_info (struct dwarf_section *section, void *file)
5994 {
5995   return process_debug_info (section, file, section->abbrev_sec, 0, 0);
5996 }
5997
5998 static int
5999 display_debug_types (struct dwarf_section *section, void *file)
6000 {
6001   return process_debug_info (section, file, section->abbrev_sec, 0, 1);
6002 }
6003
6004 static int
6005 display_trace_info (struct dwarf_section *section, void *file)
6006 {
6007   return process_debug_info (section, file, section->abbrev_sec, 0, 0);
6008 }
6009
6010 static int
6011 display_debug_aranges (struct dwarf_section *section,
6012                        void *file ATTRIBUTE_UNUSED)
6013 {
6014   unsigned char *start = section->start;
6015   unsigned char *end = start + section->size;
6016
6017   printf (_("Contents of the %s section:\n\n"), section->name);
6018
6019   /* It does not matter if this load fails,
6020      we test for that later on.  */
6021   load_debug_info (file);
6022
6023   while (start < end)
6024     {
6025       unsigned char *hdrptr;
6026       DWARF2_Internal_ARange arange;
6027       unsigned char *addr_ranges;
6028       dwarf_vma length;
6029       dwarf_vma address;
6030       unsigned char address_size;
6031       int excess;
6032       unsigned int offset_size;
6033       unsigned int initial_length_size;
6034
6035       hdrptr = start;
6036
6037       SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
6038       if (arange.ar_length == 0xffffffff)
6039         {
6040           SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
6041           offset_size = 8;
6042           initial_length_size = 12;
6043         }
6044       else
6045         {
6046           offset_size = 4;
6047           initial_length_size = 4;
6048         }
6049
6050       SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
6051       SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
6052
6053       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
6054           && num_debug_info_entries > 0
6055           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
6056         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6057               (unsigned long) arange.ar_info_offset, section->name);
6058
6059       SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
6060       SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
6061
6062       if (arange.ar_version != 2 && arange.ar_version != 3)
6063         {
6064           /* PR 19872: A version number of 0 probably means that there is
6065              padding at the end of the .debug_aranges section.  Gold puts
6066              it there when performing an incremental link, for example.
6067              So do not generate a warning in this case.  */
6068           if (arange.ar_version)
6069             warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6070           break;
6071         }
6072
6073       printf (_("  Length:                   %ld\n"),
6074               (long) arange.ar_length);
6075       printf (_("  Version:                  %d\n"), arange.ar_version);
6076       printf (_("  Offset into .debug_info:  0x%lx\n"),
6077               (unsigned long) arange.ar_info_offset);
6078       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
6079       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
6080
6081       address_size = arange.ar_pointer_size + arange.ar_segment_size;
6082
6083       /* PR 17512: file: 001-108546-0.001:0.1.  */
6084       if (address_size == 0 || address_size > 8)
6085         {
6086           error (_("Invalid address size in %s section!\n"),
6087                  section->name);
6088           break;
6089         }
6090
6091       /* The DWARF spec does not require that the address size be a power
6092          of two, but we do.  This will have to change if we ever encounter
6093          an uneven architecture.  */
6094       if ((address_size & (address_size - 1)) != 0)
6095         {
6096           warn (_("Pointer size + Segment size is not a power of two.\n"));
6097           break;
6098         }
6099
6100       if (address_size > 4)
6101         printf (_("\n    Address            Length\n"));
6102       else
6103         printf (_("\n    Address    Length\n"));
6104
6105       addr_ranges = hdrptr;
6106
6107       /* Must pad to an alignment boundary that is twice the address size.  */
6108       excess = (hdrptr - start) % (2 * address_size);
6109       if (excess)
6110         addr_ranges += (2 * address_size) - excess;
6111
6112       hdrptr = start + arange.ar_length + initial_length_size;
6113       if (hdrptr < start || hdrptr > end)
6114         {
6115           error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
6116           break;
6117         }
6118       start = hdrptr;
6119
6120       while (addr_ranges + 2 * address_size <= start)
6121         {
6122           SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
6123           SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
6124
6125           printf ("    ");
6126           print_dwarf_vma (address, address_size);
6127           print_dwarf_vma (length, address_size);
6128           putchar ('\n');
6129         }
6130     }
6131
6132   printf ("\n");
6133
6134   return 1;
6135 }
6136
6137 /* Comparison function for qsort.  */
6138 static int
6139 comp_addr_base (const void * v0, const void * v1)
6140 {
6141   debug_info * info0 = (debug_info *) v0;
6142   debug_info * info1 = (debug_info *) v1;
6143   return info0->addr_base - info1->addr_base;
6144 }
6145
6146 /* Display the debug_addr section.  */
6147 static int
6148 display_debug_addr (struct dwarf_section *section,
6149                     void *file)
6150 {
6151   debug_info **debug_addr_info;
6152   unsigned char *entry;
6153   unsigned char *end;
6154   unsigned int i;
6155   unsigned int count;
6156
6157   if (section->size == 0)
6158     {
6159       printf (_("\nThe %s section is empty.\n"), section->name);
6160       return 0;
6161     }
6162
6163   if (load_debug_info (file) == 0)
6164     {
6165       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6166             section->name);
6167       return 0;
6168     }
6169
6170   printf (_("Contents of the %s section:\n\n"), section->name);
6171
6172   /* PR  17531: file: cf38d01b.
6173      We use xcalloc because a corrupt file may not have initialised all of the
6174      fields in the debug_info structure, which means that the sort below might
6175      try to move uninitialised data.  */
6176   debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
6177                                              sizeof (debug_info *));
6178
6179   count = 0;
6180   for (i = 0; i < num_debug_info_entries; i++)
6181     if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
6182       {
6183         /* PR 17531: file: cf38d01b.  */
6184         if (debug_information[i].addr_base >= section->size)
6185           warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6186                 (unsigned long) debug_information[i].addr_base, i);
6187         else
6188           debug_addr_info [count++] = debug_information + i;
6189       }
6190
6191   /* Add a sentinel to make iteration convenient.  */
6192   debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
6193   debug_addr_info [count]->addr_base = section->size;
6194   qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
6195
6196   for (i = 0; i < count; i++)
6197     {
6198       unsigned int idx;
6199       unsigned int address_size = debug_addr_info [i]->pointer_size;
6200
6201       printf (_("  For compilation unit at offset 0x%s:\n"),
6202               dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
6203
6204       printf (_("\tIndex\tAddress\n"));
6205       entry = section->start + debug_addr_info [i]->addr_base;
6206       end = section->start + debug_addr_info [i + 1]->addr_base;
6207       idx = 0;
6208       while (entry < end)
6209         {
6210           dwarf_vma base = byte_get (entry, address_size);
6211           printf (_("\t%d:\t"), idx);
6212           print_dwarf_vma (base, address_size);
6213           printf ("\n");
6214           entry += address_size;
6215           idx++;
6216         }
6217     }
6218   printf ("\n");
6219
6220   free (debug_addr_info);
6221   return 1;
6222 }
6223
6224 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections.  */
6225 static int
6226 display_debug_str_offsets (struct dwarf_section *section,
6227                            void *file ATTRIBUTE_UNUSED)
6228 {
6229   if (section->size == 0)
6230     {
6231       printf (_("\nThe %s section is empty.\n"), section->name);
6232       return 0;
6233     }
6234   /* TODO: Dump the contents.  This is made somewhat difficult by not knowing
6235      what the offset size is for this section.  */
6236   return 1;
6237 }
6238
6239 /* Each debug_information[x].range_lists[y] gets this representation for
6240    sorting purposes.  */
6241
6242 struct range_entry
6243 {
6244   /* The debug_information[x].range_lists[y] value.  */
6245   dwarf_vma ranges_offset;
6246
6247   /* Original debug_information to find parameters of the data.  */
6248   debug_info *debug_info_p;
6249 };
6250
6251 /* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
6252
6253 static int
6254 range_entry_compar (const void *ap, const void *bp)
6255 {
6256   const struct range_entry *a_re = (const struct range_entry *) ap;
6257   const struct range_entry *b_re = (const struct range_entry *) bp;
6258   const dwarf_vma a = a_re->ranges_offset;
6259   const dwarf_vma b = b_re->ranges_offset;
6260
6261   return (a > b) - (b > a);
6262 }
6263
6264 static void
6265 display_debug_ranges_list (unsigned char *start, unsigned char *finish,
6266                            unsigned int pointer_size, unsigned long offset,
6267                            unsigned long base_address)
6268 {
6269   while (start < finish)
6270     {
6271       dwarf_vma begin;
6272       dwarf_vma end;
6273
6274       SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6275       if (start >= finish)
6276         break;
6277       SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
6278
6279       printf ("    %8.8lx ", offset);
6280
6281       if (begin == 0 && end == 0)
6282         {
6283           printf (_("<End of list>\n"));
6284           break;
6285         }
6286
6287       /* Check base address specifiers.  */
6288       if (is_max_address (begin, pointer_size)
6289           && !is_max_address (end, pointer_size))
6290         {
6291           base_address = end;
6292           print_dwarf_vma (begin, pointer_size);
6293           print_dwarf_vma (end, pointer_size);
6294           printf ("(base address)\n");
6295           continue;
6296         }
6297
6298       print_dwarf_vma (begin + base_address, pointer_size);
6299       print_dwarf_vma (end + base_address, pointer_size);
6300
6301       if (begin == end)
6302         fputs (_("(start == end)"), stdout);
6303       else if (begin > end)
6304         fputs (_("(start > end)"), stdout);
6305
6306       putchar ('\n');
6307     }
6308 }
6309
6310 static void
6311 display_debug_rnglists_list (unsigned char *start, unsigned char *finish,
6312                              unsigned int pointer_size, unsigned long offset,
6313                              unsigned long base_address)
6314 {
6315   unsigned char *next = start;
6316
6317   while (1)
6318     {
6319       unsigned long off = offset + (start - next);
6320       enum dwarf_range_list_entry rlet;
6321       /* Initialize it due to a false compiler warning.  */
6322       dwarf_vma begin = -1, length, end = -1;
6323       unsigned int bytes_read;
6324
6325       if (start + 1 > finish)
6326         {
6327           warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6328                 offset);
6329           break;
6330         }
6331
6332       printf ("    %8.8lx ", off);
6333
6334       SAFE_BYTE_GET_AND_INC (rlet, start, 1, finish);
6335
6336       switch (rlet)
6337         {
6338         case DW_RLE_end_of_list:
6339           printf (_("<End of list>\n"));
6340           break;
6341         case DW_RLE_base_address:
6342           SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, finish);
6343           print_dwarf_vma (base_address, pointer_size);
6344           printf (_("(base address)\n"));
6345           break;
6346         case DW_RLE_start_length:
6347           SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6348           length = read_uleb128 (start, &bytes_read, finish);
6349           start += bytes_read;
6350           end = begin + length;
6351           break;
6352         case DW_RLE_offset_pair:
6353           begin = read_uleb128 (start, &bytes_read, finish);
6354           start += bytes_read;
6355           end = read_uleb128 (start, &bytes_read, finish);
6356           start += bytes_read;
6357           break;
6358         case DW_RLE_start_end:
6359           SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6360           SAFE_BYTE_GET_AND_INC (end, start, pointer_size, finish);
6361           break;
6362         default:
6363           error (_("Invalid range list entry type %d\n"), rlet);
6364           rlet = DW_RLE_end_of_list;
6365           break;
6366         }
6367       if (rlet == DW_RLE_end_of_list)
6368         break;
6369       if (rlet == DW_RLE_base_address)
6370         continue;
6371
6372       print_dwarf_vma (begin + base_address, pointer_size);
6373       print_dwarf_vma (end + base_address, pointer_size);
6374
6375       if (begin == end)
6376         fputs (_("(start == end)"), stdout);
6377       else if (begin > end)
6378         fputs (_("(start > end)"), stdout);
6379
6380       putchar ('\n');
6381     }
6382 }
6383
6384 static int
6385 display_debug_ranges (struct dwarf_section *section,
6386                       void *file ATTRIBUTE_UNUSED)
6387 {
6388   unsigned char *start = section->start;
6389   unsigned char *last_start = start;
6390   unsigned long bytes = section->size;
6391   unsigned char *section_begin = start;
6392   unsigned char *finish = start + bytes;
6393   unsigned int num_range_list, i;
6394   struct range_entry *range_entries, *range_entry_fill;
6395   int is_rnglists = strstr (section->name, "debug_rnglists") != NULL;
6396   /* Initialize it due to a false compiler warning.  */
6397   unsigned char address_size = 0;
6398
6399   if (bytes == 0)
6400     {
6401       printf (_("\nThe %s section is empty.\n"), section->name);
6402       return 0;
6403     }
6404
6405   if (is_rnglists)
6406     {
6407       dwarf_vma initial_length;
6408       unsigned int initial_length_size;
6409       unsigned char segment_selector_size;
6410       unsigned int offset_size, offset_entry_count;
6411       unsigned short version;
6412
6413       /* Get and check the length of the block.  */
6414       SAFE_BYTE_GET_AND_INC (initial_length, start, 4, finish);
6415
6416       if (initial_length == 0xffffffff)
6417         {
6418           /* This section is 64-bit DWARF 3.  */
6419           SAFE_BYTE_GET_AND_INC (initial_length, start, 8, finish);
6420           offset_size = 8;
6421           initial_length_size = 12;
6422         }
6423       else
6424         {
6425           offset_size = 4;
6426           initial_length_size = 4;
6427         }
6428
6429       if (initial_length + initial_length_size > section->size)
6430         {
6431           /* If the length field has a relocation against it, then we should
6432              not complain if it is inaccurate (and probably negative).
6433              It is copied from .debug_line handling code.  */
6434           if (reloc_at (section, (start - section->start) - offset_size))
6435             {
6436               initial_length = (finish - start) - initial_length_size;
6437             }
6438           else
6439             {
6440               warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6441                     (long) initial_length);
6442               return 0;
6443             }
6444         }
6445
6446       /* Get and check the version number.  */
6447       SAFE_BYTE_GET_AND_INC (version, start, 2, finish);
6448
6449       if (version != 5)
6450         {
6451           warn (_("Only DWARF version 5 debug_rnglists info "
6452                   "is currently supported.\n"));
6453           return 0;
6454         }
6455
6456       SAFE_BYTE_GET_AND_INC (address_size, start, 1, finish);
6457
6458       SAFE_BYTE_GET_AND_INC (segment_selector_size, start, 1, finish);
6459       if (segment_selector_size != 0)
6460         {
6461           warn (_("The %s section contains "
6462                   "unsupported segment selector size: %d.\n"),
6463                 section->name, segment_selector_size);
6464           return 0;
6465         }
6466
6467       SAFE_BYTE_GET_AND_INC (offset_entry_count, start, 4, finish);
6468       if (offset_entry_count != 0)
6469         {
6470           warn (_("The %s section contains "
6471                   "unsupported offset entry count: %u.\n"),
6472                 section->name, offset_entry_count);
6473           return 0;
6474         }
6475     }
6476
6477   if (load_debug_info (file) == 0)
6478     {
6479       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6480             section->name);
6481       return 0;
6482     }
6483
6484   num_range_list = 0;
6485   for (i = 0; i < num_debug_info_entries; i++)
6486     num_range_list += debug_information [i].num_range_lists;
6487
6488   if (num_range_list == 0)
6489     {
6490       /* This can happen when the file was compiled with -gsplit-debug
6491          which removes references to range lists from the primary .o file.  */
6492       printf (_("No range lists in .debug_info section.\n"));
6493       return 1;
6494     }
6495
6496   range_entries = (struct range_entry *)
6497       xmalloc (sizeof (*range_entries) * num_range_list);
6498   range_entry_fill = range_entries;
6499
6500   for (i = 0; i < num_debug_info_entries; i++)
6501     {
6502       debug_info *debug_info_p = &debug_information[i];
6503       unsigned int j;
6504
6505       for (j = 0; j < debug_info_p->num_range_lists; j++)
6506         {
6507           range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
6508           range_entry_fill->debug_info_p = debug_info_p;
6509           range_entry_fill++;
6510         }
6511     }
6512
6513   qsort (range_entries, num_range_list, sizeof (*range_entries),
6514          range_entry_compar);
6515
6516   if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
6517     warn (_("Range lists in %s section start at 0x%lx\n"),
6518           section->name, (unsigned long) range_entries[0].ranges_offset);
6519
6520   printf (_("Contents of the %s section:\n\n"), section->name);
6521   printf (_("    Offset   Begin    End\n"));
6522
6523   for (i = 0; i < num_range_list; i++)
6524     {
6525       struct range_entry *range_entry = &range_entries[i];
6526       debug_info *debug_info_p = range_entry->debug_info_p;
6527       unsigned int pointer_size;
6528       dwarf_vma offset;
6529       unsigned char *next;
6530       dwarf_vma base_address;
6531
6532       pointer_size = (is_rnglists ? address_size : debug_info_p->pointer_size);
6533       offset = range_entry->ranges_offset;
6534       next = section_begin + offset;
6535       base_address = debug_info_p->base_address;
6536
6537       /* PR 17512: file: 001-101485-0.001:0.1.  */
6538       if (pointer_size < 2 || pointer_size > 8)
6539         {
6540           warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
6541                 pointer_size, (unsigned long) offset);
6542           continue;
6543         }
6544
6545       if (dwarf_check != 0 && i > 0)
6546         {
6547           if (start < next)
6548             warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
6549                   (unsigned long) (start - section_begin),
6550                   (unsigned long) (next - section_begin), section->name);
6551           else if (start > next)
6552             {
6553               if (next == last_start)
6554                 continue;
6555               warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
6556                     (unsigned long) (start - section_begin),
6557                     (unsigned long) (next - section_begin), section->name);
6558             }
6559         }
6560       start = next;
6561       last_start = next;
6562
6563       (is_rnglists ? display_debug_rnglists_list : display_debug_ranges_list)
6564         (start, finish, pointer_size, offset, base_address);
6565     }
6566   putchar ('\n');
6567
6568   free (range_entries);
6569
6570   return 1;
6571 }
6572
6573 typedef struct Frame_Chunk
6574 {
6575   struct Frame_Chunk *next;
6576   unsigned char *chunk_start;
6577   unsigned int ncols;
6578   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
6579   short int *col_type;
6580   int *col_offset;
6581   char *augmentation;
6582   unsigned int code_factor;
6583   int data_factor;
6584   dwarf_vma pc_begin;
6585   dwarf_vma pc_range;
6586   int cfa_reg;
6587   dwarf_vma cfa_offset;
6588   unsigned int ra;
6589   unsigned char fde_encoding;
6590   unsigned char cfa_exp;
6591   unsigned char ptr_size;
6592   unsigned char segment_size;
6593 }
6594 Frame_Chunk;
6595
6596 static const char *const *dwarf_regnames;
6597 static unsigned int dwarf_regnames_count;
6598
6599 /* A marker for a col_type that means this column was never referenced
6600    in the frame info.  */
6601 #define DW_CFA_unreferenced (-1)
6602
6603 /* Return 0 if no more space is needed, 1 if more space is needed,
6604    -1 for invalid reg.  */
6605
6606 static int
6607 frame_need_space (Frame_Chunk *fc, unsigned int reg)
6608 {
6609   unsigned int prev = fc->ncols;
6610
6611   if (reg < (unsigned int) fc->ncols)
6612     return 0;
6613
6614   if (dwarf_regnames_count
6615       && reg > dwarf_regnames_count)
6616     return -1;
6617
6618   fc->ncols = reg + 1;
6619   /* PR 17512: file: 10450-2643-0.004.
6620      If reg == -1 then this can happen...  */
6621   if (fc->ncols == 0)
6622     return -1;
6623
6624   /* PR 17512: file: 2844a11d.  */
6625   if (fc->ncols > 1024)
6626     {
6627       error (_("Unfeasibly large register number: %u\n"), reg);
6628       fc->ncols = 0;
6629       /* FIXME: 1024 is an arbitrary limit.  Increase it if
6630          we ever encounter a valid binary that exceeds it.  */
6631       return -1;
6632     }
6633
6634   fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
6635                                           sizeof (short int));
6636   fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
6637   /* PR 17512: file:002-10025-0.005.  */
6638   if (fc->col_type == NULL || fc->col_offset == NULL)
6639     {
6640       error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
6641              fc->ncols);
6642       fc->ncols = 0;
6643       return -1;
6644     }
6645
6646   while (prev < fc->ncols)
6647     {
6648       fc->col_type[prev] = DW_CFA_unreferenced;
6649       fc->col_offset[prev] = 0;
6650       prev++;
6651     }
6652   return 1;
6653 }
6654
6655 static const char *const dwarf_regnames_i386[] =
6656 {
6657   "eax", "ecx", "edx", "ebx",                     /* 0 - 3  */
6658   "esp", "ebp", "esi", "edi",                     /* 4 - 7  */
6659   "eip", "eflags", NULL,                          /* 8 - 10  */
6660   "st0", "st1", "st2", "st3",                     /* 11 - 14  */
6661   "st4", "st5", "st6", "st7",                     /* 15 - 18  */
6662   NULL, NULL,                                     /* 19 - 20  */
6663   "xmm0", "xmm1", "xmm2", "xmm3",                 /* 21 - 24  */
6664   "xmm4", "xmm5", "xmm6", "xmm7",                 /* 25 - 28  */
6665   "mm0", "mm1", "mm2", "mm3",                     /* 29 - 32  */
6666   "mm4", "mm5", "mm6", "mm7",                     /* 33 - 36  */
6667   "fcw", "fsw", "mxcsr",                          /* 37 - 39  */
6668   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47  */
6669   "tr", "ldtr",                                   /* 48 - 49  */
6670   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57  */
6671   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65  */
6672   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73  */
6673   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81  */
6674   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89  */
6675   NULL, NULL, NULL,                               /* 90 - 92  */
6676   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"  /* 93 - 100  */
6677 };
6678
6679 static const char *const dwarf_regnames_iamcu[] =
6680 {
6681   "eax", "ecx", "edx", "ebx",                     /* 0 - 3  */
6682   "esp", "ebp", "esi", "edi",                     /* 4 - 7  */
6683   "eip", "eflags", NULL,                          /* 8 - 10  */
6684   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18  */
6685   NULL, NULL,                                     /* 19 - 20  */
6686   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28  */
6687   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36  */
6688   NULL, NULL, NULL,                               /* 37 - 39  */
6689   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47  */
6690   "tr", "ldtr",                                   /* 48 - 49  */
6691   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57  */
6692   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65  */
6693   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73  */
6694   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81  */
6695   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89  */
6696   NULL, NULL, NULL,                               /* 90 - 92  */
6697   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  /* 93 - 100  */
6698 };
6699
6700 void
6701 init_dwarf_regnames_i386 (void)
6702 {
6703   dwarf_regnames = dwarf_regnames_i386;
6704   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
6705 }
6706
6707 void
6708 init_dwarf_regnames_iamcu (void)
6709 {
6710   dwarf_regnames = dwarf_regnames_iamcu;
6711   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu);
6712 }
6713
6714 static const char *const dwarf_regnames_x86_64[] =
6715 {
6716   "rax", "rdx", "rcx", "rbx",
6717   "rsi", "rdi", "rbp", "rsp",
6718   "r8",  "r9",  "r10", "r11",
6719   "r12", "r13", "r14", "r15",
6720   "rip",
6721   "xmm0",  "xmm1",  "xmm2",  "xmm3",
6722   "xmm4",  "xmm5",  "xmm6",  "xmm7",
6723   "xmm8",  "xmm9",  "xmm10", "xmm11",
6724   "xmm12", "xmm13", "xmm14", "xmm15",
6725   "st0", "st1", "st2", "st3",
6726   "st4", "st5", "st6", "st7",
6727   "mm0", "mm1", "mm2", "mm3",
6728   "mm4", "mm5", "mm6", "mm7",
6729   "rflags",
6730   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
6731   "fs.base", "gs.base", NULL, NULL,
6732   "tr", "ldtr",
6733   "mxcsr", "fcw", "fsw",
6734   "xmm16",  "xmm17",  "xmm18",  "xmm19",
6735   "xmm20",  "xmm21",  "xmm22",  "xmm23",
6736   "xmm24",  "xmm25",  "xmm26",  "xmm27",
6737   "xmm28",  "xmm29",  "xmm30",  "xmm31",
6738   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90  */
6739   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98  */
6740   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106  */
6741   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114  */
6742   NULL, NULL, NULL,                               /* 115 - 117  */
6743   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
6744 };
6745
6746 void
6747 init_dwarf_regnames_x86_64 (void)
6748 {
6749   dwarf_regnames = dwarf_regnames_x86_64;
6750   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
6751 }
6752
6753 static const char *const dwarf_regnames_aarch64[] =
6754 {
6755    "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
6756    "x8",  "x9", "x10", "x11", "x12", "x13", "x14", "x15",
6757   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
6758   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
6759    NULL, "elr",  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
6760    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
6761    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
6762    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
6763    "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",
6764    "v8",  "v9", "v10", "v11", "v12", "v13", "v14", "v15",
6765   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
6766   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6767 };
6768
6769 void
6770 init_dwarf_regnames_aarch64 (void)
6771 {
6772   dwarf_regnames = dwarf_regnames_aarch64;
6773   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
6774 }
6775
6776 static const char *const dwarf_regnames_s390[] =
6777 {
6778   /* Avoid saying "r5 (r5)", so omit the names of r0-r15.  */
6779   NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
6780   NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
6781   "f0",  "f2",  "f4",  "f6",  "f1",  "f3",  "f5",  "f7",
6782   "f8",  "f10", "f12", "f14", "f9",  "f11", "f13", "f15",
6783   "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
6784   "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
6785   "a0",  "a1",  "a2",  "a3",  "a4",  "a5",  "a6",  "a7",
6786   "a8",  "a9",  "a10", "a11", "a12", "a13", "a14", "a15",
6787   "pswm", "pswa",
6788   NULL, NULL,
6789   "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
6790   "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
6791 };
6792
6793 void
6794 init_dwarf_regnames_s390 (void)
6795 {
6796   dwarf_regnames = dwarf_regnames_s390;
6797   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390);
6798 }
6799
6800 void
6801 init_dwarf_regnames (unsigned int e_machine)
6802 {
6803   switch (e_machine)
6804     {
6805     case EM_386:
6806       init_dwarf_regnames_i386 ();
6807       break;
6808
6809     case EM_IAMCU:
6810       init_dwarf_regnames_iamcu ();
6811       break;
6812
6813     case EM_X86_64:
6814     case EM_L1OM:
6815     case EM_K1OM:
6816       init_dwarf_regnames_x86_64 ();
6817       break;
6818
6819     case EM_AARCH64:
6820       init_dwarf_regnames_aarch64 ();
6821       break;
6822
6823     case EM_S390:
6824       init_dwarf_regnames_s390 ();
6825       break;
6826
6827     default:
6828       break;
6829     }
6830 }
6831
6832 static const char *
6833 regname (unsigned int regno, int row)
6834 {
6835   static char reg[64];
6836
6837   if (dwarf_regnames
6838       && regno < dwarf_regnames_count
6839       && dwarf_regnames [regno] != NULL)
6840     {
6841       if (row)
6842         return dwarf_regnames [regno];
6843       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
6844                 dwarf_regnames [regno]);
6845     }
6846   else
6847     snprintf (reg, sizeof (reg), "r%d", regno);
6848   return reg;
6849 }
6850
6851 static void
6852 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
6853 {
6854   unsigned int r;
6855   char tmp[100];
6856
6857   if (*max_regs != fc->ncols)
6858     *max_regs = fc->ncols;
6859
6860   if (*need_col_headers)
6861     {
6862       static const char *sloc = "   LOC";
6863
6864       *need_col_headers = 0;
6865
6866       printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
6867
6868       for (r = 0; r < *max_regs; r++)
6869         if (fc->col_type[r] != DW_CFA_unreferenced)
6870           {
6871             if (r == fc->ra)
6872               printf ("ra    ");
6873             else
6874               printf ("%-5s ", regname (r, 1));
6875           }
6876
6877       printf ("\n");
6878     }
6879
6880   print_dwarf_vma (fc->pc_begin, eh_addr_size);
6881   if (fc->cfa_exp)
6882     strcpy (tmp, "exp");
6883   else
6884     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
6885   printf ("%-8s ", tmp);
6886
6887   for (r = 0; r < fc->ncols; r++)
6888     {
6889       if (fc->col_type[r] != DW_CFA_unreferenced)
6890         {
6891           switch (fc->col_type[r])
6892             {
6893             case DW_CFA_undefined:
6894               strcpy (tmp, "u");
6895               break;
6896             case DW_CFA_same_value:
6897               strcpy (tmp, "s");
6898               break;
6899             case DW_CFA_offset:
6900               sprintf (tmp, "c%+d", fc->col_offset[r]);
6901               break;
6902             case DW_CFA_val_offset:
6903               sprintf (tmp, "v%+d", fc->col_offset[r]);
6904               break;
6905             case DW_CFA_register:
6906               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
6907               break;
6908             case DW_CFA_expression:
6909               strcpy (tmp, "exp");
6910               break;
6911             case DW_CFA_val_expression:
6912               strcpy (tmp, "vexp");
6913               break;
6914             default:
6915               strcpy (tmp, "n/a");
6916               break;
6917             }
6918           printf ("%-5s ", tmp);
6919         }
6920     }
6921   printf ("\n");
6922 }
6923
6924 #define GET(VAR, N)     SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
6925
6926 static unsigned char *
6927 read_cie (unsigned char *start, unsigned char *end,
6928           Frame_Chunk **p_cie, int *p_version,
6929           unsigned long *p_aug_len, unsigned char **p_aug)
6930 {
6931   int version;
6932   Frame_Chunk *fc;
6933   unsigned int length_return;
6934   unsigned char *augmentation_data = NULL;
6935   unsigned long augmentation_data_len = 0;
6936
6937   * p_cie = NULL;
6938   /* PR 17512: file: 001-228113-0.004.  */
6939   if (start >= end)
6940     return end;
6941
6942   fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6943   memset (fc, 0, sizeof (Frame_Chunk));
6944
6945   fc->col_type = (short int *) xmalloc (sizeof (short int));
6946   fc->col_offset = (int *) xmalloc (sizeof (int));
6947
6948   version = *start++;
6949
6950   fc->augmentation = (char *) start;
6951   /* PR 17512: file: 001-228113-0.004.
6952      Skip past augmentation name, but avoid running off the end of the data.  */
6953   while (start < end)
6954     if (* start ++ == '\0')
6955       break;
6956   if (start == end)
6957     {
6958       warn (_("No terminator for augmentation name\n"));
6959       return start;
6960     }
6961
6962   if (strcmp (fc->augmentation, "eh") == 0)
6963     start += eh_addr_size;
6964
6965   if (version >= 4)
6966     {
6967       GET (fc->ptr_size, 1);
6968       if (fc->ptr_size < 1 || fc->ptr_size > 8)
6969         {
6970           warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
6971           return end;
6972         }
6973
6974       GET (fc->segment_size, 1);
6975       /* PR 17512: file: e99d2804.  */
6976       if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
6977         {
6978           warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
6979           return end;
6980         }
6981
6982       eh_addr_size = fc->ptr_size;
6983     }
6984   else
6985     {
6986       fc->ptr_size = eh_addr_size;
6987       fc->segment_size = 0;
6988     }
6989   READ_ULEB (fc->code_factor);
6990   READ_SLEB (fc->data_factor);
6991   if (version == 1)
6992     {
6993       GET (fc->ra, 1);
6994     }
6995   else
6996     {
6997       READ_ULEB (fc->ra);
6998     }
6999
7000   if (fc->augmentation[0] == 'z')
7001     {
7002       READ_ULEB (augmentation_data_len);
7003       augmentation_data = start;
7004       /* PR 17512: file: 11042-2589-0.004.  */
7005       if (augmentation_data_len > (size_t) (end - start))
7006         {
7007           warn (_("Augmentation data too long: %#lx, expected at most %#lx\n"),
7008                 augmentation_data_len, (unsigned long) (end - start));
7009           return end;
7010         }
7011       start += augmentation_data_len;
7012     }
7013
7014   if (augmentation_data_len)
7015     {
7016       unsigned char *p;
7017       unsigned char *q;
7018       unsigned char *qend;
7019
7020       p = (unsigned char *) fc->augmentation + 1;
7021       q = augmentation_data;
7022       qend = q + augmentation_data_len;
7023
7024       while (p < end && q < qend)
7025         {
7026           if (*p == 'L')
7027             q++;
7028           else if (*p == 'P')
7029             q += 1 + size_of_encoded_value (*q);
7030           else if (*p == 'R')
7031             fc->fde_encoding = *q++;
7032           else if (*p == 'S')
7033             ;
7034           else
7035             break;
7036           p++;
7037         }
7038       /* Note - it is OK if this loop terminates with q < qend.
7039          Padding may have been inserted to align the end of the CIE.  */
7040     }
7041
7042   *p_cie = fc;
7043   if (p_version)
7044     *p_version = version;
7045   if (p_aug_len)
7046     {
7047       *p_aug_len = augmentation_data_len;
7048       *p_aug = augmentation_data;
7049     }
7050   return start;
7051 }
7052
7053 static int
7054 display_debug_frames (struct dwarf_section *section,
7055                       void *file ATTRIBUTE_UNUSED)
7056 {
7057   unsigned char *start = section->start;
7058   unsigned char *end = start + section->size;
7059   unsigned char *section_start = start;
7060   Frame_Chunk *chunks = 0, *forward_refs = 0;
7061   Frame_Chunk *remembered_state = 0;
7062   Frame_Chunk *rs;
7063   int is_eh = strcmp (section->name, ".eh_frame") == 0;
7064   unsigned int length_return;
7065   unsigned int max_regs = 0;
7066   const char *bad_reg = _("bad register: ");
7067   unsigned int saved_eh_addr_size = eh_addr_size;
7068
7069   printf (_("Contents of the %s section:\n"), section->name);
7070
7071   while (start < end)
7072     {
7073       unsigned char *saved_start;
7074       unsigned char *block_end;
7075       dwarf_vma length;
7076       dwarf_vma cie_id;
7077       Frame_Chunk *fc;
7078       Frame_Chunk *cie;
7079       int need_col_headers = 1;
7080       unsigned char *augmentation_data = NULL;
7081       unsigned long augmentation_data_len = 0;
7082       unsigned int encoded_ptr_size = saved_eh_addr_size;
7083       unsigned int offset_size;
7084       unsigned int initial_length_size;
7085       bfd_boolean all_nops;
7086
7087       saved_start = start;
7088
7089       SAFE_BYTE_GET_AND_INC (length, start, 4, end);
7090
7091       if (length == 0)
7092         {
7093           printf ("\n%08lx ZERO terminator\n\n",
7094                     (unsigned long)(saved_start - section_start));
7095           /* Skip any zero terminators that directly follow.
7096              A corrupt section size could have loaded a whole
7097              slew of zero filled memory bytes.  eg
7098              PR 17512: file: 070-19381-0.004.  */
7099           while (start < end && * start == 0)
7100             ++ start;
7101           continue;
7102         }
7103
7104       if (length == 0xffffffff)
7105         {
7106           SAFE_BYTE_GET_AND_INC (length, start, 8, end);
7107           offset_size = 8;
7108           initial_length_size = 12;
7109         }
7110       else
7111         {
7112           offset_size = 4;
7113           initial_length_size = 4;
7114         }
7115
7116       block_end = saved_start + length + initial_length_size;
7117       if (block_end > end || block_end < start)
7118         {
7119           warn ("Invalid length 0x%s in FDE at %#08lx\n",
7120                 dwarf_vmatoa_1 (NULL, length, offset_size),
7121                 (unsigned long) (saved_start - section_start));
7122           block_end = end;
7123         }
7124
7125       SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
7126
7127       if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
7128                                    || (offset_size == 8 && cie_id == DW64_CIE_ID)))
7129         {
7130           int version;
7131           unsigned int mreg;
7132
7133           start = read_cie (start, end, &cie, &version,
7134                             &augmentation_data_len, &augmentation_data);
7135           /* PR 17512: file: 027-135133-0.005.  */
7136           if (cie == NULL)
7137             break;
7138
7139           fc = cie;
7140           fc->next = chunks;
7141           chunks = fc;
7142           fc->chunk_start = saved_start;
7143           mreg = max_regs > 0 ? max_regs - 1 : 0;
7144           if (mreg < fc->ra)
7145             mreg = fc->ra;
7146           if (frame_need_space (fc, mreg) < 0)
7147             break;
7148           if (fc->fde_encoding)
7149             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7150
7151           printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
7152           print_dwarf_vma (length, fc->ptr_size);
7153           print_dwarf_vma (cie_id, offset_size);
7154
7155           if (do_debug_frames_interp)
7156             {
7157               printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
7158                       fc->code_factor, fc->data_factor, fc->ra);
7159             }
7160           else
7161             {
7162               printf ("CIE\n");
7163               printf ("  Version:               %d\n", version);
7164               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
7165               if (version >= 4)
7166                 {
7167                   printf ("  Pointer Size:          %u\n", fc->ptr_size);
7168                   printf ("  Segment Size:          %u\n", fc->segment_size);
7169                 }
7170               printf ("  Code alignment factor: %u\n", fc->code_factor);
7171               printf ("  Data alignment factor: %d\n", fc->data_factor);
7172               printf ("  Return address column: %d\n", fc->ra);
7173
7174               if (augmentation_data_len)
7175                 {
7176                   unsigned long i;
7177
7178                   printf ("  Augmentation data:    ");
7179                   for (i = 0; i < augmentation_data_len; ++i)
7180                     /* FIXME: If do_wide is FALSE, then we should
7181                        add carriage returns at 80 columns...  */
7182                     printf (" %02x", augmentation_data[i]);
7183                   putchar ('\n');
7184                 }
7185               putchar ('\n');
7186             }
7187         }
7188       else
7189         {
7190           unsigned char *look_for;
7191           static Frame_Chunk fde_fc;
7192           unsigned long segment_selector;
7193
7194           if (is_eh)
7195             {
7196               dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
7197               look_for = start - 4 - ((cie_id ^ sign) - sign);
7198             }
7199           else
7200             look_for = section_start + cie_id;
7201
7202           if (look_for <= saved_start)
7203             {
7204               for (cie = chunks; cie ; cie = cie->next)
7205                 if (cie->chunk_start == look_for)
7206                   break;
7207             }
7208           else
7209             {
7210               for (cie = forward_refs; cie ; cie = cie->next)
7211                 if (cie->chunk_start == look_for)
7212                   break;
7213               if (!cie)
7214                 {
7215                   unsigned int off_size;
7216                   unsigned char *cie_scan;
7217
7218                   cie_scan = look_for;
7219                   off_size = 4;
7220                   SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
7221                   if (length == 0xffffffff)
7222                     {
7223                       SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
7224                       off_size = 8;
7225                     }
7226                   if (length != 0)
7227                     {
7228                       dwarf_vma c_id;
7229
7230                       SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
7231                       if (is_eh
7232                           ? c_id == 0
7233                           : ((off_size == 4 && c_id == DW_CIE_ID)
7234                              || (off_size == 8 && c_id == DW64_CIE_ID)))
7235                         {
7236                           int version;
7237                           unsigned int mreg;
7238
7239                           read_cie (cie_scan, end, &cie, &version,
7240                                     &augmentation_data_len, &augmentation_data);
7241                           /* PR 17512: file: 3450-2098-0.004.  */
7242                           if (cie == NULL)
7243                             {
7244                               warn (_("Failed to read CIE information\n"));
7245                               break;
7246                             }
7247                           cie->next = forward_refs;
7248                           forward_refs = cie;
7249                           cie->chunk_start = look_for;
7250                           mreg = max_regs > 0 ? max_regs - 1 : 0;
7251                           if (mreg < cie->ra)
7252                             mreg = cie->ra;
7253                           if (frame_need_space (cie, mreg) < 0)
7254                             {
7255                               warn (_("Invalid max register\n"));
7256                               break;
7257                             }
7258                           if (cie->fde_encoding)
7259                             encoded_ptr_size
7260                               = size_of_encoded_value (cie->fde_encoding);
7261                         }
7262                     }
7263                 }
7264             }
7265
7266           fc = &fde_fc;
7267           memset (fc, 0, sizeof (Frame_Chunk));
7268
7269           if (!cie)
7270             {
7271               warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7272                     dwarf_vmatoa_1 (NULL, cie_id, offset_size),
7273                     (unsigned long) (saved_start - section_start));
7274               fc->ncols = 0;
7275               fc->col_type = (short int *) xmalloc (sizeof (short int));
7276               fc->col_offset = (int *) xmalloc (sizeof (int));
7277               if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
7278                 {
7279                   warn (_("Invalid max register\n"));
7280                   break;
7281                 }
7282               cie = fc;
7283               fc->augmentation = "";
7284               fc->fde_encoding = 0;
7285               fc->ptr_size = eh_addr_size;
7286               fc->segment_size = 0;
7287             }
7288           else
7289             {
7290               fc->ncols = cie->ncols;
7291               fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
7292               fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
7293               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7294               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7295               fc->augmentation = cie->augmentation;
7296               fc->ptr_size = cie->ptr_size;
7297               eh_addr_size = cie->ptr_size;
7298               fc->segment_size = cie->segment_size;
7299               fc->code_factor = cie->code_factor;
7300               fc->data_factor = cie->data_factor;
7301               fc->cfa_reg = cie->cfa_reg;
7302               fc->cfa_offset = cie->cfa_offset;
7303               fc->ra = cie->ra;
7304               if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
7305                 {
7306                   warn (_("Invalid max register\n"));
7307                   break;
7308                 }
7309               fc->fde_encoding = cie->fde_encoding;
7310             }
7311
7312           if (fc->fde_encoding)
7313             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7314
7315           segment_selector = 0;
7316           if (fc->segment_size)
7317             {
7318               if (fc->segment_size > sizeof (segment_selector))
7319                 {
7320                   /* PR 17512: file: 9e196b3e.  */
7321                   warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
7322                   fc->segment_size = 4;
7323                 }
7324               SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
7325             }
7326
7327           fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
7328
7329           /* FIXME: It appears that sometimes the final pc_range value is
7330              encoded in less than encoded_ptr_size bytes.  See the x86_64
7331              run of the "objcopy on compressed debug sections" test for an
7332              example of this.  */
7333           SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
7334
7335           if (cie->augmentation[0] == 'z')
7336             {
7337               READ_ULEB (augmentation_data_len);
7338               augmentation_data = start;
7339               start += augmentation_data_len;
7340               /* PR 17512: file: 722-8446-0.004.  */
7341               if (start >= end || ((signed long) augmentation_data_len) < 0)
7342                 {
7343                   warn (_("Corrupt augmentation data length: %lx\n"),
7344                         augmentation_data_len);
7345                   start = end;
7346                   augmentation_data = NULL;
7347                   augmentation_data_len = 0;
7348                 }
7349             }
7350
7351           printf ("\n%08lx %s %s FDE cie=%08lx pc=",
7352                   (unsigned long)(saved_start - section_start),
7353                   dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
7354                   dwarf_vmatoa_1 (NULL, cie_id, offset_size),
7355                   (unsigned long)(cie->chunk_start - section_start));
7356
7357           if (fc->segment_size)
7358             printf ("%04lx:", segment_selector);
7359
7360           printf ("%s..%s\n",
7361                   dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
7362                   dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
7363
7364           if (! do_debug_frames_interp && augmentation_data_len)
7365             {
7366               unsigned long i;
7367
7368               printf ("  Augmentation data:    ");
7369               for (i = 0; i < augmentation_data_len; ++i)
7370                 printf (" %02x", augmentation_data[i]);
7371               putchar ('\n');
7372               putchar ('\n');
7373             }
7374         }
7375
7376       /* At this point, fc is the current chunk, cie (if any) is set, and
7377          we're about to interpret instructions for the chunk.  */
7378       /* ??? At present we need to do this always, since this sizes the
7379          fc->col_type and fc->col_offset arrays, which we write into always.
7380          We should probably split the interpreted and non-interpreted bits
7381          into two different routines, since there's so much that doesn't
7382          really overlap between them.  */
7383       if (1 || do_debug_frames_interp)
7384         {
7385           /* Start by making a pass over the chunk, allocating storage
7386              and taking note of what registers are used.  */
7387           unsigned char *tmp = start;
7388
7389           while (start < block_end)
7390             {
7391               unsigned int reg, op, opa;
7392               unsigned long temp;
7393               unsigned char * new_start;
7394
7395               op = *start++;
7396               opa = op & 0x3f;
7397               if (op & 0xc0)
7398                 op &= 0xc0;
7399
7400               /* Warning: if you add any more cases to this switch, be
7401                  sure to add them to the corresponding switch below.  */
7402               switch (op)
7403                 {
7404                 case DW_CFA_advance_loc:
7405                   break;
7406                 case DW_CFA_offset:
7407                   SKIP_ULEB ();
7408                   if (frame_need_space (fc, opa) >= 0)
7409                     fc->col_type[opa] = DW_CFA_undefined;
7410                   break;
7411                 case DW_CFA_restore:
7412                   if (frame_need_space (fc, opa) >= 0)
7413                     fc->col_type[opa] = DW_CFA_undefined;
7414                   break;
7415                 case DW_CFA_set_loc:
7416                   start += encoded_ptr_size;
7417                   break;
7418                 case DW_CFA_advance_loc1:
7419                   start += 1;
7420                   break;
7421                 case DW_CFA_advance_loc2:
7422                   start += 2;
7423                   break;
7424                 case DW_CFA_advance_loc4:
7425                   start += 4;
7426                   break;
7427                 case DW_CFA_offset_extended:
7428                 case DW_CFA_val_offset:
7429                   READ_ULEB (reg);
7430                   SKIP_ULEB ();
7431                   if (frame_need_space (fc, reg) >= 0)
7432                     fc->col_type[reg] = DW_CFA_undefined;
7433                   break;
7434                 case DW_CFA_restore_extended:
7435                   READ_ULEB (reg);
7436                   if (frame_need_space (fc, reg) >= 0)
7437                     fc->col_type[reg] = DW_CFA_undefined;
7438                   break;
7439                 case DW_CFA_undefined:
7440                   READ_ULEB (reg);
7441                   if (frame_need_space (fc, reg) >= 0)
7442                     fc->col_type[reg] = DW_CFA_undefined;
7443                   break;
7444                 case DW_CFA_same_value:
7445                   READ_ULEB (reg);
7446                   if (frame_need_space (fc, reg) >= 0)
7447                     fc->col_type[reg] = DW_CFA_undefined;
7448                   break;
7449                 case DW_CFA_register:
7450                   READ_ULEB (reg);
7451                   SKIP_ULEB ();
7452                   if (frame_need_space (fc, reg) >= 0)
7453                     fc->col_type[reg] = DW_CFA_undefined;
7454                   break;
7455                 case DW_CFA_def_cfa:
7456                   SKIP_ULEB ();
7457                   SKIP_ULEB ();
7458                   break;
7459                 case DW_CFA_def_cfa_register:
7460                   SKIP_ULEB ();
7461                   break;
7462                 case DW_CFA_def_cfa_offset:
7463                   SKIP_ULEB ();
7464                   break;
7465                 case DW_CFA_def_cfa_expression:
7466                   READ_ULEB (temp);
7467                   new_start = start + temp;
7468                   if (new_start < start)
7469                     {
7470                       warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
7471                       start = block_end;
7472                     }
7473                   else
7474                     start = new_start;
7475                   break;
7476                 case DW_CFA_expression:
7477                 case DW_CFA_val_expression:
7478                   READ_ULEB (reg);
7479                   READ_ULEB (temp);
7480                   new_start = start + temp;
7481                   if (new_start < start)
7482                     {
7483                       /* PR 17512: file:306-192417-0.005.  */
7484                       warn (_("Corrupt CFA expression value: %lu\n"), temp);
7485                       start = block_end;
7486                     }
7487                   else
7488                     start = new_start;
7489                   if (frame_need_space (fc, reg) >= 0)
7490                     fc->col_type[reg] = DW_CFA_undefined;
7491                   break;
7492                 case DW_CFA_offset_extended_sf:
7493                 case DW_CFA_val_offset_sf:
7494                   READ_ULEB (reg);
7495                   SKIP_SLEB ();
7496                   if (frame_need_space (fc, reg) >= 0)
7497                     fc->col_type[reg] = DW_CFA_undefined;
7498                   break;
7499                 case DW_CFA_def_cfa_sf:
7500                   SKIP_ULEB ();
7501                   SKIP_SLEB ();
7502                   break;
7503                 case DW_CFA_def_cfa_offset_sf:
7504                   SKIP_SLEB ();
7505                   break;
7506                 case DW_CFA_MIPS_advance_loc8:
7507                   start += 8;
7508                   break;
7509                 case DW_CFA_GNU_args_size:
7510                   SKIP_ULEB ();
7511                   break;
7512                 case DW_CFA_GNU_negative_offset_extended:
7513                   READ_ULEB (reg);
7514                   SKIP_ULEB ();
7515                   if (frame_need_space (fc, reg) >= 0)
7516                     fc->col_type[reg] = DW_CFA_undefined;
7517                   break;
7518                 default:
7519                   break;
7520                 }
7521             }
7522           start = tmp;
7523         }
7524
7525       all_nops = TRUE;
7526
7527       /* Now we know what registers are used, make a second pass over
7528          the chunk, this time actually printing out the info.  */
7529
7530       while (start < block_end)
7531         {
7532           unsigned char * tmp;
7533           unsigned op, opa;
7534           unsigned long ul, roffs;
7535           /* Note: It is tempting to use an unsigned long for 'reg' but there
7536              are various functions, notably frame_space_needed() that assume that
7537              reg is an unsigned int.  */
7538           unsigned int reg;
7539           dwarf_signed_vma l;
7540           dwarf_vma ofs;
7541           dwarf_vma vma;
7542           const char *reg_prefix = "";
7543
7544           op = *start++;
7545           opa = op & 0x3f;
7546           if (op & 0xc0)
7547             op &= 0xc0;
7548
7549           /* Make a note if something other than DW_CFA_nop happens.  */
7550           if (op != DW_CFA_nop)
7551             all_nops = FALSE;
7552
7553           /* Warning: if you add any more cases to this switch, be
7554              sure to add them to the corresponding switch above.  */
7555           switch (op)
7556             {
7557             case DW_CFA_advance_loc:
7558               if (do_debug_frames_interp)
7559                 frame_display_row (fc, &need_col_headers, &max_regs);
7560               else
7561                 printf ("  DW_CFA_advance_loc: %d to %s\n",
7562                         opa * fc->code_factor,
7563                         dwarf_vmatoa_1 (NULL,
7564                                         fc->pc_begin + opa * fc->code_factor,
7565                                         fc->ptr_size));
7566               fc->pc_begin += opa * fc->code_factor;
7567               break;
7568
7569             case DW_CFA_offset:
7570               READ_ULEB (roffs);
7571               if (opa >= (unsigned int) fc->ncols)
7572                 reg_prefix = bad_reg;
7573               if (! do_debug_frames_interp || *reg_prefix != '\0')
7574                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
7575                         reg_prefix, regname (opa, 0),
7576                         roffs * fc->data_factor);
7577               if (*reg_prefix == '\0')
7578                 {
7579                   fc->col_type[opa] = DW_CFA_offset;
7580                   fc->col_offset[opa] = roffs * fc->data_factor;
7581                 }
7582               break;
7583
7584             case DW_CFA_restore:
7585               if (opa >= (unsigned int) fc->ncols)
7586                 reg_prefix = bad_reg;
7587               if (! do_debug_frames_interp || *reg_prefix != '\0')
7588                 printf ("  DW_CFA_restore: %s%s\n",
7589                         reg_prefix, regname (opa, 0));
7590               if (*reg_prefix != '\0')
7591                 break;
7592
7593               if (opa >= (unsigned int) cie->ncols
7594                   || (do_debug_frames_interp
7595                       && cie->col_type[opa] == DW_CFA_unreferenced))
7596                 {
7597                   fc->col_type[opa] = DW_CFA_undefined;
7598                   fc->col_offset[opa] = 0;
7599                 }
7600               else
7601                 {
7602                   fc->col_type[opa] = cie->col_type[opa];
7603                   fc->col_offset[opa] = cie->col_offset[opa];
7604                 }
7605               break;
7606
7607             case DW_CFA_set_loc:
7608               vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
7609               if (do_debug_frames_interp)
7610                 frame_display_row (fc, &need_col_headers, &max_regs);
7611               else
7612                 printf ("  DW_CFA_set_loc: %s\n",
7613                         dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
7614               fc->pc_begin = vma;
7615               break;
7616
7617             case DW_CFA_advance_loc1:
7618               SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
7619               if (do_debug_frames_interp)
7620                 frame_display_row (fc, &need_col_headers, &max_regs);
7621               else
7622                 printf ("  DW_CFA_advance_loc1: %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_loc2:
7631               SAFE_BYTE_GET_AND_INC (ofs, start, 2, 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_loc2: %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_advance_loc4:
7644               SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
7645               if (do_debug_frames_interp)
7646                 frame_display_row (fc, &need_col_headers, &max_regs);
7647               else
7648                 printf ("  DW_CFA_advance_loc4: %ld to %s\n",
7649                         (unsigned long) (ofs * fc->code_factor),
7650                         dwarf_vmatoa_1 (NULL,
7651                                         fc->pc_begin + ofs * fc->code_factor,
7652                                         fc->ptr_size));
7653               fc->pc_begin += ofs * fc->code_factor;
7654               break;
7655
7656             case DW_CFA_offset_extended:
7657               READ_ULEB (reg);
7658               READ_ULEB (roffs);
7659               if (reg >= (unsigned int) fc->ncols)
7660                 reg_prefix = bad_reg;
7661               if (! do_debug_frames_interp || *reg_prefix != '\0')
7662                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
7663                         reg_prefix, regname (reg, 0),
7664                         roffs * fc->data_factor);
7665               if (*reg_prefix == '\0')
7666                 {
7667                   fc->col_type[reg] = DW_CFA_offset;
7668                   fc->col_offset[reg] = roffs * fc->data_factor;
7669                 }
7670               break;
7671
7672             case DW_CFA_val_offset:
7673               READ_ULEB (reg);
7674               READ_ULEB (roffs);
7675               if (reg >= (unsigned int) fc->ncols)
7676                 reg_prefix = bad_reg;
7677               if (! do_debug_frames_interp || *reg_prefix != '\0')
7678                 printf ("  DW_CFA_val_offset: %s%s is cfa%+ld\n",
7679                         reg_prefix, regname (reg, 0),
7680                         roffs * fc->data_factor);
7681               if (*reg_prefix == '\0')
7682                 {
7683                   fc->col_type[reg] = DW_CFA_val_offset;
7684                   fc->col_offset[reg] = roffs * fc->data_factor;
7685                 }
7686               break;
7687
7688             case DW_CFA_restore_extended:
7689               READ_ULEB (reg);
7690               if (reg >= (unsigned int) fc->ncols)
7691                 reg_prefix = bad_reg;
7692               if (! do_debug_frames_interp || *reg_prefix != '\0')
7693                 printf ("  DW_CFA_restore_extended: %s%s\n",
7694                         reg_prefix, regname (reg, 0));
7695               if (*reg_prefix != '\0')
7696                 break;
7697
7698               if (reg >= (unsigned int) cie->ncols)
7699                 {
7700                   fc->col_type[reg] = DW_CFA_undefined;
7701                   fc->col_offset[reg] = 0;
7702                 }
7703               else
7704                 {
7705                   fc->col_type[reg] = cie->col_type[reg];
7706                   fc->col_offset[reg] = cie->col_offset[reg];
7707                 }
7708               break;
7709
7710             case DW_CFA_undefined:
7711               READ_ULEB (reg);
7712               if (reg >= (unsigned int) fc->ncols)
7713                 reg_prefix = bad_reg;
7714               if (! do_debug_frames_interp || *reg_prefix != '\0')
7715                 printf ("  DW_CFA_undefined: %s%s\n",
7716                         reg_prefix, regname (reg, 0));
7717               if (*reg_prefix == '\0')
7718                 {
7719                   fc->col_type[reg] = DW_CFA_undefined;
7720                   fc->col_offset[reg] = 0;
7721                 }
7722               break;
7723
7724             case DW_CFA_same_value:
7725               READ_ULEB (reg);
7726               if (reg >= (unsigned int) fc->ncols)
7727                 reg_prefix = bad_reg;
7728               if (! do_debug_frames_interp || *reg_prefix != '\0')
7729                 printf ("  DW_CFA_same_value: %s%s\n",
7730                         reg_prefix, regname (reg, 0));
7731               if (*reg_prefix == '\0')
7732                 {
7733                   fc->col_type[reg] = DW_CFA_same_value;
7734                   fc->col_offset[reg] = 0;
7735                 }
7736               break;
7737
7738             case DW_CFA_register:
7739               READ_ULEB (reg);
7740               READ_ULEB (roffs);
7741               if (reg >= (unsigned int) fc->ncols)
7742                 reg_prefix = bad_reg;
7743               if (! do_debug_frames_interp || *reg_prefix != '\0')
7744                 {
7745                   printf ("  DW_CFA_register: %s%s in ",
7746                           reg_prefix, regname (reg, 0));
7747                   puts (regname (roffs, 0));
7748                 }
7749               if (*reg_prefix == '\0')
7750                 {
7751                   fc->col_type[reg] = DW_CFA_register;
7752                   fc->col_offset[reg] = roffs;
7753                 }
7754               break;
7755
7756             case DW_CFA_remember_state:
7757               if (! do_debug_frames_interp)
7758                 printf ("  DW_CFA_remember_state\n");
7759               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7760               rs->cfa_offset = fc->cfa_offset;
7761               rs->cfa_reg = fc->cfa_reg;
7762               rs->ra = fc->ra;
7763               rs->cfa_exp = fc->cfa_exp;
7764               rs->ncols = fc->ncols;
7765               rs->col_type = (short int *) xcmalloc (rs->ncols,
7766                                                      sizeof (* rs->col_type));
7767               rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
7768               memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
7769               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
7770               rs->next = remembered_state;
7771               remembered_state = rs;
7772               break;
7773
7774             case DW_CFA_restore_state:
7775               if (! do_debug_frames_interp)
7776                 printf ("  DW_CFA_restore_state\n");
7777               rs = remembered_state;
7778               if (rs)
7779                 {
7780                   remembered_state = rs->next;
7781                   fc->cfa_offset = rs->cfa_offset;
7782                   fc->cfa_reg = rs->cfa_reg;
7783                   fc->ra = rs->ra;
7784                   fc->cfa_exp = rs->cfa_exp;
7785                   if (frame_need_space (fc, rs->ncols - 1) < 0)
7786                     {
7787                       warn (_("Invalid column number in saved frame state\n"));
7788                       fc->ncols = 0;
7789                       break;
7790                     }
7791                   memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
7792                   memcpy (fc->col_offset, rs->col_offset,
7793                           rs->ncols * sizeof (* rs->col_offset));
7794                   free (rs->col_type);
7795                   free (rs->col_offset);
7796                   free (rs);
7797                 }
7798               else if (do_debug_frames_interp)
7799                 printf ("Mismatched DW_CFA_restore_state\n");
7800               break;
7801
7802             case DW_CFA_def_cfa:
7803               READ_SLEB (fc->cfa_reg);
7804               READ_ULEB (fc->cfa_offset);
7805               fc->cfa_exp = 0;
7806               if (! do_debug_frames_interp)
7807                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
7808                         regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
7809               break;
7810
7811             case DW_CFA_def_cfa_register:
7812               READ_SLEB (fc->cfa_reg);
7813               fc->cfa_exp = 0;
7814               if (! do_debug_frames_interp)
7815                 printf ("  DW_CFA_def_cfa_register: %s\n",
7816                         regname (fc->cfa_reg, 0));
7817               break;
7818
7819             case DW_CFA_def_cfa_offset:
7820               READ_ULEB (fc->cfa_offset);
7821               if (! do_debug_frames_interp)
7822                 printf ("  DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
7823               break;
7824
7825             case DW_CFA_nop:
7826               if (! do_debug_frames_interp)
7827                 printf ("  DW_CFA_nop\n");
7828               break;
7829
7830             case DW_CFA_def_cfa_expression:
7831               READ_ULEB (ul);
7832               if (start >= block_end || ul > (unsigned long) (block_end - start))
7833                 {
7834                   printf (_("  DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
7835                   break;
7836                 }
7837               if (! do_debug_frames_interp)
7838                 {
7839                   printf ("  DW_CFA_def_cfa_expression (");
7840                   decode_location_expression (start, eh_addr_size, 0, -1,
7841                                               ul, 0, section);
7842                   printf (")\n");
7843                 }
7844               fc->cfa_exp = 1;
7845               start += ul;
7846               break;
7847
7848             case DW_CFA_expression:
7849               READ_ULEB (reg);
7850               READ_ULEB (ul);
7851               if (reg >= (unsigned int) fc->ncols)
7852                 reg_prefix = bad_reg;
7853               /* PR 17512: file: 069-133014-0.006.  */
7854               /* PR 17512: file: 98c02eb4.  */
7855               tmp = start + ul;
7856               if (start >= block_end || tmp > block_end || tmp < start)
7857                 {
7858                   printf (_("  DW_CFA_expression: <corrupt len %lu>\n"), ul);
7859                   break;
7860                 }
7861               if (! do_debug_frames_interp || *reg_prefix != '\0')
7862                 {
7863                   printf ("  DW_CFA_expression: %s%s (",
7864                           reg_prefix, regname (reg, 0));
7865                   decode_location_expression (start, eh_addr_size, 0, -1,
7866                                               ul, 0, section);
7867                   printf (")\n");
7868                 }
7869               if (*reg_prefix == '\0')
7870                 fc->col_type[reg] = DW_CFA_expression;
7871               start = tmp;
7872               break;
7873
7874             case DW_CFA_val_expression:
7875               READ_ULEB (reg);
7876               READ_ULEB (ul);
7877               if (reg >= (unsigned int) fc->ncols)
7878                 reg_prefix = bad_reg;
7879               tmp = start + ul;
7880               if (start >= block_end || tmp > block_end || tmp < start)
7881                 {
7882                   printf ("  DW_CFA_val_expression: <corrupt len %lu>\n", ul);
7883                   break;
7884                 }
7885               if (! do_debug_frames_interp || *reg_prefix != '\0')
7886                 {
7887                   printf ("  DW_CFA_val_expression: %s%s (",
7888                           reg_prefix, regname (reg, 0));
7889                   decode_location_expression (start, eh_addr_size, 0, -1,
7890                                               ul, 0, section);
7891                   printf (")\n");
7892                 }
7893               if (*reg_prefix == '\0')
7894                 fc->col_type[reg] = DW_CFA_val_expression;
7895               start = tmp;
7896               break;
7897
7898             case DW_CFA_offset_extended_sf:
7899               READ_ULEB (reg);
7900               READ_SLEB (l);
7901               if (frame_need_space (fc, reg) < 0)
7902                 reg_prefix = bad_reg;
7903               if (! do_debug_frames_interp || *reg_prefix != '\0')
7904                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
7905                         reg_prefix, regname (reg, 0),
7906                         (long)(l * fc->data_factor));
7907               if (*reg_prefix == '\0')
7908                 {
7909                   fc->col_type[reg] = DW_CFA_offset;
7910                   fc->col_offset[reg] = l * fc->data_factor;
7911                 }
7912               break;
7913
7914             case DW_CFA_val_offset_sf:
7915               READ_ULEB (reg);
7916               READ_SLEB (l);
7917               if (frame_need_space (fc, reg) < 0)
7918                 reg_prefix = bad_reg;
7919               if (! do_debug_frames_interp || *reg_prefix != '\0')
7920                 printf ("  DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
7921                         reg_prefix, regname (reg, 0),
7922                         (long)(l * fc->data_factor));
7923               if (*reg_prefix == '\0')
7924                 {
7925                   fc->col_type[reg] = DW_CFA_val_offset;
7926                   fc->col_offset[reg] = l * fc->data_factor;
7927                 }
7928               break;
7929
7930             case DW_CFA_def_cfa_sf:
7931               READ_SLEB (fc->cfa_reg);
7932               READ_ULEB (fc->cfa_offset);
7933               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
7934               fc->cfa_exp = 0;
7935               if (! do_debug_frames_interp)
7936                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
7937                         regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
7938               break;
7939
7940             case DW_CFA_def_cfa_offset_sf:
7941               READ_ULEB (fc->cfa_offset);
7942               fc->cfa_offset *= fc->data_factor;
7943               if (! do_debug_frames_interp)
7944                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
7945               break;
7946
7947             case DW_CFA_MIPS_advance_loc8:
7948               SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
7949               if (do_debug_frames_interp)
7950                 frame_display_row (fc, &need_col_headers, &max_regs);
7951               else
7952                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %s\n",
7953                         (unsigned long) (ofs * fc->code_factor),
7954                         dwarf_vmatoa_1 (NULL,
7955                                         fc->pc_begin + ofs * fc->code_factor,
7956                                         fc->ptr_size));
7957               fc->pc_begin += ofs * fc->code_factor;
7958               break;
7959
7960             case DW_CFA_GNU_window_save:
7961               if (! do_debug_frames_interp)
7962                 printf ("  DW_CFA_GNU_window_save\n");
7963               break;
7964
7965             case DW_CFA_GNU_args_size:
7966               READ_ULEB (ul);
7967               if (! do_debug_frames_interp)
7968                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
7969               break;
7970
7971             case DW_CFA_GNU_negative_offset_extended:
7972               READ_ULEB (reg);
7973               READ_SLEB (l);
7974               l = - l;
7975               if (frame_need_space (fc, reg) < 0)
7976                 reg_prefix = bad_reg;
7977               if (! do_debug_frames_interp || *reg_prefix != '\0')
7978                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
7979                         reg_prefix, regname (reg, 0),
7980                         (long)(l * fc->data_factor));
7981               if (*reg_prefix == '\0')
7982                 {
7983                   fc->col_type[reg] = DW_CFA_offset;
7984                   fc->col_offset[reg] = l * fc->data_factor;
7985                 }
7986               break;
7987
7988             default:
7989               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
7990                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
7991               else
7992                 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
7993               start = block_end;
7994             }
7995         }
7996
7997       /* Interpret the CFA - as long as it is not completely full of NOPs.  */
7998       if (do_debug_frames_interp && ! all_nops)
7999         frame_display_row (fc, &need_col_headers, &max_regs);
8000
8001       start = block_end;
8002       eh_addr_size = saved_eh_addr_size;
8003     }
8004
8005   printf ("\n");
8006
8007   return 1;
8008 }
8009
8010 #undef GET
8011
8012 static int
8013 display_debug_names (struct dwarf_section *section, void *file)
8014 {
8015   unsigned char *hdrptr = section->start;
8016   dwarf_vma unit_length;
8017   unsigned char *unit_start;
8018   const unsigned char *const section_end = section->start + section->size;
8019   unsigned char *unit_end;
8020
8021   printf (_("Contents of the %s section:\n"), section->name);
8022
8023   load_debug_section (str, file);
8024
8025   for (; hdrptr < section_end; hdrptr = unit_end)
8026     {
8027       unsigned int offset_size;
8028       uint16_t dwarf_version, padding;
8029       uint32_t comp_unit_count, local_type_unit_count, foreign_type_unit_count;
8030       uint32_t bucket_count, name_count, abbrev_table_size;
8031       uint32_t augmentation_string_size;
8032       unsigned int i;
8033
8034       unit_start = hdrptr;
8035
8036       /* Get and check the length of the block.  */
8037       SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 4, section_end);
8038
8039       if (unit_length == 0xffffffff)
8040         {
8041           /* This section is 64-bit DWARF.  */
8042           SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 8, section_end);
8043           offset_size = 8;
8044         }
8045       else
8046         offset_size = 4;
8047       unit_end = hdrptr + unit_length;
8048
8049       if ((hdrptr - section->start) + unit_length > section->size)
8050         {
8051           warn (_("The length field (0x%lx) for unit 0x%lx in the debug_names "
8052                   "header is wrong - the section is too small\n"),
8053                 (long) unit_length, (long) (unit_start - section->start));
8054           return 0;
8055         }
8056
8057       /* Get and check the version number.  */
8058       SAFE_BYTE_GET_AND_INC (dwarf_version, hdrptr, 2, unit_end);
8059       printf (_("Version %ld\n"), (long) dwarf_version);
8060
8061       /* Prior versions did not exist, and future versions may not be
8062          backwards compatible.  */
8063       if (dwarf_version != 5)
8064         {
8065           warn (_("Only DWARF version 5 .debug_names "
8066                   "is currently supported.\n"));
8067           return 0;
8068         }
8069
8070       SAFE_BYTE_GET_AND_INC (padding, hdrptr, 2, unit_end);
8071       if (padding != 0)
8072         warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8073               padding);
8074
8075       SAFE_BYTE_GET_AND_INC (comp_unit_count, hdrptr, 4, unit_end);
8076       if (comp_unit_count == 0)
8077         warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8078
8079       SAFE_BYTE_GET_AND_INC (local_type_unit_count, hdrptr, 4, unit_end);
8080       SAFE_BYTE_GET_AND_INC (foreign_type_unit_count, hdrptr, 4, unit_end);
8081       SAFE_BYTE_GET_AND_INC (bucket_count, hdrptr, 4, unit_end);
8082       SAFE_BYTE_GET_AND_INC (name_count, hdrptr, 4, unit_end);
8083       SAFE_BYTE_GET_AND_INC (abbrev_table_size, hdrptr, 4, unit_end);
8084
8085       SAFE_BYTE_GET_AND_INC (augmentation_string_size, hdrptr, 4, unit_end);
8086       if (augmentation_string_size % 4 != 0)
8087         {
8088           warn (_("Augmentation string length %u must be rounded up "
8089                   "to a multiple of 4 in .debug_names.\n"),
8090                 augmentation_string_size);
8091           augmentation_string_size += (-augmentation_string_size) & 3;
8092         }
8093       printf (_("Augmentation string:"));
8094       for (i = 0; i < augmentation_string_size; i++)
8095         {
8096           unsigned char uc;
8097
8098           SAFE_BYTE_GET_AND_INC (uc, hdrptr, 1, unit_end);
8099           printf (" %02x", uc);
8100         }
8101       putchar ('\n');
8102       putchar ('\n');
8103
8104       printf (_("CU table:\n"));
8105       for (i = 0; i < comp_unit_count; i++)
8106         {
8107           uint64_t cu_offset;
8108
8109           SAFE_BYTE_GET_AND_INC (cu_offset, hdrptr, offset_size, unit_end);
8110           printf (_("[%3u] 0x%lx\n"), i, (unsigned long) cu_offset);
8111         }
8112       putchar ('\n');
8113
8114       printf (_("TU table:\n"));
8115       for (i = 0; i < local_type_unit_count; i++)
8116         {
8117           uint64_t tu_offset;
8118
8119           SAFE_BYTE_GET_AND_INC (tu_offset, hdrptr, offset_size, unit_end);
8120           printf (_("[%3u] 0x%lx\n"), i, (unsigned long) tu_offset);
8121         }
8122       putchar ('\n');
8123
8124       printf (_("Foreign TU table:\n"));
8125       for (i = 0; i < foreign_type_unit_count; i++)
8126         {
8127           uint64_t signature;
8128
8129           SAFE_BYTE_GET_AND_INC (signature, hdrptr, 8, unit_end);
8130           printf (_("[%3u] "), i);
8131           print_dwarf_vma (signature, 8);
8132           putchar ('\n');
8133         }
8134       putchar ('\n');
8135
8136       const uint32_t *const hash_table_buckets = (uint32_t *) hdrptr;
8137       hdrptr += bucket_count * sizeof (uint32_t);
8138       const uint32_t *const hash_table_hashes = (uint32_t *) hdrptr;
8139       hdrptr += name_count * sizeof (uint32_t);
8140       unsigned char *const name_table_string_offsets = hdrptr;
8141       hdrptr += name_count * offset_size;
8142       unsigned char *const name_table_entry_offsets = hdrptr;
8143       hdrptr += name_count * offset_size;
8144       unsigned char *const abbrev_table = hdrptr;
8145       hdrptr += abbrev_table_size;
8146       const unsigned char *const abbrev_table_end = hdrptr;
8147       unsigned char *const entry_pool = hdrptr;
8148       if (hdrptr > unit_end)
8149         {
8150           warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8151                   "for unit 0x%lx in the debug_names\n"),
8152                 (long) (hdrptr - section->start),
8153                 (long) (unit_end - section->start),
8154                 (long) (unit_start - section->start));
8155           return 0;
8156         }
8157
8158       size_t buckets_filled = 0;
8159       size_t bucketi;
8160       for (bucketi = 0; bucketi < bucket_count; bucketi++)
8161         {
8162           const uint32_t bucket = hash_table_buckets[bucketi];
8163
8164           if (bucket != 0)
8165             ++buckets_filled;
8166         }
8167       printf (_("Used %zu of %lu buckets.\n"), buckets_filled,
8168               (unsigned long) bucket_count);
8169
8170       uint32_t hash_prev = 0;
8171       size_t hash_clash_count = 0;
8172       size_t longest_clash = 0;
8173       size_t this_length = 0;
8174       size_t hashi;
8175       for (hashi = 0; hashi < name_count; hashi++)
8176         {
8177           const uint32_t hash_this = hash_table_hashes[hashi];
8178
8179           if (hashi > 0)
8180             {
8181               if (hash_prev % bucket_count == hash_this % bucket_count)
8182                 {
8183                   ++hash_clash_count;
8184                   ++this_length;
8185                   longest_clash = MAX (longest_clash, this_length);
8186                 }
8187               else
8188                 this_length = 0;
8189             }
8190           hash_prev = hash_this;
8191         }
8192       printf (_("Out of %lu items there are %zu bucket clashes"
8193                 " (longest of %zu entries).\n"),
8194               (unsigned long) name_count, hash_clash_count, longest_clash);
8195       assert (name_count == buckets_filled + hash_clash_count);
8196
8197       struct abbrev_lookup_entry
8198       {
8199         dwarf_vma abbrev_tag;
8200         unsigned char *abbrev_lookup_ptr;
8201       };
8202       struct abbrev_lookup_entry *abbrev_lookup = NULL;
8203       size_t abbrev_lookup_used = 0;
8204       size_t abbrev_lookup_allocated = 0;
8205
8206       unsigned char *abbrevptr = abbrev_table;
8207       for (;;)
8208         {
8209           unsigned int bytes_read;
8210           const dwarf_vma abbrev_tag = read_uleb128 (abbrevptr, &bytes_read,
8211                                                      abbrev_table_end);
8212           abbrevptr += bytes_read;
8213           if (abbrev_tag == 0)
8214             break;
8215           if (abbrev_lookup_used == abbrev_lookup_allocated)
8216             {
8217               abbrev_lookup_allocated = MAX (0x100,
8218                                              abbrev_lookup_allocated * 2);
8219               abbrev_lookup = xrealloc (abbrev_lookup,
8220                                         (abbrev_lookup_allocated
8221                                          * sizeof (*abbrev_lookup)));
8222             }
8223           assert (abbrev_lookup_used < abbrev_lookup_allocated);
8224           struct abbrev_lookup_entry *entry;
8225           for (entry = abbrev_lookup;
8226                entry < abbrev_lookup + abbrev_lookup_used;
8227                entry++)
8228             if (entry->abbrev_tag == abbrev_tag)
8229               {
8230                 warn (_("Duplicate abbreviation tag %lu "
8231                         "in unit 0x%lx in the debug_names\n"),
8232                       (long) abbrev_tag, (long) (unit_start - section->start));
8233                 break;
8234               }
8235           entry = &abbrev_lookup[abbrev_lookup_used++];
8236           entry->abbrev_tag = abbrev_tag;
8237           entry->abbrev_lookup_ptr = abbrevptr;
8238
8239           /* Skip DWARF tag.  */
8240           read_uleb128 (abbrevptr, &bytes_read, abbrev_table_end);
8241           abbrevptr += bytes_read;
8242           for (;;)
8243             {
8244               const dwarf_vma xindex = read_uleb128 (abbrevptr,
8245                                                      &bytes_read,
8246                                                      abbrev_table_end);
8247               abbrevptr += bytes_read;
8248               const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read,
8249                                                    abbrev_table_end);
8250               abbrevptr += bytes_read;
8251               if (xindex == 0 && form == 0)
8252                 break;
8253             }
8254         }
8255
8256       printf (_("\nSymbol table:\n"));
8257       uint32_t namei;
8258       for (namei = 0; namei < name_count; ++namei)
8259         {
8260           uint64_t string_offset, entry_offset;
8261
8262           SAFE_BYTE_GET (string_offset,
8263                          name_table_string_offsets + namei * offset_size,
8264                          offset_size, unit_end);
8265           SAFE_BYTE_GET (entry_offset,
8266                          name_table_entry_offsets + namei * offset_size,
8267                          offset_size, unit_end);
8268
8269           printf ("[%3u] #%08x %s:", namei, hash_table_hashes[namei],
8270                   fetch_indirect_string (string_offset));
8271
8272           unsigned char *entryptr = entry_pool + entry_offset;
8273
8274           // We need to scan first whether there is a single or multiple
8275           // entries.  TAGNO is -2 for the first entry, it is -1 for the
8276           // initial tag read of the second entry, then it becomes 0 for the
8277           // first entry for real printing etc.
8278           int tagno = -2;
8279           /* Initialize it due to a false compiler warning.  */
8280           dwarf_vma second_abbrev_tag = -1;
8281           for (;;)
8282             {
8283               unsigned int bytes_read;
8284               const dwarf_vma abbrev_tag = read_uleb128 (entryptr, &bytes_read,
8285                                                          unit_end);
8286               entryptr += bytes_read;
8287               if (tagno == -1)
8288                 {
8289                   second_abbrev_tag = abbrev_tag;
8290                   tagno = 0;
8291                   entryptr = entry_pool + entry_offset;
8292                   continue;
8293                 }
8294               if (abbrev_tag == 0)
8295                 break;
8296               if (tagno >= 0)
8297                 printf ("%s<%lu>",
8298                         (tagno == 0 && second_abbrev_tag == 0 ? " " : "\n\t"),
8299                         (unsigned long) abbrev_tag);
8300
8301               const struct abbrev_lookup_entry *entry;
8302               for (entry = abbrev_lookup;
8303                    entry < abbrev_lookup + abbrev_lookup_used;
8304                    entry++)
8305                 if (entry->abbrev_tag == abbrev_tag)
8306                   break;
8307               if (entry >= abbrev_lookup + abbrev_lookup_used)
8308                 {
8309                   warn (_("Undefined abbreviation tag %lu "
8310                           "in unit 0x%lx in the debug_names\n"),
8311                         (long) abbrev_tag,
8312                         (long) (unit_start - section->start));
8313                   break;
8314                 }
8315               abbrevptr = entry->abbrev_lookup_ptr;
8316               const dwarf_vma dwarf_tag = read_uleb128 (abbrevptr, &bytes_read,
8317                                                         abbrev_table_end);
8318               abbrevptr += bytes_read;
8319               if (tagno >= 0)
8320                 printf (" %s", get_TAG_name (dwarf_tag));
8321               for (;;)
8322                 {
8323                   const dwarf_vma xindex = read_uleb128 (abbrevptr,
8324                                                          &bytes_read,
8325                                                          abbrev_table_end);
8326                   abbrevptr += bytes_read;
8327                   const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read,
8328                                                        abbrev_table_end);
8329                   abbrevptr += bytes_read;
8330                   if (xindex == 0 && form == 0)
8331                     break;
8332
8333                   if (tagno >= 0)
8334                     printf (" %s", get_IDX_name (xindex));
8335                   entryptr = read_and_display_attr_value (0, form, 0, entryptr,
8336                                                           unit_end, 0, 0,
8337                                                           offset_size,
8338                                                           dwarf_version, NULL,
8339                                                           (tagno < 0), NULL,
8340                                                           NULL, '=');
8341                 }
8342               ++tagno;
8343             }
8344           if (tagno <= 0)
8345             printf (_(" <no entries>"));
8346           putchar ('\n');
8347         }
8348
8349       free (abbrev_lookup);
8350     }
8351
8352   return 1;
8353 }
8354
8355 static int
8356 display_gdb_index (struct dwarf_section *section,
8357                    void *file ATTRIBUTE_UNUSED)
8358 {
8359   unsigned char *start = section->start;
8360   uint32_t version;
8361   uint32_t cu_list_offset, tu_list_offset;
8362   uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
8363   unsigned int cu_list_elements, tu_list_elements;
8364   unsigned int address_table_size, symbol_table_slots;
8365   unsigned char *cu_list, *tu_list;
8366   unsigned char *address_table, *symbol_table, *constant_pool;
8367   unsigned int i;
8368
8369   /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
8370
8371   printf (_("Contents of the %s section:\n"), section->name);
8372
8373   if (section->size < 6 * sizeof (uint32_t))
8374     {
8375       warn (_("Truncated header in the %s section.\n"), section->name);
8376       return 0;
8377     }
8378
8379   version = byte_get_little_endian (start, 4);
8380   printf (_("Version %ld\n"), (long) version);
8381
8382   /* Prior versions are obsolete, and future versions may not be
8383      backwards compatible.  */
8384   if (version < 3 || version > 8)
8385     {
8386       warn (_("Unsupported version %lu.\n"), (unsigned long) version);
8387       return 0;
8388     }
8389   if (version < 4)
8390     warn (_("The address table data in version 3 may be wrong.\n"));
8391   if (version < 5)
8392     warn (_("Version 4 does not support case insensitive lookups.\n"));
8393   if (version < 6)
8394     warn (_("Version 5 does not include inlined functions.\n"));
8395   if (version < 7)
8396       warn (_("Version 6 does not include symbol attributes.\n"));
8397   /* Version 7 indices generated by Gold have bad type unit references,
8398      PR binutils/15021.  But we don't know if the index was generated by
8399      Gold or not, so to avoid worrying users with gdb-generated indices
8400      we say nothing for version 7 here.  */
8401
8402   cu_list_offset = byte_get_little_endian (start + 4, 4);
8403   tu_list_offset = byte_get_little_endian (start + 8, 4);
8404   address_table_offset = byte_get_little_endian (start + 12, 4);
8405   symbol_table_offset = byte_get_little_endian (start + 16, 4);
8406   constant_pool_offset = byte_get_little_endian (start + 20, 4);
8407
8408   if (cu_list_offset > section->size
8409       || tu_list_offset > section->size
8410       || address_table_offset > section->size
8411       || symbol_table_offset > section->size
8412       || constant_pool_offset > section->size)
8413     {
8414       warn (_("Corrupt header in the %s section.\n"), section->name);
8415       return 0;
8416     }
8417
8418   /* PR 17531: file: 418d0a8a.  */
8419   if (tu_list_offset < cu_list_offset)
8420     {
8421       warn (_("TU offset (%x) is less than CU offset (%x)\n"),
8422             tu_list_offset, cu_list_offset);
8423       return 0;
8424     }
8425
8426   cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
8427
8428   if (address_table_offset < tu_list_offset)
8429     {
8430       warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
8431             address_table_offset, tu_list_offset);
8432       return 0;
8433     }
8434
8435   tu_list_elements = (address_table_offset - tu_list_offset) / 8;
8436
8437   /* PR 17531: file: 18a47d3d.  */
8438   if (symbol_table_offset < address_table_offset)
8439     {
8440       warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
8441             symbol_table_offset, address_table_offset);
8442       return 0;
8443     }
8444
8445   address_table_size = symbol_table_offset - address_table_offset;
8446
8447   if (constant_pool_offset < symbol_table_offset)
8448     {
8449       warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
8450             constant_pool_offset, symbol_table_offset);
8451       return 0;
8452     }
8453
8454   symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
8455
8456   cu_list = start + cu_list_offset;
8457   tu_list = start + tu_list_offset;
8458   address_table = start + address_table_offset;
8459   symbol_table = start + symbol_table_offset;
8460   constant_pool = start + constant_pool_offset;
8461
8462   if (address_table + address_table_size > section->start + section->size)
8463     {
8464       warn (_("Address table extends beyond end of section.\n"));
8465       return 0;
8466     }
8467
8468   printf (_("\nCU table:\n"));
8469   for (i = 0; i < cu_list_elements; i += 2)
8470     {
8471       uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
8472       uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
8473
8474       printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
8475               (unsigned long) cu_offset,
8476               (unsigned long) (cu_offset + cu_length - 1));
8477     }
8478
8479   printf (_("\nTU table:\n"));
8480   for (i = 0; i < tu_list_elements; i += 3)
8481     {
8482       uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
8483       uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
8484       uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
8485
8486       printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
8487               (unsigned long) tu_offset,
8488               (unsigned long) type_offset);
8489       print_dwarf_vma (signature, 8);
8490       printf ("\n");
8491     }
8492
8493   printf (_("\nAddress table:\n"));
8494   for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
8495        i += 2 * 8 + 4)
8496     {
8497       uint64_t low = byte_get_little_endian (address_table + i, 8);
8498       uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
8499       uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
8500
8501       print_dwarf_vma (low, 8);
8502       print_dwarf_vma (high, 8);
8503       printf (_("%lu\n"), (unsigned long) cu_index);
8504     }
8505
8506   printf (_("\nSymbol table:\n"));
8507   for (i = 0; i < symbol_table_slots; ++i)
8508     {
8509       uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
8510       uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
8511       uint32_t num_cus, cu;
8512
8513       if (name_offset != 0
8514           || cu_vector_offset != 0)
8515         {
8516           unsigned int j;
8517           unsigned char * adr;
8518
8519           adr = constant_pool + name_offset;
8520           /* PR 17531: file: 5b7b07ad.  */
8521           if (adr < constant_pool || adr >= section->start + section->size)
8522             {
8523               printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
8524               warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
8525                     name_offset, i);
8526             }
8527           else
8528             printf ("[%3u] %.*s:", i,
8529                     (int) (section->size - (constant_pool_offset + name_offset)),
8530                     constant_pool + name_offset);
8531
8532           adr = constant_pool + cu_vector_offset;
8533           if (adr < constant_pool || adr >= section->start + section->size - 3)
8534             {
8535               printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
8536               warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
8537                     cu_vector_offset, i);
8538               continue;
8539             }
8540
8541           num_cus = byte_get_little_endian (adr, 4);
8542
8543           adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
8544           if (num_cus * 4 < num_cus
8545               || adr >= section->start + section->size
8546               || adr < constant_pool)
8547             {
8548               printf ("<invalid number of CUs: %d>\n", num_cus);
8549               warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
8550                     num_cus, i);
8551               continue;
8552             }
8553
8554           if (num_cus > 1)
8555             printf ("\n");
8556
8557           for (j = 0; j < num_cus; ++j)
8558             {
8559               int is_static;
8560               gdb_index_symbol_kind kind;
8561
8562               cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
8563               is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
8564               kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
8565               cu = GDB_INDEX_CU_VALUE (cu);
8566               /* Convert to TU number if it's for a type unit.  */
8567               if (cu >= cu_list_elements / 2)
8568                 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
8569                         (unsigned long) (cu - cu_list_elements / 2));
8570               else
8571                 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
8572
8573               printf (" [%s, %s]",
8574                       is_static ? _("static") : _("global"),
8575                       get_gdb_index_symbol_kind_name (kind));
8576               if (num_cus > 1)
8577                 printf ("\n");
8578             }
8579           if (num_cus <= 1)
8580             printf ("\n");
8581         }
8582     }
8583
8584   return 1;
8585 }
8586
8587 /* Pre-allocate enough space for the CU/TU sets needed.  */
8588
8589 static void
8590 prealloc_cu_tu_list (unsigned int nshndx)
8591 {
8592   if (shndx_pool == NULL)
8593     {
8594       shndx_pool_size = nshndx;
8595       shndx_pool_used = 0;
8596       shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
8597                                               sizeof (unsigned int));
8598     }
8599   else
8600     {
8601       shndx_pool_size = shndx_pool_used + nshndx;
8602       shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
8603                                                sizeof (unsigned int));
8604     }
8605 }
8606
8607 static void
8608 add_shndx_to_cu_tu_entry (unsigned int shndx)
8609 {
8610   if (shndx_pool_used >= shndx_pool_size)
8611     {
8612       error (_("Internal error: out of space in the shndx pool.\n"));
8613       return;
8614     }
8615   shndx_pool [shndx_pool_used++] = shndx;
8616 }
8617
8618 static void
8619 end_cu_tu_entry (void)
8620 {
8621   if (shndx_pool_used >= shndx_pool_size)
8622     {
8623       error (_("Internal error: out of space in the shndx pool.\n"));
8624       return;
8625     }
8626   shndx_pool [shndx_pool_used++] = 0;
8627 }
8628
8629 /* Return the short name of a DWARF section given by a DW_SECT enumerator.  */
8630
8631 static const char *
8632 get_DW_SECT_short_name (unsigned int dw_sect)
8633 {
8634   static char buf[16];
8635
8636   switch (dw_sect)
8637     {
8638       case DW_SECT_INFO:
8639         return "info";
8640       case DW_SECT_TYPES:
8641         return "types";
8642       case DW_SECT_ABBREV:
8643         return "abbrev";
8644       case DW_SECT_LINE:
8645         return "line";
8646       case DW_SECT_LOC:
8647         return "loc";
8648       case DW_SECT_STR_OFFSETS:
8649         return "str_off";
8650       case DW_SECT_MACINFO:
8651         return "macinfo";
8652       case DW_SECT_MACRO:
8653         return "macro";
8654       default:
8655         break;
8656     }
8657
8658   snprintf (buf, sizeof (buf), "%d", dw_sect);
8659   return buf;
8660 }
8661
8662 /* Process a CU or TU index.  If DO_DISPLAY is true, print the contents.
8663    These sections are extensions for Fission.
8664    See http://gcc.gnu.org/wiki/DebugFissionDWP.  */
8665
8666 static int
8667 process_cu_tu_index (struct dwarf_section *section, int do_display)
8668 {
8669   unsigned char *phdr = section->start;
8670   unsigned char *limit = phdr + section->size;
8671   unsigned char *phash;
8672   unsigned char *pindex;
8673   unsigned char *ppool;
8674   unsigned int version;
8675   unsigned int ncols = 0;
8676   unsigned int nused;
8677   unsigned int nslots;
8678   unsigned int i;
8679   unsigned int j;
8680   dwarf_vma signature_high;
8681   dwarf_vma signature_low;
8682   char buf[64];
8683
8684   /* PR 17512: file: 002-168123-0.004.  */
8685   if (phdr == NULL)
8686     {
8687       warn (_("Section %s is empty\n"), section->name);
8688       return 0;
8689     }
8690   /* PR 17512: file: 002-376-0.004.  */
8691   if (section->size < 24)
8692     {
8693       warn (_("Section %s is too small to contain a CU/TU header\n"),
8694             section->name);
8695       return 0;
8696     }
8697
8698   SAFE_BYTE_GET (version, phdr, 4, limit);
8699   if (version >= 2)
8700     SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
8701   SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
8702   SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
8703
8704   phash = phdr + 16;
8705   pindex = phash + nslots * 8;
8706   ppool = pindex + nslots * 4;
8707
8708   /* PR 17531: file: 45d69832.  */
8709   if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
8710     {
8711       warn (_("Section %s is too small for %d slots\n"),
8712             section->name, nslots);
8713       return 0;
8714     }
8715
8716   if (do_display)
8717     {
8718       printf (_("Contents of the %s section:\n\n"), section->name);
8719       printf (_("  Version:                 %d\n"), version);
8720       if (version >= 2)
8721         printf (_("  Number of columns:       %d\n"), ncols);
8722       printf (_("  Number of used entries:  %d\n"), nused);
8723       printf (_("  Number of slots:         %d\n\n"), nslots);
8724     }
8725
8726   if (ppool > limit || ppool < phdr)
8727     {
8728       warn (_("Section %s too small for %d hash table entries\n"),
8729             section->name, nslots);
8730       return 0;
8731     }
8732
8733   if (version == 1)
8734     {
8735       if (!do_display)
8736         prealloc_cu_tu_list ((limit - ppool) / 4);
8737       for (i = 0; i < nslots; i++)
8738         {
8739           unsigned char *shndx_list;
8740           unsigned int shndx;
8741
8742           SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
8743           if (signature_high != 0 || signature_low != 0)
8744             {
8745               SAFE_BYTE_GET (j, pindex, 4, limit);
8746               shndx_list = ppool + j * 4;
8747               /* PR 17531: file: 705e010d.  */
8748               if (shndx_list < ppool)
8749                 {
8750                   warn (_("Section index pool located before start of section\n"));
8751                   return 0;
8752                 }
8753
8754               if (do_display)
8755                 printf (_("  [%3d] Signature:  0x%s  Sections: "),
8756                         i, dwarf_vmatoa64 (signature_high, signature_low,
8757                                            buf, sizeof (buf)));
8758               for (;;)
8759                 {
8760                   if (shndx_list >= limit)
8761                     {
8762                       warn (_("Section %s too small for shndx pool\n"),
8763                             section->name);
8764                       return 0;
8765                     }
8766                   SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
8767                   if (shndx == 0)
8768                     break;
8769                   if (do_display)
8770                     printf (" %d", shndx);
8771                   else
8772                     add_shndx_to_cu_tu_entry (shndx);
8773                   shndx_list += 4;
8774                 }
8775               if (do_display)
8776                 printf ("\n");
8777               else
8778                 end_cu_tu_entry ();
8779             }
8780           phash += 8;
8781           pindex += 4;
8782         }
8783     }
8784   else if (version == 2)
8785     {
8786       unsigned int val;
8787       unsigned int dw_sect;
8788       unsigned char *ph = phash;
8789       unsigned char *pi = pindex;
8790       unsigned char *poffsets = ppool + ncols * 4;
8791       unsigned char *psizes = poffsets + nused * ncols * 4;
8792       unsigned char *pend = psizes + nused * ncols * 4;
8793       bfd_boolean is_tu_index;
8794       struct cu_tu_set *this_set = NULL;
8795       unsigned int row;
8796       unsigned char *prow;
8797
8798       is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
8799
8800       /* PR 17531: file: 0dd159bf.
8801          Check for wraparound with an overlarge ncols value.  */
8802       if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
8803         {
8804           warn (_("Overlarge number of columns: %x\n"), ncols);
8805           return 0;
8806         }
8807
8808       if (pend > limit)
8809         {
8810           warn (_("Section %s too small for offset and size tables\n"),
8811                 section->name);
8812           return 0;
8813         }
8814
8815       if (do_display)
8816         {
8817           printf (_("  Offset table\n"));
8818           printf ("  slot  %-16s  ",
8819                  is_tu_index ? _("signature") : _("dwo_id"));
8820         }
8821       else
8822         {
8823           if (is_tu_index)
8824             {
8825               tu_count = nused;
8826               tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
8827               this_set = tu_sets;
8828             }
8829           else
8830             {
8831               cu_count = nused;
8832               cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
8833               this_set = cu_sets;
8834             }
8835         }
8836
8837       if (do_display)
8838         {
8839           for (j = 0; j < ncols; j++)
8840             {
8841               SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
8842               printf (" %8s", get_DW_SECT_short_name (dw_sect));
8843             }
8844           printf ("\n");
8845         }
8846
8847       for (i = 0; i < nslots; i++)
8848         {
8849           SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
8850
8851           SAFE_BYTE_GET (row, pi, 4, limit);
8852           if (row != 0)
8853             {
8854               /* PR 17531: file: a05f6ab3.  */
8855               if (row > nused)
8856                 {
8857                   warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
8858                         row, nused);
8859                   return 0;
8860                 }
8861
8862               if (!do_display)
8863                 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
8864
8865               prow = poffsets + (row - 1) * ncols * 4;
8866               /* PR 17531: file: b8ce60a8.  */
8867               if (prow < poffsets || prow > limit)
8868                 {
8869                   warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
8870                         row, ncols);
8871                   return 0;
8872                 }
8873
8874               if (do_display)
8875                 printf (_("  [%3d] 0x%s"),
8876                         i, dwarf_vmatoa64 (signature_high, signature_low,
8877                                            buf, sizeof (buf)));
8878               for (j = 0; j < ncols; j++)
8879                 {
8880                   SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
8881                   if (do_display)
8882                     printf (" %8d", val);
8883                   else
8884                     {
8885                       SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
8886
8887                       /* PR 17531: file: 10796eb3.  */
8888                       if (dw_sect >= DW_SECT_MAX)
8889                         warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
8890                       else
8891                         this_set [row - 1].section_offsets [dw_sect] = val;
8892                     }
8893                 }
8894
8895               if (do_display)
8896                 printf ("\n");
8897             }
8898           ph += 8;
8899           pi += 4;
8900         }
8901
8902       ph = phash;
8903       pi = pindex;
8904       if (do_display)
8905         {
8906           printf ("\n");
8907           printf (_("  Size table\n"));
8908           printf ("  slot  %-16s  ",
8909                  is_tu_index ? _("signature") : _("dwo_id"));
8910         }
8911
8912       for (j = 0; j < ncols; j++)
8913         {
8914           SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
8915           if (do_display)
8916             printf (" %8s", get_DW_SECT_short_name (val));
8917         }
8918
8919       if (do_display)
8920         printf ("\n");
8921
8922       for (i = 0; i < nslots; i++)
8923         {
8924           SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
8925
8926           SAFE_BYTE_GET (row, pi, 4, limit);
8927           if (row != 0)
8928             {
8929               prow = psizes + (row - 1) * ncols * 4;
8930
8931               if (do_display)
8932                 printf (_("  [%3d] 0x%s"),
8933                         i, dwarf_vmatoa64 (signature_high, signature_low,
8934                                            buf, sizeof (buf)));
8935
8936               for (j = 0; j < ncols; j++)
8937                 {
8938                   SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
8939                   if (do_display)
8940                     printf (" %8d", val);
8941                   else
8942                     {
8943                       SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
8944                       if (dw_sect >= DW_SECT_MAX)
8945                         warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
8946                       else
8947                       this_set [row - 1].section_sizes [dw_sect] = val;
8948                     }
8949                 }
8950
8951               if (do_display)
8952                 printf ("\n");
8953             }
8954
8955           ph += 8;
8956           pi += 4;
8957         }
8958     }
8959   else if (do_display)
8960     printf (_("  Unsupported version (%d)\n"), version);
8961
8962   if (do_display)
8963       printf ("\n");
8964
8965   return 1;
8966 }
8967
8968 /* Load the CU and TU indexes if present.  This will build a list of
8969    section sets that we can use to associate a .debug_info.dwo section
8970    with its associated .debug_abbrev.dwo section in a .dwp file.  */
8971
8972 static bfd_boolean
8973 load_cu_tu_indexes (void *file)
8974 {
8975   static int cu_tu_indexes_read = -1; /* Tri-state variable.  */
8976
8977   /* If we have already loaded (or tried to load) the CU and TU indexes
8978      then do not bother to repeat the task.  */
8979   if (cu_tu_indexes_read == -1)
8980     {
8981       cu_tu_indexes_read = TRUE;
8982
8983       if (load_debug_section (dwp_cu_index, file))
8984         if (! process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0))
8985           cu_tu_indexes_read = FALSE;
8986
8987       if (load_debug_section (dwp_tu_index, file))
8988         if (! process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0))
8989           cu_tu_indexes_read = FALSE;
8990     }
8991
8992   return (bfd_boolean) cu_tu_indexes_read;
8993 }
8994
8995 /* Find the set of sections that includes section SHNDX.  */
8996
8997 unsigned int *
8998 find_cu_tu_set (void *file, unsigned int shndx)
8999 {
9000   unsigned int i;
9001
9002   if (! load_cu_tu_indexes (file))
9003     return NULL;
9004
9005   /* Find SHNDX in the shndx pool.  */
9006   for (i = 0; i < shndx_pool_used; i++)
9007     if (shndx_pool [i] == shndx)
9008       break;
9009
9010   if (i >= shndx_pool_used)
9011     return NULL;
9012
9013   /* Now backup to find the first entry in the set.  */
9014   while (i > 0 && shndx_pool [i - 1] != 0)
9015     i--;
9016
9017   return shndx_pool + i;
9018 }
9019
9020 /* Display a .debug_cu_index or .debug_tu_index section.  */
9021
9022 static int
9023 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
9024 {
9025   return process_cu_tu_index (section, 1);
9026 }
9027
9028 static int
9029 display_debug_not_supported (struct dwarf_section *section,
9030                              void *file ATTRIBUTE_UNUSED)
9031 {
9032   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9033             section->name);
9034
9035   return 1;
9036 }
9037
9038 /* Like malloc, 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 cmalloc (size_t nmemb, size_t size)
9043 {
9044   /* Check for overflow.  */
9045   if (nmemb >= ~(size_t) 0 / size)
9046     return NULL;
9047
9048   return xmalloc (nmemb * size);
9049 }
9050
9051 /* Like xmalloc, but takes two parameters like calloc.
9052    Verifies that the first parameter is not too large.
9053    Note: does *not* initialise the allocated memory to zero.  */
9054 void *
9055 xcmalloc (size_t nmemb, size_t size)
9056 {
9057   /* Check for overflow.  */
9058   if (nmemb >= ~(size_t) 0 / size)
9059     {
9060       fprintf (stderr,
9061                _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9062                (long) nmemb);
9063       xexit (1);
9064     }
9065
9066   return xmalloc (nmemb * size);
9067 }
9068
9069 /* Like xrealloc, but takes three parameters.
9070    Verifies that the second parameter is not too large.
9071    Note: does *not* initialise any new memory to zero.  */
9072 void *
9073 xcrealloc (void *ptr, size_t nmemb, size_t size)
9074 {
9075   /* Check for overflow.  */
9076   if (nmemb >= ~(size_t) 0 / size)
9077     {
9078       fprintf (stderr,
9079                _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9080                (long) nmemb);
9081       xexit (1);
9082     }
9083
9084   return xrealloc (ptr, nmemb * size);
9085 }
9086
9087 /* Like xcalloc, but verifies that the first parameter is not too large.  */
9088 void *
9089 xcalloc2 (size_t nmemb, size_t size)
9090 {
9091   /* Check for overflow.  */
9092   if (nmemb >= ~(size_t) 0 / size)
9093     {
9094       fprintf (stderr,
9095                _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9096                (long) nmemb);
9097       xexit (1);
9098     }
9099
9100   return xcalloc (nmemb, size);
9101 }
9102
9103 void
9104 free_debug_memory (void)
9105 {
9106   unsigned int i;
9107
9108   free_abbrevs ();
9109
9110   for (i = 0; i < max; i++)
9111     free_debug_section ((enum dwarf_section_display_enum) i);
9112
9113   if (debug_information != NULL)
9114     {
9115       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
9116         {
9117           for (i = 0; i < num_debug_info_entries; i++)
9118             {
9119               if (!debug_information [i].max_loc_offsets)
9120                 {
9121                   free (debug_information [i].loc_offsets);
9122                   free (debug_information [i].have_frame_base);
9123                 }
9124               if (!debug_information [i].max_range_lists)
9125                 free (debug_information [i].range_lists);
9126             }
9127         }
9128       free (debug_information);
9129       debug_information = NULL;
9130       alloc_num_debug_info_entries = num_debug_info_entries = 0;
9131     }
9132 }
9133
9134 void
9135 dwarf_select_sections_by_names (const char *names)
9136 {
9137   typedef struct
9138   {
9139     const char * option;
9140     int *        variable;
9141     int          val;
9142   }
9143   debug_dump_long_opts;
9144
9145   static const debug_dump_long_opts opts_table [] =
9146     {
9147       /* Please keep this table alpha- sorted.  */
9148       { "Ranges", & do_debug_ranges, 1 },
9149       { "abbrev", & do_debug_abbrevs, 1 },
9150       { "addr", & do_debug_addr, 1 },
9151       { "aranges", & do_debug_aranges, 1 },
9152       { "cu_index", & do_debug_cu_index, 1 },
9153       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
9154       { "frames", & do_debug_frames, 1 },
9155       { "frames-interp", & do_debug_frames_interp, 1 },
9156       /* The special .gdb_index section.  */
9157       { "gdb_index", & do_gdb_index, 1 },
9158       { "info", & do_debug_info, 1 },
9159       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
9160       { "loc",  & do_debug_loc, 1 },
9161       { "macro", & do_debug_macinfo, 1 },
9162       { "pubnames", & do_debug_pubnames, 1 },
9163       { "pubtypes", & do_debug_pubtypes, 1 },
9164       /* This entry is for compatibility
9165          with earlier versions of readelf.  */
9166       { "ranges", & do_debug_aranges, 1 },
9167       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
9168       { "str", & do_debug_str, 1 },
9169       /* These trace_* sections are used by Itanium VMS.  */
9170       { "trace_abbrev", & do_trace_abbrevs, 1 },
9171       { "trace_aranges", & do_trace_aranges, 1 },
9172       { "trace_info", & do_trace_info, 1 },
9173       { NULL, NULL, 0 }
9174     };
9175
9176   const char *p;
9177
9178   p = names;
9179   while (*p)
9180     {
9181       const debug_dump_long_opts * entry;
9182
9183       for (entry = opts_table; entry->option; entry++)
9184         {
9185           size_t len = strlen (entry->option);
9186
9187           if (strncmp (p, entry->option, len) == 0
9188               && (p[len] == ',' || p[len] == '\0'))
9189             {
9190               * entry->variable |= entry->val;
9191
9192               /* The --debug-dump=frames-interp option also
9193                  enables the --debug-dump=frames option.  */
9194               if (do_debug_frames_interp)
9195                 do_debug_frames = 1;
9196
9197               p += len;
9198               break;
9199             }
9200         }
9201
9202       if (entry->option == NULL)
9203         {
9204           warn (_("Unrecognized debug option '%s'\n"), p);
9205           p = strchr (p, ',');
9206           if (p == NULL)
9207             break;
9208         }
9209
9210       if (*p == ',')
9211         p++;
9212     }
9213 }
9214
9215 void
9216 dwarf_select_sections_by_letters (const char *letters)
9217 {
9218   unsigned int lindex = 0;
9219
9220   while (letters[lindex])
9221     switch (letters[lindex++])
9222       {
9223       case 'i':
9224         do_debug_info = 1;
9225         break;
9226
9227       case 'a':
9228         do_debug_abbrevs = 1;
9229         break;
9230
9231       case 'l':
9232         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
9233         break;
9234
9235       case 'L':
9236         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
9237         break;
9238
9239       case 'p':
9240         do_debug_pubnames = 1;
9241         break;
9242
9243       case 't':
9244         do_debug_pubtypes = 1;
9245         break;
9246
9247       case 'r':
9248         do_debug_aranges = 1;
9249         break;
9250
9251       case 'R':
9252         do_debug_ranges = 1;
9253         break;
9254
9255       case 'F':
9256         do_debug_frames_interp = 1;
9257         /* Fall through.  */
9258       case 'f':
9259         do_debug_frames = 1;
9260         break;
9261
9262       case 'm':
9263         do_debug_macinfo = 1;
9264         break;
9265
9266       case 's':
9267         do_debug_str = 1;
9268         break;
9269
9270       case 'o':
9271         do_debug_loc = 1;
9272         break;
9273
9274       default:
9275         warn (_("Unrecognized debug option '%s'\n"), letters);
9276         break;
9277       }
9278 }
9279
9280 void
9281 dwarf_select_sections_all (void)
9282 {
9283   do_debug_info = 1;
9284   do_debug_abbrevs = 1;
9285   do_debug_lines = FLAG_DEBUG_LINES_RAW;
9286   do_debug_pubnames = 1;
9287   do_debug_pubtypes = 1;
9288   do_debug_aranges = 1;
9289   do_debug_ranges = 1;
9290   do_debug_frames = 1;
9291   do_debug_macinfo = 1;
9292   do_debug_str = 1;
9293   do_debug_loc = 1;
9294   do_gdb_index = 1;
9295   do_trace_info = 1;
9296   do_trace_abbrevs = 1;
9297   do_trace_aranges = 1;
9298   do_debug_addr = 1;
9299   do_debug_cu_index = 1;
9300 }
9301
9302 struct dwarf_section_display debug_displays[] =
9303 {
9304   { { ".debug_abbrev",      ".zdebug_abbrev",   NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9305     display_debug_abbrev,   &do_debug_abbrevs,  FALSE },
9306   { { ".debug_aranges",     ".zdebug_aranges",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9307     display_debug_aranges,  &do_debug_aranges,  TRUE },
9308   { { ".debug_frame",       ".zdebug_frame",    NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9309     display_debug_frames,   &do_debug_frames,   TRUE },
9310   { { ".debug_info",        ".zdebug_info",     NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
9311     display_debug_info,     &do_debug_info,     TRUE },
9312   { { ".debug_line",        ".zdebug_line",     NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9313     display_debug_lines,    &do_debug_lines,    TRUE },
9314   { { ".debug_pubnames",    ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9315     display_debug_pubnames, &do_debug_pubnames, FALSE },
9316   { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9317     display_debug_gnu_pubnames, &do_debug_pubnames, FALSE },
9318   { { ".eh_frame",          "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9319     display_debug_frames,   &do_debug_frames,   TRUE },
9320   { { ".debug_macinfo",     ".zdebug_macinfo",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9321     display_debug_macinfo,  &do_debug_macinfo,  FALSE },
9322   { { ".debug_macro",       ".zdebug_macro",    NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9323     display_debug_macro,    &do_debug_macinfo,  TRUE },
9324   { { ".debug_str",         ".zdebug_str",      NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9325     display_debug_str,      &do_debug_str,      FALSE },
9326   { { ".debug_line_str",    ".zdebug_line_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9327     display_debug_str,      &do_debug_str,      FALSE },
9328   { { ".debug_loc",         ".zdebug_loc",      NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9329     display_debug_loc,      &do_debug_loc,      TRUE },
9330   { { ".debug_loclists",    ".zdebug_loclists", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9331     display_debug_loc,      &do_debug_loc,      TRUE },
9332   { { ".debug_pubtypes",    ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9333     display_debug_pubnames, &do_debug_pubtypes, FALSE },
9334   { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9335     display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE },
9336   { { ".debug_ranges",      ".zdebug_ranges",   NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9337     display_debug_ranges,   &do_debug_ranges,   TRUE },
9338   { { ".debug_rnglists",    ".zdebug_rnglists", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9339     display_debug_ranges,   &do_debug_ranges,   TRUE },
9340   { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9341     display_debug_not_supported, NULL,          FALSE },
9342   { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9343     display_debug_not_supported, NULL,          FALSE },
9344   { { ".debug_types",       ".zdebug_types",    NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
9345     display_debug_types,    &do_debug_info,     TRUE },
9346   { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9347     display_debug_not_supported, NULL,          FALSE },
9348   { { ".gdb_index",         "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9349     display_gdb_index,      &do_gdb_index,      FALSE },
9350   { { ".debug_names",       "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9351     display_debug_names,    &do_gdb_index,      FALSE },
9352   { { ".trace_info",        "",                 NULL, NULL, 0, 0, trace_abbrev, NULL, 0, NULL },
9353     display_trace_info,     &do_trace_info,     TRUE },
9354   { { ".trace_abbrev",      "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9355     display_debug_abbrev,   &do_trace_abbrevs,  FALSE },
9356   { { ".trace_aranges",     "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9357     display_debug_aranges,  &do_trace_aranges,  FALSE },
9358   { { ".debug_info.dwo",    ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
9359     display_debug_info,     &do_debug_info,     TRUE },
9360   { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9361     display_debug_abbrev,   &do_debug_abbrevs,  FALSE },
9362   { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
9363     display_debug_types,    &do_debug_info,     TRUE },
9364   { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9365     display_debug_lines,    &do_debug_lines,    TRUE },
9366   { { ".debug_loc.dwo",     ".zdebug_loc.dwo",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9367     display_debug_loc,      &do_debug_loc,      TRUE },
9368   { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9369     display_debug_macro,    &do_debug_macinfo,  TRUE },
9370   { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9371     display_debug_macinfo,  &do_debug_macinfo,  FALSE },
9372   { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9373     display_debug_str,      &do_debug_str,      TRUE },
9374   { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9375     display_debug_str_offsets, NULL,            FALSE },
9376   { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9377     display_debug_str_offsets, NULL,            FALSE },
9378   { { ".debug_addr",        ".zdebug_addr",     NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9379     display_debug_addr,     &do_debug_addr,     TRUE },
9380   { { ".debug_cu_index",    "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9381     display_cu_index,       &do_debug_cu_index, FALSE },
9382   { { ".debug_tu_index",    "",                 NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9383     display_cu_index,       &do_debug_cu_index, FALSE },
9384 };
9385
9386 /* A static assertion.  */
9387 extern int debug_displays_assert[ARRAY_SIZE (debug_displays) == max ? 1 : -1];