binutils/dwarf.c

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