binutils/dwarf.c

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