binutils/dwarf.c

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