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